[CONPRO-1333] Fix for crash in JniOnPostListener

Crash was due to post response received on deleted JniOnPostListener
object. This change make sure of valid JniOcResource object when CRUDN
callback invoked from core stack layer.

https://github.sec.samsung.net/RS7-IOTIVITY/IoTivity/pull/360
(cherry picked from commit 494f1578d7edceec084dd42b59c3198bdd2fb6a8)

Change-Id: Idac701367ed40ece7dbadd82e1484babc918aca0
Signed-off-by: Harish Kumara M <h.marappa@samsung.com>
Signed-off-by: pilli manikanta <p.manikanta@partner.samsung.com>
Signed-off-by: DoHyun Pyun <dh79.pyun@samsung.com>

diff --git a/android/android_api/base/jni/JniListenerManager.h b/android/android_api/base/jni/JniListenerManager.h
index 8965e85..6912424 100644 (file)
--- a/android/android_api/base/jni/JniListenerManager.h
+++ b/android/android_api/base/jni/JniListenerManager.h
@@ -27,15 +27,12 @@
 #define _JniListenerManager
 
 class JniOcResource;
-#ifdef WITH_CLOUD
-class JniOcAccountManager;
-#endif
 
 template <class T>
 class JniListenerManager
 {
 public:
-    T* addListener(JNIEnv* env, jobject jListener, JniOcResource* owner)
+    T* addListener(JNIEnv* env, jobject jListener, RemoveListenerCallback removeListener)
     {
         T *onEventListener = nullptr;
 
@@ -57,7 +54,7 @@ public:
 
         if (!onEventListener)
         {
-            onEventListener = new T(env, jListener, owner);
+            onEventListener = new T(env, jListener, removeListener);
             jobject jgListener = env->NewGlobalRef(jListener);
 
             if (jgListener)
@@ -80,53 +77,6 @@ public:
         return onEventListener;
     }
 
-#ifdef WITH_CLOUD
-    T* addListener(JNIEnv* env, jobject jListener, JniOcAccountManager* owner)
-    {
-        T *onEventListener = nullptr;
-
-        m_mapMutex.lock();
-
-        for (auto it = m_listenerMap.begin(); it != m_listenerMap.end(); ++it)
-        {
-            if (env->IsSameObject(jListener, it->first))
-            {
-                auto refPair = it->second;
-                onEventListener = refPair.first;
-                refPair.second++;
-                it->second = refPair;
-                m_listenerMap.insert(*it);
-                LOGD("OnEventListener: ref. count is incremented");
-                break;
-            }
-        }
-
-        if (!onEventListener)
-        {
-            onEventListener = new T(env, jListener, owner);
-            jobject jgListener = env->NewGlobalRef(jListener);
-
-            if (jgListener)
-            {
-                m_listenerMap.insert(
-                        std::pair<jobject,
-                        std::pair<T*, int>>(jgListener, std::pair<T*, int>(onEventListener, 1)));
-            }
-            else
-            {
-                LOGD("OnEventListener: Failed to create global listener ref.");
-                delete onEventListener;
-                m_mapMutex.unlock();
-                return nullptr;
-            }
-            LOGD("OnEventListener: new listener");
-        }
-
-        m_mapMutex.unlock();
-        return onEventListener;
-    }
-#endif
-
     void removeListener(JNIEnv* env, jobject jListener)
     {
         m_mapMutex.lock();

diff --git a/android/android_api/base/jni/JniOcAccountManager.cpp b/android/android_api/base/jni/JniOcAccountManager.cpp
index 2d7e861..141f493 100644 (file)
--- a/android/android_api/base/jni/JniOcAccountManager.cpp
+++ b/android/android_api/base/jni/JniOcAccountManager.cpp
@@ -86,22 +86,30 @@ JniOcAccountManager* JniOcAccountManager::getJniOcAccountManagerPtr(JNIEnv *env,
 
 JniOnGetListener* JniOcAccountManager::addOnGetListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onGetManager.addListener(env, jListener, this);
+    return this->m_onGetManager.addListener(env, jListener,
+                                            std::bind(&JniOcAccountManager::removeOnGetListener, this,
+                                            std::placeholders::_1, std::placeholders::_2));
 }
 
 JniOnPostListener* JniOcAccountManager::addOnPostListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onPostManager.addListener(env, jListener, this);
+    return this->m_onPostManager.addListener(env, jListener,
+                                             std::bind(&JniOcAccountManager::removeOnPostListener, this,
+                                             std::placeholders::_1, std::placeholders::_2));
 }
 
 JniOnDeleteListener* JniOcAccountManager::addOnDeleteListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onDeleteManager.addListener(env, jListener, this);
+    return this->m_onDeleteManager.addListener(env, jListener,
+                                               std::bind(&JniOcAccountManager::removeOnDeleteListener, this,
+                                               std::placeholders::_1, std::placeholders::_2));
 }
 
 JniOnObserveListener* JniOcAccountManager::addOnObserveListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onObserveManager.addListener(env, jListener, this);
+    return this->m_onObserveManager.addListener(env, jListener,
+                                                std::bind(&JniOcAccountManager::removeOnObserveListener, this,
+                                                std::placeholders::_1, std::placeholders::_2));
 }
 
 void JniOcAccountManager::removeOnGetListener(JNIEnv* env, jobject jListener)

