android/android_api/base/jni/JniUtils.h

   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
  23 #include "JniOcStack.h"
  24 #include "OCRepresentation.h"
  25
  26 class JniUtils
  27 {
  28 public:
  29     static void convertJavaMapToQueryParamsMap(JNIEnv *env, jobject hashMap,
  30         OC::QueryParamsMap &map);
  31     static jobject convertQueryParamsMapToJavaMap(JNIEnv *env, const OC::QueryParamsMap &map);
  32
  33     static jobject convertStrVectorToJavaStrList(JNIEnv *env, std::vector<std::string> &vector);
  34     static void convertJavaStrArrToStrVector(JNIEnv *env, jobjectArray jStrArr,
  35         std::vector<std::string> &vector);
  36
  37     static void convertJavaHeaderOptionsArrToVector(JNIEnv *env, jobjectArray jHeaderOptions,
  38         OC::HeaderOptions& headerOptions);
  39     static jobject convertHeaderOptionsVectorToJavaList(JNIEnv *env,
  40         const OC::HeaderOptions& headerOptions);
  41
  42     static void convertJavaRepresentationArrToVector(JNIEnv *env,
  43         jobjectArray jRepresentationArray,
  44         std::vector<OC::OCRepresentation>& representationVector);
  45     static jobjectArray convertRepresentationVectorToJavaArray(JNIEnv *env,
  46         const std::vector<OC::OCRepresentation>& representationVector);
  47
  48     static OC::ServiceType getServiceType(JNIEnv *env, int type)
  49     {
  50         switch (type)
  51         {
  52             case 0:
  53                 return OC::ServiceType::InProc;
  54             case 1:
  55                 return OC::ServiceType::OutOfProc;
  56             default:
  57                 ThrowOcException(OC_STACK_INVALID_PARAM, "Unexpected service type");
  58                 return OC::ServiceType::OutOfProc;
  59         };
  60     }
  61
  62     static OC::ModeType getModeType(JNIEnv *env, int type)
  63     {
  64         switch (type)
  65         {
  66             case 0:
  67                 return OC::ModeType::Server;
  68             case 1:
  69                 return OC::ModeType::Client;
  70             case 2:
  71                 return OC::ModeType::Both;
  72             case 3:
  73                 return OC::ModeType::Gateway;
  74             default:
  75                 ThrowOcException(OC_STACK_INVALID_PARAM, "Unexpected mode type");
  76                 return OC::ModeType::Both;
  77         };
  78     }
  79
  80     static OC::QualityOfService getQOS(JNIEnv *env, int type)
  81     {
  82         switch (type)
  83         {
  84             case 0:
  85                 return OC::QualityOfService::LowQos;
  86             case 1:
  87                 return OC::QualityOfService::MidQos;
  88             case 2:
  89                 return OC::QualityOfService::HighQos;
  90             case 3:
  91                 return OC::QualityOfService::NaQos;
  92             default:
  93                 ThrowOcException(OC_STACK_INVALID_PARAM, "Unexpected quality of service");
  94                 return OC::QualityOfService::NaQos;
  95         };
  96     }
  97
  98     static OC::ObserveType getObserveType(JNIEnv *env, int type)
  99     {
 100         switch (type)
 101         {
 102             case 0:
 103                 return OC::ObserveType::Observe;
 104             case 1:
 105                 return OC::ObserveType::ObserveAll;
 106             default:
 107                 ThrowOcException(OC_STACK_INVALID_PARAM, "Unexpected observe type");
 108                 return OC::ObserveType::ObserveAll;
 109         };
 110     }
 111
 112     static OCEntityHandlerResult getOCEntityHandlerResult(JNIEnv *env, int type)
 113     {
 114         switch (type)
 115         {
 116             case 0:
 117                 return OCEntityHandlerResult::OC_EH_OK;
 118             case 1:
 119                 return OCEntityHandlerResult::OC_EH_ERROR;
 120             case 2:
 121                 return OCEntityHandlerResult::OC_EH_RESOURCE_CREATED;
 122             case 3:
 123                 return OCEntityHandlerResult::OC_EH_RESOURCE_DELETED;
 124             case 4:
 125                 return OCEntityHandlerResult::OC_EH_SLOW;
 126             case 5:
 127                 return OCEntityHandlerResult::OC_EH_FORBIDDEN;
 128             case 6:
 129                 return OCEntityHandlerResult::OC_EH_RESOURCE_NOT_FOUND;
 130             default:
 131                 ThrowOcException(OC_STACK_INVALID_PARAM, "Unexpected OCEntityHandlerResult");
 132                 return OCEntityHandlerResult::OC_EH_ERROR;
 133         };
 134     }
 135
 136     static OCTransportAdapter getOCTransportAdapter(int adapter)
 137     {
 138         int transport = OCTransportAdapter::OC_DEFAULT_ADAPTER;
 139         if (adapter & CT_ADAPTER_IP)
 140         {
 141             transport |= OCTransportAdapter::OC_ADAPTER_IP;
 142         }
 143
 144         if (adapter & CT_ADAPTER_GATT_BTLE)
 145         {
 146             transport |= OCTransportAdapter::OC_ADAPTER_GATT_BTLE;
 147         }
 148
 149         if (adapter & CT_ADAPTER_RFCOMM_BTEDR)
 150         {
 151             transport |= OCTransportAdapter::OC_ADAPTER_RFCOMM_BTEDR;
 152         }
 153
 154         if (adapter & CT_ADAPTER_TCP)
 155         {
 156             transport |= OCTransportAdapter::OC_ADAPTER_TCP;
 157         }
 158
 159         if (adapter & CT_ADAPTER_NFC)
 160         {
 161             transport |= OCTransportAdapter::OC_ADAPTER_NFC;
 162         }
 163         return (OCTransportAdapter)transport;
 164     }
 165
 166     static std::string stackResultToStr(const int result)
 167     {
 168         switch (result)
 169         {
 170             /** Success status code - START HERE.*/
 171             case OC_STACK_OK:
 172                 return "OK";
 173             case OC_STACK_RESOURCE_CREATED:
 174                 return "RESOURCE_CREATED";
 175             case OC_STACK_RESOURCE_DELETED:
 176                 return "RESOURCE_DELETED";
 177             case OC_STACK_RESOURCE_CHANGED:
 178                 return "RESOURCE_CHANGED";
 179             case OC_STACK_CONTINUE:
 180                 return "CONTINUE";
 181             /* Error status code - START HERE */
 182             case OC_STACK_INVALID_URI:
 183                 return "INVALID_URI";
 184             case OC_STACK_INVALID_QUERY:
 185                 return "INVALID_QUERY";
 186             case OC_STACK_INVALID_IP:
 187                 return "INVALID_IP";
 188             case OC_STACK_INVALID_PORT:
 189                 return "INVALID_PORT";
 190             case OC_STACK_INVALID_CALLBACK:
 191                 return "INVALID_CALLBACK";
 192             case OC_STACK_INVALID_METHOD:
 193                 return "INVALID_METHOD";
 194             /** Invalid parameter.*/
 195             case OC_STACK_INVALID_PARAM:
 196                 return "INVALID_PARAM";
 197             case OC_STACK_INVALID_OBSERVE_PARAM:
 198                 return "INVALID_OBSERVE_PARAM";
 199             case OC_STACK_NO_MEMORY:
 200                 return "NO_MEMORY";
 201             case OC_STACK_COMM_ERROR:
 202                 return "COMM_ERROR";
 203             case OC_STACK_TIMEOUT:
 204                 return "TIMEOUT";
 205             case OC_STACK_ADAPTER_NOT_ENABLED:
 206                 return "ADAPTER_NOT_ENABLED";
 207             case OC_STACK_NOTIMPL:
 208                 return "NOTIMPL";
 209             /** Resource not found.*/
 210             case OC_STACK_NO_RESOURCE:
 211                 return "NO_RESOURCE";
 212             /** e.g: not supported method or interface.*/
 213             case  OC_STACK_RESOURCE_ERROR:
 214                 return "RESOURCE_ERROR";
 215             case OC_STACK_SLOW_RESOURCE:
 216                 return "SLOW_RESOURCE";
 217             case OC_STACK_DUPLICATE_REQUEST:
 218                 return "DUPLICATE_REQUEST";
 219             /** Resource has no registered observers.*/
 220             case OC_STACK_NO_OBSERVERS:
 221                 return "NO_OBSERVERS";
 222             case OC_STACK_OBSERVER_NOT_FOUND:
 223                 return "OBSERVER_NOT_FOUND";
 224             case OC_STACK_VIRTUAL_DO_NOT_HANDLE:
 225                 return "VIRTUAL_DO_NOT_HANDLE";
 226             case OC_STACK_INVALID_OPTION:
 227                 return "INVALID_OPTION";
 228             /** The remote reply contained malformed data.*/
 229             case OC_STACK_MALFORMED_RESPONSE:
 230                 return "MALFORMED_RESPONSE";
 231             case OC_STACK_PERSISTENT_BUFFER_REQUIRED:
 232                 return "PERSISTENT_BUFFER_REQUIRED";
 233             case OC_STACK_INVALID_REQUEST_HANDLE:
 234                 return "INVALID_REQUEST_HANDLE";
 235             case OC_STACK_INVALID_DEVICE_INFO:
 236                 return "INVALID_DEVICE_INFO";
 237             case OC_STACK_INVALID_JSON:
 238                 return "INVALID_JSON";
 239             /** Request is not authorized by Resource Server. */
 240             case OC_STACK_NOT_ACCEPTABLE:
 241                 return "NOT_ACCEPTABLE";
 242             case OC_STACK_UNAUTHORIZED_REQ:
 243                 return "UNAUTHORIZED_REQ";
 244             /** Error code from PDM */
 245             case OC_STACK_PDM_IS_NOT_INITIALIZED:
 246                 return "PDM_IS_NOT_INITIALIZED";
 247             case OC_STACK_DUPLICATE_UUID:
 248                 return "DUPLICATE_UUID";
 249             case OC_STACK_INCONSISTENT_DB:
 250                 return "INCONSISTENT_DB";
 251             case OC_STACK_SVR_DB_NOT_EXIST:
 252                 return "SVR_DB_NOT_EXIST";
 253             /** Error code from OTM */
 254             case OC_STACK_AUTHENTICATION_FAILURE:
 255                 return "AUTHENTICATION_FAILURE";
 256             /** Insert all new error codes here!.*/
 257 #ifdef WITH_PRESENCE
 258             case OC_STACK_PRESENCE_STOPPED:
 259                 return "PRESENCE_STOPPED";
 260             case OC_STACK_PRESENCE_TIMEOUT:
 261                 return "PRESENCE_TIMEOUT";
 262             case OC_STACK_PRESENCE_DO_NOT_HANDLE:
 263                 return "PRESENCE_DO_NOT_HANDLE";
 264 #endif
 265             case OC_STACK_ERROR:
 266                 return "ERROR";
 267
 268             case JNI_EXCEPTION:
 269                 return "JNI_EXCEPTION";
 270             case JNI_NO_NATIVE_POINTER:
 271                 return "JNI_NO_NATIVE_POINTER";
 272             case JNI_INVALID_VALUE:
 273                 return "JNI_INVALID_VALUE";
 274             default:
 275                 return "";
 276         }
 277     }
 278 };