2 *******************************************************************
4 * Copyright 2016 Samsung Electronics All Rights Reserved.
6 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 *-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
23 #include "JniOcAccountManager.h"
24 #include "JniOcRepresentation.h"
27 JniOcAccountManager::JniOcAccountManager(std::shared_ptr<OCAccountManager> accountManager)
28 : m_sharedAccountManager(accountManager)
32 JniOcAccountManager::~JniOcAccountManager()
34 LOGD("~JniOcAccountManager()");
36 m_sharedAccountManager = nullptr;
38 jint envRet = JNI_ERR;
39 JNIEnv *env = GetJNIEnv(envRet);
45 m_onGetManager.removeAllListeners(env);
46 m_onPostManager.removeAllListeners(env);
47 m_onDeleteManager.removeAllListeners(env);
49 if (JNI_EDETACHED == envRet)
51 g_jvm->DetachCurrentThread();
55 std::string JniOcAccountManager::host()
57 return m_sharedAccountManager->host();
60 OCConnectivityType JniOcAccountManager::connectivityType() const
62 return m_sharedAccountManager->connectivityType();
65 JniOcAccountManager* JniOcAccountManager::getJniOcAccountManagerPtr(JNIEnv *env, jobject thiz)
67 JniOcAccountManager *accountManager = GetHandle<JniOcAccountManager>(env, thiz);
68 if (env->ExceptionCheck())
70 LOGE("Failed to get native handle from OcAccountManager");
74 ThrowOcException(JNI_NO_NATIVE_POINTER, "");
76 return accountManager;
79 JniOnGetListener* JniOcAccountManager::addOnGetListener(JNIEnv* env, jobject jListener)
81 return this->m_onGetManager.addListener(env, jListener, this);
84 JniOnPostListener* JniOcAccountManager::addOnPostListener(JNIEnv* env, jobject jListener)
86 return this->m_onPostManager.addListener(env, jListener, this);
89 JniOnDeleteListener* JniOcAccountManager::addOnDeleteListener(JNIEnv* env, jobject jListener)
91 return this->m_onDeleteManager.addListener(env, jListener, this);
94 void JniOcAccountManager::removeOnGetListener(JNIEnv* env, jobject jListener)
96 this->m_onGetManager.removeListener(env, jListener);
99 void JniOcAccountManager::removeOnPostListener(JNIEnv* env, jobject jListener)
101 this->m_onPostManager.removeListener(env, jListener);
104 void JniOcAccountManager::removeOnDeleteListener(JNIEnv* env, jobject jListener)
106 this->m_onDeleteManager.removeListener(env, jListener);
109 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
110 const std::string& authCode, jobject jListener)
112 JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
114 PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
115 const OCRepresentation& rep, const int eCode)
117 onPostListener->onPostCallback(opts, rep, eCode);
120 return m_sharedAccountManager->signUp(authProvider, authCode, postCallback);
123 OCStackResult JniOcAccountManager::signUp(JNIEnv* env, const std::string& authProvider,
124 const std::string& authCode,
125 const QueryParamsMap& options, jobject jListener)
127 JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
129 PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
130 const OCRepresentation& rep, const int eCode)
132 onPostListener->onPostCallback(opts, rep, eCode);
135 return m_sharedAccountManager->signUp(authProvider, authCode, options, postCallback);
138 OCStackResult JniOcAccountManager::signIn(JNIEnv* env, const std::string& userUuid,
139 const std::string& accessToken, jobject jListener)
141 JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
143 PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
144 const OCRepresentation& rep, const int eCode)
146 onPostListener->onPostCallback(opts, rep, eCode);
149 return m_sharedAccountManager->signIn(userUuid, accessToken, postCallback);
152 OCStackResult JniOcAccountManager::signOut(JNIEnv* env, jobject jListener)
154 JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
156 PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
157 const OCRepresentation& rep, const int eCode)
159 onPostListener->onPostCallback(opts, rep, eCode);
162 return m_sharedAccountManager->signOut(postCallback);
165 OCStackResult JniOcAccountManager::refreshAccessToken(JNIEnv* env, const std::string& userUuid,
166 const std::string& refreshToken,
169 JniOnPostListener *onPostListener = addOnPostListener(env, jListener);
171 PostCallback postCallback = [onPostListener](const HeaderOptions& opts,
172 const OCRepresentation& rep, const int eCode)
174 onPostListener->onPostCallback(opts, rep, eCode);
177 return m_sharedAccountManager->refreshAccessToken(userUuid, refreshToken, postCallback);
180 OCStackResult JniOcAccountManager::searchUser(JNIEnv* env, const std::string& userUuid,
183 JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
185 GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
186 const OCRepresentation& rep, const int eCode)
188 onGetListener->onGetCallback(opts, rep, eCode);
191 return m_sharedAccountManager->searchUser(userUuid, getCallback);
194 OCStackResult JniOcAccountManager::searchUser(JNIEnv* env, const QueryParamsMap& queryMap,
197 JniOnGetListener *onGetListener = addOnGetListener(env, jListener);
199 GetCallback getCallback = [onGetListener](const HeaderOptions& opts,
200 const OCRepresentation& rep, const int eCode)
202 onGetListener->onGetCallback(opts, rep, eCode);
205 return m_sharedAccountManager->searchUser(queryMap, getCallback);
208 OCStackResult JniOcAccountManager::deleteDevice(JNIEnv* env, const std::string& deviceId,
211 JniOnDeleteListener *onDeleteListener = addOnDeleteListener(env, jListener);
213 DeleteCallback deleteCallback = [onDeleteListener](const HeaderOptions& opts,
216 onDeleteListener->onDeleteCallback(opts, eCode);
219 return m_sharedAccountManager->deleteDevice(deviceId, deleteCallback);
223 * Class: org_iotivity_base_OcAccountManager
225 * Signature: ()Ljava/lang/String;
227 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcAccountManager_getHost
228 (JNIEnv *env, jobject thiz)
230 LOGD("OcAccountManager_getHost");
231 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
238 return env->NewStringUTF(accountManager->host().c_str());
242 * Class: org_iotivity_base_OcAccountManager
243 * Method: getConnectivityTypeN
246 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcAccountManager_getConnectivityTypeN
247 (JNIEnv *env, jobject thiz)
249 LOGD("OcAccountManager_getConnectivityType");
250 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
257 OCConnectivityType connectivityType = accountManager->connectivityType();
258 return static_cast<jint>(connectivityType);
262 * Class: org_iotivity_base_OcAccountManager
264 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
266 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp0
267 (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jListener)
269 LOGD("OcAccountManager_signUp");
272 ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
276 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
283 std::string authProvider;
284 std::string authCode;
287 authProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
291 authCode = env->GetStringUTFChars(jAuthCode, nullptr);
296 OCStackResult result = accountManager->signUp(env,
301 if (OC_STACK_OK != result)
303 ThrowOcException(result, "OcAccountManager_signUp");
306 catch (OCException& e)
308 LOGE("%s", e.reason().c_str());
309 ThrowOcException(e.code(), e.reason().c_str());
314 * Class: org_iotivity_base_OcAccountManager
316 * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
318 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signUp1
319 (JNIEnv *env, jobject thiz, jstring jAuthProvider, jstring jAuthCode, jobject jOptionsMap,
322 LOGD("OcAccountManager_signUp");
325 ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
330 ThrowOcException(OC_STACK_INVALID_PARAM, "options cannot be null");
334 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
341 std::string authProvider;
342 std::string authCode;
345 authProvider = env->GetStringUTFChars(jAuthProvider, nullptr);
349 authCode = env->GetStringUTFChars(jAuthCode, nullptr);
352 QueryParamsMap optionsMap;
353 JniUtils::convertJavaMapToQueryParamsMap(env, jOptionsMap, optionsMap);
357 OCStackResult result = accountManager->signUp(env,
363 if (OC_STACK_OK != result)
365 ThrowOcException(result, "OcAccountManager_signUp");
368 catch (OCException& e)
370 LOGE("%s", e.reason().c_str());
371 ThrowOcException(e.code(), e.reason().c_str());
376 * Class: org_iotivity_base_OcAccountManager
378 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
380 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signIn0
381 (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jAccessToken, jobject jListener)
383 LOGD("OcAccountManager_signIn");
386 ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
390 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
397 std::string userUuid;
398 std::string accessToken;
401 userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
405 accessToken = env->GetStringUTFChars(jAccessToken, nullptr);
410 OCStackResult result = accountManager->signIn(env,
415 if (OC_STACK_OK != result)
417 ThrowOcException(result, "OcAccountManager_signIn");
420 catch (OCException& e)
422 LOGE("%s", e.reason().c_str());
423 ThrowOcException(e.code(), e.reason().c_str());
428 * Class: org_iotivity_base_OcAccountManager
430 * Signature: (Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
432 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_signOut0
433 (JNIEnv *env, jobject thiz, jobject jListener)
435 LOGD("OcAccountManager_signOut");
438 ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
442 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
451 OCStackResult result = accountManager->signOut(env,
454 if (OC_STACK_OK != result)
456 ThrowOcException(result, "OcAccountManager_signOut");
459 catch (OCException& e)
461 LOGE("%s", e.reason().c_str());
462 ThrowOcException(e.code(), e.reason().c_str());
467 * Class: org_iotivity_base_OcAccountManager
468 * Method: refreshAccessToken0
469 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnPostListener;)V
471 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_refreshAccessToken0
472 (JNIEnv *env, jobject thiz, jstring jUserUuid, jstring jRefreshAccessToken, jobject jListener)
474 LOGD("OcAccountManager_refreshAccessToken");
477 ThrowOcException(OC_STACK_INVALID_PARAM, "onPostListener cannot be null");
481 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
488 std::string userUuid;
489 std::string refreshAccessToken;
492 userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
494 if (jRefreshAccessToken)
496 refreshAccessToken = env->GetStringUTFChars(jRefreshAccessToken, nullptr);
501 OCStackResult result = accountManager->refreshAccessToken(env,
506 if (OC_STACK_OK != result)
508 ThrowOcException(result, "OcAccountManager_refreshAccessToken");
511 catch (OCException& e)
513 LOGE("%s", e.reason().c_str());
514 ThrowOcException(e.code(), e.reason().c_str());
519 * Class: org_iotivity_base_OcAccountManager
520 * Method: searchUser0
521 * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
523 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_searchUser0
524 (JNIEnv *env, jobject thiz, jstring jUserUuid, jobject jListener)
526 LOGD("OcAccountManager_searchUser");
529 ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
533 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
540 std::string userUuid;
543 userUuid = env->GetStringUTFChars(jUserUuid, nullptr);
548 OCStackResult result = accountManager->searchUser(env,
552 if (OC_STACK_OK != result)
554 ThrowOcException(result, "OcAccountManager_searchUser");
557 catch (OCException& e)
559 LOGE("%s", e.reason().c_str());
560 ThrowOcException(e.code(), e.reason().c_str());
565 * Class: org_iotivity_base_OcAccountManager
566 * Method: searchUser1
567 * Signature: (Ljava/util/Map;Lorg/iotivity/base/OcAccountManager/OnGetListener;)V
569 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_searchUser1
570 (JNIEnv *env, jobject thiz, jobject jQueryMap, jobject jListener)
572 LOGD("OcAccountManager_searchUser");
575 ThrowOcException(OC_STACK_INVALID_PARAM, "onGetListener cannot be null");
580 ThrowOcException(OC_STACK_INVALID_PARAM, "queryMap cannot be null");
584 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
591 QueryParamsMap queryMap;
592 JniUtils::convertJavaMapToQueryParamsMap(env, jQueryMap, queryMap);
596 OCStackResult result = accountManager->searchUser(env,
600 if (OC_STACK_OK != result)
602 ThrowOcException(result, "OcAccountManager_searchUser");
605 catch (OCException& e)
607 LOGE("%s", e.reason().c_str());
608 ThrowOcException(e.code(), e.reason().c_str());
613 * Class: org_iotivity_base_OcAccountManager
614 * Method: deleteDevice0
615 * Signature: (Ljava/lang/String;Ljava/lang/String;Lorg/iotivity/base/OcAccountManager/onDeleteListener;)V
617 JNIEXPORT void JNICALL Java_org_iotivity_base_OcAccountManager_deleteDevice0
618 (JNIEnv *env, jobject thiz, jstring jDeviceId, jobject jListener)
620 LOGD("OcAccountManager_deleteDevice");
623 ThrowOcException(OC_STACK_INVALID_PARAM, "onDeleteListener cannot be null");
627 JniOcAccountManager *accountManager = JniOcAccountManager::getJniOcAccountManagerPtr(env,
634 std::string deviceId;
637 deviceId = env->GetStringUTFChars(jDeviceId, nullptr);
642 OCStackResult result = accountManager->deleteDevice(env,
646 if (OC_STACK_OK != result)
648 ThrowOcException(result, "OcAccountManager_deleteDevice");
651 catch (OCException& e)
653 LOGE("%s", e.reason().c_str());
654 ThrowOcException(e.code(), e.reason().c_str());