diff --git a/android/android_api/base/jni/JniOcPlatform.cpp b/android/android_api/base/jni/JniOcPlatform.cpp
index 87d08a2..f5f4665 100644 (file)
--- a/android/android_api/base/jni/JniOcPlatform.cpp
+++ b/android/android_api/base/jni/JniOcPlatform.cpp
@@ -351,7 +351,7 @@ JniOnObserveListener* AddOnObserveListener(JNIEnv* env, jobject jListener)
     }
     if (!onObserveListener)
     {
-        onObserveListener = new JniOnObserveListener(env, jListener, (JniOcResource*)nullptr);
+        onObserveListener = new JniOnObserveListener(env, jListener, nullptr);
         jobject jgListener = env->NewGlobalRef(jListener);
         onObserveListenerMap.insert(
             std::pair<jobject, std::pair<JniOnObserveListener*, int>>(

diff --git a/android/android_api/base/jni/JniOcResource.cpp b/android/android_api/base/jni/JniOcResource.cpp
index 9d30ba2..f376cdd 100644 (file)
--- a/android/android_api/base/jni/JniOcResource.cpp
+++ b/android/android_api/base/jni/JniOcResource.cpp
@@ -24,14 +24,147 @@
 #include "JniOcRepresentation.h"
 #include "JniUtils.h"
 
-JniOcResource::JniOcResource(std::shared_ptr<OCResource> resource)
-    : m_sharedResource(resource)
-{
-}
+class JniOcResourceImpl : public std::enable_shared_from_this<JniOcResourceImpl>
+{
+public:
+    typedef std::shared_ptr<JniOcResourceImpl> Ptr;
+
+    JniOcResourceImpl(std::shared_ptr<OCResource> &resource);
+    ~JniOcResourceImpl();
+
+    OCStackResult get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener);
+    OCStackResult get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
+        QualityOfService QoS);
+    OCStackResult get(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const QueryParamsMap &queryParametersMap, jobject jListener);
+    OCStackResult get(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS);
+
+    OCStackResult put(JNIEnv* env, const OCRepresentation &representation, const QueryParamsMap &queryParametersMap,
+        jobject jListener);
+    OCStackResult put(JNIEnv* env, const OCRepresentation &representation, const QueryParamsMap &queryParametersMap,
+        jobject jListener, QualityOfService QoS);
+    OCStackResult put(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const OCRepresentation &representation, const QueryParamsMap &queryParametersMap, jobject jListener);
+    OCStackResult put(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const OCRepresentation &representation, const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS);
+
+    OCStackResult post(JNIEnv* env, const OCRepresentation &representation, const QueryParamsMap &queryParametersMap,
+        jobject jListener);
+    OCStackResult post(JNIEnv* env, const OCRepresentation &representation, const QueryParamsMap &queryParametersMap,
+        jobject jListener, QualityOfService QoS);
+    OCStackResult post(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const OCRepresentation &representation, const QueryParamsMap &queryParametersMap, jobject jListener);
+    OCStackResult post(JNIEnv* env, const std::string &resourceType, const std::string &resourceInterface,
+        const OCRepresentation &representation, const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS);
+
+    OCStackResult deleteResource(JNIEnv* env, jobject jListener);
+    OCStackResult deleteResource(JNIEnv* env, jobject jListener, QualityOfService QoS);
+
+    OCStackResult observe(JNIEnv* env, ObserveType observeType, const QueryParamsMap &queryParametersMap,
+        jobject jListener);
+    OCStackResult observe(JNIEnv* env, ObserveType observeType, const QueryParamsMap &queryParametersMap,
+        jobject jListener, QualityOfService qos);
+
+    OCStackResult cancelObserve(JNIEnv* env);
+    OCStackResult cancelObserve(JNIEnv* env, QualityOfService qos);
+
+    void setHeaderOptions(const HeaderOptions &headerOptions);
+    void unsetHeaderOptions();
+    std::string host();
+    std::string uri();
+    OCConnectivityType connectivityType() const;
+    bool isObservable();
+    std::vector< std::string >  getResourceTypes() const;
+    std::vector< std::string >  getResourceInterfaces(void) const;
+    OCResourceIdentifier uniqueIdentifier() const;
+    std::string sid() const;
+    std::string deviceName() const;
+
+    JniOnGetListener* addOnGetListener(JNIEnv* env, jobject jListener);
+    JniOnPutListener* addOnPutListener(JNIEnv* env, jobject jListener);
+    JniOnPostListener* addOnPostListener(JNIEnv* env, jobject jListener);
+    JniOnDeleteListener* addOnDeleteListener(JNIEnv* env, jobject jListener);
+    JniOnObserveListener* addOnObserveListener(JNIEnv* env, jobject jListener);
+
+    void removeOnGetListener(JNIEnv* env, jobject jListener);
+    void removeOnPutListener(JNIEnv* env, jobject jListener);
+    void removeOnPostListener(JNIEnv* env, jobject jListener);
+    void removeOnDeleteListener(JNIEnv* env, jobject jListener);
+    void removeOnObserveListener(JNIEnv* env, jobject jListener);
+
+    std::shared_ptr<OCResource> getOCResource();
+
+#ifdef WITH_MQ
+    JniOnMQTopicFoundListener* addOnTopicFoundListener(JNIEnv* env, jobject jListener);
+    void removeOnTopicFoundListener(JNIEnv* env, jobject jListener);
+
+    JniOnMQSubscribeListener* addOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener);
+    void removeOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener);
+
+    OCStackResult discoveryMQTopics(JNIEnv* env, const QueryParamsMap &queryParametersMap,
+                                    jobject jListener, QualityOfService QoS);
+    OCStackResult createMQTopic(JNIEnv* env, const OCRepresentation &representation,
+                                const std::string &targetUri,
+                                const QueryParamsMap &queryParametersMap,
+                                jobject jListener, QualityOfService QoS);
+#endif
+#ifdef MQ_SUBSCRIBER
+    OCStackResult subscribeMQTopic(JNIEnv* env, const QueryParamsMap &queryParametersMap,
+                                   jobject jListener, QualityOfService QoS);
+    OCStackResult unsubscribeMQTopic(QualityOfService QoS);
+    OCStackResult requestMQPublish(JNIEnv* env, const QueryParamsMap &queryParametersMap,
+                                   jobject jListener, QualityOfService QoS);
+#endif
+#ifdef MQ_PUBLISHER
+    OCStackResult publishMQTopic(JNIEnv* env, const OCRepresentation &representation,
+                                 const QueryParamsMap &queryParametersMap,
+                                 jobject jListener, QualityOfService QoS);
+#endif
+
+private:
+
+    static void onGetCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                              const int eCode, JniOnGetListener *listener,
+                              std::weak_ptr<JniOcResourceImpl> weakRef);
+
+    static void onPutCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                              const int eCode, JniOnPutListener *listener,
+                              std::weak_ptr<JniOcResourceImpl> weakRef);
+
+    static void onPostCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                               const int eCode, JniOnPostListener *listener,
+                               std::weak_ptr<JniOcResourceImpl> weakRef);
+
+    static void onDeleteCallback(const HeaderOptions& opts,
+                                 const int eCode, JniOnDeleteListener *listener,
+                                 std::weak_ptr<JniOcResourceImpl> weakRef);
+
+    static void onObserveCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                                  const int eCode, const int& sequenceNumber,
+                                  JniOnObserveListener *listener,
+                                  std::weak_ptr<JniOcResourceImpl> weakRef);
+
+
+    JniListenerManager<JniOnGetListener> m_onGetManager;
+    JniListenerManager<JniOnPutListener> m_onPutManager;
+    JniListenerManager<JniOnPostListener> m_onPostManager;
+    JniListenerManager<JniOnDeleteListener> m_onDeleteManager;
+    JniListenerManager<JniOnObserveListener> m_onObserveManager;
+#ifdef WITH_MQ
+    JniListenerManager<JniOnMQTopicFoundListener> m_onFoundTopicResourceManager;
+    JniListenerManager<JniOnMQSubscribeListener> m_onSubcribeTopicManager;
+#endif
+
+    std::shared_ptr<OCResource> m_sharedResource;
+};
 
-JniOcResource::~JniOcResource()
+JniOcResourceImpl::JniOcResourceImpl(std::shared_ptr<OCResource> &resource)
+    : m_sharedResource(resource) {}
+
+JniOcResourceImpl::~JniOcResourceImpl()
 {
-    LOGD("~JniOcResource()");
+    LOGD("~JniOcResourceImpl()");
 
     m_sharedResource = nullptr;
 
@@ -58,36 +191,44 @@ JniOcResource::~JniOcResource()
     }
 }
 
-OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener)
+void JniOcResourceImpl::onGetCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                                      const int eCode, JniOnGetListener *listener,
+                                      std::weak_ptr<JniOcResourceImpl> weakRef)
+{
+    auto obj = weakRef.lock();
+       if (!obj)
+    {
+        LOGD("Get callback called on deleted object\n");
+        return;
+    }
+
+    listener->onGetCallback(opts, rep, eCode);
+}
+
+OCStackResult JniOcResourceImpl::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 
-    GetCallback getCallback = [onGetListener](
-        const HeaderOptions& opts,
-        const OCRepresentation& rep,
-        const int eCode)
-    {
-        onGetListener->onGetCallback(opts, rep, eCode);
-    };
+    GetCallback getCallback = std::bind(JniOcResourceImpl::onGetCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onGetListener,
+                                        shared_from_this());
 
     return m_sharedResource->get(queryParametersMap, getCallback);
 }
 
-OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
+OCStackResult JniOcResourceImpl::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
     QualityOfService QoS)
 {
     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 
-    GetCallback getCallback = [onGetListener](const HeaderOptions& opts, const OCRepresentation& rep,
-        const int eCode)
-    {
-        onGetListener->onGetCallback(opts, rep, eCode);
-    };
+    GetCallback getCallback = std::bind(JniOcResourceImpl::onGetCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onGetListener,
+                                        shared_from_this());
 
     return m_sharedResource->get(queryParametersMap, getCallback, QoS);
 }
 
