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     }
 141 }
 142
 143 /*
 144  * Class:     org_iotivity_base_OcProvisioning
 145  * Method:    provisionInit
 146  * Signature: (Ljava/lang/String;)V
 147  */
 148 JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_provisionInit
 149   (JNIEnv *env, jclass calzz, jstring jdbPath)
 150 {
 151     LOGI("OcProvisioning_provisionInit");
 152     char *dbpath;
 153
 154     if (!jdbPath)
 155     {
 156         ThrowOcException(OC_STACK_INVALID_PARAM, "SVR db path cannot be null");
 157         return;
 158     }
 159
 160     try
 161     {
 162         dbpath = (char*)env->GetStringUTFChars(jdbPath, NULL);
 163         OCStackResult result = OCSecure::provisionInit(env->GetStringUTFChars(jdbPath, NULL));
 164
 165         if (OC_STACK_OK != result)
 166         {
 167             env->ReleaseStringUTFChars(jdbPath, (const char*)dbpath);
 168             ThrowOcException(result, "Failed to Init Provisioning Manager");
 169             return;
 170         }
 171         env->ReleaseStringUTFChars(jdbPath, (const char*)dbpath);
 172     }
 173     catch (OCException& e)
 174     {
 175         LOGE("%s", e.reason().c_str());
 176         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 177     }
 178 }
 179
 180 /*
 181  * Class:     org_iotivity_base_OcProvisioning
 182  * Method:    discoverOwnedDevices
 183  * Signature: (I)[Lorg/iotivity/base/OcSecureResource;
 184  */
 185 JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_discoverOwnedDevices1
 186   (JNIEnv *env, jclass clazz , jint timeout)
 187 {
 188     LOGI("OcProvisioning_discoverOwnedDevices");
 189     DeviceList_t list;
 190
 191     try
 192     {
 193         OCStackResult result = OCSecure::discoverOwnedDevices((unsigned short)timeout, list);
 194         if (OC_STACK_OK != result)
 195         {
 196             ThrowOcException(result, "Failed to discover Owned devices");
 197             return nullptr;
 198         }
 199
 200         return JniSecureUtils::convertDeviceVectorToJavaArray(env, list);
 201     }
 202     catch (OCException& e)
 203     {
 204         LOGE("%s", e.reason().c_str());
 205         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 206     }
 207 }
 208
 209 /*
 210  * Class:     org_iotivity_base_OcProvisioning
 211  * Method:    getDevicestatusLists
 212  * Signature: (I)[Lorg/iotivity/base/OcSecureResource;
 213  */
 214 JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_getDeviceStatusList1
 215   (JNIEnv *env, jclass clazz, jint timeout)
 216 {
 217     LOGI("OcProvisioning_getDeviceStatusList");
 218     DeviceList_t  ownedDevList, unownedDevList;
 219
 220     try
 221     {
 222         OCStackResult result = OCSecure::getDevInfoFromNetwork((unsigned short)timeout,
 223                 ownedDevList, unownedDevList);
 224         if (OC_STACK_OK != result)
 225         {
 226             ThrowOcException(result, "Failed to get Device Status List");
 227             return nullptr;
 228         }
 229         ownedDevList.insert(ownedDevList.end(), unownedDevList.begin(), unownedDevList.end());
 230         return JniSecureUtils::convertDeviceVectorToJavaArray(env, ownedDevList);
 231     }
 232     catch (OCException& e)
 233     {
 234         LOGE("%s", e.reason().c_str());
 235         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 236     }
 237 }
 238
 239 /*
 240  * Class:     org_iotivity_base_OcProvisioning
 241  * Method:    setDisplayPinListener
 242  * Signature: (Lorg/iotivity/base/OcProvisioning/DisplayPinListener;)V
 243  */
 244 JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_setDisplayPinListener
 245   (JNIEnv *env, jclass thiz, jobject jListener)
 246 {
 247
 248     LOGI("OcProvisioning_setDisplayPinListener");
 249
 250     if (!jListener)
 251     {
 252         ThrowOcException(OC_STACK_INVALID_PARAM, "displayPinListener can't be null");
 253         return;
 254     }
 255     delete jniDisplayPinListener;
 256     jniDisplayPinListener = new JniDisplayPinListener(env, jListener);
 257
 258     try
 259     {
 260         OCStackResult result = OCSecure::setDisplayPinCB(displayPinCB);
 261         if (OC_STACK_OK != result)
 262         {
 263             ThrowOcException(result, "Failed to set displayPinListener");
 264             return;
 265         }
 266     }
 267     catch (OCException& e)
 268     {
 269         LOGE("%s", e.reason().c_str());
 270         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
 271     }
 272 }