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