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
  49     if (JNI_EDETACHED == envRet)
  50     {
  51         g_jvm->DetachCurrentThread();
  52     }
  53 }
  54
  55 std::string JniOcAccountManager::host()
  56 {
  57     return m_sharedAccountManager->host();
  58 }
  59
  60 OCConnectivityType JniOcAccountManager::connectivityType() const
  61 {
  62     return m_sharedAccountManager->connectivityType();
  63 }
  64
  65 JniOcAccountManager* JniOcAccountManager::getJniOcAccountManagerPtr(JNIEnv *env, jobject thiz)
  66 {
  67     JniOcAccountManager *accountManager = GetHandle<JniOcAccountManager>(env, thiz);
  68     if (env->ExceptionCheck())
  69     {
  70         LOGE("Failed to get native handle from OcAccountManager");
  71     }
  72     if (!accountManager)
  73     {
  74         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
  75     }
  76     return accountManager;
  77 }
  78
  79 JniOnGetListener* JniOcAccountManager::addOnGetListener(JNIEnv* env, jobject jListener)
  80 {
  81     return this->m_onGetManager.addListener(env, jListener, this);
  82 }
  83
  84 JniOnPostListener* JniOcAccountManager::addOnPostListener(JNIEnv* env, jobject jListener)
  85 {
  86     return this->m_onPostManager.addListener(env, jListener, this);
  87 }
  88
  89 JniOnDeleteListener* JniOcAccountManager::addOnDeleteListener(JNIEnv* env, jobject jListener)
  90 {
  91     return this->m_onDeleteManager.addListener(env, jListener, this);
  92 }
  93
  94 void JniOcAccountManager::removeOnGetListener(JNIEnv* env, jobject jListener)
  95 {
  96     this->m_onGetManager.removeListener(env, jListener);
  97 }
  98
  99 void JniOcAccountManager::removeOnPostListener(JNIEnv* env, jobject jListener)
 100 {
 101     this->m_onPostManager.removeListener(env, jListener);
 102 }
 103
 104 void JniOcAccountManager::removeOnDeleteListener(JNIEnv* env, jobject jListener)
 105 {
 106     this->m_onDeleteManager.removeListener(env, jListener);
 107 }
 108
 109 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
 110                                           const std::string& authCode, jobject jListener)
 111 {
 112     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 113
 114     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 115         const OCRepresentation& rep, const int eCode)
 116     {
 117         onPostListener->onPostCallback(opts, rep, eCode);
 118     };
 119
 120     return m_sharedAccountManager->signUp(authProvider, authCode, postCallback);
 121 }
 122
 123 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
 124                                           const std::string& authCode,
 125                                           const QueryParamsMap& options, jobject jListener)
 126 {
 127     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 128
 129     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 130         const OCRepresentation& rep, const int eCode)
 131     {
 132         onPostListener->onPostCallback(opts, rep, eCode);
 133     };
 134
 135     return m_sharedAccountManager->signUp(authProvider, authCode, options, postCallback);
 136 }
 137
 138 OCStackResult JniOcAccountManager::signIn(JNIEnv* env, const std::string& userUuid,
 139                                           const std::string& accessToken, jobject jListener)
 140 {
 141     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 142
 143     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 144         const OCRepresentation& rep, const int eCode)
 145     {
 146         onPostListener->onPostCallback(opts, rep, eCode);
 147     };
 148
 149     return m_sharedAccountManager->signIn(userUuid, accessToken, postCallback);
 150 }
 151
 152 OCStackResult JniOcAccountManager::signOut(JNIEnv* env, jobject jListener)
 153 {
 154     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 155
 156     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 157         const OCRepresentation& rep, const int eCode)
 158     {
 159         onPostListener->onPostCallback(opts, rep, eCode);
 160     };
 161
 162     return m_sharedAccountManager->signOut(postCallback);
 163 }
 164
 165 OCStackResult JniOcAccountManager::refreshAccessToken(JNIEnv* env, const std::string& userUuid,
 166                                                       const std::string& refreshToken,
 167                                                       jobject jListener)
 168 {
 169     JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
 170
 171     PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
 172         const OCRepresentation& rep, const int eCode)
 173     {
 174         onPostListener->onPostCallback(opts, rep, eCode);
 175     };
 176
 177     return m_sharedAccountManager->refreshAccessToken(userUuid, refreshToken, postCallback);
 178 }
 179
 180 OCStackResult JniOcAccountManager::searchUser(JNIEnv* env, const std::string& userUuid,
 181                                               jobject jListener)
 182 {
 183     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 184
 185     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 186         const OCRepresentation& rep, const int eCode)
 187     {
 188         onGetListener->onGetCallback(opts, rep, eCode);
 189     };
 190
 191     return m_sharedAccountManager->searchUser(userUuid, getCallback);
 192 }
 193
 194 OCStackResult JniOcAccountManager::searchUser(JNIEnv* env, const QueryParamsMap& queryMap,
 195                                               jobject jListener)
 196 {
 197     JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
 198
 199     GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
 200         const OCRepresentation& rep, const int eCode)
 201     {
 202         onGetListener->onGetCallback(opts, rep, eCode);
 203     };
 204
 205     return m_sharedAccountManager->searchUser(queryMap, getCallback);
 206 }
 207
 208 OCStackResult JniOcAccountManager::deleteDevice(JNIEnv* env, const std::string& deviceId,
 209                                                 jobject jListener)
 210 {
 211     JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
 212
 213     DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
 214         const int eCode)
 215     {
 216         onDeleteListener->onDeleteCallback(opts, eCode);
 217     };
 218
 219     return m_sharedAccountManager->deleteDevice(deviceId, deleteCallback);
 220 }
 221
 222 /*
 223 * Class:     org_iotivity_base_OcAccountManager
 224 * Method:    getHost
 225 * Signature: ()Ljava/lang/String;
 226 */
 227 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcAccountManager_getHost
 228     (JNIEnv *env, jobject thiz)
 229 {
 230     LOGD("OcAccountManager_getHost");
 231     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 232                                                                                          thiz);
 233     if (!accountManager)
 234     {
 235         return nullptr;
 236     }
 237
 238     return env->NewStringUTF(accountManager->host().c_str());
 239 }
 240
 241 /*
 242 * Class:     org_iotivity_base_OcAccountManager
 243 * Method:    getConnectivityTypeN
 244 * Signature: ()I
 245 */
 246 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcAccountManager_getConnectivityTypeN
 247     (JNIEnv *env, jobject thiz)
 248 {
 249     LOGD("OcAccountManager_getConnectivityType");
 250     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 251                                                                                          thiz);
 252     if (!accountManager)
 253     {
 254         return -1;
 255     }
 256
 257     OCConnectivityType connectivityType = accountManager->connectivityType();
 258     return static_cast<jint>(connectivityType);
 259 }
 260
 261 /*
 262 * Class:     org_iotivity_base_OcAccountManager
 263 * Method:    signUp0
 264 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 265 */
 266 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp0
 267     (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jListener)
 268 {
 269     LOGD("OcAccountManager_signUp");
 270     if (!jListener)
 271     {
 272         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 273         return;
 274     }
 275
 276     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 277                                                                                          thiz);
 278     if (!accountManager)
 279     {
 280         return;
 281     }
 282
 283     std::string authProvider;
 284     std::string authCode;
 285     if (jAuthProvider)
 286     {
 287         authProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
 288     }
 289     if (jAuthCode)
 290     {
 291         authCode = env->GetStringUTFChars(jAuthCode, nullptr);
 292     }
 293
 294     try
 295     {
 296         OCStackResult result = accountManager->signUp(env,
 297                                                       authProvider,
 298                                                       authCode,
 299                                                       jListener);
 300
 301         if (OC_STACK_OK != result)
 302         {
 303             ThrowOcException(result, "OcAccountManager_signUp");
 304         }
 305     }
 306     catch (OCException& e)
 307     {
 308         LOGE("%s", e.reason().c_str());
 309         ThrowOcException(e.code(), e.reason().c_str());
 310     }
 311 }
 312
 313 /*
 314 * Class:     org_iotivity_base_OcAccountManager
 315 * Method:    signUp1
 316 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 317 */
 318 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp1
 319     (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jOptionsMap,
 320      jobject jListener)
 321 {
 322     LOGD("OcAccountManager_signUp");
 323     if (!jListener)
 324     {
 325         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 326         return;
 327     }
 328     if (!jOptionsMap)
 329     {
 330         ThrowOcException(OC_STACK_INVALID_PARAM, "options cannot be null");
 331         return;
 332     }
 333
 334     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 335                                                                                          thiz);
 336     if (!accountManager)
 337     {
 338         return;
 339     }
 340
 341     std::string authProvider;
 342     std::string authCode;
 343     if (jAuthProvider)
 344     {
 345         authProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
 346     }
 347     if (jAuthCode)
 348     {
 349         authCode = env->GetStringUTFChars(jAuthCode, nullptr);
 350     }
 351
 352     QueryParamsMap optionsMap;
 353     JniUtils::convertJavaMapToQueryParamsMap(env, jOptionsMap, optionsMap);
 354
 355     try
 356     {
 357         OCStackResult result = accountManager->signUp(env,
 358                                                       authProvider,
 359                                                       authCode,
 360                                                       optionsMap,
 361                                                       jListener);
 362
 363         if (OC_STACK_OK != result)
 364         {
 365             ThrowOcException(result, "OcAccountManager_signUp");
 366         }
 367     }
 368     catch (OCException& e)
 369     {
 370         LOGE("%s", e.reason().c_str());
 371         ThrowOcException(e.code(), e.reason().c_str());
 372     }
 373 }
 374
 375 /*
 376 * Class:     org_iotivity_base_OcAccountManager
 377 * Method:    signIn0
 378 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 379 */
 380 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signIn0
 381     (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jAccessToken, jobject jListener)
 382 {
 383     LOGD("OcAccountManager_signIn");
 384     if (!jListener)
 385     {
 386         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 387         return;
 388     }
 389
 390     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 391                                                                                          thiz);
 392     if (!accountManager)
 393     {
 394         return;
 395     }
 396
 397     std::string userUuid;
 398     std::string accessToken;
 399     if (jUserUuid)
 400     {
 401         userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
 402     }
 403     if (jAccessToken)
 404     {
 405         accessToken = env->GetStringUTFChars(jAccessToken, nullptr);
 406     }
 407
 408     try
 409     {
 410         OCStackResult result = accountManager->signIn(env,
 411                                                       userUuid,
 412                                                       accessToken,
 413                                                       jListener);
 414
 415         if (OC_STACK_OK != result)
 416         {
 417             ThrowOcException(result, "OcAccountManager_signIn");
 418         }
 419     }
 420     catch (OCException& e)
 421     {
 422         LOGE("%s", e.reason().c_str());
 423         ThrowOcException(e.code(), e.reason().c_str());
 424     }
 425 }
 426
 427 /*
 428 * Class:     org_iotivity_base_OcAccountManager
 429 * Method:    signOut0
 430 * Signature: (Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 431 */
 432 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signOut0
 433     (JNIEnv *env, jobject thiz, jobject jListener)
 434 {
 435     LOGD("OcAccountManager_signOut");
 436     if (!jListener)
 437     {
 438         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 439         return;
 440     }
 441
 442     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 443                                                                                          thiz);
 444     if (!accountManager)
 445     {
 446         return;
 447     }
 448
 449     try
 450     {
 451         OCStackResult result = accountManager->signOut(env,
 452                                                        jListener);
 453
 454         if (OC_STACK_OK != result)
 455         {
 456             ThrowOcException(result, "OcAccountManager_signOut");
 457         }
 458     }
 459     catch (OCException& e)
 460     {
 461         LOGE("%s", e.reason().c_str());
 462         ThrowOcException(e.code(), e.reason().c_str());
 463     }
 464 }
 465
 466 /*
 467 * Class:     org_iotivity_base_OcAccountManager
 468 * Method:    refreshAccessToken0
 469 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
 470 */
 471 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_refreshAccessToken0
 472     (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jRefreshAccessToken, jobject jListener)
 473 {
 474     LOGD("OcAccountManager_refreshAccessToken");
 475     if (!jListener)
 476     {
 477         ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
 478         return;
 479     }
 480
 481     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 482                                                                                          thiz);
 483     if (!accountManager)
 484     {
 485         return;
 486     }
 487
 488     std::string userUuid;
 489     std::string refreshAccessToken;
 490     if (jUserUuid)
 491     {
 492         userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
 493     }
 494     if (jRefreshAccessToken)
 495     {
 496         refreshAccessToken = env->GetStringUTFChars(jRefreshAccessToken, nullptr);
 497     }
 498
 499     try
 500     {
 501         OCStackResult result = accountManager->refreshAccessToken(env,
 502                                                                   userUuid,
 503                                                                   refreshAccessToken,
 504                                                                   jListener);
 505
 506         if (OC_STACK_OK != result)
 507         {
 508             ThrowOcException(result, "OcAccountManager_refreshAccessToken");
 509         }
 510     }
 511     catch (OCException& e)
 512     {
 513         LOGE("%s", e.reason().c_str());
 514         ThrowOcException(e.code(), e.reason().c_str());
 515     }
 516 }
 517
 518 /*
 519 * Class:     org_iotivity_base_OcAccountManager
 520 * Method:    searchUser0
 521 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
 522 */
 523 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_searchUser0
 524     (JNIEnv *env, jobject thiz, jstring jUserUuid, jobject jListener)
 525 {
 526     LOGD("OcAccountManager_searchUser");
 527     if (!jListener)
 528     {
 529         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 530         return;
 531     }
 532
 533     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 534                                                                                          thiz);
 535     if (!accountManager)
 536     {
 537         return;
 538     }
 539
 540     std::string userUuid;
 541     if (jUserUuid)
 542     {
 543         userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
 544     }
 545
 546     try
 547     {
 548         OCStackResult result = accountManager->searchUser(env,
 549                                                           userUuid,
 550                                                           jListener);
 551
 552         if (OC_STACK_OK != result)
 553         {
 554             ThrowOcException(result, "OcAccountManager_searchUser");
 555         }
 556     }
 557     catch (OCException& e)
 558     {
 559         LOGE("%s", e.reason().c_str());
 560         ThrowOcException(e.code(), e.reason().c_str());
 561     }
 562 }
 563
 564 /*
 565 * Class:     org_iotivity_base_OcAccountManager
 566 * Method:    searchUser1
 567 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
 568 */
 569 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_searchUser1
 570     (JNIEnv *env, jobject thiz, jobject jQueryMap, jobject jListener)
 571 {
 572     LOGD("OcAccountManager_searchUser");
 573     if (!jListener)
 574     {
 575         ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
 576         return;
 577     }
 578     if (!jQueryMap)
 579     {
 580         ThrowOcException(OC_STACK_INVALID_PARAM, "queryMap cannot be null");
 581         return;
 582     }
 583
 584     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 585                                                                                          thiz);
 586     if (!accountManager)
 587     {
 588         return;
 589     }
 590
 591     QueryParamsMap queryMap;
 592     JniUtils::convertJavaMapToQueryParamsMap(env, jQueryMap, queryMap);
 593
 594     try
 595     {
 596         OCStackResult result = accountManager->searchUser(env,
 597                                                           queryMap,
 598                                                           jListener);
 599
 600         if (OC_STACK_OK != result)
 601         {
 602             ThrowOcException(result, "OcAccountManager_searchUser");
 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:    deleteDevice0
 615 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/onDeleteListener;)V
 616 */
 617 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_deleteDevice0
 618     (JNIEnv *env, jobject thiz, jstring jDeviceId, jobject jListener)
 619 {
 620     LOGD("OcAccountManager_deleteDevice");
 621     if (!jListener)
 622     {
 623         ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteListener cannot be null");
 624         return;
 625     }
 626
 627     JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
 628                                                                                          thiz);
 629     if (!accountManager)
 630     {
 631         return;
 632     }
 633
 634     std::string deviceId;
 635     if (jDeviceId)
 636     {
 637         deviceId = env->GetStringUTFChars(jDeviceId, nullptr);
 638     }
 639
 640     try
 641     {
 642         OCStackResult result = accountManager->deleteDevice(env,
 643                                                             deviceId,
 644                                                             jListener);
 645
 646         if (OC_STACK_OK != result)
 647         {
 648             ThrowOcException(result, "OcAccountManager_deleteDevice");
 649         }
 650     }
 651     catch (OCException& e)
 652     {
 653         LOGE("%s", e.reason().c_str());
 654         ThrowOcException(e.code(), e.reason().c_str());
 655     }
 656 }