Removed extra space
[iotivity.git] / java / common / src / main / java / org / iotivity / base / OcResource.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 java.util.EnumSet;
26 import java.util.List;
27 import java.util.Map;
28
29 /**
30  * OcResource represents an OC resource. A resource could be a light controller, temperature sensor,
31  * smoke detector, etc. A resource comes with a well-defined contract or interface onto which you
32  * can perform different operations, such as turning on the light, getting the current temperature
33  * or subscribing for event notifications from the smoke detector. A resource can be composed of
34  * one or more resources.
35  */
36 public class OcResource {
37     public static final String CREATED_URI_KEY = "createduri";
38
39     private OcResource(long nativeHandle) {
40         this.mNativeHandle = nativeHandle;
41     }
42
43     /**
44      * Method to get the attributes of a resource.
45      *
46      * @param queryParamsMap map which can have the query parameter name and value
47      * @param onGetListener  The event handler will be invoked with a map of attribute name and
48      *                       values. The event handler will also have the result from this Get
49      *                       operation This will have error codes
50      * @throws OcException if failure
51      */
52     public native void get(Map<String, String> queryParamsMap,
53                            OnGetListener onGetListener) throws OcException;
54
55     /**
56      * Method to get the attributes of a resource.
57      *
58      * @param queryParamsMap   map which can have the query parameter name and value
59      * @param onGetListener    The event handler will be invoked with a map of attribute name and
60      *                         values. The event handler will also have the result from this Get
61      *                         operation This will have error codes
62      * @param qualityOfService the quality of communication
63      * @throws OcException if failure
64      */
65     public void get(Map<String, String> queryParamsMap,
66                     OnGetListener onGetListener,
67                     QualityOfService qualityOfService) throws OcException {
68
69         if (qualityOfService == null) {
70             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
71         }
72
73         this.get1(queryParamsMap, onGetListener, qualityOfService.getValue());
74     }
75
76     private native void get1(Map<String, String> queryParamsMap,
77                              OnGetListener onGetListener,
78                              int qualityOfService) throws OcException;
79
80     /**
81      * Method to get the attributes of a resource.
82      *
83      * @param resourceType      resourceType of the resource to operate on
84      * @param resourceInterface interface type of the resource to operate on
85      * @param queryParamsMap    map which can have the query parameter name and value
86      * @param onGetListener     The event handler will be invoked with a map of attribute name and
87      *                          values. The event handler will also have the result from this Get
88      *                          operation This will have error codes
89      * @throws OcException if failure
90      */
91     public void get(String resourceType,
92                     String resourceInterface,
93                     Map<String, String> queryParamsMap,
94                     OnGetListener onGetListener) throws OcException {
95         this.get2(
96                 resourceType,
97                 resourceInterface,
98                 queryParamsMap,
99                 onGetListener);
100     }
101
102     private native void get2(String resourceType,
103                              String resourceInterface,
104                              Map<String, String> queryParamsMap,
105                              OnGetListener onGetListener) throws OcException;
106
107     /**
108      * Method to get the attributes of a resource.
109      *
110      * @param resourceType      resourceType of the resource to operate on
111      * @param resourceInterface interface type of the resource to operate on
112      * @param queryParamsMap    map which can have the query parameter name and value
113      * @param onGetListener     The event handler will be invoked with a map of attribute name and
114      *                          values. The event handler will also have the result from this Get
115      *                          operation This will have error codes
116      * @param qualityOfService  the quality of communication
117      * @throws OcException if failure
118      */
119     public void get(String resourceType,
120                     String resourceInterface,
121                     Map<String, String> queryParamsMap,
122                     OnGetListener onGetListener,
123                     QualityOfService qualityOfService) throws OcException {
124
125         if (qualityOfService == null) {
126             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
127         }
128
129         this.get3(
130                 resourceType,
131                 resourceInterface,
132                 queryParamsMap,
133                 onGetListener,
134                 qualityOfService.getValue());
135     }
136
137     private native void get3(String resourceType,
138                              String resourceInterface,
139                              Map<String, String> queryParamsMap,
140                              OnGetListener onGetListener,
141                              int qualityOfService) throws OcException;
142
143     /**
144      * Method to set the representation of a resource (via PUT)
145      *
146      * @param representation representation of the resource
147      * @param queryParamsMap Map which can have the query parameter name and value
148      * @param onPutListener  event handler The event handler will be invoked with a map of attribute
149      *                       name and values.
150      * @throws OcException if failure
151      */
152     public native void put(OcRepresentation representation,
153                            Map<String, String> queryParamsMap,
154                            OnPutListener onPutListener) throws OcException;
155
156     /**
157      * Method to set the representation of a resource (via PUT)
158      *
159      * @param ocRepresentation representation of the resource
160      * @param queryParamsMap   Map which can have the query parameter name and value
161      * @param onPutListener    event handler The event handler will be invoked with a map of
162      *                         attribute name and values.
163      * @param qualityOfService the quality of communication
164      * @throws OcException if failure
165      */
166     public void put(OcRepresentation ocRepresentation,
167                     Map<String, String> queryParamsMap,
168                     OnPutListener onPutListener,
169                     QualityOfService qualityOfService) throws OcException {
170
171         if (qualityOfService == null) {
172             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
173         }
174
175         this.put1(
176                 ocRepresentation,
177                 queryParamsMap,
178                 onPutListener,
179                 qualityOfService.getValue());
180     }
181
182     private native void put1(OcRepresentation ocRepresentation,
183                              Map<String, String> queryParamsMap,
184                              OnPutListener onPutListener,
185                              int qualityOfService) throws OcException;
186
187     /**
188      * Method to set the representation of a resource (via PUT)
189      *
190      * @param resourceType      resource type of the resource to operate on
191      * @param resourceInterface interface type of the resource to operate on
192      * @param ocRepresentation  representation of the resource
193      * @param queryParamsMap    Map which can have the query parameter name and value
194      * @param onPutListener     event handler The event handler will be invoked with a map of
195      *                          attribute name and values.
196      * @throws OcException if failure
197      */
198     public void put(String resourceType,
199                     String resourceInterface,
200                     OcRepresentation ocRepresentation,
201                     Map<String, String> queryParamsMap,
202                     OnPutListener onPutListener) throws OcException {
203         this.put2(
204                 resourceType,
205                 resourceInterface,
206                 ocRepresentation,
207                 queryParamsMap,
208                 onPutListener);
209     }
210
211     private native void put2(String resourceType,
212                              String resourceInterface,
213                              OcRepresentation ocRepresentation,
214                              Map<String, String> queryParamsMap,
215                              OnPutListener onPutListener) throws OcException;
216
217     /**
218      * Method to set the representation of a resource (via PUT)
219      *
220      * @param resourceType      resource type of the resource to operate on
221      * @param resourceInterface interface type of the resource to operate on
222      * @param ocRepresentation  representation of the resource
223      * @param queryParamsMap    Map which can have the query parameter name and value
224      * @param onPutListener     event handler The event handler will be invoked with a map of
225      *                          attribute name and values.
226      * @param qualityOfService  the quality of communication
227      * @throws OcException if failure
228      */
229     public void put(String resourceType,
230                     String resourceInterface,
231                     OcRepresentation ocRepresentation,
232                     Map<String, String> queryParamsMap,
233                     OnPutListener onPutListener,
234                     QualityOfService qualityOfService) throws OcException {
235
236         if (qualityOfService == null) {
237             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
238         }
239
240         this.put3(
241                 resourceType,
242                 resourceInterface,
243                 ocRepresentation,
244                 queryParamsMap,
245                 onPutListener,
246                 qualityOfService.getValue());
247     }
248
249     private native void put3(String resourceType,
250                              String resourceInterface,
251                              OcRepresentation ocRepresentation,
252                              Map<String, String> queryParamsMap,
253                              OnPutListener onPutListener,
254                              int qualityOfService) throws OcException;
255
256     /**
257      * Method to POST on a resource
258      *
259      * @param ocRepresentation representation of the resource
260      * @param queryParamsMap   Map which can have the query parameter name and value
261      * @param onPostListener   event handler The event handler will be invoked with a map of
262      *                         attribute name and values.
263      * @throws OcException if failure
264      */
265     public native void post(OcRepresentation ocRepresentation,
266                             Map<String, String> queryParamsMap,
267                             OnPostListener onPostListener) throws OcException;
268
269     /**
270      * Method to POST on a resource
271      *
272      * @param ocRepresentation representation of the resource
273      * @param queryParamsMap   Map which can have the query parameter name and value
274      * @param onPostListener   event handler The event handler will be invoked with a map of
275      *                         attribute name and values.
276      * @param qualityOfService the quality of communication
277      * @throws OcException if failure
278      */
279     public void post(OcRepresentation ocRepresentation,
280                      Map<String, String> queryParamsMap,
281                      OnPostListener onPostListener,
282                      QualityOfService qualityOfService) throws OcException {
283
284         if (qualityOfService == null) {
285             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
286         }
287
288         this.post1(
289                 ocRepresentation,
290                 queryParamsMap,
291                 onPostListener,
292                 qualityOfService.getValue());
293     }
294
295     private native void post1(OcRepresentation ocRepresentation,
296                               Map<String, String> queryParamsMap,
297                               OnPostListener onPostListener,
298                               int qualityOfService) throws OcException;
299
300     /**
301      * Method to POST on a resource
302      *
303      * @param resourceType      resource type of the resource to operate on
304      * @param resourceInterface interface type of the resource to operate on
305      * @param ocRepresentation  representation of the resource
306      * @param queryParamsMap    Map which can have the query parameter name and value
307      * @param onPostListener    event handler The event handler will be invoked with a map of
308      *                          attribute name and values.
309      * @throws OcException if failure
310      */
311     public void post(String resourceType,
312                      String resourceInterface,
313                      OcRepresentation ocRepresentation,
314                      Map<String, String> queryParamsMap,
315                      OnPostListener onPostListener) throws OcException {
316         this.post2(
317                 resourceType,
318                 resourceInterface,
319                 ocRepresentation,
320                 queryParamsMap,
321                 onPostListener);
322     }
323
324     private native void post2(String resourceType,
325                               String resourceInterface,
326                               OcRepresentation ocRepresentation,
327                               Map<String, String> queryParamsMap,
328                               OnPostListener onPostListener) throws OcException;
329
330     /**
331      * Method to POST on a resource
332      *
333      * @param resourceType      resource type of the resource to operate on
334      * @param resourceInterface interface type of the resource to operate on
335      * @param ocRepresentation  representation of the resource
336      * @param queryParamsMap    Map which can have the query parameter name and value
337      * @param onPostListener    event handler The event handler will be invoked with a map of
338      *                          attribute name and values.
339      * @param qualityOfService  the quality of communication
340      * @throws OcException Failed to POST.
341      *                     Use OcException.GetErrorCode() for more details.
342      */
343     public void post(String resourceType,
344                      String resourceInterface,
345                      OcRepresentation ocRepresentation,
346                      Map<String, String> queryParamsMap,
347                      OnPostListener onPostListener,
348                      QualityOfService qualityOfService) throws OcException {
349
350         if (qualityOfService == null) {
351             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
352         }
353
354         this.post3(
355                 resourceType,
356                 resourceInterface,
357                 ocRepresentation,
358                 queryParamsMap,
359                 onPostListener,
360                 qualityOfService.getValue());
361     }
362
363     private native void post3(String resourceType,
364                               String resourceInterface,
365                               OcRepresentation ocRepresentation,
366                               Map<String, String> queryParamsMap,
367                               OnPostListener onPostListener,
368                               int qualityOfService) throws OcException;
369
370     /**
371      * Method to perform DELETE operation
372      *
373      * @param onDeleteListener event handler The event handler will have headerOptionList
374      *
375      * @throws OcException Failed to perform DELETE operation.
376      *                     Use OcException.GetErrorCode() for more details.
377      */
378     public native void deleteResource(OnDeleteListener onDeleteListener) throws OcException;
379
380     /**
381      * Method to perform DELETE operation
382      *
383      * @param onDeleteListener event handler The event handler will have headerOptionList
384      * @param qualityOfService the quality of communication
385      *
386      * @throws OcException Failed to perform DELETE operation.
387      *                     Use OcException.GetErrorCode() for more details.
388      */
389     public void deleteResource(OnDeleteListener onDeleteListener,
390                                QualityOfService qualityOfService) throws OcException {
391
392         if (qualityOfService == null) {
393             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
394         }
395
396         this.deleteResource1(onDeleteListener,
397                 qualityOfService.getValue());
398     }
399
400     private native void deleteResource1(OnDeleteListener onDeleteListener,
401                                         int qualityOfService) throws OcException;
402
403     /**
404      * Method to set observation on the resource
405      *
406      * @param observeType       allows the client to specify how it wants to observe
407      * @param queryParamsMap    map which can have the query parameter name and value
408      * @param onObserveListener event handler The handler method will be invoked with a map
409      *                          of attribute name and values.
410      * @throws OcException Failed to set observation.
411      *                     Use OcException.GetErrorCode() for more details.
412      */
413     public void observe(ObserveType observeType,
414                         Map<String, String> queryParamsMap,
415                         OnObserveListener onObserveListener) throws OcException {
416
417         if (observeType == null) {
418             throw new OcException(ErrorCode.INVALID_PARAM, "observeType cannot be null");
419         }
420
421         this.observe(
422                 observeType.getValue(),
423                 queryParamsMap,
424                 onObserveListener);
425     }
426
427     private synchronized native void observe(int observeType,
428                                              Map<String, String> queryParamsMap,
429                                              OnObserveListener onObserveListener) throws OcException;
430
431     /**
432      * Method to set observation on the resource
433      *
434      * @param observeType       allows the client to specify how it wants to observe
435      * @param queryParamsMap    map which can have the query parameter name and value
436      * @param onObserveListener event handler The handler method will be invoked with a map
437      *                          of attribute name and values.
438      * @param qualityOfService  the quality of communication
439      * @throws OcException Failed to set observation.
440      *                     Use OcException.GetErrorCode() for more details.
441      */
442     public void observe(ObserveType observeType,
443                         Map<String, String> queryParamsMap,
444                         OnObserveListener onObserveListener,
445                         QualityOfService qualityOfService) throws OcException {
446
447         if (observeType == null) {
448             throw new OcException(ErrorCode.INVALID_PARAM, "observeType cannot be null");
449         }
450
451         if (qualityOfService == null) {
452             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
453         }
454
455         this.observe1(
456                 observeType.getValue(),
457                 queryParamsMap,
458                 onObserveListener,
459                 qualityOfService.getValue());
460     }
461
462     private synchronized native void observe1(int observeType,
463                                               Map<String, String> queryParamsMap,
464                                               OnObserveListener onObserveListener,
465                                               int qualityOfService) throws OcException;
466
467     /**
468      * Method to cancel the observation on the resource
469      *
470      * @throws OcException Failed to cancel observation.
471      *                     Use OcException.GetErrorCode() for more details.
472      */
473     public void cancelObserve() throws OcException{
474         this.cancelObserve(OcPlatform.getPlatformQualityOfService());
475     }
476
477     /**
478      * Method to cancel the observation on the resource
479      *
480      * @param qualityOfService the quality of communication
481      * @throws OcException Failed to cancel observation.
482      *                     Use OcException.GetErrorCode() for more details.
483      */
484     public void cancelObserve(QualityOfService qualityOfService) throws OcException {
485
486         if (qualityOfService == null) {
487             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
488         }
489
490         this.cancelObserve1(qualityOfService.getValue());
491     }
492
493     private native void cancelObserve1(int qualityOfService) throws OcException;
494
495     /**
496      * Method to set header options
497      *
498      * @param headerOptionList List OcHeaderOption where header information(header optionID and
499      *                         optionData is passed
500      * @throws OcException Failed to set header options.
501      *                     Use OcException.GetErrorCode() for more details.
502      */
503     public void setHeaderOptions(List<OcHeaderOption> headerOptionList) throws OcException {
504
505         if (headerOptionList == null) {
506             throw new OcException(ErrorCode.INVALID_PARAM, "headerOptionList cannot be null");
507         }
508
509         this.setHeaderOptions(headerOptionList.toArray(
510                         new OcHeaderOption[headerOptionList.size()])
511         );
512     }
513
514     private native void setHeaderOptions(OcHeaderOption[] headerOptionList);
515
516     /**
517      * Method to unset header options
518      */
519     public native void unsetHeaderOptions();
520
521     /**
522      * Method to get the host address of this resource
523      *
524      * @return host address NOTE: This might or might not be exposed in future due to
525      * security concerns
526      */
527     public native String getHost();
528
529     /**
530      * Method to get the endpoints information of this resource
531      *
532      * @return List of endpoints information
533      */
534     public native List<String> getAllHosts();
535
536     /**
537      * Method to get the URI for this resource
538      *
539      * @return resource URI
540      */
541     public native String getUri();
542
543     /**
544      * Method to get the connectivity type of this resource
545      *
546      * @return EnumSet OcConnectivityType connectivity type set
547      */
548     public EnumSet<OcConnectivityType> getConnectivityTypeSet() {
549         return OcConnectivityType.convertToEnumSet(
550                 this.getConnectivityTypeN()
551         );
552     }
553
554     private native int getConnectivityTypeN();
555
556     /**
557      * Method to provide ability to check if this resource is observable or not
558      *
559      * @return true indicates resource is observable; false indicates resource is not observable
560      */
561     public native boolean isObservable();
562
563     /**
564      * Function to change host of this reource
565      * @return New host Address.
566      *         Not observable.
567      */
568     public native String setHost(String host);
569
570     /**
571      * Method to get the list of resource types
572      *
573      * @return List of resource types
574      */
575     public native List<String> getResourceTypes();
576
577     /**
578      * Method to get the list of resource interfaces
579      *
580      * @return List of resource interface
581      */
582     public native List<String> getResourceInterfaces();
583
584     /**
585      * Method to get a unique identifier for this resource across network interfaces.  This will
586      * be guaranteed unique for every resource-per-server independent of how this was discovered.
587      *
588      * @return OcResourceIdentifier object, which can be used for all comparison and hashing
589      */
590     public native OcResourceIdentifier getUniqueIdentifier();
591
592     /**
593      * Method to get a string representation of the resource's server ID.
594      * <p>
595      * This is unique per- server independent on how it was discovered.
596      * </p>
597      *
598      * @return server ID
599      */
600     public native String getServerId();
601
602     /**
603      * An OnGetListener can be registered via the resource get call.
604      * Event listeners are notified asynchronously
605      */
606     public interface OnGetListener {
607         public void onGetCompleted(List<OcHeaderOption> headerOptionList,
608                                    OcRepresentation ocRepresentation);
609
610         public void onGetFailed(Throwable ex);
611     }
612
613     /**
614      * An OnPutListener can be registered via the resource put call.
615      * Event listeners are notified asynchronously
616      */
617     public interface OnPutListener {
618         public void onPutCompleted(List<OcHeaderOption> headerOptionList,
619                                    OcRepresentation ocRepresentation);
620
621         public void onPutFailed(Throwable ex);
622     }
623
624     /**
625      * An OnPostListener can be registered via the resource post call.
626      * Event listeners are notified asynchronously
627      */
628     public interface OnPostListener {
629         public void onPostCompleted(List<OcHeaderOption> headerOptionList,
630                                     OcRepresentation ocRepresentation);
631
632         public void onPostFailed(Throwable ex);
633     }
634
635     /**
636      * An OnDeleteListener can be registered via the resource delete call.
637      * Event listeners are notified asynchronously
638      */
639     public interface OnDeleteListener {
640         public void onDeleteCompleted(List<OcHeaderOption> headerOptionList);
641
642         public void onDeleteFailed(Throwable ex);
643     }
644
645     /**
646      * An OnObserveListener can be registered via the resource observe call.
647      * Event listeners are notified asynchronously
648      */
649     public interface OnObserveListener {
650         /**
651          * To Register.
652          */
653         public static final int REGISTER = 0;
654         /**
655          * To Deregister.
656          */
657         public static final int DEREGISTER = 1;
658         /**
659          * Others.
660          */
661         public static final int NO_OPTION = 2;
662
663         public void onObserveCompleted(List<OcHeaderOption> headerOptionList,
664                                        OcRepresentation ocRepresentation,
665                                        int sequenceNumber);
666
667         public void onObserveFailed(Throwable ex);
668     }
669
670     @Override
671     protected void finalize() throws Throwable {
672         super.finalize();
673
674         dispose();
675     }
676
677     private native void dispose();
678
679     private long mNativeHandle;
680
681     /**
682      * Method to discovery Topics
683      *
684      * @param queryParamsMap    map which can have the query parameter name and value
685      * @param onTopicFoundListener    event handler The handler method will be invoked with a map
686      *                                of attribute name and values.
687      * @param qualityOfService the quality of communication.
688      * @throws OcException Failed to discover Topic.
689      *                     Use OcException.GetErrorCode() for more details.
690      */
691     public void discoveryMQTopics(Map<String, String> queryParamsMap,
692                                   OnMQTopicFoundListener onTopicFoundListener,
693                                   QualityOfService qualityOfService) throws OcException {
694
695         if (qualityOfService == null) {
696             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
697         }
698
699         this.discoveryMQTopicsImpl(queryParamsMap, onTopicFoundListener,
700                                    qualityOfService.getValue());
701     }
702
703     private synchronized native void discoveryMQTopicsImpl(
704             Map<String, String> queryParamsMap,
705             OnMQTopicFoundListener onTopicFoundListener,
706             int qualityOfService) throws OcException;
707
708     /**
709      * Method to create Topic into MQ Broker.
710      *
711      * @param ocRepresentation  representation of the MQ Broker.
712      * @param uri               new MQ Topic uri which want to create.
713      * @param queryParamsMap    map which can have the query parameter name and value.
714      * @param onTopicCreatedListener    event handler The handler method will be invoked with a map
715      *                                  of attribute name and values.
716      * @param qualityOfService the quality of communication.
717      * @throws OcException Failed to create Topic.
718      *                     Use OcException.GetErrorCode() for more details.
719      */
720     public void createMQTopic(OcRepresentation ocRepresentation,
721                               String uri,
722                               Map<String, String> queryParamsMap,
723                               OnMQTopicCreatedListener onTopicCreatedListener,
724                               QualityOfService qualityOfService) throws OcException {
725
726         if (qualityOfService == null) {
727             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
728         }
729
730         this.createMQTopicImpl(ocRepresentation, uri, queryParamsMap,
731                                onTopicCreatedListener, qualityOfService.getValue());
732     }
733
734     private synchronized native void createMQTopicImpl(
735             OcRepresentation ocRepresentation,
736             String uri,
737             Map<String, String> queryParamsMap,
738             OnMQTopicCreatedListener onTopicCreatedListener,
739             int qualityOfService) throws OcException;
740
741     /**
742      * Method to set subscribe on the Topic.
743      *
744      * @param queryParamsMap    map which can have the query parameter name and value.
745      * @param onObserveListener event handler The handler method will be invoked with a map
746      *                          of attribute name and values.
747      * @param qualityOfService the quality of communication.
748      * @throws OcException Failed to subscribe on the Topic.
749      *                     Use OcException.GetErrorCode() for more details.
750      * 
751      */
752     public void subscribeMQTopic(Map<String, String> queryParamsMap,
753                                  OnObserveListener onObserveListener,
754                                  QualityOfService qualityOfService) throws OcException {
755
756         if (qualityOfService == null) {
757             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
758         }
759
760         this.subscribeMQTopicImpl(queryParamsMap,
761                                   onObserveListener,
762                                   qualityOfService.getValue());
763     }
764
765     private synchronized native void subscribeMQTopicImpl(Map<String, String> queryParamsMap,
766             OnObserveListener onObserveListener,
767             int qualityOfService) throws OcException;
768
769     /**
770      * Method to cancel the observation on the Topic.
771      *
772      * @param qualityOfService the quality of communication.
773      * @throws OcException Failed to cancel MQTopic subscription.
774      *                     Use OcException.GetErrorCode() for more details.
775      */
776     public void unsubscribeMQTopic(QualityOfService qualityOfService) throws OcException{
777
778         if (qualityOfService == null) {
779             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
780         }
781
782         this.unsubscribeMQTopicImpl(qualityOfService.getValue());
783     }
784
785     private native void unsubscribeMQTopicImpl(
786             int qualityOfService) throws OcException;
787
788     /**
789      * Method to requestMQPublish on a Topic
790      *
791      * @param queryParamsMap   Map which can have the query parameter name and value
792      * @param onPostListener   event handler The event handler will be invoked with a map of
793      *                         attribute name and values.
794      * @param qualityOfService the quality of communication.
795      * @throws OcException Request failure.
796      *                     Use OcException.GetErrorCode() for more details.
797      */
798     public void requestMQPublish(Map<String, String> queryParamsMap,
799                      OnPostListener onPostListener,
800                      QualityOfService qualityOfService) throws OcException {
801
802         if (qualityOfService == null) {
803             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
804         }
805
806         this.requestMQPublishImpl(queryParamsMap,
807                                   onPostListener,
808                                   qualityOfService.getValue());
809     }
810
811     private native void requestMQPublishImpl(Map<String, String> queryParamsMap,
812                               OnPostListener onPostListener,
813                               int qualityOfService) throws OcException;
814
815     /**
816      * Method to publishMQTopic on a Topic
817      *
818      * @param ocRepresentation representation of the resource
819      * @param queryParamsMap   Map which can have the query parameter name and value
820      * @param onPostListener   event handler The event handler will be invoked with a map of
821      *                         attribute name and values.
822      * @param qualityOfService the quality of communication.
823      * @throws OcException Failed to publish MQTopic.
824      *                     Use OcException.GetErrorCode() for more details.
825      */
826     public void publishMQTopic(OcRepresentation ocRepresentation,
827                      Map<String, String> queryParamsMap,
828                      OnPostListener onPostListener,
829                      QualityOfService qualityOfService) throws OcException {
830
831         if (qualityOfService == null) {
832             throw new OcException(ErrorCode.INVALID_PARAM, "qualityOfService cannot be null");
833         }
834
835         this.publishMQTopicImpl(ocRepresentation,
836                                 queryParamsMap,
837                                 onPostListener,
838                                 qualityOfService.getValue());
839     }
840
841     private native void publishMQTopicImpl(OcRepresentation ocRepresentation,
842                               Map<String, String> queryParamsMap,
843                               OnPostListener onPostListener,
844                               int qualityOfService) throws OcException;
845
846     /**
847      * An OnMQTopicFoundListener can be registered via the OcResource.discoveryMQTopics call.
848      * Event listeners are notified asynchronously
849      */
850     public interface OnMQTopicFoundListener {
851         public void onTopicDiscoveried(OcResource resource);
852         public void onDiscoveryTopicFailed(Throwable ex, String uri);
853     }
854
855     /**
856      * An OnMQTopicCreatedListener can be registered via the OcResource.createMQTopic call.
857      * Event listeners are notified asynchronously
858      */
859     public interface OnMQTopicCreatedListener {
860         public void onTopicResourceCreated(OcResource resource);
861         public void onCreateTopicFailed(Throwable ex, String uri);
862     }
863
864     /**
865      * An OnMQTopicSubscribeListener can be registered via the OcResource.subscribeMQTopic call.
866      * Event listeners are notified asynchronously
867      */
868     public interface OnMQTopicSubscribeListener {
869         /**
870          * To Subscriber.
871          */
872         public static final int SUBSCRIBER = 0;
873         /**
874          * To Unrubscriber.
875          */
876         public static final int UNSUBSCRIBER = 1;
877         /**
878          * Others.
879          */
880         public static final int NO_OPTION = 2;
881         public void onSubScribeCompleted(List<OcHeaderOption> headerOptionList,
882                 OcRepresentation ocRepresentation,
883                 int sequenceNumber);
884         public void onUnsubScribeCompleted(OcRepresentation ocRepresentation,
885                 int sequenceNumber);
886         public void onSubScribeFailed(Throwable ex);
887     }
888 }