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                 ocDeviceInfo.getDeviceTypes().toArray(
 546                         new String[ocDeviceInfo.getDeviceTypes().size()]
 547                 )
 548         );
 549     }
 550
 551     private static native void registerDeviceInfo0(
 552             String deviceName,
 553             String[] deviceTypes
 554     ) throws OcException;
 555
 556     /**
 557      * Register Platform Info
 558      *
 559      * @param ocPlatformInfo object containing all the platform specific information
 560      * @throws OcException if failure
 561      */
 562     public static void registerPlatformInfo(
 563             OcPlatformInfo ocPlatformInfo) throws OcException {
 564         OcPlatform.initCheck();
 565         OcPlatform.registerPlatformInfo0(
 566                 ocPlatformInfo.getPlatformId(),
 567                 ocPlatformInfo.getManufacturerName(),
 568                 ocPlatformInfo.getManufacturerUrl(),
 569                 ocPlatformInfo.getModelNumber(),
 570                 ocPlatformInfo.getDateOfManufacture(),
 571                 ocPlatformInfo.getPlatformVersion(),
 572                 ocPlatformInfo.getOperatingSystemVersion(),
 573                 ocPlatformInfo.getHardwareVersion(),
 574                 ocPlatformInfo.getFirmwareVersion(),
 575                 ocPlatformInfo.getSupportUrl(),
 576                 ocPlatformInfo.getSystemTime()
 577         );
 578     }
 579
 580     private static native void registerPlatformInfo0(
 581             String platformId, String manufacturerName, String manufacturerUrl,
 582             String modelNumber, String dateOfManufacture, String platformVersion,
 583             String operatingSystemVersion, String hardwareVersion, String firmwareVersion,
 584             String supportUrl, String systemTime
 585     ) throws OcException;
 586
 587     /**
 588      * This API unregisters a resource with the server NOTE: This API applies to server side only.
 589      *
 590      * @param ocResourceHandle This is the resource handle which we which to unregister from the
 591      *                         server
 592      * @throws OcException if failure
 593      */
 594     public static void unregisterResource(
 595             OcResourceHandle ocResourceHandle) throws OcException {
 596         OcPlatform.initCheck();
 597         OcPlatform.unregisterResource0(ocResourceHandle);
 598     }
 599
 600     private static native void unregisterResource0(
 601             OcResourceHandle ocResourceHandle) throws OcException;
 602
 603
 604     /**
 605      * Add a resource to a collection resource
 606      *
 607      * @param ocResourceCollectionHandle handle to the collection resource
 608      * @param ocResourceHandle           handle to resource to be added to the collection resource
 609      * @throws OcException if failure
 610      */
 611     public static void bindResource(
 612             OcResourceHandle ocResourceCollectionHandle,
 613             OcResourceHandle ocResourceHandle) throws OcException {
 614         OcPlatform.initCheck();
 615         OcPlatform.bindResource0(ocResourceCollectionHandle, ocResourceHandle);
 616     }
 617
 618     private static native void bindResource0(
 619             OcResourceHandle ocResourceCollectionHandle,
 620             OcResourceHandle ocResourceHandle) throws OcException;
 621
 622     /**
 623      * Add multiple resources to a collection resource.
 624      *
 625      * @param ocResourceCollectionHandle handle to the collection resource
 626      * @param ocResourceHandleList       reference to list of resource handles to be added to the
 627      *                                   collection resource
 628      * @throws OcException if failure
 629      */
 630     public static void bindResources(
 631             OcResourceHandle ocResourceCollectionHandle,
 632             List<OcResourceHandle> ocResourceHandleList) throws OcException {
 633         OcPlatform.initCheck();
 634         OcPlatform.bindResources0(
 635                 ocResourceCollectionHandle,
 636                 ocResourceHandleList.toArray(
 637                         new OcResourceHandle[ocResourceHandleList.size()])
 638         );
 639     }
 640
 641     private static native void bindResources0(
 642             OcResourceHandle ocResourceCollectionHandle,
 643             OcResourceHandle[] ocResourceHandleArray) throws OcException;
 644
 645     /**
 646      * Unbind a resource from a collection resource.
 647      *
 648      * @param ocResourceCollectionHandle handle to the collection resource
 649      * @param ocResourceHandle           resource handle to be unbound from the collection resource
 650      * @throws OcException if failure
 651      */
 652     public static void unbindResource(
 653             OcResourceHandle ocResourceCollectionHandle,
 654             OcResourceHandle ocResourceHandle) throws OcException {
 655         OcPlatform.initCheck();
 656         OcPlatform.unbindResource0(ocResourceCollectionHandle, ocResourceHandle);
 657     }
 658
 659     private static native void unbindResource0(
 660             OcResourceHandle ocResourceCollectionHandle,
 661             OcResourceHandle ocResourceHandle) throws OcException;
 662
 663     /**
 664      * Unbind resources from a collection resource.
 665      *
 666      * @param ocResourceCollectionHandle Handle to the collection resource
 667      * @param ocResourceHandleList       List of resource handles to be unbound from the collection
 668      *                                   resource
 669      * @throws OcException if failure
 670      */
 671     public static void unbindResources(
 672             OcResourceHandle ocResourceCollectionHandle,
 673             List<OcResourceHandle> ocResourceHandleList) throws OcException {
 674         OcPlatform.initCheck();
 675         OcPlatform.unbindResources0(
 676                 ocResourceCollectionHandle,
 677                 ocResourceHandleList.toArray(
 678                         new OcResourceHandle[ocResourceHandleList.size()])
 679         );
 680     }
 681
 682     private static native void unbindResources0(
 683             OcResourceHandle ocResourceCollectionHandle,
 684             OcResourceHandle[] ocResourceHandleArray) throws OcException;
 685
 686     /**
 687      * Binds a type to a particular resource
 688      *
 689      * @param ocResourceHandle handle to the resource
 690      * @param resourceTypeName new typename to bind to the resource
 691      * @throws OcException if failure
 692      */
 693     public static void bindTypeToResource(
 694             OcResourceHandle ocResourceHandle,
 695             String resourceTypeName) throws OcException {
 696         OcPlatform.initCheck();
 697         OcPlatform.bindTypeToResource0(ocResourceHandle, resourceTypeName);
 698     }
 699
 700     private static native void bindTypeToResource0(
 701             OcResourceHandle ocResourceHandle,
 702             String resourceTypeName) throws OcException;
 703
 704     /**
 705      * Binds an interface to a particular resource
 706      *
 707      * @param ocResourceHandle      handle to the resource
 708      * @param resourceInterfaceName new interface to bind to the resource
 709      * @throws OcException if failure
 710      */
 711     public static void bindInterfaceToResource(
 712             OcResourceHandle ocResourceHandle,
 713             String resourceInterfaceName) throws OcException {
 714         OcPlatform.initCheck();
 715         OcPlatform.bindInterfaceToResource0(ocResourceHandle, resourceInterfaceName);
 716     }
 717
 718     private static native void bindInterfaceToResource0(
 719             OcResourceHandle ocResourceHandle,
 720             String resourceInterfaceName) throws OcException;
 721
 722     /**
 723      * Start Presence announcements.
 724      *
 725      * @param ttl time to live in seconds
 726      * @throws OcException if failure
 727      */
 728     public static void startPresence(int ttl) throws OcException {
 729         OcPlatform.initCheck();
 730         OcPlatform.startPresence0(ttl);
 731     }
 732
 733     private static native void startPresence0(int ttl) throws OcException;
 734
 735     /**
 736      * Stop Presence announcements.
 737      *
 738      * @throws OcException if failure
 739      */
 740     public static void stopPresence() throws OcException {
 741         OcPlatform.initCheck();
 742         OcPlatform.stopPresence0();
 743     }
 744
 745     private static native void stopPresence0() throws OcException;
 746
 747     /**
 748      * Subscribes to a server's presence change events. By making this subscription, every time a
 749      * server adds/removes/alters a resource, starts or is intentionally stopped
 750      *
 751      * @param host                The IP address/addressable name of the server to subscribe to
 752      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 753      * @param onPresenceListener  listener that will receive notifications/subscription events
 754      * @return a handle object that can be used to identify this subscription request. It can be
 755      * used to unsubscribe from these events in the future
 756      * @throws OcException if failure
 757      */
 758     public static OcPresenceHandle subscribePresence(
 759             String host,
 760             EnumSet<OcConnectivityType> connectivityTypeSet,
 761             OnPresenceListener onPresenceListener) throws OcException {
 762         OcPlatform.initCheck();
 763         int connTypeInt = 0;
 764
 765         for (OcConnectivityType connType : OcConnectivityType.values()) {
 766             if (connectivityTypeSet.contains(connType))
 767                 connTypeInt |= connType.getValue();
 768         }
 769         return OcPlatform.subscribePresence0(
 770                 host,
 771                 connTypeInt,
 772                 onPresenceListener
 773         );
 774     }
 775
 776     private static native OcPresenceHandle subscribePresence0(
 777             String host,
 778             int connectivityType,
 779             OnPresenceListener onPresenceListener) throws OcException;
 780
 781     /**
 782      * Subscribes to a server's presence change events. By making this subscription, every time a
 783      * server adds/removes/alters a resource, starts or is intentionally stopped
 784      *
 785      * @param host                The IP address/addressable name of the server to subscribe to
 786      * @param resourceType        a resource type specified as a filter for subscription events.
 787      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 788      * @param onPresenceListener  listener that will receive notifications/subscription events
 789      * @return a handle object that can be used to identify this subscription request. It can be
 790      * used to unsubscribe from these events in the future
 791      * @throws OcException if failure
 792      */
 793     public static OcPresenceHandle subscribePresence(
 794             String host,
 795             String resourceType,
 796             EnumSet<OcConnectivityType> connectivityTypeSet,
 797             OnPresenceListener onPresenceListener) throws OcException {
 798         OcPlatform.initCheck();
 799         int connTypeInt = 0;
 800
 801         for (OcConnectivityType connType : OcConnectivityType.values()) {
 802             if (connectivityTypeSet.contains(connType))
 803                 connTypeInt |= connType.getValue();
 804         }
 805         return OcPlatform.subscribePresence1(
 806                 host,
 807                 resourceType,
 808                 connTypeInt,
 809                 onPresenceListener);
 810     }
 811
 812     private static native OcPresenceHandle subscribePresence1(
 813             String host,
 814             String resourceType,
 815             int connectivityType,
 816             OnPresenceListener onPresenceListener) throws OcException;
 817
 818     /**
 819      * Unsubscribes from a previously subscribed server's presence events. Note that you may for
 820      * a short time still receive events from the server since it may take time for the
 821      * unsubscribe to take effect.
 822      *
 823      * @param ocPresenceHandle the handle object provided by the subscribePresence call that
 824      *                         identifies this subscription
 825      * @throws OcException if failure
 826      */
 827     public static void unsubscribePresence(
 828             OcPresenceHandle ocPresenceHandle) throws OcException {
 829         OcPlatform.initCheck();
 830         OcPlatform.unsubscribePresence0(ocPresenceHandle);
 831     }
 832
 833     private static native void unsubscribePresence0(
 834             OcPresenceHandle ocPresenceHandle) throws OcException;
 835
 836     /**
 837      * Creates a resource proxy object so that get/put/observe functionality can be used without
 838      * discovering the object in advance. Note that the consumer of this method needs to provide
 839      * all of the details required to correctly contact and observe the object. If the consumer
 840      * lacks any of this information, they should discover the resource object normally.
 841      * Additionally, you can only create this object if OcPlatform was initialized to be a Client
 842      * or Client/Server.
 843      *
 844      * @param host                a string containing a resolvable host address of the server holding
 845      *                            the resource
 846      * @param uri                 the rest of the resource's URI that will permit messages to be
 847      *                            properly routed.
 848      *                            Example: /a/light
 849      * @param connectivityTypeSet Set of types of connectivity. Example: IP
 850      * @param isObservable        a boolean containing whether the resource supports observation
 851      * @param resourceTypeList    a collection of resource types implemented by the resource
 852      * @param interfaceList       a collection of interfaces that the resource supports/implements
 853      * @return new resource object
 854      * @throws OcException if failure
 855      */
 856     public static OcResource constructResourceObject(
 857             String host,
 858             String uri,
 859             EnumSet<OcConnectivityType> connectivityTypeSet,
 860             boolean isObservable,
 861             List<String> resourceTypeList,
 862             List<String> interfaceList) throws OcException {
 863         OcPlatform.initCheck();
 864         int connTypeInt = 0;
 865
 866         for (OcConnectivityType connType : OcConnectivityType.values()) {
 867             if (connectivityTypeSet.contains(connType))
 868                 connTypeInt |= connType.getValue();
 869         }
 870         return OcPlatform.constructResourceObject0(
 871                 host,
 872                 uri,
 873                 connTypeInt,
 874                 isObservable,
 875                 resourceTypeList.toArray(new String[resourceTypeList.size()]),
 876                 interfaceList.toArray(new String[interfaceList.size()])
 877         );
 878     }
 879
 880     private static native OcResource constructResourceObject0(
 881             String host,
 882             String uri,
 883             int connectivityType,
 884             boolean isObservable,
 885             String[] resourceTypes,
 886             String[] interfaces) throws OcException;
 887
 888     /**
 889      * Allows application entity handler to send response to an incoming request.
 890      *
 891      * @param ocResourceResponse resource response
 892      * @throws OcException if failure
 893      */
 894     public static void sendResponse(OcResourceResponse ocResourceResponse)
 895             throws OcException {
 896         OcPlatform.initCheck();
 897         OcPlatform.sendResponse0(ocResourceResponse);
 898     }
 899
 900     private static native void sendResponse0(OcResourceResponse ocResourceResponse)
 901             throws OcException;
 902
 903     /**
 904      *  Method to find all devices which are eligible for direct pairing and return the list.
 905      *
 906      *  @param timeout timeout for discovering direct pair devices.
 907      *  @param FindDirectPairingListener Callback function, which will receive the list of direct
 908      *                                  pairable devices.
 909      *  @throws OcException
 910      */
 911    public static native void findDirectPairingDevices(int timeout,
 912             FindDirectPairingListener onFindDirectPairingListener) throws OcException;
 913
 914     /**
 915      *  Method to get list of all paired devices for a given device.
 916      *
 917      *  @param GetDirectPairedListener Callback function, which will receive the list of direct
 918      *                                 paired devices.
 919      *  @throws OcException
 920      */
 921     public native void getDirectPairedDevices(GetDirectPairedListener onGetDirectPairedListener)
 922         throws OcException;
 923
 924     /**
 925      *  Method to perform direct pairing between two devices.
 926      *
 927      *  @param peer  Target peer
 928      *  @param prmType Pairing Method to be used for Pairing
 929      *  @param pin pin
 930      *  @param DirectPairingListener Callback function, which will be called after
 931      *                                      completion of direct pairing.
 932      *  @throws OcException
 933      */
 934     public static void doDirectPairing(
 935             OcDirectPairDevice peer,
 936             OcPrmType prmType,
 937             String pin,
 938             DirectPairingListener onDirectPairingListener) throws OcException {
 939
 940         OcPlatform.doDirectPairing0(
 941                 peer,
 942                 prmType.getValue(),
 943                 pin,
 944                 onDirectPairingListener
 945                 );
 946     }
 947
 948     private static native void doDirectPairing0(OcDirectPairDevice peer,
 949             int pmSel, String pinNumber, DirectPairingListener onDirectPairingListener)
 950     throws OcException;
 951
 952     /**
 953      * An FindDirectPairingListener can be registered via the OcPlatform.findDirectPairingDevices call.
 954      * Event listeners are notified asynchronously
 955      */
 956     public interface FindDirectPairingListener {
 957         public void onFindDirectPairingListener(List<OcDirectPairDevice> ocPairedDeviceList);
 958     }
 959
 960     /**
 961      * Listerner to Get List of already Direct Paired devices.
 962      * An GetDirectPairedListener can be registered via the OcPlatform.getDirectPairedDevices call.
 963      * Event listeners are notified asynchronously
 964      */
 965     public interface GetDirectPairedListener {
 966         public void onGetDirectPairedListener(List<OcDirectPairDevice> ocPairedDeviceList);
 967     }
 968
 969     /**
 970      * Listner to get result of doDirectPairing.
 971      * An DirectPairingListener can be registered via the OcPlatform.doDirectPairing call.
 972      * Event listeners are notified asynchronously
 973      */
 974     public interface DirectPairingListener {
 975         public void onDirectPairingListener(String devId, int result);
 976     }
 977
 978     /**
 979      * An OnResourceFoundListener can be registered via the OcPlatform.findResource call.
 980      * Event listeners are notified asynchronously
 981      */
 982     public interface OnResourceFoundListener {
 983         public void onResourceFound(OcResource resource);
 984     }
 985
 986     /**
 987      * An OnDeviceFoundListener can be registered via the OcPlatform.getDeviceInfo call.
 988      * Event listeners are notified asynchronously
 989      */
 990     public interface OnDeviceFoundListener {
 991         public void onDeviceFound(OcRepresentation ocRepresentation);
 992     }
 993
 994     /**
 995      * An OnPlatformFoundListener can be registered via the OcPlatform.getPlatformInfo call.
 996      * Event listeners are notified asynchronously
 997      */
 998     public interface OnPlatformFoundListener {
 999         public void onPlatformFound(OcRepresentation ocRepresentation);
1000     }
1001
1002     /**
1003      * An OnPresenceListener can be registered via the OcPlatform.subscribePresence call.
1004      * Event listeners are notified asynchronously
1005      */
1006     public interface OnPresenceListener {
1007         public void onPresence(OcPresenceStatus ocPresenceStatus, int nonce, String hostAddress);
1008     }
1009
1010     /**
1011      * An EntityHandler can be registered via the OcPlatform.registerResource call.
1012      * Event listeners are notified asynchronously
1013      */
1014     public interface EntityHandler {
1015         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest);
1016     }
1017
1018     private static void initCheck() {
1019         if (!sIsPlatformInitialized) {
1020             throw new IllegalStateException("OcPlatform must be configured by making a call to " +
1021                     "OcPlatform.Configure before any other API calls are permitted");
1022         }
1023     }
1024
1025     /**
1026      * Gets platform quality of service
1027      *
1028      * @return quality of service
1029      */
1030     public static QualityOfService getPlatformQualityOfService() {
1031         OcPlatform.initCheck();
1032         return sPlatformQualityOfService;
1033     }
1034 }