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