android/android_api/base/jni/JniOcRDClient.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20 #include "JniOcRDClient.h"
  21 #include "JniUtils.h"
  22 #include "JniOcResourceHandle.h"
  23
  24 #include "RDClient.h"
  25
  26 void RemoveOnPublishResourceListener(JNIEnv* env, jobject jListener)
  27 {
  28     if (!env)
  29     {
  30         LOGE("env is null");
  31         return;
  32     }
  33
  34     publishResourceListenerMapLock.lock();
  35     bool isFound = false;
  36     for (auto it = onPublishResourceListenerMap.begin(); it != onPublishResourceListenerMap.end(); ++it)
  37     {
  38         if (env->IsSameObject(jListener, it->first))
  39         {
  40             auto refPair = it->second;
  41             if (refPair.second > 1)
  42             {
  43                 refPair.second--;
  44                 it->second = refPair;
  45                 onPublishResourceListenerMap.insert(*it);
  46                 LOGI("onPublishResourceListener: ref. count decremented");
  47             }
  48             else
  49             {
  50                 env->DeleteGlobalRef(it->first);
  51                 JniOnPublishResourceListener* listener = refPair.first;
  52                 delete listener;
  53                 onPublishResourceListenerMap.erase(it);
  54                 LOGI("onPublishResourceListener is removed");
  55             }
  56             isFound = true;
  57             break;
  58         }
  59     }
  60     if (!isFound)
  61     {
  62         ThrowOcException(JNI_EXCEPTION, "onPublishResourceListener not found");
  63     }
  64     publishResourceListenerMapLock.unlock();
  65 }
  66
  67 JniOnPublishResourceListener* AddOnPublishResourceListener(JNIEnv* env, jobject jListener)
  68 {
  69     if (!env)
  70     {
  71         LOGD("env is null");
  72         return nullptr;
  73     }
  74
  75     JniOnPublishResourceListener *onPublishResourceListener = nullptr;
  76
  77     publishResourceListenerMapLock.lock();
  78
  79     for (auto it = onPublishResourceListenerMap.begin(); it !=
  80             onPublishResourceListenerMap.end(); ++it)
  81     {
  82         if (env->IsSameObject(jListener, it->first))
  83         {
  84             auto refPair = it->second;
  85             onPublishResourceListener = refPair.first;
  86             refPair.second++;
  87             it->second = refPair;
  88             onPublishResourceListenerMap.insert(*it);
  89             LOGD("onPublishResourceListener: ref. count incremented");
  90             break;
  91         }
  92     }
  93     if (!onPublishResourceListener)
  94     {
  95         onPublishResourceListener = new JniOnPublishResourceListener(env, jListener,
  96                 RemoveOnPublishResourceListener);
  97
  98         jobject jgListener = env->NewGlobalRef(jListener);
  99         onPublishResourceListenerMap.insert(
 100                 std::pair<jobject, std::pair<JniOnPublishResourceListener*, int>>(
 101                     jgListener,
 102                     std::pair<JniOnPublishResourceListener*, int>(onPublishResourceListener, 1)));
 103         LOGI("onPublishResourceListener: new listener");
 104     }
 105     publishResourceListenerMapLock.unlock();
 106     return onPublishResourceListener;
 107 }
 108
 109 void RemoveOnDeleteResourceListener(JNIEnv* env, jobject jListener)
 110 {
 111     if (!env)
 112     {
 113         LOGE("env is null");
 114         return;
 115     }
 116
 117     deleteResourceListenerMapLock.lock();
 118     bool isFound = false;
 119     for (auto it = onDeleteResourceListenerMap.begin(); it !=
 120             onDeleteResourceListenerMap.end(); ++it)
 121     {
 122         if (env->IsSameObject(jListener, it->first))
 123         {
 124             auto refPair = it->second;
 125             if (refPair.second > 1)
 126             {
 127                 refPair.second--;
 128                 it->second = refPair;
 129                 onDeleteResourceListenerMap.insert(*it);
 130                 LOGI("onDeleteResourceListener: ref. count decremented");
 131             }
 132             else
 133             {
 134                 env->DeleteGlobalRef(it->first);
 135                 JniOnDeleteResourceListener* listener = refPair.first;
 136                 delete listener;
 137                 onDeleteResourceListenerMap.erase(it);
 138                 LOGI("onDeleteResourceListener is removed");
 139             }
 140             isFound = true;
 141             break;
 142         }
 143     }
 144     if (!isFound)
 145     {
 146         ThrowOcException(JNI_EXCEPTION, "onDeleteResourceListener not found");
 147     }
 148     deleteResourceListenerMapLock.unlock();
 149 }
 150
 151 JniOnDeleteResourceListener* AddOnDeleteResourceListener(JNIEnv* env, jobject jListener)
 152 {
 153     if (!env)
 154     {
 155         LOGD("env is null");
 156         return nullptr;
 157     }
 158
 159     JniOnDeleteResourceListener *onDeleteResourceListener = nullptr;
 160
 161     deleteResourceListenerMapLock.lock();
 162
 163     for (auto it = onDeleteResourceListenerMap.begin(); it !=
 164             onDeleteResourceListenerMap.end(); ++it)
 165     {
 166         if (env->IsSameObject(jListener, it->first))
 167         {
 168             auto refPair = it->second;
 169             onDeleteResourceListener = refPair.first;
 170             refPair.second++;
 171             it->second = refPair;
 172             onDeleteResourceListenerMap.insert(*it);
 173             LOGD("onDeleteResourceListener: ref. count incremented");
 174             break;
 175         }
 176     }
 177     if (!onDeleteResourceListener)
 178     {
 179         onDeleteResourceListener = new JniOnDeleteResourceListener(env, jListener,
 180                 RemoveOnDeleteResourceListener);
 181         jobject jgListener = env->NewGlobalRef(jListener);
 182         onDeleteResourceListenerMap.insert(
 183                 std::pair<jobject, std::pair<JniOnDeleteResourceListener*, int>>(
 184                     jgListener,
 185                     std::pair<JniOnDeleteResourceListener*, int>(onDeleteResourceListener, 1)));
 186         LOGI("onDeleteResourceListener: new listener");
 187     }
 188     deleteResourceListenerMapLock.unlock();
 189     return onDeleteResourceListener;
 190 }
 191
 192 /*
 193  * Class:     org_iotivity_base_OcRDClient
 194  * Method:    publishResourceToRD0
 195  * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcRDClient/OnPublishResourceListener;I)V
 196  */
 197 JNIEXPORT void JNICALL Java_org_iotivity_base_OcRDClient_publishResourceToRD0(
 198         JNIEnv *env,
 199         jclass clazz,
 200         jstring jHost,
 201         jint jConnectivityType,
 202         jobject jListener,
 203         jint jQoS)
 204 {
 205     LOGD("OcRDClient_publishResourceToRD");
 206 #ifdef RD_CLIENT
 207     std::string host;
 208     if (jHost)
 209     {
 210         host = env->GetStringUTFChars(jHost, nullptr);
 211     }
 212     if (!jListener)
 213     {
 214         ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
 215         return;
 216     }
 217     JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
 218
 219     PublishResourceCallback pubResCallback = [onPubResListener](
 220             const OCRepresentation& ocRepresentation,
 221             const int eCode)
 222     {
 223         onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
 224     };
 225
 226     try
 227     {
 228         OCStackResult result = RDClient::Instance().publishResourceToRD(
 229             host,
 230             static_cast<OCConnectivityType>(jConnectivityType),
 231             pubResCallback,
 232             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 233
 234         if (OC_STACK_OK != result)
 235         {
 236             ThrowOcException(result, "Publish resource has failed");
 237             return;
 238         }
 239     }
 240     catch (OCException& e)
 241     {
 242         LOGE("%s", e.reason().c_str());
 243         ThrowOcException(e.code(), e.reason().c_str());
 244     }
 245 #else
 246     ThrowOcException(JNI_NO_SUPPORT, "Not supported");
 247     return;
 248 #endif
 249 }
 250
 251 /*
 252  * Class:     org_iotivity_base_OcRDClient
 253  * Method:    publishResourceToRD1
 254  * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcRDClient/OnPublishResourceListener;I)V
 255  */
 256 JNIEXPORT void JNICALL Java_org_iotivity_base_OcRDClient_publishResourceToRD1(
 257         JNIEnv *env,
 258         jclass clazz,
 259         jstring jHost,
 260         jint jConnectivityType,
 261         jobjectArray jResourceHandleArray,
 262         jobject jListener,
 263         jint jQoS)
 264 {
 265     LOGD("OcRDClient_publishResourceToRD");
 266 #ifdef RD_CLIENT
 267     if (!env)
 268     {
 269         LOGE("env is null");
 270         return;
 271     }
 272     std::string host;
 273     if (jHost)
 274     {
 275         host = env->GetStringUTFChars(jHost, nullptr);
 276     }
 277     if (!jListener)
 278     {
 279         ThrowOcException(OC_STACK_INVALID_PARAM, "onPublishResourceListener cannot be null");
 280         return;
 281     }
 282     if (!jResourceHandleArray)
 283     {
 284         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
 285         return;
 286     }
 287     JniOnPublishResourceListener *onPubResListener = AddOnPublishResourceListener(env, jListener);
 288
 289     PublishResourceCallback pubResCallback = [onPubResListener](
 290             const OCRepresentation& ocRepresentation,
 291             const int eCode)
 292     {
 293         onPubResListener->onPublishResourceCallback(ocRepresentation, eCode);
 294     };
 295
 296     std::vector<OCResourceHandle> resourceHandleList;
 297     size_t len = env->GetArrayLength(jResourceHandleArray);
 298     for (size_t i = 0; i < len; ++i)
 299     {
 300         jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
 301         if (!jResourceHandle)
 302         {
 303             ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
 304             return;
 305         }
 306         JniOcResourceHandle* jniOcResourceHandle =
 307             JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 308         if (!jniOcResourceHandle)
 309         {
 310             ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
 311             return;
 312         }
 313
 314         resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
 315     }
 316
 317     try
 318     {
 319         OCStackResult result = RDClient::Instance().publishResourceToRD(
 320             host,
 321             static_cast<OCConnectivityType>(jConnectivityType),
 322             resourceHandleList,
 323             pubResCallback,
 324             JniUtils::getQOS(env, static_cast<int>(jQoS)));
 325
 326         if (OC_STACK_OK != result)
 327         {
 328             ThrowOcException(result, "Publish resource has failed");
 329             return;
 330         }
 331     }
 332     catch (OCException& e)
 333     {
 334         LOGE("%s", e.reason().c_str());
 335         ThrowOcException(e.code(), e.reason().c_str());
 336     }
 337 #else
 338     ThrowOcException(JNI_NO_SUPPORT, "Not supported");
 339     return;
 340 #endif
 341 }
 342
 343 /*
 344  * Class:     org_iotivity_base_OcRDClient
 345  * Method:    deleteResourceFromRD0
 346  * Signature: (Ljava/lang/String;ILorg/iotivity/base/OcRDClient/OnDeleteResourceListener;I)V
 347  */
 348 JNIEXPORT void JNICALL Java_org_iotivity_base_OcRDClient_deleteResourceFromRD0(
 349         JNIEnv *env,
 350         jclass clazz,
 351         jstring jHost,
 352         jint jConnectivityType,
 353         jobject jListener,
 354         jint jQoS)
 355 {
 356     LOGD("OcRDClient_deleteResourceFromRD");
 357 #ifdef RD_CLIENT
 358     std::string host;
 359     if (jHost)
 360     {
 361         host = env->GetStringUTFChars(jHost, nullptr);
 362     }
 363     if (!jListener)
 364     {
 365         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
 366         return;
 367     }
 368     JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
 369
 370     DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
 371     {
 372         onDelResListener->onDeleteResourceCallback(eCode);
 373     };
 374     try
 375      {
 376          OCStackResult result = RDClient::Instance().deleteResourceFromRD(
 377              host,
 378              static_cast<OCConnectivityType>(jConnectivityType),
 379              delResCallback,
 380              JniUtils::getQOS(env, static_cast<int>(jQoS)));
 381
 382          if (OC_STACK_OK != result)
 383          {
 384              ThrowOcException(result, "Delete resource has failed");
 385              return;
 386          }
 387      }
 388      catch (OCException& e)
 389      {
 390          LOGE("%s", e.reason().c_str());
 391          ThrowOcException(e.code(), e.reason().c_str());
 392      }
 393  #else
 394      ThrowOcException(JNI_NO_SUPPORT, "Not supported");
 395      return;
 396  #endif
 397  }
 398
 399  /*
 400   * Class:     org_iotivity_base_OcRDClient
 401   * Method:    deleteResourceFromRD1
 402   * Signature: (Ljava/lang/String;I[Lorg/iotivity/base/OcResourceHandle;Lorg/iotivity/base/OcRDClient/OnDeleteResourceListener;I)V
 403   */
 404  JNIEXPORT void JNICALL Java_org_iotivity_base_OcRDClient_deleteResourceFromRD1(
 405          JNIEnv *env,
 406          jclass clazz,
 407          jstring jHost,
 408          jint jConnectivityType,
 409          jobjectArray jResourceHandleArray,
 410          jobject jListener,
 411          jint jQoS)
 412  {
 413      LOGD("OcRDClient_deleteResourceFromRD");
 414  #ifdef RD_CLIENT
 415      if (!env)
 416      {
 417          LOGE("env is null");
 418          return;
 419      }
 420      std::string host;
 421      if (jHost)
 422      {
 423          host = env->GetStringUTFChars(jHost, nullptr);
 424      }
 425      if (!jListener)
 426      {
 427          ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteResourceListener cannot be null");
 428          return;
 429      }
 430      if (!jResourceHandleArray)
 431      {
 432          ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandleList cannot be null");
 433          return;
 434      }
 435      JniOnDeleteResourceListener *onDelResListener = AddOnDeleteResourceListener(env, jListener);
 436
 437      DeleteResourceCallback delResCallback = [onDelResListener](const int eCode)
 438      {
 439          onDelResListener->onDeleteResourceCallback(eCode);
 440      };
 441
 442      std::vector<OCResourceHandle> resourceHandleList;
 443      size_t len = env->GetArrayLength(jResourceHandleArray);
 444      for (size_t i = 0; i < len; ++i)
 445      {
 446          jobject jResourceHandle = env->GetObjectArrayElement(jResourceHandleArray, i);
 447          if (!jResourceHandle)
 448          {
 449              ThrowOcException(JNI_EXCEPTION, "resource handle cannot be null");
 450              return;
 451          }
 452
 453          JniOcResourceHandle* jniOcResourceHandle =
 454              JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 455          if (!jniOcResourceHandle)
 456          {
 457              ThrowOcException(OC_STACK_INVALID_PARAM, "resource handle is invalid");
 458              return;
 459          }
 460
 461          resourceHandleList.push_back(jniOcResourceHandle->getOCResourceHandle());
 462      }
 463
 464      try
 465      {
 466          OCStackResult result = RDClient::Instance().deleteResourceFromRD(
 467              host,
 468              static_cast<OCConnectivityType>(jConnectivityType),
 469              resourceHandleList,
 470              delResCallback,
 471              JniUtils::getQOS(env, static_cast<int>(jQoS)));
 472
 473          if (OC_STACK_OK != result)
 474          {
 475              ThrowOcException(result, "Delete resource has failed");
 476              return;
 477          }
 478      }
 479      catch (OCException& e)
 480      {
 481          LOGE("%s", e.reason().c_str());
 482          ThrowOcException(e.code(), e.reason().c_str());
 483      }
 484  #else
 485      ThrowOcException(JNI_NO_SUPPORT, "Not supported");
 486      return;
 487  #endif
 488  }