-OCStackResult JniOcResource::get(
+OCStackResult JniOcResourceImpl::get(
     JNIEnv* env,
     const std::string &resourceType,
     const std::string &resourceInterface,
@@ -96,206 +237,238 @@ OCStackResult JniOcResource::get(
 {
     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 
-    GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onGetListener->onGetCallback(opts, rep, eCode);
-    };
+    GetCallback getCallback = std::bind(JniOcResourceImpl::onGetCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onGetListener,
+                                        shared_from_this());
 
     return m_sharedResource->get(resourceType, resourceInterface, queryParametersMap,
         getCallback);
 }
 
-OCStackResult JniOcResource::get(JNIEnv* env, const std::string &resourceType,
+OCStackResult JniOcResourceImpl::get(JNIEnv* env, const std::string &resourceType,
     const std::string &resourceInterface, const QueryParamsMap &queryParametersMap,
     jobject jListener, QualityOfService QoS)
 {
     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 
-    GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onGetListener->onGetCallback(opts, rep, eCode);
-    };
+    GetCallback getCallback = std::bind(JniOcResourceImpl::onGetCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onGetListener,
+                                        shared_from_this());
 
     return m_sharedResource->get(resourceType, resourceInterface, queryParametersMap,
         getCallback, QoS);
 }
 
-OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
+void JniOcResourceImpl::onPutCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                                      const int eCode, JniOnPutListener *listener,
+                                      std::weak_ptr<JniOcResourceImpl> weakRef)
+{
+    auto obj = weakRef.lock();
+       if (!obj)
+    {
+        LOGD("Put callback called on deleted object\n");
+        return;
+    }
+
+    listener->onPutCallback(opts, rep, eCode);
+}
+
+OCStackResult JniOcResourceImpl::put(JNIEnv* env, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 
-    PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPutListener->onPutCallback(opts, rep, eCode);
-    };
+    PutCallback putCallback = std::bind(JniOcResourceImpl::onPutCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPutListener,
+                                        shared_from_this());
 
     return m_sharedResource->put(representation, queryParametersMap, putCallback);
 }
 
-OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
+OCStackResult JniOcResourceImpl::put(JNIEnv* env, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 
-    PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPutListener->onPutCallback(opts, rep, eCode);
-    };
+    PutCallback putCallback = std::bind(JniOcResourceImpl::onPutCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPutListener,
+                                        shared_from_this());
 
     return m_sharedResource->put(representation, queryParametersMap, putCallback, QoS);
 }
 
-OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
+OCStackResult JniOcResourceImpl::put(JNIEnv* env, const std::string &resourceType,
     const std::string &resourceInterface, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 
-    PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPutListener->onPutCallback(opts, rep, eCode);
-    };
+    PutCallback putCallback = std::bind(JniOcResourceImpl::onPutCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPutListener,
+                                        shared_from_this());
 
     return m_sharedResource->put(resourceType, resourceInterface, representation,
         queryParametersMap, putCallback);
 }
 
-OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
+OCStackResult JniOcResourceImpl::put(JNIEnv* env, const std::string &resourceType,
     const std::string &resourceInterface, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPutListener *onPutListener = addOnPutListener(env, jListener);
 
-    PutCallback putCallback = [onPutListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPutListener->onPutCallback(opts, rep, eCode);
-    };
+    PutCallback putCallback = std::bind(JniOcResourceImpl::onPutCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPutListener,
+                                        shared_from_this());
 
     return m_sharedResource->put(resourceType, resourceInterface, representation,
         queryParametersMap, putCallback, QoS);
 }
 
-OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
+void JniOcResourceImpl::onPostCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                                      const int eCode, JniOnPostListener *listener,
+                                      std::weak_ptr<JniOcResourceImpl> weakRef)
+{
+    auto obj = weakRef.lock();
+       if (!obj)
+    {
+        LOGD("Post callback called on deleted object\n");
+        return;
+    }
+
+    listener->onPostCallback(opts, rep, eCode);
+}
+
+OCStackResult JniOcResourceImpl::post(JNIEnv* env, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->post(representation, queryParametersMap, postCallback);
 }
 
-OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
+OCStackResult JniOcResourceImpl::post(JNIEnv* env, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->post(representation, queryParametersMap, postCallback, QoS);
 }
 
-OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
+OCStackResult JniOcResourceImpl::post(JNIEnv* env, const std::string &resourceType,
     const std::string &resourceInterface, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->post(resourceType, resourceInterface, representation,
         queryParametersMap, postCallback);
 }
 
-OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
+OCStackResult JniOcResourceImpl::post(JNIEnv* env, const std::string &resourceType,
     const std::string &resourceInterface, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->post(resourceType, resourceInterface, representation,
         queryParametersMap, postCallback, QoS);
 }
 
-OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::onDeleteCallback(const HeaderOptions& opts,
+                                      const int eCode, JniOnDeleteListener *listener,
+                                      std::weak_ptr<JniOcResourceImpl> weakRef)
+{
+    auto obj = weakRef.lock();
+       if (!obj)
+    {
+        LOGD("Delete callback called on deleted object\n");
+        return;
+    }
+
+    listener->onDeleteCallback(opts, eCode);
+}
+
+OCStackResult JniOcResourceImpl::deleteResource(JNIEnv* env, jobject jListener)
 {
     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 
-    DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
-        const int eCode)
-    {
-        onDeleteListener->onDeleteCallback(opts, eCode);
-    };
+    DeleteCallback deleteCallback = std::bind(JniOcResourceImpl::onDeleteCallback, std::placeholders::_1,
+                                        std::placeholders::_2, onDeleteListener,
+                                        shared_from_this());
 
     return m_sharedResource->deleteResource(deleteCallback);
 }
 
-OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener, QualityOfService QoS)
+OCStackResult JniOcResourceImpl::deleteResource(JNIEnv* env, jobject jListener, QualityOfService QoS)
 {
     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 
-    DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts, const int eCode)
-    {
-        onDeleteListener->onDeleteCallback(opts, eCode);
-    };
+    DeleteCallback deleteCallback = std::bind(JniOcResourceImpl::onDeleteCallback, std::placeholders::_1,
+                                        std::placeholders::_2, onDeleteListener,
+                                        shared_from_this());
 
     return m_sharedResource->deleteResource(deleteCallback, QoS);
 }
 
-OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
+void JniOcResourceImpl::onObserveCallback(const HeaderOptions& opts, const OCRepresentation& rep,
+                                      const int eCode, const int& sequenceNumber,
+                                      JniOnObserveListener *listener,
+                                      std::weak_ptr<JniOcResourceImpl> weakRef)
+{
+    auto obj = weakRef.lock();
+       if (!obj)
+    {
+        LOGD("Observe callback called on deleted object\n");
+        return;
+    }
+
+    listener->onObserveCallback(opts, rep, eCode, sequenceNumber);
+}
+
+OCStackResult JniOcResourceImpl::observe(JNIEnv* env, ObserveType observeType,
     const QueryParamsMap &queryParametersMap, jobject jListener)
 {
     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 
-    ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
-    {
-        onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
-    };
+    ObserveCallback observeCallback = std::bind(JniOcResourceImpl::onObserveCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3,
+                                        std::placeholders::_4, onObserveListener,
+                                        shared_from_this());
 
     return m_sharedResource->observe(observeType, queryParametersMap, observeCallback);
 }
 
-OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
+OCStackResult JniOcResourceImpl::observe(JNIEnv* env, ObserveType observeType,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 
-    ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
-    {
-        onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
-    };
+    ObserveCallback observeCallback = std::bind(JniOcResourceImpl::onObserveCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3,
+                                        std::placeholders::_4, onObserveListener,
+                                        shared_from_this());
 
     return m_sharedResource->observe(observeType, queryParametersMap, observeCallback, QoS);
 }
 
-OCStackResult JniOcResource::cancelObserve(JNIEnv* env, QualityOfService qos)
+OCStackResult JniOcResourceImpl::cancelObserve(JNIEnv* env, QualityOfService qos)
 {
     // In Low case, after delete the callback and send empty message when client receive the notify.
     // But TCP does not support EMPTY message.
@@ -306,178 +479,197 @@ OCStackResult JniOcResource::cancelObserve(JNIEnv* env, QualityOfService qos)
     return m_sharedResource->cancelObserve(qos);
 }
 
