android/android_api/base/jni/JniOcResourceResponse.cpp

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 Intel Corporation.
   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 #include "JniOcResourceResponse.h"
  23 #include "OCResourceResponse.h"
  24 #include "JniOcRepresentation.h"
  25 #include "JniOcRequestHandle.h"
  26 #include "JniOcResourceHandle.h"
  27 #include "JniUtils.h"
  28
  29 using namespace OC;
  30
  31 JniOcResourceResponse::JniOcResourceResponse
  32 (std::shared_ptr<OCResourceResponse> resourceResponse)
  33 : m_response(resourceResponse)
  34 {
  35 }
  36
  37 JniOcResourceResponse::~JniOcResourceResponse()
  38 {
  39 }
  40
  41 void JniOcResourceResponse::setErrorCode(const int eCode)
  42 {
  43     this->m_response->setErrorCode(eCode);
  44 }
  45
  46 std::string JniOcResourceResponse::getNewResourceUri(void)
  47 {
  48     return this->m_response->getNewResourceUri();
  49 }
  50
  51 void
  52 JniOcResourceResponse::setNewResourceUri(const std::string newResourceUri)
  53 {
  54     this->m_response->setNewResourceUri(newResourceUri);
  55 }
  56
  57 void JniOcResourceResponse::setHeaderOptions(const HeaderOptions& headerOptions)
  58 {
  59     this->m_response->setHeaderOptions(headerOptions);
  60 }
  61
  62 void JniOcResourceResponse::setRequestHandle(const OCRequestHandle& requestHandle)
  63 {
  64     this->m_response->setRequestHandle(requestHandle);
  65 }
  66
  67 void JniOcResourceResponse::setResourceHandle(const OCResourceHandle& resourceHandle)
  68 {
  69     this->m_response->setResourceHandle(resourceHandle);
  70 }
  71
  72 void JniOcResourceResponse::setResponseResult(const OCEntityHandlerResult& responseResult)
  73 {
  74     this->m_response->setResponseResult(responseResult);
  75 }
  76
  77 void JniOcResourceResponse::setResourceRepresentation(OCRepresentation& rep,
  78     std::string interfaceStr)
  79 {
  80     this->m_response->setResourceRepresentation(rep, interfaceStr);
  81 }
  82
  83 void JniOcResourceResponse::setResourceRepresentation(OCRepresentation& rep)
  84 {
  85     this->m_response->setResourceRepresentation(rep);
  86 }
  87
  88 std::shared_ptr<OCResourceResponse> JniOcResourceResponse::getOCResourceResponse()
  89 {
  90     return this->m_response;
  91 }
  92
  93 JniOcResourceResponse* JniOcResourceResponse::getJniOcResourceResponsePtr
  94 (JNIEnv *env, jobject thiz)
  95 {
  96     JniOcResourceResponse *request = GetHandle<JniOcResourceResponse>(env, thiz);
  97     if (env->ExceptionCheck())
  98     {
  99         LOGE("Failed to get native handle from JniOcResourceResponse");
 100     }
 101     if (!request)
 102     {
 103         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
 104     }
 105     return request;
 106 }
 107 /*
 108 * Class:     org_iotivity_base_OcResourceResponse
 109 * Method:    setErrorCode
 110 * Signature: (I)V
 111 */
 112 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setErrorCode
 113 (JNIEnv *env, jobject thiz, jint eCode)
 114 {
 115     LOGD("OcResourceResponse_setErrorCode");
 116     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 117     if (!response)
 118     {
 119         return;
 120     }
 121     response->setErrorCode(static_cast<int>(eCode));
 122 }
 123
 124 /*
 125 * Class:     org_iotivity_base_OcResourceResponse
 126 * Method:    getNewResourceUri
 127 * Signature: ()Ljava/lang/String;
 128 */
 129 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResourceResponse_getNewResourceUri
 130 (JNIEnv *env, jobject thiz)
 131 {
 132     LOGD("OcResourceResponse_getNewResourceUri");
 133     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 134     if (!response)
 135     {
 136         return nullptr;
 137     }
 138     return env->NewStringUTF(response->getNewResourceUri().c_str());
 139 }
 140
 141 /*
 142 * Class:     org_iotivity_base_OcResourceResponse
 143 * Method:    setNewResourceUri
 144 * Signature: (Ljava/lang/String;)V
 145 */
 146 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setNewResourceUri
 147 (JNIEnv *env, jobject thiz, jstring jstr)
 148 {
 149     LOGD("OcResourceResponse_setNewResourceUri");
 150     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 151     if (!response)
 152     {
 153         return;
 154     }
 155     response->setNewResourceUri(env->GetStringUTFChars(jstr, 0));
 156 }
 157
 158 /*
 159 * Class:     org_iotivity_base_OcResourceResponse
 160 * Method:    setHeaderOptions
 161 * Signature: (Ljava/util/List;)V
 162 */
 163 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setHeaderOptions
 164 (JNIEnv *env, jobject thiz, jobjectArray jHeaderOptions)
 165 {
 166     LOGD("OcResourceResponse_setHeaderOptions");
 167     if (!jHeaderOptions)
 168     {
 169         ThrowOcException(OC_STACK_INVALID_PARAM, "headerOptionList cannot be null");
 170         return;
 171     }
 172     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 173     if (!jniResponse)
 174     {
 175         return;
 176     }
 177     HeaderOptions headerOptions;
 178     JniUtils::convertJavaHeaderOptionsArrToVector(env, jHeaderOptions, headerOptions);
 179
 180     jniResponse->setHeaderOptions(headerOptions);
 181 }
 182
 183 /*
 184 * Class:     org_iotivity_base_OcResourceResponse
 185 * Method:    setRequestHandle
 186 * Signature: (Lorg/iotivity/base/OcRequestHandle;)V
 187 */
 188 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setRequestHandle
 189 (JNIEnv *env, jobject thiz, jobject jRequestHandle)
 190 {
 191     LOGI("OcResourceResponse_setRequestHandle");
 192     if (!jRequestHandle)
 193     {
 194         ThrowOcException(OC_STACK_INVALID_PARAM, "requestHandle cannot be null");
 195         return;
 196     }
 197     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 198     if (!jniResponse)
 199     {
 200         return;
 201     }
 202     JniOcRequestHandle* jniOcRequestHandle = JniOcRequestHandle::getJniOcRequestHandlePtr(env, jRequestHandle);
 203     if (!jniOcRequestHandle)
 204     {
 205         return;
 206     }
 207     jniResponse->setRequestHandle(jniOcRequestHandle->getOCRequestHandle());
 208 }
 209
 210 /*
 211 * Class:     org_iotivity_base_OcResourceResponse
 212 * Method:    setResourceHandle
 213 * Signature: (Lorg/iotivity/base/OcResourceHandle;)V
 214 */
 215 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setResourceHandle
 216 (JNIEnv *env, jobject thiz, jobject jResourceHandle)
 217 {
 218     LOGI("OcResourceResponse_setResourceHandle");
 219     if (!jResourceHandle)
 220     {
 221         ThrowOcException(OC_STACK_INVALID_PARAM, "resourceHandle cannot be null");
 222         return;
 223     }
 224     JniOcResourceResponse *jniResponse = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 225     if (!jniResponse)
 226     {
 227         return;
 228     }
 229     JniOcResourceHandle* jniOcResourceHandle = JniOcResourceHandle::getJniOcResourceHandlePtr(env, jResourceHandle);
 230     if (!jniOcResourceHandle)
 231     {
 232         return;
 233     }
 234     jniResponse->setResourceHandle(jniOcResourceHandle->getOCResourceHandle());
 235 }
 236
 237 /*
 238 * Class:     org_iotivity_base_OcResourceResponse
 239 * Method:    setResponseResult
 240 * Signature: (I)V
 241 */
 242 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setResponseResult
 243 (JNIEnv *env, jobject thiz, jint responseResult)
 244 {
 245     LOGD("OcResourceResponse_setResponseResult");
 246     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 247     if (!response)
 248     {
 249         return;
 250     }
 251     response->setResponseResult(JniUtils::getOCEntityHandlerResult(env, static_cast<int>(responseResult)));
 252 }
 253
 254 /*
 255 * Class:     org_iotivity_base_OcResourceResponse
 256 * Method:    setResourceRepresentation
 257 * Signature: (Lorg/iotivity/base/OcRepresentation;Ljava/lang/String;)V
 258 */
 259 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setResourceRepresentation
 260 (JNIEnv *env, jobject thiz, jobject jRepresentation, jstring jstr)
 261 {
 262     LOGD("OcResourceResponse_setResourceRepresentation");
 263     if (!jRepresentation)
 264     {
 265         ThrowOcException(OC_STACK_INVALID_PARAM, "Representation cannot be null");
 266         return;
 267     }
 268     if (!jstr)
 269     {
 270         ThrowOcException(OC_STACK_INVALID_PARAM, "interface cannot be null");
 271         return;
 272     }
 273
 274     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env,
 275         thiz);
 276     if (!response)
 277     {
 278         return;
 279     }
 280     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env,
 281         jRepresentation);
 282     if (!representation)
 283     {
 284         return;
 285     }
 286     response->setResourceRepresentation(*representation, env->GetStringUTFChars(jstr, 0));
 287 }
 288
 289 /*
 290 * Class:     org_iotivity_base_OcResourceResponse
 291 * Method:    setResourceRepresentation1
 292 * Signature: (Lorg/iotivity/base/OcRepresentation;)V
 293 */
 294 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_setResourceRepresentation1
 295 (JNIEnv *env, jobject thiz, jobject jRepresentation)
 296 {
 297     LOGD("OcResourceResponse_setResourceRepresentation");
 298     if (!jRepresentation)
 299     {
 300         ThrowOcException(OC_STACK_INVALID_PARAM, "Representation cannot be null");
 301         return;
 302     }
 303     JniOcResourceResponse *response = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 304     if (!response)
 305     {
 306         return;
 307     }
 308     OCRepresentation *representation = JniOcRepresentation::getOCRepresentationPtr(env,
 309         jRepresentation);
 310
 311     if (representation)
 312     {
 313         response->setResourceRepresentation(*representation);
 314     }
 315 }
 316
 317 /*
 318 * Class:     org_iotivity_base_OcResourceResponse
 319 * Method:    create
 320 * Signature: ()V
 321 */
 322 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_create
 323 (JNIEnv *env, jobject thiz)
 324 {
 325     LOGI("OcResourceResponse_create");
 326     auto pResponse = std::make_shared<OC::OCResourceResponse>();
 327     JniOcResourceResponse* jniResourceResponse = new JniOcResourceResponse(pResponse);
 328     SetHandle<JniOcResourceResponse>(env, thiz, jniResourceResponse);
 329     if (env->ExceptionCheck())
 330     {
 331         LOGE("Failed to create OcResourceResponse");
 332         delete jniResourceResponse;
 333     }
 334 }
 335
 336 /*
 337 * Class:     org_iotivity_base_OcResourceResponse
 338 * Method:    dispose
 339 * Signature: ()V
 340 */
 341 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceResponse_dispose
 342 (JNIEnv *env, jobject thiz)
 343 {
 344     LOGD("OcResourceResponse_dispose");
 345     JniOcResourceResponse *resp = JniOcResourceResponse::getJniOcResourceResponsePtr(env, thiz);
 346     delete resp;
 347 }