android/android_api/base/jni/JniOcResourceRequest.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 "JniOcResourceRequest.h"
  23 #include "OCResourceRequest.h"
  24 #include "JniOcResourceHandle.h"
  25 #include "JniOcRequestHandle.h"
  26 #include "JniUtils.h"
  27
  28 using namespace OC;
  29
  30 JniOcResourceRequest::JniOcResourceRequest(const std::shared_ptr<OCResourceRequest> request)
  31     : m_request(request)
  32 {}
  33
  34 JniOcResourceRequest::~JniOcResourceRequest()
  35 {}
  36
  37 std::string
  38 JniOcResourceRequest::getRequestType()
  39 {
  40     return m_request->getRequestType();
  41 }
  42
  43 const QueryParamsMap&
  44 JniOcResourceRequest::getQueryParameters() const
  45 {
  46     return m_request->getQueryParameters();
  47 }
  48
  49 int
  50 JniOcResourceRequest::getRequestHandlerFlag() const
  51 {
  52     return m_request->getRequestHandlerFlag();
  53 }
  54
  55 const OCRepresentation&
  56 JniOcResourceRequest::getResourceRepresentation() const
  57 {
  58     return m_request->getResourceRepresentation();
  59 }
  60
  61 const ObservationInfo&
  62 JniOcResourceRequest::getObservationInfo() const
  63 {
  64     return m_request->getObservationInfo();
  65 }
  66
  67 void
  68 JniOcResourceRequest::setResourceUri(const std::string resourceUri)
  69 {
  70     m_request->setResourceUri(resourceUri);
  71 }
  72
  73 std::string
  74 JniOcResourceRequest::getResourceUri(void)
  75 {
  76     return m_request->getResourceUri();
  77 }
  78
  79 const HeaderOptions&
  80 JniOcResourceRequest::getHeaderOptions() const
  81 {
  82     return m_request->getHeaderOptions();
  83 }
  84
  85 const OCRequestHandle&
  86 JniOcResourceRequest::getRequestHandle() const
  87 {
  88     return m_request->getRequestHandle();
  89 }
  90
  91 const OCResourceHandle&
  92 JniOcResourceRequest::getResourceHandle() const
  93 {
  94     return m_request->getResourceHandle();
  95 }
  96
  97 JniOcResourceRequest* JniOcResourceRequest::getJniOcResourceRequestPtr
  98 (JNIEnv *env, jobject thiz)
  99 {
 100     JniOcResourceRequest *request = GetHandle<JniOcResourceRequest>(env, thiz);
 101     if (env->ExceptionCheck())
 102     {
 103         LOGE("Failed to get native handle from OcResourceRequest");
 104     }
 105     if (!request)
 106     {
 107         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
 108     }
 109     return request;
 110 }
 111
 112 /*
 113 * Class:     org_iotivity_base_OcResourceRequest
 114 * Method:    getRequestTypeNative
 115 * Signature: ()Ljava/lang/String;
 116 */
 117 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResourceRequest_getRequestTypeNative
 118 (JNIEnv *env, jobject thiz)
 119 {
 120     LOGD("OcResourceRequest_getRequestTypeNative");
 121     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 122     if (!request) return nullptr;
 123
 124     std::string requestType = request->getRequestType();
 125     return env->NewStringUTF(requestType.c_str());
 126 }
 127
 128 /*
 129 * Class:     org_iotivity_base_OcResourceRequest
 130 * Method:    getQueryParameters
 131 * Signature: ()Ljava/util/Map;
 132 */
 133 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getQueryParameters
 134 (JNIEnv *env, jobject thiz)
 135 {
 136     LOGD("OcResourceRequest_getQueryParameters");
 137     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 138     if (!request) return nullptr;
 139
 140     return JniUtils::convertQueryParamsMapToJavaMap(env, request->getQueryParameters());
 141 }
 142
 143 /*
 144 * Class:     org_iotivity_base_OcResourceRequest
 145 * Method:    getRequestHandlerFlagNative
 146 * Signature: ()I
 147 */
 148 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcResourceRequest_getRequestHandlerFlagNative
 149 (JNIEnv *env, jobject thiz)
 150 {
 151     LOGD("OcResourceRequest_getRequestHandlerFlagNative");
 152     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 153     if (!request) return -1;
 154
 155     return static_cast<jint>(request->getRequestHandlerFlag());
 156 }
 157
 158 /*
 159 * Class:     org_iotivity_base_OcResourceRequest
 160 * Method:    getResourceRepresentation
 161 * Signature: ()Lorg/iotivity/base/OcRepresentation;
 162 */
 163 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getResourceRepresentation
 164 (JNIEnv *env, jobject thiz)
 165 {
 166     LOGD("OcResourceRequest_getResourceRepresentation");
 167     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 168     if (!request) return nullptr;
 169
 170     OCRepresentation *ocRepresentation = new OCRepresentation(request->getResourceRepresentation());
 171     if (!ocRepresentation) return nullptr;
 172
 173     jlong handle = reinterpret_cast<jlong>(ocRepresentation);
 174     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 175         handle, true);
 176     if (!jRepresentation)
 177     {
 178         LOGE("Failed to create OcRepresentation");
 179         delete ocRepresentation;
 180     }
 181
 182     return jRepresentation;
 183 }
 184
 185 /*
 186 * Class:     org_iotivity_base_OcResourceRequest
 187 * Method:    getObservationInfo
 188 * Signature: ()Lorg/iotivity/base/ObservationInfo;
 189 */
 190 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getObservationInfo
 191 (JNIEnv *env, jobject thiz)
 192 {
 193     LOGD("OcResourceRequest_getObservationInfo");
 194     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 195     if (!request) return nullptr;
 196
 197     ObservationInfo oInfo = request->getObservationInfo();
 198
 199     jobject jObservationInfo = env->NewObject(g_cls_ObservationInfo, g_mid_ObservationInfo_N_ctor,
 200         (jint)oInfo.action, (jbyte)oInfo.obsId);
 201
 202     if (!jObservationInfo)
 203     {
 204         LOGE("Failed to create ObservationInfo");
 205     }
 206
 207     return jObservationInfo;
 208 }
 209
 210 /*
 211 * Class:     org_iotivity_base_OcResourceRequest
 212 * Method:    setResourceUri
 213 * Signature: (Ljava/lang/String);
 214 */
 215 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceRequest_setResourceUri
 216 (JNIEnv *env, jobject thiz, jstring jUri)
 217 {
 218     LOGD("OcResourceRequest_setResourceUri");
 219     if (!jUri)
 220     {
 221         ThrowOcException(OC_STACK_INVALID_PARAM, "URI cannot be null");
 222         return;
 223     }
 224     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 225     if (!request) return;
 226
 227     request->setResourceUri(env->GetStringUTFChars(jUri, 0));
 228 }
 229
 230 /*
 231 * Class:     org_iotivity_base_OcResourceRequest
 232 * Method:    getResourceUri
 233 * Signature: ()Ljava/lang/String;
 234 */
 235 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcResourceRequest_getResourceUri
 236 (JNIEnv *env, jobject thiz)
 237 {
 238     LOGD("OcResourceRequest_getResourceUri");
 239     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 240     if (!request) return nullptr;
 241
 242     std::string requestUri = request->getResourceUri();
 243     return env->NewStringUTF(requestUri.c_str());
 244 }
 245
 246 /*
 247 * Class:     org_iotivity_base_OcResourceRequest
 248 * Method:    getHeaderOptions
 249 * Signature: ()Ljava/util/List;
 250 */
 251 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getHeaderOptions
 252 (JNIEnv *env, jobject thiz)
 253 {
 254     LOGD("OcResourceRequest_getHeaderOptions");
 255     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 256     if (!request) return nullptr;
 257
 258     return JniUtils::convertHeaderOptionsVectorToJavaList(env, request->getHeaderOptions());
 259 }
 260
 261 /*
 262 * Class:     org_iotivity_base_OcResourceRequest
 263 * Method:    getRequestHandle
 264 * Signature: ()Lorg/iotivity/base/OcRequestHandle;
 265 */
 266 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getRequestHandle
 267 (JNIEnv *env, jobject thiz)
 268 {
 269     LOGD("OcResourceRequest_getRequestHandle");
 270     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 271     if (!request) return nullptr;
 272
 273     JniOcRequestHandle* jniHandle = new JniOcRequestHandle(request->getRequestHandle());
 274     jlong handle = reinterpret_cast<jlong>(jniHandle);
 275     jobject jRequestHandle = env->NewObject(g_cls_OcRequestHandle, g_mid_OcRequestHandle_N_ctor, handle);
 276     if (!jRequestHandle)
 277     {
 278         LOGE("Failed to create OcRequestHandle");
 279         delete jniHandle;
 280     }
 281
 282     return jRequestHandle;
 283 }
 284
 285 /*
 286 * Class:     org_iotivity_base_OcResourceRequest
 287 * Method:    getResourceHandle
 288 * Signature: ()Lorg/iotivity/base/OcResourceHandle;
 289 */
 290 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcResourceRequest_getResourceHandle
 291 (JNIEnv *env, jobject thiz)
 292 {
 293     LOGD("OcResourceRequest_getResourceHandle");
 294     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 295     if (!request) return nullptr;
 296
 297     JniOcResourceHandle* jniHandle = new JniOcResourceHandle(
 298         request->getResourceHandle());
 299     jlong handle = reinterpret_cast<jlong>(jniHandle);
 300     jobject jResourceHandle = env->NewObject(g_cls_OcResourceHandle, g_mid_OcResourceHandle_N_ctor, handle);
 301     if (!jResourceHandle)
 302     {
 303         LOGE("Failed to create OcResourceHandle");
 304         delete jniHandle;
 305     }
 306
 307     return jResourceHandle;
 308 }
 309
 310 /*
 311 * Class:     org_iotivity_base_OcResourceRequest
 312 * Method:    dispose
 313 * Signature: ()V
 314 */
 315 JNIEXPORT void JNICALL Java_org_iotivity_base_OcResourceRequest_dispose
 316 (JNIEnv *env, jobject thiz)
 317 {
 318     LOGD("OcResourceRequest_dispose");
 319     JniOcResourceRequest *request = JniOcResourceRequest::getJniOcResourceRequestPtr(env, thiz);
 320     delete request;
 321 }