-void JniOcResource::setHeaderOptions(const HeaderOptions &headerOptions)
+void JniOcResourceImpl::setHeaderOptions(const HeaderOptions &headerOptions)
 {
     m_sharedResource->setHeaderOptions(headerOptions);
 }
 
-void JniOcResource::unsetHeaderOptions()
+void JniOcResourceImpl::unsetHeaderOptions()
 {
     m_sharedResource->unsetHeaderOptions();
 }
 
-std::string JniOcResource::host()
+std::string JniOcResourceImpl::host()
 {
     return m_sharedResource->host();
 }
 
-std::string JniOcResource::uri()
+std::string JniOcResourceImpl::uri()
 {
     return m_sharedResource->uri();
 }
 
-OCConnectivityType JniOcResource::connectivityType() const
+OCConnectivityType JniOcResourceImpl::connectivityType() const
 {
     return m_sharedResource->connectivityType();
 }
 
-bool JniOcResource::isObservable()
+bool JniOcResourceImpl::isObservable()
 {
     return m_sharedResource->isObservable();
 }
 
-std::vector< std::string > JniOcResource::getResourceTypes() const
+std::vector< std::string > JniOcResourceImpl::getResourceTypes() const
 {
     return m_sharedResource->getResourceTypes();
 }
 
-std::vector< std::string > JniOcResource::getResourceInterfaces(void) const
+std::vector< std::string > JniOcResourceImpl::getResourceInterfaces(void) const
 {
     return m_sharedResource->getResourceInterfaces();
 }
 
-OCResourceIdentifier JniOcResource::uniqueIdentifier() const
+OCResourceIdentifier JniOcResourceImpl::uniqueIdentifier() const
 {
     return m_sharedResource->uniqueIdentifier();
 }
 
-std::string JniOcResource::sid() const
+std::string JniOcResourceImpl::sid() const
 {
     return m_sharedResource->sid();
 }
 
-std::string JniOcResource::deviceName() const
+std::string JniOcResourceImpl::deviceName() const
 {
     return m_sharedResource->deviceName();
 }
 
-JniOnGetListener* JniOcResource::addOnGetListener(JNIEnv* env, jobject jListener)
+JniOnGetListener* JniOcResourceImpl::addOnGetListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onGetManager.addListener(env, jListener, this);
+    return this->m_onGetManager.addListener(env, jListener,
+                                            std::bind(&JniOcResourceImpl::removeOnGetListener, this,
+                                            std::placeholders::_1, std::placeholders::_2));
 }
 
-JniOnPutListener* JniOcResource::addOnPutListener(JNIEnv* env, jobject jListener)
+JniOnPutListener* JniOcResourceImpl::addOnPutListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onPutManager.addListener(env, jListener, this);
+    return this->m_onPutManager.addListener(env, jListener,
+                                            std::bind(&JniOcResourceImpl::removeOnPutListener, this,
+                                            std::placeholders::_1, std::placeholders::_2));
 }
 
-JniOnPostListener* JniOcResource::addOnPostListener(JNIEnv* env, jobject jListener)
+JniOnPostListener* JniOcResourceImpl::addOnPostListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onPostManager.addListener(env, jListener, this);
+    return this->m_onPostManager.addListener(env, jListener,
+                                             std::bind(&JniOcResourceImpl::removeOnPostListener, this,
+                                             std::placeholders::_1, std::placeholders::_2));
 }
 
-JniOnDeleteListener* JniOcResource::addOnDeleteListener(JNIEnv* env, jobject jListener)
+JniOnDeleteListener* JniOcResourceImpl::addOnDeleteListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onDeleteManager.addListener(env, jListener, this);
+    return this->m_onDeleteManager.addListener(env, jListener,
+                                               std::bind(&JniOcResourceImpl::removeOnDeleteListener, this,
+                                               std::placeholders::_1, std::placeholders::_2));
 }
 
-JniOnObserveListener* JniOcResource::addOnObserveListener(JNIEnv* env, jobject jListener)
+JniOnObserveListener* JniOcResourceImpl::addOnObserveListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onObserveManager.addListener(env, jListener, this);
+    return this->m_onObserveManager.addListener(env, jListener,
+                                                std::bind(&JniOcResourceImpl::removeOnObserveListener, this,
+                                                std::placeholders::_1, std::placeholders::_2));
 }
 
-void JniOcResource::removeOnGetListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnGetListener(JNIEnv* env, jobject jListener)
 {
     this->m_onGetManager.removeListener(env, jListener);
 }
 
-void JniOcResource::removeOnPutListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnPutListener(JNIEnv* env, jobject jListener)
 {
     this->m_onPutManager.removeListener(env, jListener);
 }
 
-void JniOcResource::removeOnPostListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnPostListener(JNIEnv* env, jobject jListener)
 {
     this->m_onPostManager.removeListener(env, jListener);
 }
 
-void JniOcResource::removeOnDeleteListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnDeleteListener(JNIEnv* env, jobject jListener)
 {
     this->m_onDeleteManager.removeListener(env, jListener);
 }
 
-void JniOcResource::removeOnObserveListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnObserveListener(JNIEnv* env, jobject jListener)
 {
     this->m_onObserveManager.removeListener(env, jListener);
 }
 
 #ifdef WITH_MQ
-JniOnMQTopicFoundListener* JniOcResource::addOnTopicFoundListener(JNIEnv* env, jobject jListener)
+JniOnMQTopicFoundListener* JniOcResourceImpl::addOnTopicFoundListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onFoundTopicResourceManager.addListener(env, jListener, this);
+    return this->m_onFoundTopicResourceManager.addListener(env, jListener,
+                                                           std::bind(&JniOcResource::removeOnTopicFoundListener, this,
+                                                           std::placeholders::_1, std::placeholders::_2));
 }
 
-void JniOcResource::removeOnTopicFoundListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnTopicFoundListener(JNIEnv* env, jobject jListener)
 {
     this->m_onFoundTopicResourceManager.removeListener(env, jListener);
 }
 
-JniOnMQSubscribeListener* JniOcResource::addOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener)
+JniOnMQSubscribeListener* JniOcResourceImpl::addOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener)
 {
-    return this->m_onSubcribeTopicManager.addListener(env, jListener, this);
+    return this->m_onSubcribeTopicManager.addListener(env, jListener,
+                                                      std::bind(&JniOcResource::removeOnMQTopicSubscribeListener, this
+                                                      std::placeholders::_1, std::placeholders::_2));
 }
 
-void JniOcResource::removeOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener)
+void JniOcResourceImpl::removeOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener)
 {
     this->m_onSubcribeTopicManager.removeListener(env, jListener);
 }
 #endif
 
-std::shared_ptr<OCResource> JniOcResource::getOCResource()
+std::shared_ptr<OCResource> JniOcResourceImpl::getOCResource()
 {
     return this->m_sharedResource;
 }
 
-JniOcResource* JniOcResource::getJniOcResourcePtr(JNIEnv *env, jobject thiz)
-{
-    JniOcResource *resource = GetHandle<JniOcResource>(env, thiz);
-    if (env->ExceptionCheck())
-    {
-        LOGE("Failed to get native handle from OcResource");
-    }
-    if (!resource)
-    {
-        ThrowOcException(JNI_NO_NATIVE_POINTER, "");
-    }
-    return resource;
-}
-
 #ifdef WITH_MQ
