android/android_api/base/jni/JniOcAccountManager.cpp

   1 /*
   2  *******************************************************************
   3  *
   4  * Copyright 2016 Samsung Electronics All Rights Reserved.
   5  *
   6  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22
  23 #include "JniOcAccountManager.h"
  24 #include "JniOcRepresentation.h"
  25 #include "JniUtils.h"
  26
  27 #define VERIFY_NON_NULL_THROW_EXCEPTION(arg, log_message, exc) \
  28     if (!(arg)) \
  29     { \
  30         ThrowOcException(exc, log_message); \
  31         return; \
  32     } \
  33
  34 JniOcAccountManager::JniOcAccountManager(std::shared_ptr<OCAccountManager> accountManager)
  35     : m_sharedAccountManager(accountManager)
  36 {
  37 }
  38
  39 JniOcAccountManager::~JniOcAccountManager()
  40 {
  41     LOGD("~JniOcAccountManager()");
  42
  43     m_sharedAccountManager = nullptr;
  44
  45     jint envRet = JNI_ERR;
  46     JNIEnv *env = GetJNIEnv(envRet);
  47     if (nullptr == env)
  48     {
  49         return;
  50     }
  51
  52     m_onGetManager.removeAllListeners(env);
  53     m_onPostManager.removeAllListeners(env);
  54     m_onDeleteManager.removeAllListeners(env);
  55     m_onObserveManager.removeAllListeners(env);
  56
  57     if (JNI_EDETACHED == envRet)
  58     {
  59         g_jvm->DetachCurrentThread();
  60     }
  61 }
  62
  63 std::string JniOcAccountManager::host()
  64 {
  65     return m_sharedAccountManager->host();
  66 }
  67
  68 OCConnectivityType JniOcAccountManager::connectivityType() const
  69 {
  70     return m_sharedAccountManager->connectivityType();
  71 }
  72
  73 JniOcAccountManager* JniOcAccountManager::getJniOcAccountManagerPtr(JNIEnv *env, jobject thiz)
  74 {
  75     JniOcAccountManager *accountManager = GetHandle<JniOcAccountManager>(env, thiz);
  76     if (env->ExceptionCheck())
  77     {
  78         LOGE("Failed to get native handle from OcAccountManager");
  79     }
  80     if (!accountManager)
  81     {
  82         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
  83     }
  84     return accountManager;
  85 }
  86
  87 JniOnGetListener* JniOcAccountManager::addOnGetListener(JNIEnv* env, jobject jListener)
  88 {
  89     return this->m_onGetManager.addListener(env, jListener, this);
  90 }
  91
  92 JniOnPostListener* JniOcAccountManager::addOnPostListener(JNIEnv* env, jobject jListener)
  93 {
  94     return this->m_onPostManager.addListener(env, jListener, this);
  95 }
  96
  97 JniOnDeleteListener* JniOcAccountManager::addOnDeleteListener(JNIEnv* env, jobject jListener)
  98 {
  99     return this->m_onDeleteManager.addListener(env, jListener, this);
 100 }
 101
 102 JniOnObserveListener* JniOcAccountManager::addOnObserveListener(JNIEnv* env, jobject jListener)
 103 {
 104     return this->m_onObserveManager.addListener(env, jListener, this);
 105 }
 106
 107 void JniOcAccountManager::removeOnGetListener(JNIEnv* env, jobject jListener)
 108 {
 109     this->m_onGetManager.removeListener(env, jListener);
 110 }
 111
 112 void JniOcAccountManager::removeOnPostListener(JNIEnv* env, jobject jListener)
 113 {
 114     this->m_onPostManager.removeListener(env, jListener);
 115 }
 116
 117 void JniOcAccountManager::removeOnDeleteListener(JNIEnv* env, jobject jListener)
 118 {
 119     this->m_onDeleteManager.removeListener(env, jListener);
 120 }
 121
 122 void JniOcAccountManager::removeOnObserveListener(JNIEnv* env, jobject jListener)
 123 {
 124     this->m_onObserveManager.removeListener(env, jListener);
 125 }
 126
 127 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
 128                                           const std::string& authCode, jobject jListener)
 129 {
 130     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 131     if (nullptr == onPostListener)
 132     {
 133         LOGE("onPostListener is null");
 134         return OC_STACK_ERROR;
 135     }
 136
 137     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 138         const OCRepresentation& rep, const int eCode)
 139     {
 140         onPostListener->onPostCallback(opts, rep, eCode);
 141     };
 142
 143     return m_sharedAccountManager->signUp(authProvider, authCode, postCallback);
 144 }
 145
 146 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
 147                                           const std::string& authCode,
 148                                           const QueryParamsMap& options, jobject jListener)
 149 {
 150     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 151     if (nullptr == onPostListener)
 152     {
 153         LOGE("onPostListener is null");
 154         return OC_STACK_ERROR;
 155     }
 156
 157     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 158         const OCRepresentation& rep, const int eCode)
 159     {
 160         onPostListener->onPostCallback(opts, rep, eCode);
 161     };
 162
 163     return m_sharedAccountManager->signUp(authProvider, authCode, options, postCallback);
 164 }
 165
 166 OCStackResult JniOcAccountManager::signIn(JNIEnv* env, const std::string& userUuid,
 167                                           const std::string& accessToken, jobject jListener)
 168 {
 169     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 170     if (nullptr == onPostListener)
 171     {
 172         LOGE("onPostListener is null");
 173         return OC_STACK_ERROR;
 174     }
 175
 176     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 177         const OCRepresentation& rep, const int eCode)
 178     {
 179         onPostListener->onPostCallback(opts, rep, eCode);
 180     };
 181
 182     return m_sharedAccountManager->signIn(userUuid, accessToken, postCallback);
 183 }
 184
 185 OCStackResult JniOcAccountManager::signOut(JNIEnv* env, const std::string& accessToken,
 186                                            jobject jListener)
 187 {
 188     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 189     if (nullptr == onPostListener)
 190     {
 191         LOGE("onPostListener is null");
 192         return OC_STACK_ERROR;
 193     }
 194
 195     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 196         const OCRepresentation& rep, const int eCode)
 197     {
 198         onPostListener->onPostCallback(opts, rep, eCode);
 199     };
 200
 201     return m_sharedAccountManager->signOut(accessToken, postCallback);
 202 }
 203
 204 OCStackResult JniOcAccountManager::refreshAccessToken(JNIEnv* env, const std::string& userUuid,
 205                                                       const std::string& refreshToken,
 206                                                       jobject jListener)
 207 {
 208     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 209     if (nullptr == onPostListener)
 210     {
 211         LOGE("onPostListener is null");
 212         return OC_STACK_ERROR;
 213     }
 214
 215     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 216         const OCRepresentation& rep, const int eCode)
 217     {
 218         onPostListener->onPostCallback(opts, rep, eCode);
 219     };
 220
 221     return m_sharedAccountManager->refreshAccessToken(userUuid, refreshToken, postCallback);
 222 }
 223
 224 OCStackResult JniOcAccountManager::searchUser(JNIEnv* env, const QueryParamsMap& queryMap,
 225                                               jobject jListener)
 226 {
 227     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 228     if (nullptr == onGetListener)
 229     {
 230         LOGE("onGetListener is null");
 231         return OC_STACK_ERROR;
 232     }
 233
 234     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 235         const OCRepresentation& rep, const int eCode)
 236     {
 237         onGetListener->onGetCallback(opts, rep, eCode);
 238     };
 239
 240     return m_sharedAccountManager->searchUser(queryMap, getCallback);
 241 }
 242
 243 OCStackResult JniOcAccountManager::deleteDevice(JNIEnv* env, const std::string& accessToken,
 244                                                 const std::string& deviceId, jobject jListener)
 245 {
 246     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 247     if (nullptr == onDeleteListener)
 248     {
 249         LOGE("onDeleteListener is null");
 250         return OC_STACK_ERROR;
 251     }
 252
 253     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 254         const int eCode)
 255     {
 256         onDeleteListener->onDeleteCallback(opts, eCode);
 257     };
 258
 259     return m_sharedAccountManager->deleteDevice(accessToken, deviceId, deleteCallback);
 260 }
 261
 262 OCStackResult JniOcAccountManager::createGroup(JNIEnv* env, jobject jListener)
 263 {
 264     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 265     if (nullptr == onPostListener)
 266     {
 267         LOGE("onPostListener is null");
 268         return OC_STACK_ERROR;
 269     }
 270
 271     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 272         const OCRepresentation& rep, const int eCode)
 273     {
 274         onPostListener->onPostCallback(opts, rep, eCode);
 275     };
 276
 277     return m_sharedAccountManager->createGroup(postCallback);
 278 }
 279
 280 OCStackResult JniOcAccountManager::createGroup(JNIEnv* env, const QueryParamsMap& queryMap,
 281                                                jobject jListener)
 282 {
 283     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 284     if (nullptr == onPostListener)
 285     {
 286         LOGE("onPostListener is null");
 287         return OC_STACK_ERROR;
 288     }
 289
 290     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 291         const OCRepresentation& rep, const int eCode)
 292     {
 293         onPostListener->onPostCallback(opts, rep, eCode);
 294     };
 295
 296     return m_sharedAccountManager->createGroup(queryMap, postCallback);
 297 }
 298
 299 OCStackResult JniOcAccountManager::deleteGroup(JNIEnv* env, const std::string& groupId,
 300                                                jobject jListener)
 301 {
 302     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 303     if (nullptr == onDeleteListener)
 304     {
 305         LOGE("onDeleteListener is null");
 306         return OC_STACK_ERROR;
 307     }
 308
 309     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 310         const int eCode)
 311     {
 312         onDeleteListener->onDeleteCallback(opts, eCode);
 313     };
 314
 315     return m_sharedAccountManager->deleteGroup(groupId, deleteCallback);
 316 }
 317
 318 OCStackResult JniOcAccountManager::getGroupInfoAll(JNIEnv* env, jobject jListener)
 319 {
 320     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 321     if (nullptr == onGetListener)
 322     {
 323         LOGE("onGetListener is null");
 324         return OC_STACK_ERROR;
 325     }
 326
 327     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 328         const OCRepresentation& rep, const int eCode)
 329     {
 330         onGetListener->onGetCallback(opts, rep, eCode);
 331     };
 332
 333     return m_sharedAccountManager->getGroupInfoAll(getCallback);
 334 }
 335
 336 OCStackResult JniOcAccountManager::getGroupInfo(JNIEnv* env, const std::string& groupId,
 337                                                 jobject jListener)
 338 {
 339     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 340     if (nullptr == onGetListener)
 341     {
 342         LOGE("onGetListener is null");
 343         return OC_STACK_ERROR;
 344     }
 345
 346     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 347         const OCRepresentation& rep, const int eCode)
 348     {
 349         onGetListener->onGetCallback(opts, rep, eCode);
 350     };
 351
 352     return m_sharedAccountManager->getGroupInfo(groupId, getCallback);
 353 }
 354
 355 OCStackResult JniOcAccountManager::addPropertyValueToGroup(JNIEnv* env, const std::string& groupId,
 356                                                            const OCRepresentation& propertyValue,
 357                                                            jobject jListener)
 358 {
 359     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 360     if (nullptr == onPostListener)
 361     {
 362         LOGE("onPostListener is null");
 363         return OC_STACK_ERROR;
 364     }
 365
 366     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 367         const OCRepresentation& rep, const int eCode)
 368     {
 369         onPostListener->onPostCallback(opts, rep, eCode);
 370     };
 371
 372     return m_sharedAccountManager->addPropertyValueToGroup(groupId, propertyValue, postCallback);
 373 }
 374
 375 OCStackResult JniOcAccountManager::deletePropertyValueFromGroup(JNIEnv* env,
 376                                                         const std::string& groupId,
 377                                                         const OCRepresentation& propertyValue,
 378                                                         jobject jListener)
 379 {
 380     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 381     if (nullptr == onPostListener)
 382     {
 383         LOGE("onPostListener is null");
 384         return OC_STACK_ERROR;
 385     }
 386
 387     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 388         const OCRepresentation& rep, const int eCode)
 389     {
 390         onPostListener->onPostCallback(opts, rep, eCode);
 391     };
 392
 393     return m_sharedAccountManager->deletePropertyValueFromGroup(groupId, propertyValue,
 394                                                                 postCallback);
 395 }
 396
 397 OCStackResult JniOcAccountManager::updatePropertyValueOnGroup(JNIEnv* env,
 398                                                         const std::string& groupId,
 399                                                         const OCRepresentation& propertyValue,
 400                                                         jobject jListener)
 401 {
 402     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 403     if (nullptr == onPostListener)
 404     {
 405         LOGE("onPostListener is null");
 406         return OC_STACK_ERROR;
 407     }
 408
 409     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 410         const OCRepresentation& rep, const int eCode)
 411     {
 412         onPostListener->onPostCallback(opts, rep, eCode);
 413     };
 414
 415     return m_sharedAccountManager->updatePropertyValueOnGroup(groupId, propertyValue,
 416                                                               postCallback);
 417 }
 418
 419 OCStackResult JniOcAccountManager::observeGroup(JNIEnv* env, jobject jListener)
 420 {
 421     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 422     if (nullptr == onObserveListener)
 423     {
 424         LOGE("onObserveListener is null");
 425         return OC_STACK_ERROR;
 426     }
 427
 428     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
 429         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
 430     {
 431         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
 432     };
 433
 434     return m_sharedAccountManager->observeGroup(observeCallback);
 435 }
 436
 437 OCStackResult JniOcAccountManager::cancelObserveGroup()
 438 {
 439     return m_sharedAccountManager->cancelObserveGroup();
 440 }
 441
 442 OCStackResult JniOcAccountManager::observeInvitation(JNIEnv* env, jobject jListener)
 443 {
 444     JniOnObserveListener *onObserveListener = addOnObserveListener(env, jListener);
 445     if (nullptr == onObserveListener)
 446     {
 447         LOGE("onObserveListener is null");
 448         return OC_STACK_ERROR;
 449     }
 450
 451     ObserveCallback observeCallback = [onObserveListener](const HeaderOptions& opts,
 452         const OCRepresentation& rep, const int& eCode, const int& sequenceNumber)
 453     {
 454         onObserveListener->onObserveCallback(opts, rep, eCode, sequenceNumber);
 455     };
 456
 457     return m_sharedAccountManager->observeInvitation(observeCallback);
 458 }
 459
 460 OCStackResult JniOcAccountManager::cancelObserveInvitation()
 461 {
 462     return m_sharedAccountManager->cancelObserveInvitation();
 463 }
 464
 465 OCStackResult JniOcAccountManager::sendInvitation(JNIEnv* env, const std::string& groupId,
 466                                                   const std::string& userUuid, jobject jListener)
 467 {
 468     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 469     if (nullptr == onPostListener)
 470     {
 471         LOGE("onPostListener is null");
 472         return OC_STACK_ERROR;
 473     }
 474
 475     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 476         const OCRepresentation& rep, const int eCode)
 477     {
 478         onPostListener->onPostCallback(opts, rep, eCode);
 479     };
 480
 481     return m_sharedAccountManager->sendInvitation(groupId, userUuid, postCallback);
 482 }
 483
 484 OCStackResult JniOcAccountManager::cancelInvitation(JNIEnv* env, const std::string& groupId,
 485                                                     const std::string& userUuid, jobject jListener)
 486 {
 487     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 488     if (nullptr == onDeleteListener)
 489     {
 490         LOGE("onDeleteListener is null");
 491         return OC_STACK_ERROR;
 492     }
 493
 494     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 495         const int eCode)
 496     {
 497         onDeleteListener->onDeleteCallback(opts, eCode);
 498     };
 499
 500     return m_sharedAccountManager->cancelInvitation(groupId, userUuid, deleteCallback);
 501 }
 502
 503 OCStackResult JniOcAccountManager::replyToInvitation(JNIEnv* env, const std::string& groupId,
 504                                                      const bool accept, jobject jListener)
 505 {
 506     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 507     if (nullptr == onDeleteListener)
 508     {
 509         LOGE("onDeleteListener is null");
 510         return OC_STACK_ERROR;
 511     }
 512
 513     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 514         const int eCode)
 515     {
 516         onDeleteListener->onDeleteCallback(opts, eCode);
 517     };
 518
 519     return m_sharedAccountManager->replyToInvitation(groupId, accept, deleteCallback);
 520 }
 521
 522 /*
 523 * Class:     org_iotivity_base_OcAccountManager
 524 * Method:    getHost
 525 * Signature: ()Ljava/lang/String;
 526 */
 527 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcAccountManager_getHost
 528     (JNIEnv *env, jobject thiz)
 529 {
 530     LOGD("OcAccountManager_getHost");
 531     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 532                                                                                          thiz);
 533     if (!accountManager)
 534     {
 535         return nullptr;
 536     }
 537
 538     return env->NewStringUTF(accountManager->host().c_str());
 539 }
 540
 541 /*
 542 * Class:     org_iotivity_base_OcAccountManager
 543 * Method:    getConnectivityTypeN
 544 * Signature: ()I
 545 */
 546 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcAccountManager_getConnectivityTypeN
 547     (JNIEnv *env, jobject thiz)
 548 {
 549     LOGD("OcAccountManager_getConnectivityType");
 550     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 551                                                                                          thiz);
 552     if (!accountManager)
 553     {
 554         return -1;
 555     }
 556
 557     OCConnectivityType connectivityType = accountManager->connectivityType();
 558     return static_cast<jint>(connectivityType);
 559 }
 560
 561 /*
 562 * Class:     org_iotivity_base_OcAccountManager
 563 * Method:    signUp0
 564 * Signature: (Ljava/lang/String;Ljava/lang/String;
 565 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 566 */
 567 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp0
 568     (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jListener)
 569 {
 570     LOGD("OcAccountManager_signUp");
 571     VERIFY_NON_NULL_THROW_EXCEPTION(jAuthProvider, "authProvider cannot be null",
 572                                     OC_STACK_INVALID_PARAM);
 573     VERIFY_NON_NULL_THROW_EXCEPTION(jAuthCode, "authCode cannot be null", OC_STACK_INVALID_PARAM);
 574     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 575                                     OC_STACK_INVALID_PARAM);
 576
 577     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 578                                                                                          thiz);
 579     if (!accountManager)
 580     {
 581         return;
 582     }
 583
 584     const char *charAuthProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
 585     VERIFY_NON_NULL_THROW_EXCEPTION(charAuthProvider, "charAuthProvider is null", JNI_EXCEPTION);
 586     std::string authProvider(charAuthProvider);
 587     env->ReleaseStringUTFChars(jAuthProvider, charAuthProvider);
 588
 589     const char *charAuthCode = env->GetStringUTFChars(jAuthCode, nullptr);
 590     VERIFY_NON_NULL_THROW_EXCEPTION(charAuthCode, "charAuthCode is null", JNI_EXCEPTION);
 591     std::string authCode(charAuthCode);
 592     env->ReleaseStringUTFChars(jAuthCode, charAuthCode);
 593
 594     try
 595     {
 596         OCStackResult result = accountManager->signUp(env,
 597                                                       authProvider,
 598                                                       authCode,
 599                                                       jListener);
 600         if (OC_STACK_OK != result)
 601         {
 602             ThrowOcException(result, "OcAccountManager_signUp");
 603         }
 604     }
 605     catch (OCException& e)
 606     {
 607         LOGE("%s", e.reason().c_str());
 608         ThrowOcException(e.code(), e.reason().c_str());
 609     }
 610 }
 611
 612 /*
 613 * Class:     org_iotivity_base_OcAccountManager
 614 * Method:    signUp1
 615 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;
 616 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 617 */
 618 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp1
 619     (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jOptionsMap,
 620      jobject jListener)
 621 {
 622     LOGD("OcAccountManager_signUp");
 623     VERIFY_NON_NULL_THROW_EXCEPTION(jAuthProvider, "authProvider cannot be null",
 624                                     OC_STACK_INVALID_PARAM);
 625     VERIFY_NON_NULL_THROW_EXCEPTION(jAuthCode, "authCode cannot be null", OC_STACK_INVALID_PARAM);
 626     VERIFY_NON_NULL_THROW_EXCEPTION(jOptionsMap, "options cannot be null", OC_STACK_INVALID_PARAM);
 627     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 628                                     OC_STACK_INVALID_PARAM);
 629
 630     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 631                                                                                          thiz);
 632     if (!accountManager)
 633     {
 634         return;
 635     }
 636
 637     const char *charAuthProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
 638     VERIFY_NON_NULL_THROW_EXCEPTION(charAuthProvider, "charAuthProvider is null", JNI_EXCEPTION);
 639     std::string authProvider(charAuthProvider);
 640     env->ReleaseStringUTFChars(jAuthProvider, charAuthProvider);
 641
 642     const char *charAuthCode = env->GetStringUTFChars(jAuthCode, nullptr);
 643     VERIFY_NON_NULL_THROW_EXCEPTION(charAuthCode, "charAuthCode is null", JNI_EXCEPTION);
 644     std::string authCode(charAuthCode);
 645     env->ReleaseStringUTFChars(jAuthCode, charAuthCode);
 646
 647     QueryParamsMap optionsMap;
 648     JniUtils::convertJavaMapToQueryParamsMap(env, jOptionsMap, optionsMap);
 649
 650     try
 651     {
 652         OCStackResult result = accountManager->signUp(env,
 653                                                       authProvider,
 654                                                       authCode,
 655                                                       optionsMap,
 656                                                       jListener);
 657         if (OC_STACK_OK != result)
 658         {
 659             ThrowOcException(result, "OcAccountManager_signUp");
 660         }
 661     }
 662     catch (OCException& e)
 663     {
 664         LOGE("%s", e.reason().c_str());
 665         ThrowOcException(e.code(), e.reason().c_str());
 666     }
 667 }
 668
 669 /*
 670 * Class:     org_iotivity_base_OcAccountManager
 671 * Method:    signIn0
 672 * Signature: (Ljava/lang/String;Ljava/lang/String;
 673 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 674 */
 675 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signIn0
 676     (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jAccessToken, jobject jListener)
 677 {
 678     LOGD("OcAccountManager_signIn");
 679     VERIFY_NON_NULL_THROW_EXCEPTION(jUserUuid, "userUuid cannot be null", OC_STACK_INVALID_PARAM);
 680     VERIFY_NON_NULL_THROW_EXCEPTION(jAccessToken, "accessToken cannot be null",
 681                                     OC_STACK_INVALID_PARAM);
 682     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 683                                     OC_STACK_INVALID_PARAM);
 684
 685     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 686                                                                                          thiz);
 687     if (!accountManager)
 688     {
 689         return;
 690     }
 691
 692     const char *charUserUuid = env->GetStringUTFChars(jUserUuid, nullptr);
 693     VERIFY_NON_NULL_THROW_EXCEPTION(charUserUuid, "charUserUuid is null", JNI_EXCEPTION);
 694     std::string userUuid(charUserUuid);
 695     env->ReleaseStringUTFChars(jUserUuid, charUserUuid);
 696
 697     const char *charAccessToken = env->GetStringUTFChars(jAccessToken, nullptr);
 698     VERIFY_NON_NULL_THROW_EXCEPTION(charAccessToken, "charAccessToken is null", JNI_EXCEPTION);
 699     std::string accessToken(charAccessToken);
 700     env->ReleaseStringUTFChars(jAccessToken, charAccessToken);
 701
 702     try
 703     {
 704         OCStackResult result = accountManager->signIn(env,
 705                                                       userUuid,
 706                                                       accessToken,
 707                                                       jListener);
 708         if (OC_STACK_OK != result)
 709         {
 710             ThrowOcException(result, "OcAccountManager_signIn");
 711         }
 712     }
 713     catch (OCException& e)
 714     {
 715         LOGE("%s", e.reason().c_str());
 716         ThrowOcException(e.code(), e.reason().c_str());
 717     }
 718 }
 719
 720 /*
 721 * Class:     org_iotivity_base_OcAccountManager
 722 * Method:    signOut0
 723 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 724 */
 725 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signOut0
 726     (JNIEnv *env, jobject thiz, jstring jAccessToken, jobject jListener)
 727 {
 728     LOGD("OcAccountManager_signOut");
 729     VERIFY_NON_NULL_THROW_EXCEPTION(jAccessToken, "accessToken cannot be null",
 730                                     OC_STACK_INVALID_PARAM);
 731     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 732                                     OC_STACK_INVALID_PARAM);
 733
 734     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 735                                                                                          thiz);
 736     if (!accountManager)
 737     {
 738         return;
 739     }
 740
 741     const char *charAccessToken = env->GetStringUTFChars(jAccessToken, nullptr);
 742     VERIFY_NON_NULL_THROW_EXCEPTION(charAccessToken, "charAccessToken is null", JNI_EXCEPTION);
 743     std::string accessToken(charAccessToken);
 744     env->ReleaseStringUTFChars(jAccessToken, charAccessToken);
 745
 746     try
 747     {
 748         OCStackResult result = accountManager->signOut(env,
 749                                                        accessToken,
 750                                                        jListener);
 751         if (OC_STACK_OK != result)
 752         {
 753             ThrowOcException(result, "OcAccountManager_signOut");
 754         }
 755     }
 756     catch (OCException& e)
 757     {
 758         LOGE("%s", e.reason().c_str());
 759         ThrowOcException(e.code(), e.reason().c_str());
 760     }
 761 }
 762
 763 /*
 764 * Class:     org_iotivity_base_OcAccountManager
 765 * Method:    refreshAccessToken0
 766 * Signature: (Ljava/lang/String;Ljava/lang/String;
 767 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 768 */
 769 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_refreshAccessToken0
 770     (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jRefreshAccessToken, jobject jListener)
 771 {
 772     LOGD("OcAccountManager_refreshAccessToken");
 773     VERIFY_NON_NULL_THROW_EXCEPTION(jUserUuid, "userUuid cannot be null", OC_STACK_INVALID_PARAM);
 774     VERIFY_NON_NULL_THROW_EXCEPTION(jRefreshAccessToken, "refreshAccessToken cannot be null",
 775                                     OC_STACK_INVALID_PARAM);
 776     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 777                                     OC_STACK_INVALID_PARAM);
 778
 779     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 780                                                                                          thiz);
 781     if (!accountManager)
 782     {
 783         return;
 784     }
 785
 786     const char *charUserUuid = env->GetStringUTFChars(jUserUuid, nullptr);
 787     VERIFY_NON_NULL_THROW_EXCEPTION(charUserUuid, "charUserUuid is null", JNI_EXCEPTION);
 788     std::string userUuid(charUserUuid);
 789     env->ReleaseStringUTFChars(jUserUuid, charUserUuid);
 790
 791     const char *charRefreshAccessToken = env->GetStringUTFChars(jRefreshAccessToken, nullptr);
 792     VERIFY_NON_NULL_THROW_EXCEPTION(charRefreshAccessToken, "charRefreshAccessToken is null",
 793                                     JNI_EXCEPTION);
 794     std::string refreshAccessToken(charRefreshAccessToken);
 795     env->ReleaseStringUTFChars(jRefreshAccessToken, charRefreshAccessToken);
 796
 797     try
 798     {
 799         OCStackResult result = accountManager->refreshAccessToken(env,
 800                                                                   userUuid,
 801                                                                   refreshAccessToken,
 802                                                                   jListener);
 803         if (OC_STACK_OK != result)
 804         {
 805             ThrowOcException(result, "OcAccountManager_refreshAccessToken");
 806         }
 807     }
 808     catch (OCException& e)
 809     {
 810         LOGE("%s", e.reason().c_str());
 811         ThrowOcException(e.code(), e.reason().c_str());
 812     }
 813 }
 814
 815 /*
 816 * Class:     org_iotivity_base_OcAccountManager
 817 * Method:    searchUser0
 818 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
 819 */
 820 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_searchUser0
 821     (JNIEnv *env, jobject thiz, jobject jQueryMap, jobject jListener)
 822 {
 823     LOGD("OcAccountManager_searchUser");
 824     VERIFY_NON_NULL_THROW_EXCEPTION(jQueryMap, "queryMap cannot be null", OC_STACK_INVALID_PARAM);
 825     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onGetListener cannot be null",
 826                                     OC_STACK_INVALID_PARAM);
 827
 828     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 829                                                                                          thiz);
 830     if (!accountManager)
 831     {
 832         return;
 833     }
 834
 835     QueryParamsMap queryMap;
 836     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryMap, queryMap);
 837
 838     try
 839     {
 840         OCStackResult result = accountManager->searchUser(env,
 841                                                           queryMap,
 842                                                           jListener);
 843         if (OC_STACK_OK != result)
 844         {
 845             ThrowOcException(result, "OcAccountManager_searchUser");
 846         }
 847     }
 848     catch (OCException& e)
 849     {
 850         LOGE("%s", e.reason().c_str());
 851         ThrowOcException(e.code(), e.reason().c_str());
 852     }
 853 }
 854
 855 /*
 856 * Class:     org_iotivity_base_OcAccountManager
 857 * Method:    deleteDevice0
 858 * Signature: (Ljava/lang/String;Ljava/lang/String;
 859 *             Lorg/iotivity/base/OcAccountManager/onDeleteListener;)V
 860 */
 861 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_deleteDevice0
 862     (JNIEnv *env, jobject thiz, jstring jAccessToken, jstring jDeviceId, jobject jListener)
 863 {
 864     LOGD("OcAccountManager_deleteDevice");
 865     VERIFY_NON_NULL_THROW_EXCEPTION(jAccessToken, "accessToken cannot be null",
 866                                     OC_STACK_INVALID_PARAM);
 867     VERIFY_NON_NULL_THROW_EXCEPTION(jDeviceId, "deviceId cannot be null", OC_STACK_INVALID_PARAM);
 868     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onDeleteListener cannot be null",
 869                                     OC_STACK_INVALID_PARAM);
 870
 871     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 872                                                                                          thiz);
 873     if (!accountManager)
 874     {
 875         return;
 876     }
 877
 878     const char *charAccessToken = env->GetStringUTFChars(jAccessToken, nullptr);
 879     VERIFY_NON_NULL_THROW_EXCEPTION(charAccessToken, "charAccessToken is null", JNI_EXCEPTION);
 880     std::string accessToken(charAccessToken);
 881     env->ReleaseStringUTFChars(jAccessToken, charAccessToken);
 882
 883     const char *charDeviceId = env->GetStringUTFChars(jDeviceId, nullptr);
 884     VERIFY_NON_NULL_THROW_EXCEPTION(charDeviceId, "charDeviceId is null", JNI_EXCEPTION);
 885     std::string deviceId(charDeviceId);
 886     env->ReleaseStringUTFChars(jDeviceId, charDeviceId);
 887
 888     try
 889     {
 890         OCStackResult result = accountManager->deleteDevice(env,
 891                                                             accessToken,
 892                                                             deviceId,
 893                                                             jListener);
 894         if (OC_STACK_OK != result)
 895         {
 896             ThrowOcException(result, "OcAccountManager_deleteDevice");
 897         }
 898     }
 899     catch (OCException& e)
 900     {
 901         LOGE("%s", e.reason().c_str());
 902         ThrowOcException(e.code(), e.reason().c_str());
 903     }
 904 }
 905
 906 /*
 907 * Class:     org_iotivity_base_OcAccountManager
 908 * Method:    createGroup0
 909 * Signature: (Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 910 */
 911 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_createGroup0
 912     (JNIEnv *env, jobject thiz, jobject jListener)
 913 {
 914     LOGD("OcAccountManager_createGroup");
 915     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 916                                     OC_STACK_INVALID_PARAM);
 917
 918     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 919                                                                                          thiz);
 920     if (!accountManager)
 921     {
 922         return;
 923     }
 924
 925     try
 926     {
 927         OCStackResult result = accountManager->createGroup(env,
 928                                                            jListener);
 929         if (OC_STACK_OK != result)
 930         {
 931             ThrowOcException(result, "OcAccountManager_createGroup");
 932         }
 933     }
 934     catch (OCException& e)
 935     {
 936         LOGE("%s", e.reason().c_str());
 937         ThrowOcException(e.code(), e.reason().c_str());
 938     }
 939 }
 940
 941 /*
 942 * Class:     org_iotivity_base_OcAccountManager
 943 * Method:    createGroup1
 944 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 945 */
 946 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_createGroup1
 947     (JNIEnv *env, jobject thiz, jobject jQueryMap, jobject jListener)
 948 {
 949     LOGD("OcAccountManager_createGroup");
 950     VERIFY_NON_NULL_THROW_EXCEPTION(jQueryMap, "queryMap cannot be null", OC_STACK_INVALID_PARAM);
 951     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
 952                                     OC_STACK_INVALID_PARAM);
 953
 954     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 955                                                                                          thiz);
 956     if (!accountManager)
 957     {
 958         return;
 959     }
 960
 961     QueryParamsMap queryMap;
 962     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryMap, queryMap);
 963
 964     try
 965     {
 966         OCStackResult result = accountManager->createGroup(env,
 967                                                            queryMap,
 968                                                            jListener);
 969         if (OC_STACK_OK != result)
 970         {
 971             ThrowOcException(result, "OcAccountManager_createGroup");
 972         }
 973     }
 974     catch (OCException& e)
 975     {
 976         LOGE("%s", e.reason().c_str());
 977         ThrowOcException(e.code(), e.reason().c_str());
 978     }
 979 }
 980
 981 /*
 982 * Class:     org_iotivity_base_OcAccountManager
 983 * Method:    deleteGroup0
 984 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/onDeleteListener;)V
 985 */
 986 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_deleteGroup0
 987     (JNIEnv *env, jobject thiz, jstring jGroupId, jobject jListener)
 988 {
 989     LOGD("OcAccountManager_deleteGroup");
 990     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
 991     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onDeleteListener cannot be null",
 992                                     OC_STACK_INVALID_PARAM);
 993
 994     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 995                                                                                          thiz);
 996     if (!accountManager)
 997     {
 998         return;
 999     }
