Implementation of JNI for publishing resource to RD
[platform/upstream/iotivity.git] / 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      * API to publish resource to remote resource-directory.
954      *
955      * @param host                        Host Address of a service to publish resource.
956      * @param connectivityTypeSet         Set of types of connectivity. Example: IP
957      * @param onPublishResourceListener   Handles events, success states and failure states.
958      * @throws OcException if failure
959      */
960     public static void publishResourceToRD(
961             String host,
962             EnumSet<OcConnectivityType> connectivityTypeSet,
963             OnPublishResourceListener onPublishResourceListener) throws OcException {
964         OcPlatform.initCheck();
965
966         int connTypeInt = 0;
967
968         for (OcConnectivityType connType : OcConnectivityType.values()) {
969             if (connectivityTypeSet.contains(connType)) {
970                 connTypeInt |= connType.getValue();
971             }
972         }
973
974         OcPlatform.publishResourceToRD0(
975                 host,
976                 connTypeInt,
977                 onPublishResourceListener,
978                 sPlatformQualityOfService.getValue()
979         );
980     }
981
982     /**
983      * API to publish resource to remote resource-directory.
984      *
985      * @param host                        Host Address of a service to publish resource.
986      * @param connectivityTypeSet         Set of types of connectivity. Example: IP
987      * @param onPublishResourceListener   Handles events, success states and failure states.
988      * @param qualityOfService            the quality of communication.
989      * @throws OcException if failure
990      */
991     public static void publishResourceToRD(
992             String host,
993             EnumSet<OcConnectivityType> connectivityTypeSet,
994             OnPublishResourceListener onPublishResourceListener,
995             QualityOfService qualityOfService) throws OcException {
996         OcPlatform.initCheck();
997
998         int connTypeInt = 0;
999
1000         for (OcConnectivityType connType : OcConnectivityType.values()) {
1001             if (connectivityTypeSet.contains(connType)) {
1002                 connTypeInt |= connType.getValue();
1003             }
1004         }
1005
1006         OcPlatform.publishResourceToRD0(
1007                 host,
1008                 connTypeInt,
1009                 onPublishResourceListener,
1010                 qualityOfService.getValue()
1011         );
1012     }
1013
1014     private static native void publishResourceToRD0(
1015             String host,
1016             int connectivityType,
1017             OnPublishResourceListener onPublishResourceListener,
1018             int qualityOfService) throws OcException;
1019
1020     /**
1021      * API to publish resource to remote resource-directory.
1022      *
1023      * @param host                        Host Address of a service to publish resource.
1024      * @param connectivityTypeSet         Set of types of connectivity. Example: IP
1025      * @param ocResourceHandleList        reference to list of resource handles to be published.
1026      * @param onPublishResourceListener   Handles events, success states and failure states.
1027      * @throws OcException if failure
1028      */
1029     public static void publishResourceToRD(
1030             String host,
1031             EnumSet<OcConnectivityType> connectivityTypeSet,
1032             List<OcResourceHandle> ocResourceHandleList,
1033             OnPublishResourceListener onPublishResourceListener) throws OcException {
1034         OcPlatform.initCheck();
1035
1036         int connTypeInt = 0;
1037
1038         for (OcConnectivityType connType : OcConnectivityType.values()) {
1039             if (connectivityTypeSet.contains(connType)) {
1040                 connTypeInt |= connType.getValue();
1041             }
1042         }
1043
1044         OcPlatform.publishResourceToRD1(
1045                 host,
1046                 connTypeInt,
1047                 ocResourceHandleList.toArray(
1048                         new OcResourceHandle[ocResourceHandleList.size()]),
1049                 onPublishResourceListener,
1050                 sPlatformQualityOfService.getValue()
1051         );
1052     }
1053
1054     /**
1055      * API to publish resource to remote resource-directory.
1056      *
1057      * @param host                        Host IP Address of a service to publish resource.
1058      * @param connectivityTypeSet         Set of types of connectivity. Example: IP
1059      * @param ocResourceHandleList        reference to list of resource handles to be published.
1060      * @param onPublishResourceListener   Handles events, success states and failure states.
1061      * @param qualityOfService            the quality of communication
1062      * @throws OcException if failure
1063      */
1064     public static void publishResourceToRD(
1065             String host,
1066             EnumSet<OcConnectivityType> connectivityTypeSet,
1067             List<OcResourceHandle> ocResourceHandleList,
1068             OnPublishResourceListener onPublishResourceListener,
1069             QualityOfService qualityOfService) throws OcException {
1070         OcPlatform.initCheck();
1071
1072         int connTypeInt = 0;
1073
1074         for (OcConnectivityType connType : OcConnectivityType.values()) {
1075             if (connectivityTypeSet.contains(connType)) {
1076                 connTypeInt |= connType.getValue();
1077             }
1078         }
1079
1080         OcPlatform.publishResourceToRD1(
1081             host,
1082             connTypeInt,
1083             ocResourceHandleList.toArray(
1084                     new OcResourceHandle[ocResourceHandleList.size()]),
1085             onPublishResourceListener,
1086             qualityOfService.getValue()
1087         );
1088     }
1089
1090     private static native void publishResourceToRD1(
1091             String host,
1092             int connectivityType,
1093             OcResourceHandle[] ocResourceHandleArray,
1094             OnPublishResourceListener onPublishResourceListener,
1095             int qualityOfService) throws OcException;
1096
1097     /**
1098      * An OnPublishResourceListener can be registered via the OcPlatform.publishResourceToRD call.
1099      * Event listeners are notified asynchronously
1100      */
1101     public interface OnPublishResourceListener {
1102         public void onPublishResourceCompleted(OcRepresentation ocRepresentation);
1103         public void onPublishResourceFailed(Throwable ex);
1104     }
1105
1106     /**
1107      * An FindDirectPairingListener can be registered via the OcPlatform.findDirectPairingDevices call.
1108      * Event listeners are notified asynchronously
1109      */
1110     public interface FindDirectPairingListener {
1111         public void onFindDirectPairingListener(List<OcDirectPairDevice> ocPairedDeviceList);
1112     }
1113
1114     /**
1115      * Listerner to Get List of already Direct Paired devices.
1116      * An GetDirectPairedListener can be registered via the OcPlatform.getDirectPairedDevices call.
1117      * Event listeners are notified asynchronously
1118      */
1119     public interface GetDirectPairedListener {
1120         public void onGetDirectPairedListener(List<OcDirectPairDevice> ocPairedDeviceList);
1121     }
1122
1123     /**
1124      * Listner to get result of doDirectPairing.
1125      * An DirectPairingListener can be registered via the OcPlatform.doDirectPairing call.
1126      * Event listeners are notified asynchronously
1127      */
1128     public interface DirectPairingListener {
1129         public void onDirectPairingListener(String devId, int result);
1130     }
1131
1132     /**
1133      * An OnResourceFoundListener can be registered via the OcPlatform.findResource call.
1134      * Event listeners are notified asynchronously
1135      */
1136     public interface OnResourceFoundListener {
1137         public void onResourceFound(OcResource resource);
1138         public void onFindResourceFailed(Throwable ex, String uri);
1139     }
1140
1141     /**
1142      * An OnDeviceFoundListener can be registered via the OcPlatform.getDeviceInfo call.
1143      * Event listeners are notified asynchronously
1144      */
1145     public interface OnDeviceFoundListener {
1146         public void onDeviceFound(OcRepresentation ocRepresentation);
1147     }
1148
1149     /**
1150      * An OnPlatformFoundListener can be registered via the OcPlatform.getPlatformInfo call.
1151      * Event listeners are notified asynchronously
1152      */
1153     public interface OnPlatformFoundListener {
1154         public void onPlatformFound(OcRepresentation ocRepresentation);
1155     }
1156
1157     /**
1158      * An OnPresenceListener can be registered via the OcPlatform.subscribePresence call.
1159      * Event listeners are notified asynchronously
1160      */
1161     public interface OnPresenceListener {
1162         public void onPresence(OcPresenceStatus ocPresenceStatus, int nonce, String hostAddress);
1163     }
1164
1165     /**
1166      * An EntityHandler can be registered via the OcPlatform.registerResource call.
1167      * Event listeners are notified asynchronously
1168      */
1169     public interface EntityHandler {
1170         public EntityHandlerResult handleEntity(OcResourceRequest ocResourceRequest);
1171     }
1172
1173     private static void initCheck() {
1174         if (!sIsPlatformInitialized) {
1175             throw new IllegalStateException("OcPlatform must be configured by making a call to " +
1176                     "OcPlatform.Configure before any other API calls are permitted");
1177         }
1178     }
1179
1180     /**
1181      * Gets platform quality of service
1182      *
1183      * @return quality of service
1184      */
1185     public static QualityOfService getPlatformQualityOfService() {
1186         OcPlatform.initCheck();
1187         return sPlatformQualityOfService;
1188     }
1189 }