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