1000
1001     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1002     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1003     std::string groupId(charGroupId);
1004     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1005
1006     try
1007     {
1008         OCStackResult result = accountManager->deleteGroup(env,
1009                                                            groupId,
1010                                                            jListener);
1011         if (OC_STACK_OK != result)
1012         {
1013             ThrowOcException(result, "OcAccountManager_deleteGroup");
1014         }
1015     }
1016     catch (OCException& e)
1017     {
1018         LOGE("%s", e.reason().c_str());
1019         ThrowOcException(e.code(), e.reason().c_str());
1020     }
1021 }
1022
1023 /*
1024 * Class:     org_iotivity_base_OcAccountManager
1025 * Method:    getGroupInfoAll0
1026 * Signature: (Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
1027 */
1028 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_getGroupInfoAll0
1029     (JNIEnv *env, jobject thiz, jobject jListener)
1030 {
1031     LOGD("OcAccountManager_getGroupInfoAll");
1032     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onGetListener cannot be null",
1033                                     OC_STACK_INVALID_PARAM);
1034
1035     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1036                                                                                          thiz);
1037     if (!accountManager)
1038     {
1039         return;
1040     }
1041
1042     try
1043     {
1044         OCStackResult result = accountManager->getGroupInfoAll(env,
1045                                                                jListener);
1046         if (OC_STACK_OK != result)
1047         {
1048             ThrowOcException(result, "OcAccountManager_getGroupInfoAll");
1049         }
1050     }
1051     catch (OCException& e)
1052     {
1053         LOGE("%s", e.reason().c_str());
1054         ThrowOcException(e.code(), e.reason().c_str());
1055     }
1056 }
1057
1058 /*
1059 * Class:     org_iotivity_base_OcAccountManager
1060 * Method:    getGroupInfo0
1061 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
1062 */
1063 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_getGroupInfo0
1064     (JNIEnv *env, jobject thiz, jstring jGroupId, jobject jListener)
1065 {
1066     LOGD("OcAccountManager_getGroupInfo");
1067     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1068     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onGetListener cannot be null",
1069                                     OC_STACK_INVALID_PARAM);
1070
1071     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1072                                                                                          thiz);
1073     if (!accountManager)
1074     {
1075         return;
1076     }
1077
1078     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1079     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1080     std::string groupId(charGroupId);
1081     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1082
1083     try
1084     {
1085         OCStackResult result = accountManager->getGroupInfo(env,
1086                                                             groupId,
1087                                                             jListener);
1088         if (OC_STACK_OK != result)
1089         {
1090             ThrowOcException(result, "OcAccountManager_getGroupInfo");
1091         }
1092     }
1093     catch (OCException& e)
1094     {
1095         LOGE("%s", e.reason().c_str());
1096         ThrowOcException(e.code(), e.reason().c_str());
1097     }
1098 }
1099
1100 /*
1101 * Class:     org_iotivity_base_OcAccountManager
1102 * Method:    addPropertyValueToGroup0
1103 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
1104 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
1105 */
1106 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_addPropertyValueToGroup0
1107     (JNIEnv *env, jobject thiz, jstring jGroupId, jobject jPropertyValue, jobject jListener)
1108 {
1109     LOGD("OcAccountManager_addPropertyValueToGroup");
1110     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1111     VERIFY_NON_NULL_THROW_EXCEPTION(jPropertyValue, "propertyValue cannot be null",
1112                                     OC_STACK_INVALID_PARAM);
1113     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
1114                                     OC_STACK_INVALID_PARAM);
1115
1116     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1117                                                                                          thiz);
1118     if (!accountManager)
1119     {
1120         return;
1121     }
1122
1123     OCRepresentation *propertyValue = JniOcRepresentation::getOCRepresentationPtr(env,
1124                                                                                   jPropertyValue);
1125     if (!propertyValue)
1126     {
1127         return;
1128     }
1129
1130     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1131     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1132     std::string groupId(charGroupId);
1133     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1134
1135     try
1136     {
1137         OCStackResult result = accountManager->addPropertyValueToGroup(env,
1138                                                                        groupId,
1139                                                                        *propertyValue,
1140                                                                        jListener);
1141
1142         if (OC_STACK_OK != result)
1143         {
1144             ThrowOcException(result, "OcAccountManager_addPropertyValueToGroup");
1145         }
1146     }
1147     catch (OCException& e)
1148     {
1149         LOGE("%s", e.reason().c_str());
1150         ThrowOcException(e.code(), e.reason().c_str());
1151     }
1152 }
1153
1154 /*
1155 * Class:     org_iotivity_base_OcAccountManager
1156 * Method:    deletePropertyValueFromGroup0
1157 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
1158 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
1159 */
1160 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_deletePropertyValueFromGroup0
1161     (JNIEnv *env, jobject thiz, jstring jGroupId, jobject jPropertyValue, jobject jListener)
1162 {
1163     LOGD("OcAccountManager_deletePropertyValueFromGroup");
1164     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1165     VERIFY_NON_NULL_THROW_EXCEPTION(jPropertyValue, "propertyValue cannot be null",
1166                                     OC_STACK_INVALID_PARAM);
1167     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
1168                                     OC_STACK_INVALID_PARAM);
1169
1170     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1171                                                                                          thiz);
1172     if (!accountManager)
1173     {
1174         return;
1175     }
1176
1177     OCRepresentation *propertyValue = JniOcRepresentation::getOCRepresentationPtr(env,
1178                                                                                   jPropertyValue);
1179     if (!propertyValue)
1180     {
1181         return;
1182     }
1183
1184     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1185     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1186     std::string groupId(charGroupId);
1187     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1188
1189     try
1190     {
1191         OCStackResult result = accountManager->deletePropertyValueFromGroup(env,
1192                                                                             groupId,
1193                                                                             *propertyValue,
1194                                                                             jListener);
1195
1196         if (OC_STACK_OK != result)
1197         {
1198             ThrowOcException(result, "OcAccountManager_deletePropertyValueFromGroup");
1199         }
1200     }
1201     catch (OCException& e)
1202     {
1203         LOGE("%s", e.reason().c_str());
1204         ThrowOcException(e.code(), e.reason().c_str());
1205     }
1206 }
1207
1208 /*
1209 * Class:     org_iotivity_base_OcAccountManager
1210 * Method:    updatePropertyValueOnGroup0
1211 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;
1212 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
1213 */
1214 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_updatePropertyValueOnGroup0
1215     (JNIEnv *env, jobject thiz, jstring jGroupId, jobject jPropertyValue, jobject jListener)
1216 {
1217     LOGD("OcAccountManager_updatePropertyValueOnGroup");
1218     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1219     VERIFY_NON_NULL_THROW_EXCEPTION(jPropertyValue, "propertyValue cannot be null",
1220                                     OC_STACK_INVALID_PARAM);
1221     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
1222                                     OC_STACK_INVALID_PARAM);
1223
1224     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1225                                                                                          thiz);
1226     if (!accountManager)
1227     {
1228         return;
1229     }
1230
1231     OCRepresentation *propertyValue = JniOcRepresentation::getOCRepresentationPtr(env,
1232                                                                                   jPropertyValue);
1233     if (!propertyValue)
1234     {
1235         return;
1236     }
1237
1238     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1239     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1240     std::string groupId(charGroupId);
1241     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1242
1243     try
1244     {
1245         OCStackResult result = accountManager->updatePropertyValueOnGroup(env,
1246                                                                           groupId,
1247                                                                           *propertyValue,
1248                                                                           jListener);
1249
1250         if (OC_STACK_OK != result)
1251         {
1252             ThrowOcException(result, "OcAccountManager_updatePropertyValueOnGroup");
1253         }
1254     }
1255     catch (OCException& e)
1256     {
1257         LOGE("%s", e.reason().c_str());
1258         ThrowOcException(e.code(), e.reason().c_str());
1259     }
1260 }
1261
1262 /*
1263 * Class:     org_iotivity_base_OcAccountManager
1264 * Method:    observeGroup0
1265 * Signature: (Lorg/iotivity/base/OcResource/OnObserveListener;)V
1266 */
1267 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_observeGroup0
1268     (JNIEnv *env, jobject thiz, jobject jListener)
1269 {
1270     LOGD("OcAccountManager_observeGroup");
1271     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onObserveListener cannot be null",
1272                                     OC_STACK_INVALID_PARAM);
1273
1274     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1275                                                                                          thiz);
1276     if (!accountManager)
1277     {
1278         return;
1279     }
1280
1281     try
1282     {
1283         OCStackResult result = accountManager->observeGroup(env,
1284                                                             jListener);
1285         if (OC_STACK_OK != result)
1286         {
1287             ThrowOcException(result, "OcAccountManager_observeGroup");
1288         }
1289     }
1290     catch (OCException& e)
1291     {
1292         LOGE("%s", e.reason().c_str());
1293         ThrowOcException(e.code(), e.reason().c_str());
1294     }
1295 }
1296
1297 /*
1298 * Class:     org_iotivity_base_OcAccountManager
1299 * Method:    cancelObserveGroup0
1300 * Signature: ()V
1301 */
1302 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_cancelObserveGroup0
1303     (JNIEnv *env, jobject thiz)
1304 {
1305     LOGD("OcAccountManager_cancelObserveGroup");
1306
1307     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1308                                                                                          thiz);
1309     if (!accountManager)
1310     {
1311         return;
1312     }
1313
1314     try
1315     {
1316         OCStackResult result = accountManager->cancelObserveGroup();
1317         if (OC_STACK_OK != result)
1318         {
1319             ThrowOcException(result, "OcAccountManager_cancelObserveGroup");
1320         }
1321     }
1322     catch (OCException& e)
1323     {
1324         LOGE("%s", e.reason().c_str());
1325         ThrowOcException(e.code(), e.reason().c_str());
1326     }
1327 }
1328
1329 /*
1330 * Class:     org_iotivity_base_OcAccountManager
1331 * Method:    observeInvitation0
1332 * Signature: (Lorg/iotivity/base/OcResource/OnObserveListener;)V
1333 */
1334 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_observeInvitation0
1335     (JNIEnv *env, jobject thiz, jobject jListener)
1336 {
1337     LOGD("OcAccountManager_observeInvitation");
1338     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onObserveListener cannot be null",
1339                                     OC_STACK_INVALID_PARAM);
1340
1341     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1342                                                                                          thiz);
1343     if (!accountManager)
1344     {
1345         return;
1346     }
1347
1348     try
1349     {
1350         OCStackResult result = accountManager->observeInvitation(env,
1351                                                                  jListener);
1352         if (OC_STACK_OK != result)
1353         {
1354             ThrowOcException(result, "OcAccountManager_observeInvitation");
1355         }
1356     }
1357     catch (OCException& e)
1358     {
1359         LOGE("%s", e.reason().c_str());
1360         ThrowOcException(e.code(), e.reason().c_str());
1361     }
1362 }
1363
1364 /*
1365 * Class:     org_iotivity_base_OcAccountManager
1366 * Method:    cancelObserveInvitation0
1367 * Signature: ()V
1368 */
1369 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_cancelObserveInvitation0
1370     (JNIEnv *env, jobject thiz)
1371 {
1372     LOGD("OcAccountManager_cancelObserveInvitation");
1373
1374     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1375                                                                                          thiz);
1376     if (!accountManager)
1377     {
1378         return;
1379     }
1380
1381     try
1382     {
1383         OCStackResult result = accountManager->cancelObserveInvitation();
1384         if (OC_STACK_OK != result)
1385         {
1386             ThrowOcException(result, "OcAccountManager_cancelObserveInvitation");
1387         }
1388     }
1389     catch (OCException& e)
1390     {
1391         LOGE("%s", e.reason().c_str());
1392         ThrowOcException(e.code(), e.reason().c_str());
1393     }
1394 }
1395
1396 /*
1397 * Class:     org_iotivity_base_OcAccountManager
1398 * Method:    sendInvitation0
1399 * Signature: (Ljava/lang/String;Ljava/lang/String;
1400 *             Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
1401 */
1402 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_sendInvitation0
1403     (JNIEnv *env, jobject thiz, jstring jGroupId, jstring jUserUuid, jobject jListener)
1404 {
1405     LOGD("OcAccountManager_sendInvitation");
1406     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1407     VERIFY_NON_NULL_THROW_EXCEPTION(jUserUuid, "userUuid cannot be null", OC_STACK_INVALID_PARAM);
1408     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onPostListener cannot be null",
1409                                     OC_STACK_INVALID_PARAM);
1410
1411     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1412                                                                                          thiz);
1413     if (!accountManager)
1414     {
1415         return;
1416     }
1417
1418     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1419     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1420     std::string groupId(charGroupId);
1421     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1422
1423     const char *charUserUuid = env->GetStringUTFChars(jUserUuid, nullptr);
1424     VERIFY_NON_NULL_THROW_EXCEPTION(charUserUuid, "charUserUuid is null", JNI_EXCEPTION);
1425     std::string userUuid(charUserUuid);
1426     env->ReleaseStringUTFChars(jUserUuid, charUserUuid);
1427
1428     try
1429     {
1430         OCStackResult result = accountManager->sendInvitation(env,
1431                                                               groupId,
1432                                                               userUuid,
1433                                                               jListener);
1434         if (OC_STACK_OK != result)
1435         {
1436             ThrowOcException(result, "OcAccountManager_sendInvitation");
1437         }
1438     }
1439     catch (OCException& e)
1440     {
1441         LOGE("%s", e.reason().c_str());
1442         ThrowOcException(e.code(), e.reason().c_str());
1443     }
1444 }
1445
1446 /*
1447 * Class:     org_iotivity_base_OcAccountManager
1448 * Method:    cancelInvitation0
1449 * Signature: (Ljava/lang/String;Ljava/lang/String;
1450 *             Lorg/iotivity/base/OcAccountManager/onDeleteListener;)V
1451 */
1452 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_cancelInvitation0
1453     (JNIEnv *env, jobject thiz, jstring jGroupId, jstring jUserUuid, jobject jListener)
1454 {
1455     LOGD("OcAccountManager_cancelInvitation");
1456     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1457     VERIFY_NON_NULL_THROW_EXCEPTION(jUserUuid, "userUuid cannot be null", OC_STACK_INVALID_PARAM);
1458     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onDeleteListener cannot be null",
1459                                     OC_STACK_INVALID_PARAM);
1460
1461     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1462                                                                                          thiz);
1463     if (!accountManager)
1464     {
1465         return;
1466     }
1467
1468     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1469     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1470     std::string groupId(charGroupId);
1471     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1472
1473     const char *charUserUuid = env->GetStringUTFChars(jUserUuid, nullptr);
1474     VERIFY_NON_NULL_THROW_EXCEPTION(charUserUuid, "charUserUuid is null", JNI_EXCEPTION);
1475     std::string userUuid(charUserUuid);
1476     env->ReleaseStringUTFChars(jUserUuid, charUserUuid);
1477
1478     try
1479     {
1480         OCStackResult result = accountManager->cancelInvitation(env,
1481                                                                 groupId,
1482                                                                 userUuid,
1483                                                                 jListener);
1484         if (OC_STACK_OK != result)
1485         {
1486             ThrowOcException(result, "OcAccountManager_cancelInvitation");
1487         }
1488     }
1489     catch (OCException& e)
1490     {
1491         LOGE("%s", e.reason().c_str());
1492         ThrowOcException(e.code(), e.reason().c_str());
1493     }
1494 }
1495
1496 /*
1497 * Class:     org_iotivity_base_OcAccountManager
1498 * Method:    replyToInvitation0
1499 * Signature: (Ljava/lang/String;ZLorg/iotivity/base/OcAccountManager/onDeleteListener;)V
1500 */
1501 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_replyToInvitation0
1502     (JNIEnv *env, jobject thiz, jstring jGroupId, jboolean jAccept, jobject jListener)
1503 {
1504     LOGD("OcAccountManager_replyToInvitation");
1505     VERIFY_NON_NULL_THROW_EXCEPTION(jGroupId, "groupId cannot be null", OC_STACK_INVALID_PARAM);
1506     VERIFY_NON_NULL_THROW_EXCEPTION(jListener, "onDeleteListener cannot be null",
1507                                     OC_STACK_INVALID_PARAM);
1508
1509     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
1510                                                                                          thiz);
1511     if (!accountManager)
1512     {
1513         return;
1514     }
1515
1516     const char *charGroupId = env->GetStringUTFChars(jGroupId, nullptr);
1517     VERIFY_NON_NULL_THROW_EXCEPTION(charGroupId, "charGroupId is null", JNI_EXCEPTION);
1518     std::string groupId(charGroupId);
1519     env->ReleaseStringUTFChars(jGroupId, charGroupId);
1520
1521     try
1522     {
1523         OCStackResult result = accountManager->replyToInvitation(env,
1524                                                                  groupId,
1525                                                                  static_cast<bool>(jAccept),
1526                                                                  jListener);
1527         if (OC_STACK_OK != result)
1528         {
1529             ThrowOcException(result, "OcAccountManager_replyToInvitation");
1530         }
1531     }
1532     catch (OCException& e)
1533     {
1534         LOGE("%s", e.reason().c_str());
1535         ThrowOcException(e.code(), e.reason().c_str());
1536     }
1537 }
1538
1539