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