service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/manager/UiListenerHandler.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.serviceprovider.manager;
  18
  19 import java.util.ArrayList;
  20 import java.util.Iterator;
  21 import java.util.List;
  22
  23 import oic.simulator.serviceprovider.listener.IAutomationListener;
  24 import oic.simulator.serviceprovider.listener.IDataChangeListener;
  25 import oic.simulator.serviceprovider.listener.IDeviceInfoListener;
  26 import oic.simulator.serviceprovider.listener.IObserverListChangedListener;
  27 import oic.simulator.serviceprovider.listener.IPropertiesChangedListener;
  28 import oic.simulator.serviceprovider.listener.IResourceListChangedListener;
  29 import oic.simulator.serviceprovider.listener.ISelectionChangedListener;
  30 import oic.simulator.serviceprovider.model.AttributeElement;
  31 import oic.simulator.serviceprovider.model.Resource;
  32 import oic.simulator.serviceprovider.model.ResourceType;
  33 import oic.simulator.serviceprovider.model.SingleResource;
  34
  35 public class UiListenerHandler {
  36
  37     private static UiListenerHandler           uiHandler;
  38
  39     private List<IResourceListChangedListener> resourceListChangedUIListeners;
  40
  41     private List<ISelectionChangedListener>    selectionChangedUIListeners;
  42
  43     private List<IAutomationListener>          automationUIListeners;
  44
  45     private List<IObserverListChangedListener> observerUIListeners;
  46
  47     private List<IPropertiesChangedListener>   propertiesChangedUIListeners;
  48
  49     private List<IDeviceInfoListener>          deviceInfoUIListeners;
  50
  51     private List<IDataChangeListener>          dataChangeListeners;
  52
  53     private UiListenerHandler() {
  54         resourceListChangedUIListeners = new ArrayList<IResourceListChangedListener>();
  55         selectionChangedUIListeners = new ArrayList<ISelectionChangedListener>();
  56         automationUIListeners = new ArrayList<IAutomationListener>();
  57         observerUIListeners = new ArrayList<IObserverListChangedListener>();
  58         propertiesChangedUIListeners = new ArrayList<IPropertiesChangedListener>();
  59         deviceInfoUIListeners = new ArrayList<IDeviceInfoListener>();
  60         dataChangeListeners = new ArrayList<IDataChangeListener>();
  61     }
  62
  63     public static UiListenerHandler getInstance() {
  64         if (null == uiHandler) {
  65             uiHandler = new UiListenerHandler();
  66         }
  67         return uiHandler;
  68     }
  69
  70     public void addResourceListChangedUIListener(
  71             IResourceListChangedListener resourceListChangedUIListener) {
  72         synchronized (resourceListChangedUIListeners) {
  73             resourceListChangedUIListeners.add(resourceListChangedUIListener);
  74         }
  75     }
  76
  77     public void addResourceSelectionChangedUIListener(
  78             ISelectionChangedListener resourceSelectionChangedUIListener) {
  79         synchronized (selectionChangedUIListeners) {
  80             selectionChangedUIListeners.add(resourceSelectionChangedUIListener);
  81         }
  82     }
  83
  84     public void addAutomationUIListener(IAutomationListener automationUIListener) {
  85         synchronized (automationUIListeners) {
  86             automationUIListeners.add(automationUIListener);
  87         }
  88     }
  89
  90     public void addObserverListChangedUIListener(
  91             IObserverListChangedListener observerListChangedUIListener) {
  92         synchronized (observerUIListeners) {
  93             observerUIListeners.add(observerListChangedUIListener);
  94         }
  95     }
  96
  97     public void addResourcePropertiesChangedUIListener(
  98             IPropertiesChangedListener resourcePropertiesChangedUIListener) {
  99         synchronized (propertiesChangedUIListeners) {
 100             propertiesChangedUIListeners
 101                     .add(resourcePropertiesChangedUIListener);
 102         }
 103     }
 104
 105     public void addDataChangeListener(IDataChangeListener dataChangeListener) {
 106         synchronized (dataChangeListeners) {
 107             dataChangeListeners.add(dataChangeListener);
 108         }
 109     }
 110
 111     public void removeResourceListChangedUIListener(
 112             IResourceListChangedListener listener) {
 113         synchronized (resourceListChangedUIListeners) {
 114             if (null != listener && resourceListChangedUIListeners.size() > 0) {
 115                 resourceListChangedUIListeners.remove(listener);
 116             }
 117         }
 118     }
 119
 120     public void removeResourceSelectionChangedUIListener(
 121             ISelectionChangedListener listener) {
 122         synchronized (selectionChangedUIListeners) {
 123             if (null != listener && selectionChangedUIListeners.size() > 0) {
 124                 selectionChangedUIListeners.remove(listener);
 125             }
 126         }
 127     }
 128
 129     public void removeAutomationUIListener(IAutomationListener listener) {
 130         synchronized (automationUIListeners) {
 131             if (null != listener && automationUIListeners.size() > 0) {
 132                 automationUIListeners.remove(listener);
 133             }
 134         }
 135     }
 136
 137     public void removeObserverListChangedUIListener(
 138             IObserverListChangedListener listener) {
 139         synchronized (observerUIListeners) {
 140             if (null != listener && observerUIListeners.size() > 0) {
 141                 observerUIListeners.remove(listener);
 142             }
 143         }
 144     }
 145
 146     public void removeResourcePropertiesChangedUIListener(
 147             IPropertiesChangedListener resourcePropertiesChangedUIListener) {
 148         synchronized (propertiesChangedUIListeners) {
 149             propertiesChangedUIListeners
 150                     .remove(resourcePropertiesChangedUIListener);
 151         }
 152     }
 153
 154     public void removeDataChangeListener(IDataChangeListener dataChangeListener) {
 155         synchronized (dataChangeListeners) {
 156             dataChangeListeners.remove(dataChangeListener);
 157         }
 158     }
 159
 160     public void addDeviceInfoUIListener(IDeviceInfoListener deviceUIListener) {
 161         synchronized (deviceInfoUIListeners) {
 162             deviceInfoUIListeners.add(deviceUIListener);
 163         }
 164     }
 165
 166     public void removeDeviceInfoUIListener(
 167             IDeviceInfoListener platformUIListener) {
 168         synchronized (deviceInfoUIListeners) {
 169             deviceInfoUIListeners.remove(platformUIListener);
 170         }
 171     }
 172
 173     public void resourceCreatedUINotification(ResourceType type) {
 174         synchronized (resourceListChangedUIListeners) {
 175             if (resourceListChangedUIListeners.size() > 0) {
 176                 IResourceListChangedListener listener;
 177                 Iterator<IResourceListChangedListener> listenerItr = resourceListChangedUIListeners
 178                         .iterator();
 179                 while (listenerItr.hasNext()) {
 180                     listener = listenerItr.next();
 181                     if (null != listener) {
 182                         listener.onResourceCreation(type);
 183                     }
 184                 }
 185             }
 186         }
 187     }
 188
 189     public void resourceDeletedUINotification(ResourceType type) {
 190         synchronized (resourceListChangedUIListeners) {
 191             if (resourceListChangedUIListeners.size() > 0) {
 192                 IResourceListChangedListener listener;
 193                 Iterator<IResourceListChangedListener> listenerItr = resourceListChangedUIListeners
 194                         .iterator();
 195                 while (listenerItr.hasNext()) {
 196                     listener = listenerItr.next();
 197                     if (null != listener) {
 198                         listener.onResourceDeletion(type);
 199                     }
 200                 }
 201             }
 202         }
 203     }
 204
 205     public void resourceListUpdateUINotification(ResourceType type) {
 206         synchronized (resourceListChangedUIListeners) {
 207             if (resourceListChangedUIListeners.size() > 0) {
 208                 IResourceListChangedListener listener;
 209                 Iterator<IResourceListChangedListener> listenerItr = resourceListChangedUIListeners
 210                         .iterator();
 211                 while (listenerItr.hasNext()) {
 212                     listener = listenerItr.next();
 213                     if (null != listener) {
 214                         listener.onResourceListUpdate(type);
 215                     }
 216                 }
 217             }
 218         }
 219     }
 220
 221     public void resourceSelectionChangedUINotification(Resource resource) {
 222         synchronized (selectionChangedUIListeners) {
 223             if (selectionChangedUIListeners.size() > 0) {
 224                 ISelectionChangedListener listener;
 225                 Iterator<ISelectionChangedListener> listenerItr = selectionChangedUIListeners
 226                         .iterator();
 227                 while (listenerItr.hasNext()) {
 228                     listener = listenerItr.next();
 229                     if (null != listener) {
 230                         listener.onResourceSelectionChange(resource);
 231                     }
 232                 }
 233             }
 234         }
 235     }
 236
 237     public void attributeUpdatedUINotification(AttributeElement attribute) {
 238         synchronized (dataChangeListeners) {
 239             if (dataChangeListeners.size() > 0 && null != attribute) {
 240                 IDataChangeListener listener;
 241                 Iterator<IDataChangeListener> listenerItr = dataChangeListeners
 242                         .iterator();
 243                 while (listenerItr.hasNext()) {
 244                     listener = listenerItr.next();
 245                     if (null != listener) {
 246                         listener.update(attribute);
 247                     }
 248                 }
 249             }
 250         }
 251     }
 252
 253     public void attributeAddedUINotification(AttributeElement attribute) {
 254         synchronized (dataChangeListeners) {
 255             if (dataChangeListeners.size() > 0 && null != attribute) {
 256                 IDataChangeListener listener;
 257                 Iterator<IDataChangeListener> listenerItr = dataChangeListeners
 258                         .iterator();
 259                 while (listenerItr.hasNext()) {
 260                     listener = listenerItr.next();
 261                     if (null != listener) {
 262                         listener.add(attribute);
 263                     }
 264                 }
 265             }
 266         }
 267     }
 268
 269     public void attributeRemovedUINotification(AttributeElement attribute) {
 270         synchronized (dataChangeListeners) {
 271             if (dataChangeListeners.size() > 0 && null != attribute) {
 272                 IDataChangeListener listener;
 273                 Iterator<IDataChangeListener> listenerItr = dataChangeListeners
 274                         .iterator();
 275                 while (listenerItr.hasNext()) {
 276                     listener = listenerItr.next();
 277                     if (null != listener) {
 278                         listener.remove(attribute);
 279                     }
 280                 }
 281             }
 282         }
 283     }
 284
 285     public void resourceAutomationStartedUINotification(SingleResource resource) {
 286         synchronized (automationUIListeners) {
 287             if (automationUIListeners.size() > 0 && null != resource) {
 288                 IAutomationListener listener;
 289                 Iterator<IAutomationListener> listenerItr = automationUIListeners
 290                         .iterator();
 291                 while (listenerItr.hasNext()) {
 292                     listener = listenerItr.next();
 293                     if (null != listener) {
 294                         listener.onResourceAutomationStart(resource);
 295                     }
 296                 }
 297             }
 298         }
 299     }
 300
 301     public void automationCompleteUINotification(SingleResource resource,
 302             String attName) {
 303         synchronized (automationUIListeners) {
 304             if (automationUIListeners.size() > 0 && null != resource) {
 305                 IAutomationListener listener;
 306                 Iterator<IAutomationListener> listenerItr = automationUIListeners
 307                         .iterator();
 308                 while (listenerItr.hasNext()) {
 309                     listener = listenerItr.next();
 310                     if (null != listener) {
 311                         listener.onAutomationComplete(resource, attName);
 312                     }
 313                 }
 314             }
 315         }
 316     }
 317
 318     public void observerListChangedUINotification(Resource resource) {
 319         synchronized (observerUIListeners) {
 320             if (observerUIListeners.size() > 0 && null != resource) {
 321                 IObserverListChangedListener listener;
 322                 Iterator<IObserverListChangedListener> listenerItr = observerUIListeners
 323                         .iterator();
 324                 while (listenerItr.hasNext()) {
 325                     listener = listenerItr.next();
 326                     if (null != listener) {
 327                         listener.onObserverListChanged(resource);
 328                     }
 329                 }
 330             }
 331         }
 332     }
 333
 334     public void propertiesChangedUINotification(Class<?> targetClass) {
 335         synchronized (propertiesChangedUIListeners) {
 336             if (propertiesChangedUIListeners.size() > 0) {
 337                 IPropertiesChangedListener listener;
 338                 Iterator<IPropertiesChangedListener> listenerItr = propertiesChangedUIListeners
 339                         .iterator();
 340                 while (listenerItr.hasNext()) {
 341                     listener = listenerItr.next();
 342                     if (null != listener) {
 343                         if (targetClass == Resource.class) {
 344                             listener.onResourcePropertyChange();
 345                         }
 346                     }
 347                 }
 348             }
 349         }
 350     }
 351
 352     public void deviceInfoReceivedNotification() {
 353         synchronized (deviceInfoUIListeners) {
 354             if (deviceInfoUIListeners.size() > 0) {
 355                 IDeviceInfoListener listener;
 356                 Iterator<IDeviceInfoListener> listenerItr = deviceInfoUIListeners
 357                         .iterator();
 358                 while (listenerItr.hasNext()) {
 359                     listener = listenerItr.next();
 360                     if (null != listener) {
 361                         listener.onDeviceInfoFound();
 362                     }
 363                 }
 364             }
 365         }
 366     }
 367 }