android/android_api/base/jni/JniOcProvisioning.cpp

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 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 "JniOcProvisioning.h"
  24 #include "JniPinCheckListener.h"
  25 #include "JniDisplayPinListener.h"
  26
  27 using namespace OC;
  28 namespace PH = std::placeholders;
  29
  30 static JniPinCheckListener *jniPinListener = nullptr;
  31 static JniDisplayPinListener *jniDisplayPinListener = nullptr;
  32
  33 void Callback(char *buf, size_t size)
  34 {
  35     if (jniPinListener)
  36     {
  37         jniPinListener->PinCallback(buf, size);
  38     }
  39     else
  40     {
  41         LOGE("jniPinListener is null");
  42     }
  43 }
  44
  45 void displayPinCB(char *pinBuf, size_t pinSize)
  46 {
  47     if (jniDisplayPinListener)
  48     {
  49         jniDisplayPinListener->displayPinCallback(pinBuf, pinSize);
  50     }
  51     else
  52     {
  53         LOGE("DisplayPinListener is null");
  54     }
  55 }
  56
  57 /*
  58  * Class:     org_iotivity_base_OcProvisioning
  59  * Method:    ownershipTransferCDdata
  60  * Signature: (I)V
  61  */
  62 JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_ownershipTransferCBdata
  63   (JNIEnv *env, jobject thiz, jint OxmType, jobject jListener)
  64 {
  65     LOGD("OcProvisioning_ownershipTransferCBdata");
  66     OCStackResult result = OC_STACK_ERROR;
  67
  68     try
  69     {
  70         OTMCallbackData_t CBData = {0};
  71         if (OIC_JUST_WORKS == (OicSecOxm_t)OxmType)
  72         {
  73             CBData.loadSecretCB = LoadSecretJustWorksCallback;
  74             CBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
  75             CBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
  76             CBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
  77
  78             result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
  79                     &CBData, NULL);
  80         }
  81         if (OIC_RANDOM_DEVICE_PIN == (OicSecOxm_t)OxmType)
  82         {
  83             if (jListener)
  84             {
  85                 delete jniPinListener;
  86                 jniPinListener = new JniPinCheckListener(env, jListener);
  87                 CBData.loadSecretCB = InputPinCodeCallback;
  88                 CBData.createSecureSessionCB = CreateSecureSessionRandomPinCallbak;
  89                 CBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
  90                 CBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
  91                 result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
  92                         &CBData, Callback);
  93             }
  94             else
  95             {
  96                 result = OC_STACK_ERROR;
  97             }
  98         }
  99
 100         if (OC_STACK_OK != result)
 101         {
 102             ThrowOcException(result, "OcProvisioning_ownershipTransferCDdata");
 103             return;
 104         }
 105     }
 106     catch (OCException& e)
 107     {
 108         LOGE("%s", e.reason().c_str());
 109         ThrowOcException(e.code(), e.reason().c_str());
 110     }
 111 }
 112
 113 /*
 114 * Class:     org_iotivity_base_OcProvisioning
 115 * Method:    discoverUnownedDevices
 116 * Signature: (I)[Lorg/iotivity/base/OcSecureResource;
 117 */
 118 JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_discoverUnownedDevices1
 119   (JNIEnv *env, jclass clazz, jint timeout)
 120 {
 121     LOGI("OcProvisioning_discoverUnownedDevices");
 122     DeviceList_t list;
 123
 124     try
 125     {
 126         OCStackResult result = OCSecure::discoverUnownedDevices((unsigned short)timeout, list);
 127
 128         if (OC_STACK_OK != result)
 129         {
 130             ThrowOcException(result, "Failed to discover Unowned devices");
 131             return nullptr;
 132         }
 133
 134         return JniSecureUtils::convertDeviceVectorToJavaArray(env, list);
 135     }
 136     catch (OCException& e)
 137     {
 138         LOGE("%s", e.reason().c_str());
 139         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 140         return nullptr;
 141     }
 142 }
 143
 144 /*
 145  * Class:     org_iotivity_base_OcProvisioning
 146  * Method:    provisionInit
 147  * Signature: (Ljava/lang/String;)V
 148  */
 149 JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_provisionInit
 150   (JNIEnv *env, jclass calzz, jstring jdbPath)
 151 {
 152     LOGI("OcProvisioning_provisionInit");
 153     char *dbpath;
 154
 155     if (!jdbPath)
 156     {
 157         ThrowOcException(OC_STACK_INVALID_PARAM, "SVR db path cannot be null");
 158         return;
 159     }
 160
 161     try
 162     {
 163         dbpath = (char*)env->GetStringUTFChars(jdbPath, NULL);
 164         OCStackResult result = OCSecure::provisionInit(env->GetStringUTFChars(jdbPath, NULL));
 165
 166         if (OC_STACK_OK != result)
 167         {
 168             env->ReleaseStringUTFChars(jdbPath, (const char*)dbpath);
 169             ThrowOcException(result, "Failed to Init Provisioning Manager");
 170             return;
 171         }
 172         env->ReleaseStringUTFChars(jdbPath, (const char*)dbpath);
 173     }
 174     catch (OCException& e)
 175     {
 176         LOGE("%s", e.reason().c_str());
 177         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 178     }
 179 }
 180
 181 /*
 182  * Class:     org_iotivity_base_OcProvisioning
 183  * Method:    discoverOwnedDevices
 184  * Signature: (I)[Lorg/iotivity/base/OcSecureResource;
 185  */
 186 JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_discoverOwnedDevices1
 187   (JNIEnv *env, jclass clazz , jint timeout)
 188 {
 189     LOGI("OcProvisioning_discoverOwnedDevices");
 190     DeviceList_t list;
 191
 192     try
 193     {
 194         OCStackResult result = OCSecure::discoverOwnedDevices((unsigned short)timeout, list);
 195         if (OC_STACK_OK != result)
 196         {
 197             ThrowOcException(result, "Failed to discover Owned devices");
 198             return nullptr;
 199         }
 200
 201         return JniSecureUtils::convertDeviceVectorToJavaArray(env, list);
 202     }
 203     catch (OCException& e)
 204     {
 205         LOGE("%s", e.reason().c_str());
 206         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 207         return nullptr;
 208     }
 209 }
 210
 211 /*
 212  * Class:     org_iotivity_base_OcProvisioning
 213  * Method:    getDevicestatusLists
 214  * Signature: (I)[Lorg/iotivity/base/OcSecureResource;
 215  */
 216 JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_getDeviceStatusList1
 217   (JNIEnv *env, jclass clazz, jint timeout)
 218 {
 219     LOGI("OcProvisioning_getDeviceStatusList");
 220     DeviceList_t  ownedDevList, unownedDevList;
 221
 222     try
 223     {
 224         OCStackResult result = OCSecure::getDevInfoFromNetwork((unsigned short)timeout,
 225                 ownedDevList, unownedDevList);
 226         if (OC_STACK_OK != result)
 227         {
 228             ThrowOcException(result, "Failed to get Device Status List");
 229             return nullptr;
 230         }
 231         ownedDevList.insert(ownedDevList.end(), unownedDevList.begin(), unownedDevList.end());
 232         return JniSecureUtils::convertDeviceVectorToJavaArray(env, ownedDevList);
 233     }
 234     catch (OCException& e)
 235     {
 236         LOGE("%s", e.reason().c_str());
 237         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 238         return nullptr;
 239     }
 240 }
 241
 242 /*
 243  * Class:     org_iotivity_base_OcProvisioning
 244  * Method:    setDisplayPinListener
 245  * Signature: (Lorg/iotivity/base/OcProvisioning/DisplayPinListener;)V
 246  */
 247 JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_setDisplayPinListener
 248   (JNIEnv *env, jclass thiz, jobject jListener)
 249 {
 250
 251     LOGI("OcProvisioning_setDisplayPinListener");
 252
 253     if (!jListener)
 254     {
 255         ThrowOcException(OC_STACK_INVALID_PARAM, "displayPinListener can't be null");
 256         return;
 257     }
 258     delete jniDisplayPinListener;
 259     jniDisplayPinListener = new JniDisplayPinListener(env, jListener);
 260
 261     try
 262     {
 263         OCStackResult result = OCSecure::setDisplayPinCB(displayPinCB);
 264         if (OC_STACK_OK != result)
 265         {
 266             ThrowOcException(result, "Failed to set displayPinListener");
 267             return;
 268         }
 269     }
 270     catch (OCException& e)
 271     {
 272         LOGE("%s", e.reason().c_str());
 273         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 274     }
 275 }