android/android_api/base/src/main/java/org/iotivity/base/OcPlatform.java

   1 /*
   2  * //******************************************************************
   3  * //
   4  * // Copyright 2015 Intel Corporation.
   5  * //
   6  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  * //
   8  * // Licensed under the Apache License, Version 2.0 (the "License");
   9  * // you may not use this file except in compliance with the License.
  10  * // You may obtain a copy of the License at
  11  * //
  12  * //      http://www.apache.org/licenses/LICENSE-2.0
  13  * //
  14  * // Unless required by applicable law or agreed to in writing, software
  15  * // distributed under the License is distributed on an "AS IS" BASIS,
  16  * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * // See the License for the specific language governing permissions and
  18  * // limitations under the License.
  19  * //
  20  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22
  23 package org.iotivity.base;
  24
  25 import org.iotivity.ca.CaInterface;
  26 import org.iotivity.base.BuildConfig;
  27
  28 import java.util.EnumSet;
  29 import java.util.Iterator;
  30 import java.util.List;
  31
  32 /**
  33  * This class contains the main entrance/functionality of the product. To set a custom
  34  * configuration, the implementer must make a call to OcPlatform.Configure before the first usage
  35  * of a method in this class.
  36  */
  37 public final class OcPlatform {
  38
  39     static {
  40         System.loadLibrary("oc_logger");
  41         System.loadLibrary("octbstack");
  42         System.loadLibrary("connectivity_abstraction");
  43         System.loadLibrary("oc");
  44         if (0 != BuildConfig.SECURED)
  45         {
  46             System.loadLibrary("ocprovision");
  47         }
  48         System.loadLibrary("ocstack-jni");
  49     }
  50
  51     /**
  52      * Default interface
  53      */
  54     public static final String DEFAULT_INTERFACE = "oic.if.baseline";
  55
  56     /**
  57      * Used in discovering (GET) links to other resources of a collection
  58      */
  59     public static final String LINK_INTERFACE = "oic.if.ll";
  60
  61     /**
  62      * Used in GET, PUT, POST, DELETE methods on links to other resources of a collection
  63      */
  64     public static final String BATCH_INTERFACE = "oic.if.b";
  65
  66     /**
  67      * Used in GET, PUT, POST methods on links to other remote resources of a group
  68      */
  69     public static final String GROUP_INTERFACE = "oic.mi.grp";
  70
  71     public static final String WELL_KNOWN_QUERY = "/oic/res";
  72     public static final String WELL_KNOWN_DEVICE_QUERY = "/oic/d";
  73     public static final String WELL_KNOWN_PLATFORM_QUERY = "/oic/p";
  74     public static final int DEFAULT_PRESENCE_TTL = 60;
  75     public static final String PRESENCE_URI = "/oic/ad";
  76
  77     private static volatile boolean sIsPlatformInitialized = false;
  78     private static QualityOfService sPlatformQualityOfService = QualityOfService.NA;
  79
  80     private OcPlatform() {
  81     }
  82
  83     /**
  84      * API for setting the configuration of the OcPlatform.
  85      * <p>
  86      * Note: Any calls made to this AFTER the first call to OcPlatform.Configure will have no affect
  87      * </p>
  88      *
  89      * @param platformConfig platform configuration
  90      */
  91     public synchronized static void Configure(PlatformConfig platformConfig) {
  92         if (!sIsPlatformInitialized) {
  93             CaInterface.initialize(platformConfig.getActivity(), platformConfig.getContext());
  94
  95             sPlatformQualityOfService = platformConfig.getQualityOfService();
  96
  97             OcPlatform.configure(
  98                     platformConfig.getServiceType().getValue(),
  99                     platformConfig.getModeType().getValue(),
 100                     platformConfig.getIpAddress(),
 101                     platformConfig.getPort(),
 102                     platformConfig.getQualityOfService().getValue(),
 103                     platformConfig.getSvrDbPath()
 104             );
 105
 106             sIsPlatformInitialized = true;
 107         }
 108     }
 109
 110     private static native void configure(int serviceType,
 111                                          int modeType,
 112                                          String ipAddress,
 113                                          int port,
 114                                          int qualityOfService,
 115                                          String dbPath);
 116
 117     /**
 118      * API for notifying base that resource's attributes have changed.
 119      * <p>
 120      * Note: This API is for server side only.
 121      * </p>
 122      *
 123      * @param ocResourceHandle resource handle of the resource
 124      * @throws OcException if failure
 125      */
 126     public static void notifyAllObservers(
 127             OcResourceHandle ocResourceHandle) throws OcException {
 128         OcPlatform.initCheck();
 129         OcPlatform.notifyAllObservers0(ocResourceHandle);
 130     }
 131
 132     private static native void notifyAllObservers0(
 133             OcResourceHandle ocResourceHandle) throws OcException;
 134
 135     /**
 136      * API for notifying base that resource's attributes have changed.
 137      * <p>
 138      * Note: This API is for server side only.
 139      * </p>
 140      *
 141      * @param ocResourceHandle resource handle of the resource
 142      * @param qualityOfService the quality of communication
 143      * @throws OcException if failure
 144      */
 145     public static void notifyAllObservers(
 146             OcResourceHandle ocResourceHandle,
 147             QualityOfService qualityOfService) throws OcException {
 148         OcPlatform.initCheck();
 149         OcPlatform.notifyAllObservers1(ocResourceHandle, qualityOfService.getValue());
 150     }
 151
 152     private static native void notifyAllObservers1(
 153             OcResourceHandle ocResourceHandle,
 154             int qualityOfService) throws OcException;
 155
 156     /**
 157      * API for notifying only specific clients that resource's attributes have changed.
 158      * <p>
 159      * Note: This API is for server side only.
 160      * </p>
 161      *
 162      * @param ocResourceHandle    resource handle of the resource
 163      * @param ocObservationIdList These set of ids are ones which which will be notified upon
 164      *                            resource change.
 165      * @param ocResourceResponse  OcResourceResponse object used by app to fill the response for
 166      *                            this resource change
 167      * @throws OcException if failure
 168      */
 169     public static void notifyListOfObservers(
 170             OcResourceHandle ocResourceHandle,
 171             List<Byte> ocObservationIdList,
 172             OcResourceResponse ocResourceResponse) throws OcException {
 173         OcPlatform.initCheck();
 174
 175         byte[] idArr = new byte[ocObservationIdList.size()];
 176         Iterator<Byte> it = ocObservationIdList.iterator();
 177         int i = 0;
 178         while (it.hasNext()) {
 179             idArr[i++] = (byte) it.next();
 180         }
 181
 182         OcPlatform.notifyListOfObservers2(
 183                 ocResourceHandle,
 184                 idArr,
 185                 ocResourceResponse);
 186     }
 187
 188     private static native void notifyListOfObservers2(
 189             OcResourceHandle ocResourceHandle,
 190             byte[] ocObservationIdArray,
 191             OcResourceResponse ocResourceResponse) throws OcException;
 192
 193     /**
 194      * API for notifying only specific clients that resource's attributes have changed.
 195      * <p>
 196      * Note: This API is for server side only.
 197      * </p>
 198      *
 199      * @param ocResourceHandle    resource handle of the resource
 200      * @param ocObservationIdList These set of ids are ones which which will be notified upon
 201      *                            resource change.
 202      * @param ocResourceResponse  OcResourceResponse object used by app to fill the response for
 203      *                            this resource change
 204      * @param qualityOfService    the quality of communication
 205      * @throws OcException if failure
 206      */
 207     public static void notifyListOfObservers(
 208             OcResourceHandle ocResourceHandle,
 209             List<Byte> ocObservationIdList,
 210             OcResourceResponse ocResourceResponse,
 211             QualityOfService qualityOfService) throws OcException {
 212         OcPlatform.initCheck();
 213
 214         byte[] idArr = new byte[ocObservationIdList.size()];
 215         Iterator<Byte> it = ocObservationIdList.iterator();
 216         int i = 0;
 217         while (it.hasNext()) {
 218             idArr[i++] = (byte) it.next();
 219         }
 220
 221         OcPlatform.notifyListOfObservers3(
 222                 ocResourceHandle,
 223                 idArr,
 224                 ocResourceResponse,
 225                 qualityOfService.getValue()
 226         );
 227     }
 228
 229     private static native void notifyListOfObservers3(
 230             OcResourceHandle ocResourceHandle,
 231             byte[] ocObservationIdArray,
 232             OcResourceResponse ocResourceResponse,
 233             int qualityOfService) throws OcException;
 234
 235     /**
 236      * API for Service and Resource Discovery
 237      * <p>
 238      * Note: This API is for client side only.
 239      * </p>
 240      *
 241      * @param host                    Host Address of a service to direct resource discovery query.
 242      *                                If empty, performs multicast resource discovery query
 243      * @param resourceUri             name of the resource. If null or empty, performs search for all
 244      *                                resource names
 245      * @param connectivityTypeSet     Set of types of connectivity. Example: IP
 246      * @param onResourceFoundListener Handles events, success states and failure states.
 247      * @throws OcException if failure
 248      */
 249     public static void findResource(
 250             String host,
 251             String resourceUri,
 252             EnumSet<OcConnectivityType> connectivityTypeSet,
 253             OnResourceFoundListener onResourceFoundListener) throws OcException {
 254         OcPlatform.initCheck();
 255
 256         int connTypeInt = 0;
 257
 258         for (OcConnectivityType connType : OcConnectivityType.values()) {
 259             if (connectivityTypeSet.contains(connType))
 260                 connTypeInt |= connType.getValue();
 261         }
 262
 263         OcPlatform.findResource0(
 264                 host,
 265                 resourceUri,
 266                 connTypeInt,
 267                 onResourceFoundListener
 268         );
 269     }
 270
 271     private static native void findResource0(
 272             String host,
 273             String resourceUri,
 274             int connectivityType,
 275             OnResourceFoundListener onResourceFoundListener) throws OcException;
 276
 277     /**
 278      * API for Service and Resource Discovery.
 279      * <p>
 280      * Note: This API is for client side only.
 281      * </p>
 282      *
 283      * @param host                    Host IP Address of a service to direct resource discovery query.
 284      *                                If empty, performs multicast resource discovery query
 285      * @param resourceUri             name of the resource. If null or empty, performs search for all
 286      *                                resource names
 287      * @param connectivityTypeSet     Set of types of connectivity. Example: IP
 288      * @param onResourceFoundListener Handles events, success states and failure states.
 289      * @param qualityOfService        the quality of communication
 290      * @throws OcException if failure
 291      */
 292     public static void findResource(
 293             String host,
 294             String resourceUri,
 295             EnumSet<OcConnectivityType> connectivityTypeSet,
 296             OnResourceFoundListener onResourceFoundListener,
 297             QualityOfService qualityOfService) throws OcException {
 298         OcPlatform.initCheck();
 299
 300         int connTypeInt = 0;
 301
 302         for (OcConnectivityType connType : OcConnectivityType.values()) {
 303             if (connectivityTypeSet.contains(connType))
 304                 connTypeInt |= connType.getValue();
 305         }
 306
 307         OcPlatform.findResource1(host,
 308                 resourceUri,
 309                 connTypeInt,
 310                 onResourceFoundListener,
 311                 qualityOfService.getValue()
 312         );
 313     }
 314
 315     private static native void findResource1(
 316             String host,
 317             String resourceUri,
 318             int connectivityType,
 319             OnResourceFoundListener onResourceFoundListener,
 320             int qualityOfService) throws OcException;
 321
 322     /**
 323      * API for Device Discovery
 324      *
 325      * @param host                  Host IP Address. If null or empty, Multicast is performed.
 326      * @param deviceUri             Uri containing address to the virtual device
 327      * @param connectivityTypeSet   Set of types of connectivity. Example: IP
 328      * @param onDeviceFoundListener Handles events, success states and failure states.
 329      * @throws OcException if failure
 330      */
 331     public static void getDeviceInfo(
 332             String host,
 333             String deviceUri,
 334             EnumSet<OcConnectivityType> connectivityTypeSet,
 335             OnDeviceFoundListener onDeviceFoundListener) throws OcException {
 336         OcPlatform.initCheck();
 337         int connTypeInt = 0;
 338
 339         for (OcConnectivityType connType : OcConnectivityType.values()) {
 340             if (connectivityTypeSet.contains(connType))
 341                 connTypeInt |= connType.getValue();
 342         }
 343         OcPlatform.getDeviceInfo0(
 344                 host,
 345                 deviceUri,
 346                 connTypeInt,
 347                 onDeviceFoundListener
 348         );
 349     }
 350
 351     private static native void getDeviceInfo0(
 352             String host,
 353             String deviceUri,
 354             int connectivityType,
 355             OnDeviceFoundListener onDeviceFoundListener) throws OcException;
 356
 357     /**
 358      * API for Device Discovery
 359      *
 360      * @param host                  Host IP Address. If null or empty, Multicast is performed.
 361      * @param deviceUri             Uri containing address to the virtual device
 362      * @param connectivityTypeSet   Set of types of connectivity. Example: IP
 363      * @param onDeviceFoundListener Handles events, success states and failure states.
 364      * @param qualityOfService      the quality of communication
 365      * @throws OcException if failure
 366      */
 367     public static void getDeviceInfo(
 368             String host,
 369             String deviceUri,
 370             EnumSet<OcConnectivityType> connectivityTypeSet,
 371             OnDeviceFoundListener onDeviceFoundListener,
 372             QualityOfService qualityOfService) throws OcException {
 373         OcPlatform.initCheck();
 374         int connTypeInt = 0;
 375
 376         for (OcConnectivityType connType : OcConnectivityType.values()) {
 377             if (connectivityTypeSet.contains(connType))
 378                 connTypeInt |= connType.getValue();
 379         }
 380         OcPlatform.getDeviceInfo1(
 381                 host,
 382                 deviceUri,
 383                 connTypeInt,
 384                 onDeviceFoundListener,
 385                 qualityOfService.getValue()
 386         );
 387     }
 388
 389     private static native void getDeviceInfo1(
 390             String host,
 391             String deviceUri,
 392             int connectivityType,
 393             OnDeviceFoundListener onDeviceFoundListener,
 394             int qualityOfService) throws OcException;
 395
 396     /**
 397      * API for Platform Discovery
 398      *
 399      * @param host                    Host IP Address. If null or empty, Multicast is performed.
 400      * @param platformUri             Uri containing address to the platform
 401      * @param connectivityTypeSet     Set of types of connectivity. Example: IP
 402      * @param onPlatformFoundListener Handles events, success states and failure states.
 403      * @throws OcException if failure
 404      */
 405
 406     public static void getPlatformInfo(
 407             String host,
 408             String platformUri,
 409             EnumSet<OcConnectivityType> connectivityTypeSet,
 410             OnPlatformFoundListener onPlatformFoundListener) throws OcException {
 411         OcPlatform.initCheck();
 412         int connTypeInt = 0;
 413
 414         for (OcConnectivityType connType : OcConnectivityType.values()) {
 415             if (connectivityTypeSet.contains(connType))
 416                 connTypeInt |= connType.getValue();
 417         }
 418         OcPlatform.getPlatformInfo0(
 419                 host,
 420                 platformUri,
 421                 connTypeInt,
 422                 onPlatformFoundListener
 423         );
 424     }
 425
 426     private static native void getPlatformInfo0(
 427             String host,
 428             String platformUri,
 429             int connectivityType,
 430             OnPlatformFoundListener onPlatformInfoFoundListener) throws OcException;
 431
 432     /**
 433      * API for Platform Discovery
 434      *
 435      * @param host                    Host IP Address. If null or empty, Multicast is performed.
 436      * @param platformUri             Uri containing address to the platform
 437      * @param connectivityTypeSet     Set of types of connectivity. Example: IP
 438      * @param onPlatformFoundListener Handles events, success states and failure states.
 439      * @param qualityOfService        the quality of communication
 440      * @throws OcException if failure
 441      */
 442
 443     public static void getPlatformInfo(
 444             String host,
 445             String platformUri,
 446             EnumSet<OcConnectivityType> connectivityTypeSet,
 447             OnPlatformFoundListener onPlatformFoundListener,
 448             QualityOfService qualityOfService) throws OcException {
 449         OcPlatform.initCheck();
 450         int connTypeInt = 0;
 451
 452         for (OcConnectivityType connType : OcConnectivityType.values()) {
 453             if (connectivityTypeSet.contains(connType))
 454                 connTypeInt |= connType.getValue();
 455         }
 456         OcPlatform.getPlatformInfo1(
 457                 host,
 458                 platformUri,
 459                 connTypeInt,
 460                 onPlatformFoundListener,
 461                 qualityOfService.getValue()
 462         );
 463     }
 464
 465     private static native void getPlatformInfo1(
 466             String host,
 467             String platformUri,
 468             int connectivityType,
 469             OnPlatformFoundListener onPlatformFoundListener,
 470             int qualityOfService) throws OcException;
 471
 472     /**
 473      * This API registers a resource with the server
 474      * <p/>
 475      * Note: This API applies to server & client side.
 476      * </P>
 477      *
 478      * @param ocResource The instance of OcResource with all data filled
 479      * @return resource handle
 480      * @throws OcException if failure
 481      */
 482     public static OcResourceHandle registerResource(
 483             OcResource ocResource) throws OcException {
 484         OcPlatform.initCheck();
 485         return OcPlatform.registerResource0(ocResource);
 486     }
 487
 488     private static native OcResourceHandle registerResource0(
 489             OcResource ocResource) throws OcException;
 490
 491     /**
 492      * This API registers a resource with the server NOTE: This API applies to server side only.
 493      * <p/>
 494      * Note: This API applies to server side only.
 495      * </P>
 496      *
 497      * @param resourceUri         The URI of the resource. Example: "a/light"
 498      * @param resourceTypeName    The resource type. Example: "light"
 499      * @param resourceInterface   The resource interface (whether it is collection etc).
 500      * @param entityHandler       entity handler.
 501      * @param resourcePropertySet indicates the property of the resource
 502      * @return resource handle
 503      * @throws OcException if failure
 504      */
 505     public static OcResourceHandle registerResource(
 506             String resourceUri,
 507             String resourceTypeName,
 508             String resourceInterface,
 509             EntityHandler entityHandler,
 510             EnumSet<ResourceProperty> resourcePropertySet) throws OcException {
 511         OcPlatform.initCheck();
 512
 513         int resProperty = 0;
 514
 515         for (ResourceProperty prop : ResourceProperty.values()) {
 516             if (resourcePropertySet.contains(prop))
 517                 resProperty |= prop.getValue();
 518         }
 519
 520         return OcPlatform.registerResource1(resourceUri,
 521                 resourceTypeName,
 522                 resourceInterface,
 523                 entityHandler,
 524                 resProperty);
 525     }
 526
 527     private static native OcResourceHandle registerResource1(
 528             String resourceUri,
 529             String resourceTypeName,
 530             String resourceInterface,
 531             EntityHandler entityHandler,
 532             int resourceProperty) throws OcException;
 533
 534     /**
 535      * Register Device Info
 536      *
 537      * @param ocDeviceInfo object containing all the device specific information
 538      * @throws OcException if failure
 539      */
 540     public static void registerDeviceInfo(
 541             OcDeviceInfo ocDeviceInfo) throws OcException {
 542         OcPlatform.initCheck();
 543         OcPlatform.registerDeviceInfo0(
 544                 ocDeviceInfo.getDeviceName()
 545         );
 546     }
 547
 548     private static native void registerDeviceInfo0(
 549             String deviceName
 550     ) throws OcException;
 551
 552     /**
 553      * Register Platform Info
 554      *
 555      * @param ocPlatformInfo object containing all the platform specific information
 556      * @throws OcException if failure
 557      */
 558     public static void registerPlatformInfo(
 559             OcPlatformInfo ocPlatformInfo) throws OcException {
 560         OcPlatform.initCheck();
 561         OcPlatform.registerPlatformInfo0(
 562                 ocPlatformInfo.getPlatformId(),
 563                 ocPlatformInfo.getManufacturerName(),
 564                 ocPlatformInfo.getManufacturerUrl(),
 565                 ocPlatformInfo.getModelNumber(),
 566                 ocPlatformInfo.getDateOfManufacture(),
 567                 ocPlatformInfo.getPlatformVersion(),
 568                 ocPlatformInfo.getOperatingSystemVersion(),
 569                 ocPlatformInfo.getHardwareVersion(),
 570                 ocPlatformInfo.getFirmwareVersion(),
 571                 ocPlatformInfo.getSupportUrl(),
 572                 ocPlatformInfo.getSystemTime()
 573         );
 574     }
 575
 576     private static native void registerPlatformInfo0(
 577             String platformId, String manufacturerName, String manufacturerUrl,
 578             String modelNumber, String dateOfManufacture, String platformVersion,
 579             String operatingSystemVersion, String hardwareVersion, String firmwareVersion,
 580             String supportUrl, String systemTime
 581     ) throws OcException;
 582
 583     /**
 584      * This API unregisters a resource with the server NOTE: This API applies to server side only.
 585      *
 586      * @param ocResourceHandle This is the resource handle which we which to unregister from the
 587      *                         server
 588      * @throws OcException if failure
 589      */
 590     public static void unregisterResource(
 591             OcResourceHandle ocResourceHandle) throws OcException {
 592         OcPlatform.initCheck();
 593         OcPlatform.unregisterResource0(ocResourceHandle);
 594     }
 595
 596     private static native void unregisterResource0(
 597             OcResourceHandle ocResourceHandle) throws OcException;
 598
 599
 600     /**
 601      * Add a resource to a collection resource
 602      *
 603      * @param ocResourceCollectionHandle handle to the collection resource
 604      * @param ocResourceHandle           handle to resource to be added to the collection resource
 605      * @throws OcException if failure
 606      */
 607     public static void bindResource(
 608             OcResourceHandle ocResourceCollectionHandle,
 609             OcResourceHandle ocResourceHandle) throws OcException {
 610         OcPlatform.initCheck();
 611         OcPlatform.bindResource0(ocResourceCollectionHandle, ocResourceHandle);
 612     }
 613
 614     private static native void bindResource0(
 615             OcResourceHandle ocResourceCollectionHandle,
 616             OcResourceHandle ocResourceHandle) throws OcException;
 617
 618     /**
 619      * Add multiple resources to a collection resource.
 620      *
 621      * @param ocResourceCollectionHandle handle to the collection resource
 622      * @param ocResourceHandleList       reference to list of resource handles to be added to the
 623      *                                   collection resource
 624      * @throws OcException if failure
 625      */
 626     public static void bindResources(
 627             OcResourceHandle ocResourceCollectionHandle,
 628             List<OcResourceHandle> ocResourceHandleList) throws OcException {
 629         OcPlatform.initCheck();
 630         OcPlatform.bindResources0(
 631                 ocResourceCollectionHandle,
 632                 ocResourceHandleList.toArray(
 633                         new OcResourceHandle[ocResourceHandleList.size()])
 634         );
 635     }
 636
 637     private static native void bindResources0(
 638             OcResourceHandle ocResourceCollectionHandle,
 639             OcResourceHandle[] ocResourceHandleArray) throws OcException;
 640
 641     /**
 642      * Unbind a resource from a collection resource.
 643      *
 644      * @param ocResourceCollectionHandle handle to the collection resource
 645      * @param ocResourceHandle           resource handle to be unbound from the collection resource
 646      * @throws OcException if failure
 647      */
 648     public static void unbindResource(
 649             OcResourceHandle ocResourceCollectionHandle,
 650             OcResourceHandle ocResourceHandle) throws OcException {
 651         OcPlatform.initCheck();
 652         OcPlatform.unbindResource0(ocResourceCollectionHandle, ocResourceHandle);
 653     }
 654
 655     private static native void unbindResource0(
 656             OcResourceHandle ocResourceCollectionHandle,
 657             OcResourceHandle ocResourceHandle) throws OcException;
 658
 659     /**
 660      * Unbind resources from a collection resource.
 661      *
 662      * @param ocResourceCollectionHandle Handle to the collection resource
 663      * @param ocResourceHandleList       List of resource handles to be unbound from the collection
 664      *                                   resource
 665      * @throws OcException if failure
 666      */
 667     public static void unbindResources(
 668             OcResourceHandle ocResourceCollectionHandle,
 669             List<OcResourceHandle> ocResourceHandleList) throws OcException {
 670         OcPlatform.initCheck();
 671         OcPlatform.unbindResources0(
 672                 ocResourceCollectionHandle,
 673                 ocResourceHandleList.toArray(
 674                         new OcResourceHandle[ocResourceHandleList.size()])
 675         );
 676     }
 677
 678     private static native void unbindResources0(
 679             OcResourceHandle ocResourceCollectionHandle,
 680             OcResourceHandle[] ocResourceHandleArray) throws OcException;
 681
 682     /**
 683      * Binds a type to a particular resource
 684      *
 685      * @param ocResourceHandle handle to the resource
 686      * @param resourceTypeName new typename to bind to the resource
 687      * @throws OcException if failure
 688      */
 689     public static void bindTypeToResource(
 690             OcResourceHandle ocResourceHandle,
 691             String resourceTypeName) throws OcException {
 692         OcPlatform.initCheck();
 693         OcPlatform.bindTypeToResource0(ocResourceHandle, resourceTypeName);
 694     }
 695
 696     private static native void bindTypeToResource0(
 697             OcResourceHandle ocResourceHandle,
 698             String resourceTypeName) throws OcException;
 699
 700     /**
 701      * Binds an interface to a particular resource
 702      *
 703      * @param ocResourceHandle      handle to the resource
 704      * @param resourceInterfaceName new interface to bind to the resource
 705      * @throws OcException if failure
 706      */
 707     public static void bindInterfaceToResource(
 708             OcResourceHandle ocResourceHandle,
 709             String resourceInterfaceName) throws OcException {
 710         OcPlatform.initCheck();
 711         OcPlatform.bindInterfaceToResource0(ocResourceHandle, resourceInterfaceName);
 712     }
 713
 714     private static native void bindInterfaceToResource0(
 715             OcResourceHandle ocResourceHandle,
 716             String resourceInterfaceName) throws OcException;
 717
 718     /**
 719      * Start Presence announcements.
 720      *
 721      * @param ttl time to live in seconds
 722      * @throws OcException if failure
 723      */
 724     public static void startPresence(int ttl) throws OcException {
 725         OcPlatform.initCheck();
 726         OcPlatform.startPresence0(ttl);
 727     }
 728
 729     private static native void startPresence0(int ttl) throws OcException;
 730
 731     /**
 732      * Stop Presence announcements.
 733      *
 734      * @throws OcException if failure
 735      */
 736     public static void stopPresence() throws OcException {
 737         OcPlatform.initCheck();
 738         OcPlatform.stopPresence0();
 739     }
 740
 741     private static native void stopPresence0() throws OcException;
 742
 743     /**
 744      * Subscribes to a server's presence change events. By making this subscription, every time a
 745      * server adds/removes/alters a resource, starts or is intentionally stopped
 746      *
 747      * @param host                The IP address/addressable name of the server to subscribe to
 748      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 749      * @param onPresenceListener  listener that will receive notifications/subscription events
 750      * @return a handle object that can be used to identify this subscription request. It can be
 751      * used to unsubscribe from these events in the future
 752      * @throws OcException if failure
 753      */
 754     public static OcPresenceHandle subscribePresence(
 755             String host,
 756             EnumSet<OcConnectivityType> connectivityTypeSet,
 757             OnPresenceListener onPresenceListener) throws OcException {
 758         OcPlatform.initCheck();
 759         int connTypeInt = 0;
 760
 761         for (OcConnectivityType connType : OcConnectivityType.values()) {
 762             if (connectivityTypeSet.contains(connType))
 763                 connTypeInt |= connType.getValue();
 764         }
 765         return OcPlatform.subscribePresence0(
 766                 host,
 767                 connTypeInt,
 768                 onPresenceListener
 769         );
 770     }
 771
 772     private static native OcPresenceHandle subscribePresence0(
 773             String host,
 774             int connectivityType,
 775             OnPresenceListener onPresenceListener) throws OcException;
 776
 777     /**
 778      * Subscribes to a server's presence change events. By making this subscription, every time a
 779      * server adds/removes/alters a resource, starts or is intentionally stopped
 780      *
 781      * @param host                The IP address/addressable name of the server to subscribe to
 782      * @param resourceType        a resource type specified as a filter for subscription events.
 783      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 784      * @param onPresenceListener  listener that will receive notifications/subscription events
 785      * @return a handle object that can be used to identify this subscription request. It can be
 786      * used to unsubscribe from these events in the future
 787      * @throws OcException if failure
 788      */
 789     public static OcPresenceHandle subscribePresence(
 790             String host,
 791             String resourceType,
 792             EnumSet<OcConnectivityType> connectivityTypeSet,
 793             OnPresenceListener onPresenceListener) throws OcException {
 794         OcPlatform.initCheck();
 795         int connTypeInt = 0;
 796
 797         for (OcConnectivityType connType : OcConnectivityType.values()) {
 798             if (connectivityTypeSet.contains(connType))
 799                 connTypeInt |= connType.getValue();
 800         }
 801         return OcPlatform.subscribePresence1(
 802                 host,
 803                 resourceType,
 804                 connTypeInt,
 805                 onPresenceListener);
 806     }
 807
 808     private static native OcPresenceHandle subscribePresence1(
 809             String host,
 810             String resourceType,
 811             int connectivityType,
 812             OnPresenceListener onPresenceListener) throws OcException;
 813
 814     /**
 815      * Unsubscribes from a previously subscribed server's presence events. Note that you may for
 816      * a short time still receive events from the server since it may take time for the
 817      * unsubscribe to take effect.
 818      *
 819      * @param ocPresenceHandle the handle object provided by the subscribePresence call that
 820      *                         identifies this subscription
 821      * @throws OcException if failure
 822      */
 823     public static void unsubscribePresence(
 824             OcPresenceHandle ocPresenceHandle) throws OcException {
 825         OcPlatform.initCheck();
 826         OcPlatform.unsubscribePresence0(ocPresenceHandle);
 827     }
 828
 829     private static native void unsubscribePresence0(
 830             OcPresenceHandle ocPresenceHandle) throws OcException;
 831
 832     /**
 833      * Creates a resource proxy object so that get/put/observe functionality can be used without
 834      * discovering the object in advance. Note that the consumer of this method needs to provide
 835      * all of the details required to correctly contact and observe the object. If the consumer
 836      * lacks any of this information, they should discover the resource object normally.
 837      * Additionally, you can only create this object if OcPlatform was initialized to be a Client
 838      * or Client/Server.
 839      *
 840      * @param host                a string containing a resolvable host address of the server holding
 841      *                            the resource
 842      * @param uri                 the rest of the resource's URI that will permit messages to be
 843      *                            properly routed.
 844      *                            Example: /a/light
 845      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 846      * @param isObservable        a boolean containing whether the resource supports observation
 847      * @param resourceTypeList    a collection of resource types implemented by the resource
 848      * @param interfaceList       a collection of interfaces that the resource supports/implements
 849      * @return new resource object
 850      * @throws OcException if failure
 851      */
 852     public static OcResource constructResourceObject(
 853             String host,
 854             String uri,
 855             EnumSet<OcConnectivityType> connectivityTypeSet,
 856             boolean isObservable,
 857             List<String> resourceTypeList,
 858             List<String> interfaceList) throws OcException {
 859         OcPlatform.initCheck();
 860         int connTypeInt = 0;
 861
 862         for (OcConnectivityType connType : OcConnectivityType.values()) {
 863             if (connectivityTypeSet.contains(connType))
 864                 connTypeInt |= connType.getValue();
 865         }
 866         return OcPlatform.constructResourceObject0(
 867                 host,
 868                 uri,
 869                 connTypeInt,
 870                 isObservable,
 871                 resourceTypeList.toArray(new String[resourceTypeList.size()]),
 872                 interfaceList.toArray(new String[interfaceList.size()])
 873         );
 874     }
 875
 876     private static native OcResource constructResourceObject0(
 877             String host,
 878             String uri,
 879             int connectivityType,
 880             boolean isObservable,
 881             String[] resourceTypes,
 882             String[] interfaces) throws OcException;
 883
 884     /**
 885      * Allows application entity handler to send response to an incoming request.
 886      *
 887      * @param ocResourceResponse resource response
 888      * @throws OcException if failure
 889      */
 890     public static void sendResponse(OcResourceResponse ocResourceResponse)
 891             throws OcException {
 892         OcPlatform.initCheck();
 893         OcPlatform.sendResponse0(ocResourceResponse);
 894     }
 895
 896     private static native void sendResponse0(OcResourceResponse ocResourceResponse)
 897             throws OcException;
 898
 899     /**
 900      * An OnResourceFoundListener can be registered via the OcPlatform.findResource call.
 901      * Event listeners are notified asynchronously
 902      */
 903     public interface OnResourceFoundListener {
 904         public void onResourceFound(OcResource resource);
 905     }
 906
 907     /**
 908      * An OnDeviceFoundListener can be registered via the OcPlatform.getDeviceInfo call.
 909      * Event listeners are notified asynchronously
 910      */
 911     public interface OnDeviceFoundListener {
 912         public void onDeviceFound(OcRepresentation ocRepresentation);
 913     }
 914
 915     /**
 916      * An OnPlatformFoundListener can be registered via the OcPlatform.getPlatformInfo call.
 917      * Event listeners are notified asynchronously
 918      */
 919     public interface OnPlatformFoundListener {
 920         public void onPlatformFound(OcRepresentation ocRepresentation);
 921     }
 922
 923     /**
 924      * An OnPresenceListener can be registered via the OcPlatform.subscribePresence call.
 925      * Event listeners are notified asynchronously
 926      */
 927     public interface OnPresenceListener {
 928         public void onPresence(OcPresenceStatus ocPresenceStatus, int nonce, String hostAddress);
 929     }
 930
 931     /**
 932      * An EntityHandler can be registered via the OcPlatform.registerResource call.
 933      * Event listeners are notified asynchronously
 934      */
 935     public interface EntityHandler {
 936         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest);
 937     }
 938
 939     private static void initCheck() {
 940         if (!sIsPlatformInitialized) {
 941             throw new IllegalStateException("OcPlatform must be configured by making a call to " +
 942                     "OcPlatform.Configure before any other API calls are permitted");
 943         }
 944     }
 945
 946     /**
 947      * Gets platform quality of service
 948      *
 949      * @return quality of service
 950      */
 951     public static QualityOfService getPlatformQualityOfService() {
 952         OcPlatform.initCheck();
 953         return sPlatformQualityOfService;
 954     }
 955 }