-OCStackResult JniOcResource::discoveryMQTopics(JNIEnv* env,
+OCStackResult JniOcResourceImpl::discoveryMQTopics(JNIEnv* env,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnMQTopicFoundListener *onTopicFoundListener = addOnTopicFoundListener(env, jListener);
 
-    MQTopicCallback findCallback = [onTopicFoundListener](const int& eCode,
-            const std::string& uri, std::shared_ptr<OCResource> resource)
+    MQTopicCallback findCallback = std::bind([](const int& eCode,
+                                                const std::string& uri, std::shared_ptr<OCResource> resource,
+                                                JniOnMQTopicFoundListener *listener,
+                                                std::weak_ptr<JniOcResourceImpl> weakRef)
     {
-        onTopicFoundListener->foundTopicCallback(eCode, uri, resource);
-    };
+        auto obj = weakRef.lock();
+           if (!obj)
+        {
+            LOGD("Topic callback called on deleted object\n");
+            return;
+        }
+        listener->foundTopicCallback(eCode, uri, resource);
+    }, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+       onTopicFoundListener, shared_from_this());
 
     return m_sharedResource->discoveryMQTopics(queryParametersMap, findCallback, QoS);
 }
 
-OCStackResult JniOcResource::createMQTopic(JNIEnv* env,
+OCStackResult JniOcResourceImpl::createMQTopic(JNIEnv* env,
     const OCRepresentation &representation, const std::string &targetUri,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnMQTopicFoundListener *onTopicCreatedListener = addOnTopicFoundListener(env, jListener);
 
-    MQTopicCallback createCallback = [onTopicCreatedListener](const int& eCode,
-            const std::string& uri, std::shared_ptr<OCResource> resource)
+    MQTopicCallback createCallback = std::bind([](const int& eCode,
+                                                  const std::string& uri,
+                                                  std::shared_ptr<OCResource> resource,
+                                                  JniOnMQTopicFoundListener *listener,
+                                                  std::weak_ptr<JniOcResourceImpl> weakRef)
     {
-        onTopicCreatedListener->createdTopicCallback(eCode, uri, resource);
-    };
+        auto obj = weakRef.lock();
+           if (!obj)
+        {
+            LOGD("Topic callback called on deleted object\n");
+            return;
+        }
+        listener->createdTopicCallback(eCode, uri, resource);
+    }, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
+       onTopicCreatedListener, shared_from_this());
 
     return m_sharedResource->createMQTopic(representation, targetUri,
                                            queryParametersMap,
@@ -485,57 +677,290 @@ OCStackResult JniOcResource::createMQTopic(JNIEnv* env,
 }
 #endif
 #ifdef MQ_SUBSCRIBER
-OCStackResult JniOcResource::subscribeMQTopic(JNIEnv* env,
+OCStackResult JniOcResourceImpl::subscribeMQTopic(JNIEnv* env,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnMQSubscribeListener *onSubscribeListener = addOnMQTopicSubscribeListener(env, jListener);
 
-    ObserveCallback subscribeCallback = [onSubscribeListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
+    ObserveCallback subscribeCallback = std::bind([](const HeaderOptions& opts,
+                                                     const OCRepresentation& rep, const int& eCode,
+                                                     const int& sequenceNumber,
+                                                     JniOnMQSubscribeListener *listener,
+                                                     std::weak_ptr<JniOcResourceImpl> weakRef)
     {
-        onSubscribeListener->onSubscribeCallback(opts, rep, eCode, sequenceNumber);
-    };
+        auto obj = weakRef.lock();
+           if (!obj)
+        {
+            LOGD("Subscribe MQ callback called on deleted object\n");
+            return;
+        }
+        listener->onSubscribeCallback(opts, rep, eCode, sequenceNumber);
+    }, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4,
+       onSubscribeListener, shared_from_this());
 
     return m_sharedResource->subscribeMQTopic(ObserveType::Observe, queryParametersMap,
                                               subscribeCallback, QoS);
 }
 
-OCStackResult JniOcResource::unsubscribeMQTopic(QualityOfService QoS)
+OCStackResult JniOcResourceImpl::unsubscribeMQTopic(QualityOfService QoS)
 {
     return m_sharedResource->unsubscribeMQTopic(QoS);
 }
 
-OCStackResult JniOcResource::requestMQPublish(JNIEnv* env,
+OCStackResult JniOcResourceImpl::requestMQPublish(JNIEnv* env,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->requestMQPublish(queryParametersMap, postCallback, QoS);
 }
 #endif
 #ifdef MQ_PUBLISHER
-OCStackResult JniOcResource::publishMQTopic(JNIEnv* env, const OCRepresentation &representation,
+OCStackResult JniOcResourceImpl::publishMQTopic(JNIEnv* env, const OCRepresentation &representation,
     const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
 {
     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 
-    PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
-        const OCRepresentation& rep, const int eCode)
-    {
-        onPostListener->onPostCallback(opts, rep, eCode);
-    };
+    PostCallback postCallback = std::bind(JniOcResourceImpl::onPostCallback, std::placeholders::_1,
+                                        std::placeholders::_2, std::placeholders::_3, onPostListener,
+                                        shared_from_this());
 
     return m_sharedResource->publishMQTopic(representation, queryParametersMap,
                                             postCallback, QoS);
 }
 #endif
 
+
+JniOcResource::JniOcResource(std::shared_ptr<OCResource> &resource)
+{
+    m_impl = std::make_shared<JniOcResourceImpl>(resource);
+}
+
+OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->get(env, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
+    QualityOfService QoS)
+{
+    return m_impl->get(env, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::get(
+    JNIEnv* env,
+    const std::string &resourceType,
+    const std::string &resourceInterface,
+    const QueryParamsMap &queryParametersMap,
+    jobject jListener)
+{
+    return m_impl->get(env, resourceType, resourceInterface, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::get(JNIEnv* env, const std::string &resourceType,
+    const std::string &resourceInterface, const QueryParamsMap &queryParametersMap,
+    jobject jListener, QualityOfService QoS)
+{
+    return m_impl->get(env, resourceType, resourceInterface, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->put(env, representation, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::put(JNIEnv* env, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->put(env, representation, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
+    const std::string &resourceInterface, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->put(env, resourceType, resourceInterface, representation, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::put(JNIEnv* env, const std::string &resourceType,
+    const std::string &resourceInterface, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->put(env, resourceType, resourceInterface, representation, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->post(env, representation, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::post(JNIEnv* env, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->post(env, representation, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
+    const std::string &resourceInterface, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->post(env, resourceType, resourceInterface, representation, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::post(JNIEnv* env, const std::string &resourceType,
+    const std::string &resourceInterface, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->post(env, resourceType, resourceInterface, representation, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener)
+{
+    return m_impl->deleteResource(env, jListener);
+}
+
+OCStackResult JniOcResource::deleteResource(JNIEnv* env, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->deleteResource(env, jListener, QoS);
+}
+
+OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
+    const QueryParamsMap &queryParametersMap, jobject jListener)
+{
+    return m_impl->observe(env, observeType, queryParametersMap, jListener);
+}
+
+OCStackResult JniOcResource::observe(JNIEnv* env, ObserveType observeType,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->observe(env, observeType, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::cancelObserve(JNIEnv* env, QualityOfService qos)
+{
+    return m_impl->cancelObserve(env, qos);
+}
+
+void JniOcResource::setHeaderOptions(const HeaderOptions &headerOptions)
+{
+    m_impl->setHeaderOptions(headerOptions);
+}
+
+void JniOcResource::unsetHeaderOptions()
+{
+    m_impl->unsetHeaderOptions();
+}
+
+std::string JniOcResource::host()
+{
+    return m_impl->host();
+}
+
+std::string JniOcResource::uri()
+{
+    return m_impl->uri();
+}
+
+OCConnectivityType JniOcResource::connectivityType() const
+{
+    return m_impl->connectivityType();
+}
+
+bool JniOcResource::isObservable()
+{
+    return m_impl->isObservable();
+}
+
+std::vector< std::string > JniOcResource::getResourceTypes() const
+{
+    return m_impl->getResourceTypes();
+}
+
+std::vector< std::string > JniOcResource::getResourceInterfaces(void) const
+{
+    return m_impl->getResourceInterfaces();
+}
+
+OCResourceIdentifier JniOcResource::uniqueIdentifier() const
+{
+    return m_impl->uniqueIdentifier();
+}
+
+std::string JniOcResource::sid() const
+{
+    return m_impl->sid();
+}
+
+std::string JniOcResource::deviceName() const
+{
+    return m_impl->deviceName();
+}
+
+std::shared_ptr<OCResource> JniOcResource::getOCResource()
+{
+    return m_impl->getOCResource();
+}
+
+JniOcResource* JniOcResource::getJniOcResourcePtr(JNIEnv *env, jobject thiz)
+{
+    JniOcResource *resource = GetHandle<JniOcResource>(env, thiz);
+    if (env->ExceptionCheck())
+    {
+        LOGE("Failed to get native handle from OcResource");
+    }
+    if (!resource)
+    {
+        ThrowOcException(JNI_NO_NATIVE_POINTER, "");
+    }
+    return resource;
+}
+
+#ifdef WITH_MQ
+OCStackResult JniOcResource::discoveryMQTopics(JNIEnv* env,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->discoveryMQTopics(env, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::createMQTopic(JNIEnv* env,
+    const OCRepresentation &representation, const std::string &targetUri,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->createMQTopic(env, representation, targetUri, queryParametersMap, jListener, QoS);
+}
+#endif
+#ifdef MQ_SUBSCRIBER
+OCStackResult JniOcResource::subscribeMQTopic(JNIEnv* env,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->subscribeMQTopic(env, queryParametersMap, jListener, QoS);
+}
+
+OCStackResult JniOcResource::unsubscribeMQTopic(QualityOfService QoS)
+{
+    return m_impl->unsubscribeMQTopic(QoS);
+}
+
+OCStackResult JniOcResource::requestMQPublish(JNIEnv* env,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return  m_impl->requestMQPublish(env, queryParametersMap, jListener, QoS);
+}
+#endif
+#ifdef MQ_PUBLISHER
+OCStackResult JniOcResource::publishMQTopic(JNIEnv* env, const OCRepresentation &representation,
+    const QueryParamsMap &queryParametersMap, jobject jListener, QualityOfService QoS)
+{
+    return m_impl->publishMQTopic(env, representation, queryParametersMap, jListener, QoS);
+}
+#endif
+
 /*
 * Class:     org_iotivity_base_OcResource
 * Method:    get

diff --git a/android/android_api/base/jni/JniOcResource.h b/android/android_api/base/jni/JniOcResource.h
index e05da82..5ed1e39 100644 (file)
--- a/android/android_api/base/jni/JniOcResource.h
+++ b/android/android_api/base/jni/JniOcResource.h
@@ -39,11 +39,12 @@
 
 using namespace OC;
 
+class JniOcResourceImpl;
 class JniOcResource
 {
 public:
-    JniOcResource(std::shared_ptr<OCResource> resource);
-    ~JniOcResource();
+    JniOcResource(std::shared_ptr<OCResource> &resource);
+    ~JniOcResource() = default;
 
     OCStackResult get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener);
     OCStackResult get(JNIEnv* env, const QueryParamsMap &queryParametersMap, jobject jListener,
@@ -94,29 +95,11 @@ public:
     std::string sid() const;
     std::string deviceName() const;
 
-    JniOnGetListener* addOnGetListener(JNIEnv* env, jobject jListener);
-    JniOnPutListener* addOnPutListener(JNIEnv* env, jobject jListener);
-    JniOnPostListener* addOnPostListener(JNIEnv* env, jobject jListener);
-    JniOnDeleteListener* addOnDeleteListener(JNIEnv* env, jobject jListener);
-    JniOnObserveListener* addOnObserveListener(JNIEnv* env, jobject jListener);
-
-    void removeOnGetListener(JNIEnv* env, jobject jListener);
-    void removeOnPutListener(JNIEnv* env, jobject jListener);
-    void removeOnPostListener(JNIEnv* env, jobject jListener);
-    void removeOnDeleteListener(JNIEnv* env, jobject jListener);
-    void removeOnObserveListener(JNIEnv* env, jobject jListener);
-
     std::shared_ptr<OCResource> getOCResource();
 
     static JniOcResource* getJniOcResourcePtr(JNIEnv *env, jobject thiz);
 
 #ifdef WITH_MQ
-    JniOnMQTopicFoundListener* addOnTopicFoundListener(JNIEnv* env, jobject jListener);
-    void removeOnTopicFoundListener(JNIEnv* env, jobject jListener);
-
-    JniOnMQSubscribeListener* addOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener);
-    void removeOnMQTopicSubscribeListener(JNIEnv* env, jobject jListener);
-
     OCStackResult discoveryMQTopics(JNIEnv* env, const QueryParamsMap &queryParametersMap,
                                     jobject jListener, QualityOfService QoS);
     OCStackResult createMQTopic(JNIEnv* env, const OCRepresentation &representation,
@@ -138,17 +121,7 @@ public:
 #endif
 
 private:
-    JniListenerManager<JniOnGetListener> m_onGetManager;
-    JniListenerManager<JniOnPutListener> m_onPutManager;
-    JniListenerManager<JniOnPostListener> m_onPostManager;
-    JniListenerManager<JniOnDeleteListener> m_onDeleteManager;
-    JniListenerManager<JniOnObserveListener> m_onObserveManager;
-#ifdef WITH_MQ
-    JniListenerManager<JniOnMQTopicFoundListener> m_onFoundTopicResourceManager;
-    JniListenerManager<JniOnMQSubscribeListener> m_onSubcribeTopicManager;
-#endif
-
-    std::shared_ptr<OCResource> m_sharedResource;
+    std::shared_ptr<JniOcResourceImpl> m_impl;
 };
 
 /* DO NOT EDIT THIS FILE BEYOND THIS LINE - it is machine generated */

diff --git a/android/android_api/base/jni/JniOcStack.h b/android/android_api/base/jni/JniOcStack.h
index db5ea1e..cc530d6 100644 (file)
--- a/android/android_api/base/jni/JniOcStack.h
+++ b/android/android_api/base/jni/JniOcStack.h
@@ -163,7 +163,8 @@ extern jmethodID g_mid_OcOicSecPdAcl_get_periods;
 extern jmethodID g_mid_OcOicSecPdAcl_get_recurrences;
 
 
-typedef void(*RemoveListenerCallback)(JNIEnv* env, jobject jListener);
+//typedef void(*RemoveListenerCallback)(JNIEnv* env, jobject jListener);
+typedef std::function<void(JNIEnv* env, jobject jListener)> RemoveListenerCallback;
 
 static jfieldID GetHandleField(JNIEnv *env, jobject jobj)
 {

diff --git a/android/android_api/base/jni/JniOnDeleteListener.cpp b/android/android_api/base/jni/JniOnDeleteListener.cpp
index bb0f5db..31749c5 100644 (file)
--- a/android/android_api/base/jni/JniOnDeleteListener.cpp
+++ b/android/android_api/base/jni/JniOnDeleteListener.cpp
@@ -23,28 +23,13 @@
 #include "JniOnDeleteListener.h"
 #include "JniOcResource.h"
 #include "JniUtils.h"
-#ifdef WITH_CLOUD
-#include "JniOcAccountManager.h"
-#endif
 
-JniOnDeleteListener::JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
-    : m_ownerResource(owner)
+JniOnDeleteListener::JniOnDeleteListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
-#ifdef WITH_CLOUD
-    m_ownerAccountManager = nullptr;
-#endif
 }
 
-#ifdef WITH_CLOUD
-JniOnDeleteListener::JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner)
-    : m_ownerAccountManager(owner)
-{
-    m_jwListener = env->NewWeakGlobalRef(jListener);
-    m_ownerResource = nullptr;
-}
-#endif
-
 JniOnDeleteListener::~JniOnDeleteListener()
 {
     if (m_jwListener)
@@ -158,33 +143,11 @@ void JniOnDeleteListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnDeleteListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnDeleteListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnDeleteListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnDeleteListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnDeleteListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnDeleteListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnDeleteListener.h b/android/android_api/base/jni/JniOnDeleteListener.h
index 9354232..4a2be30 100644 (file)
--- a/android/android_api/base/jni/JniOnDeleteListener.h
+++ b/android/android_api/base/jni/JniOnDeleteListener.h
@@ -26,28 +26,18 @@
 
 using namespace OC;
 
-class JniOcResource;
-#ifdef WITH_CLOUD
-class JniOcAccountManager;
-#endif
-
 class JniOnDeleteListener
 {
 public:
-    JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcResource* owner);
-#ifdef WITH_CLOUD
-    JniOnDeleteListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner);
-#endif
+
+    JniOnDeleteListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnDeleteListener();
 
     void onDeleteCallback(const HeaderOptions&, const int eCode);
 
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
-#ifdef WITH_CLOUD
-    JniOcAccountManager* m_ownerAccountManager;
-#endif
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/android/android_api/base/jni/JniOnGetListener.cpp b/android/android_api/base/jni/JniOnGetListener.cpp
index 9a801f1..b8d2273 100644 (file)
--- a/android/android_api/base/jni/JniOnGetListener.cpp
+++ b/android/android_api/base/jni/JniOnGetListener.cpp
@@ -23,28 +23,13 @@
 #include "JniOcResource.h"
 #include "JniOcRepresentation.h"
 #include "JniUtils.h"
-#ifdef WITH_CLOUD
-#include "JniOcAccountManager.h"
-#endif
 
-JniOnGetListener::JniOnGetListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
-    : m_ownerResource(owner)
+JniOnGetListener::JniOnGetListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
-#ifdef WITH_CLOUD
-    m_ownerAccountManager = nullptr;
-#endif
 }
 
-#ifdef WITH_CLOUD
-JniOnGetListener::JniOnGetListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner)
-    : m_ownerAccountManager(owner)
-{
-    m_jwListener = env->NewWeakGlobalRef(jListener);
-    m_ownerResource = nullptr;
-}
-#endif
-
 JniOnGetListener::~JniOnGetListener()
 {
     LOGD("~JniOnGetListener");
@@ -184,33 +169,11 @@ void JniOnGetListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnGetListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnGetListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnGetListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnGetListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnGetListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnGetListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnGetListener.h b/android/android_api/base/jni/JniOnGetListener.h
index abffaa0..09b4d7b 100644 (file)
--- a/android/android_api/base/jni/JniOnGetListener.h
+++ b/android/android_api/base/jni/JniOnGetListener.h
@@ -26,27 +26,17 @@
 
 using namespace OC;
 
-class JniOcResource;
-#ifdef WITH_CLOUD
-class JniOcAccountManager;
-#endif
-
 class JniOnGetListener
 {
 public:
-    JniOnGetListener(JNIEnv *env, jobject listener, JniOcResource* resource);
-#ifdef WITH_CLOUD
-    JniOnGetListener(JNIEnv *env, jobject listener, JniOcAccountManager* resource);
-#endif
+
+    JniOnGetListener(JNIEnv *env, jobject listener, RemoveListenerCallback removeListener);
     ~JniOnGetListener();
     void onGetCallback(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode);
 
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
-#ifdef WITH_CLOUD
-    JniOcAccountManager* m_ownerAccountManager;
-#endif
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/android/android_api/base/jni/JniOnMQSubscribeListener.cpp b/android/android_api/base/jni/JniOnMQSubscribeListener.cpp
index 705f644..fdcbfb6 100644 (file)
--- a/android/android_api/base/jni/JniOnMQSubscribeListener.cpp
+++ b/android/android_api/base/jni/JniOnMQSubscribeListener.cpp
@@ -25,8 +25,8 @@
 
 JniOnMQSubscribeListener::JniOnMQSubscribeListener(JNIEnv *env,
                                                    jobject jListener,
-                                                   JniOcResource* owner)
-    : m_ownerResource(owner)
+                                                   RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
 }
@@ -198,11 +198,11 @@ void JniOnMQSubscribeListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-        m_ownerResource->removeOnMQTopicSubscribeListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-        m_ownerResource->removeOnMQTopicSubscribeListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnMQSubscribeListener.h b/android/android_api/base/jni/JniOnMQSubscribeListener.h
index 6b7c059..c4929b4 100644 (file)
--- a/android/android_api/base/jni/JniOnMQSubscribeListener.h
+++ b/android/android_api/base/jni/JniOnMQSubscribeListener.h
@@ -27,18 +27,16 @@
 
 using namespace OC;
 
-class JniOcResource;
-
 class JniOnMQSubscribeListener
 {
 public:
-    JniOnMQSubscribeListener(JNIEnv *env, jobject jListener, JniOcResource* owner);
+    JniOnMQSubscribeListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnMQSubscribeListener();
     void onSubscribeCallback(const HeaderOptions headerOptions, const OCRepresentation& rep,
         const int& eCode, const int& sequenceNumber);
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/android/android_api/base/jni/JniOnMQTopicFoundListener.cpp b/android/android_api/base/jni/JniOnMQTopicFoundListener.cpp
index 6fb1845..8888ee9 100644 (file)
--- a/android/android_api/base/jni/JniOnMQTopicFoundListener.cpp
+++ b/android/android_api/base/jni/JniOnMQTopicFoundListener.cpp
@@ -24,8 +24,8 @@
 #include "JniUtils.h"
 
 JniOnMQTopicFoundListener::JniOnMQTopicFoundListener(JNIEnv *env, jobject jListener,
-                                                     JniOcResource* owner)
-    : m_ownerResource(owner)
+                                                     RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
 }
@@ -255,11 +255,11 @@ void JniOnMQTopicFoundListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-        m_ownerResource->removeOnTopicFoundListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-        m_ownerResource->removeOnTopicFoundListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnMQTopicFoundListener.h b/android/android_api/base/jni/JniOnMQTopicFoundListener.h
index 45b73a0..3dda033 100644 (file)
--- a/android/android_api/base/jni/JniOnMQTopicFoundListener.h
+++ b/android/android_api/base/jni/JniOnMQTopicFoundListener.h
@@ -24,12 +24,10 @@
 
 using namespace OC;
 
-class JniOcResource;
-
 class JniOnMQTopicFoundListener
 {
 public:
-    JniOnMQTopicFoundListener(JNIEnv *env, jobject jListener, JniOcResource* owner);
+    JniOnMQTopicFoundListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnMQTopicFoundListener();
 
     void foundTopicCallback(const int eCode, const std::string& uri,
@@ -39,7 +37,7 @@ public:
 
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv* env);
 };
 

diff --git a/android/android_api/base/jni/JniOnObserveListener.cpp b/android/android_api/base/jni/JniOnObserveListener.cpp
index 060b19e..ce27374 100644 (file)
--- a/android/android_api/base/jni/JniOnObserveListener.cpp
+++ b/android/android_api/base/jni/JniOnObserveListener.cpp
@@ -23,30 +23,15 @@
 #include "JniOcResource.h"
 #include "JniOcRepresentation.h"
 #include "JniUtils.h"
-#ifdef WITH_CLOUD
-#include "JniOcAccountManager.h"
-#endif
 
 #define CA_OBSERVE_MAX_SEQUENCE_NUMBER 0xFFFFFF
 
-JniOnObserveListener::JniOnObserveListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
-    : m_ownerResource(owner)
+JniOnObserveListener::JniOnObserveListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
-#ifdef WITH_CLOUD
-    m_ownerAccountManager = nullptr;
-#endif
 }
 
-#ifdef WITH_CLOUD
-JniOnObserveListener::JniOnObserveListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner)
-    : m_ownerAccountManager(owner)
-{
-    m_jwListener = env->NewWeakGlobalRef(jListener);
-    m_ownerResource = nullptr;
-}
-#endif
-
 JniOnObserveListener::~JniOnObserveListener()
 {
     if (m_jwListener)
@@ -166,18 +151,7 @@ void JniOnObserveListener::onObserveCallback(const HeaderOptions headerOptions,
             env->DeleteLocalRef(jHeaderOptionList);
             jthrowable ex = env->ExceptionOccurred();
             env->ExceptionClear();
-#ifndef WITH_CLOUD
-            m_ownerResource->removeOnObserveListener(env, m_jwListener);
-#else
-            if (nullptr != m_ownerResource)
-            {
-                m_ownerResource->removeOnObserveListener(env, m_jwListener);
-            }
-            if (nullptr != m_ownerAccountManager)
-            {
-                m_ownerAccountManager->removeOnObserveListener(env, m_jwListener);
-            }
-#endif
+            m_removeListener(env, m_jwListener);
             env->Throw((jthrowable)ex);
         }
 
@@ -213,34 +187,12 @@ void JniOnObserveListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnObserveListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnObserveListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnObserveListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnObserveListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnObserveListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnObserveListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
     }
 }
 

diff --git a/android/android_api/base/jni/JniOnObserveListener.h b/android/android_api/base/jni/JniOnObserveListener.h
index 3fc478d..38b0b18 100644 (file)
--- a/android/android_api/base/jni/JniOnObserveListener.h
+++ b/android/android_api/base/jni/JniOnObserveListener.h
@@ -26,28 +26,17 @@
 
 using namespace OC;
 
-class JniOcResource;
-#ifdef WITH_CLOUD
-class JniOcAccountManager;
-#endif
-
 class JniOnObserveListener
 {
 public:
-    JniOnObserveListener(JNIEnv *env, jobject jListener, JniOcResource* owner);
-#ifdef WITH_CLOUD
-    JniOnObserveListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner);
-#endif
+    JniOnObserveListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnObserveListener();
     void onObserveCallback(const HeaderOptions headerOptions, const OCRepresentation& rep,
         const int& eCode, const int& sequenceNumber);
     jweak getJWListener();
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
-#ifdef WITH_CLOUD
-    JniOcAccountManager* m_ownerAccountManager;
-#endif
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/android/android_api/base/jni/JniOnPostListener.cpp b/android/android_api/base/jni/JniOnPostListener.cpp
index 62f6e96..b11c376 100644 (file)
--- a/android/android_api/base/jni/JniOnPostListener.cpp
+++ b/android/android_api/base/jni/JniOnPostListener.cpp
@@ -23,28 +23,13 @@
 #include "JniOcResource.h"
 #include "JniOcRepresentation.h"
 #include "JniUtils.h"
-#ifdef WITH_CLOUD
-#include "JniOcAccountManager.h"
-#endif
 
-JniOnPostListener::JniOnPostListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
-    : m_ownerResource(owner)
+JniOnPostListener::JniOnPostListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
-#ifdef WITH_CLOUD
-    m_ownerAccountManager = nullptr;
-#endif
 }
 
-#ifdef WITH_CLOUD
-JniOnPostListener::JniOnPostListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner)
-    : m_ownerAccountManager(owner)
-{
-    m_jwListener = env->NewWeakGlobalRef(jListener);
-    m_ownerResource = nullptr;
-}
-#endif
-
 JniOnPostListener::~JniOnPostListener()
 {
     if (m_jwListener)
@@ -183,33 +168,11 @@ void JniOnPostListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnPostListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnPostListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnPostListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-#ifndef WITH_CLOUD
-        m_ownerResource->removeOnPostListener(env, m_jwListener);
-#else
-        if (nullptr != m_ownerResource)
-        {
-            m_ownerResource->removeOnPostListener(env, m_jwListener);
-        }
-        if (nullptr != m_ownerAccountManager)
-        {
-            m_ownerAccountManager->removeOnPostListener(env, m_jwListener);
-        }
-#endif
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnPostListener.h b/android/android_api/base/jni/JniOnPostListener.h
index bf3387c..c4e30f1 100644 (file)
--- a/android/android_api/base/jni/JniOnPostListener.h
+++ b/android/android_api/base/jni/JniOnPostListener.h
@@ -26,28 +26,17 @@
 
 using namespace OC;
 
-class JniOcResource;
-#ifdef WITH_CLOUD
-class JniOcAccountManager;
-#endif
-
 class JniOnPostListener
 {
 public:
-    JniOnPostListener(JNIEnv *env, jobject jListener, JniOcResource* owner);
-#ifdef WITH_CLOUD
-    JniOnPostListener(JNIEnv *env, jobject jListener, JniOcAccountManager* owner);
-#endif
+    JniOnPostListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnPostListener();
 
     void onPostCallback(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode);
 
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
-#ifdef WITH_CLOUD
-    JniOcAccountManager* m_ownerAccountManager;
-#endif
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/android/android_api/base/jni/JniOnPutListener.cpp b/android/android_api/base/jni/JniOnPutListener.cpp
index 5e2dd4a..6a4d147 100644 (file)
--- a/android/android_api/base/jni/JniOnPutListener.cpp
+++ b/android/android_api/base/jni/JniOnPutListener.cpp
@@ -24,8 +24,8 @@
 #include "JniOcRepresentation.h"
 #include "JniUtils.h"
 
-JniOnPutListener::JniOnPutListener(JNIEnv *env, jobject jListener, JniOcResource* owner)
-    : m_ownerResource(owner)
+JniOnPutListener::JniOnPutListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener)
+    : m_removeListener(removeListener)
 {
     m_jwListener = env->NewWeakGlobalRef(jListener);
 }
@@ -168,11 +168,11 @@ void JniOnPutListener::checkExAndRemoveListener(JNIEnv* env)
     {
         jthrowable ex = env->ExceptionOccurred();
         env->ExceptionClear();
-        m_ownerResource->removeOnPutListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
         env->Throw((jthrowable)ex);
     }
     else
     {
-        m_ownerResource->removeOnPutListener(env, m_jwListener);
+        m_removeListener(env, m_jwListener);
     }
 }

diff --git a/android/android_api/base/jni/JniOnPutListener.h b/android/android_api/base/jni/JniOnPutListener.h
index 80057e1..e8fccaf 100644 (file)
--- a/android/android_api/base/jni/JniOnPutListener.h
+++ b/android/android_api/base/jni/JniOnPutListener.h
@@ -26,19 +26,18 @@
 
 using namespace OC;
 
-class JniOcResource;
-
 class JniOnPutListener
 {
 public:
-    JniOnPutListener(JNIEnv *env, jobject jListener, JniOcResource* resource);
+    JniOnPutListener(JNIEnv *env, jobject jListener, RemoveListenerCallback removeListener);
     ~JniOnPutListener();
-
     void onPutCallback(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode);
 
+
+
 private:
     jweak m_jwListener;
-    JniOcResource* m_ownerResource;
+    RemoveListenerCallback m_removeListener;
     void checkExAndRemoveListener(JNIEnv *env);
 };
 

diff --git a/service/easy-setup/mediator/richsdk/android/EasySetupCore/src/main/jni/JniJvm.h b/service/easy-setup/mediator/richsdk/android/EasySetupCore/src/main/jni/JniJvm.h
index ce8111b..30a5a64 100755 (executable)
--- a/service/easy-setup/mediator/richsdk/android/EasySetupCore/src/main/jni/JniJvm.h
+++ b/service/easy-setup/mediator/richsdk/android/EasySetupCore/src/main/jni/JniJvm.h
@@ -65,8 +65,6 @@ extern jmethodID g_mid_CloudPropProvisioningStatus_ctor;
 extern jmethodID g_mid_Integer_ctor;
 extern jmethodID g_mid_OcRepresentation_N_ctor_bool;
 
-typedef void(*RemoveListenerCallback)(JNIEnv *env, jobject jListener);
-
 /**
  * @brief Get the native handle field
  */