m2mdevice.cpp

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #include "mbed-client/m2mdevice.h"
00018 #include "mbed-client/m2mconstants.h"
00019 #include "mbed-client/m2mobject.h"
00020 #include "mbed-client/m2mobjectinstance.h"
00021 #include "mbed-client/m2mresource.h"
00022 #include "mbed-trace/mbed_trace.h"
00023 
00024 #define BUFFER_SIZE 21
00025 #define TRACE_GROUP "mClt"
00026 
00027 M2MDevice* M2MDevice::_instance = NULL;
00028 
00029 M2MDevice* M2MDevice::get_instance()
00030 {
00031     if(_instance == NULL) {
00032         _instance = new M2MDevice();
00033     }
00034     return _instance;
00035 }
00036 
00037 void M2MDevice::delete_instance()
00038 {
00039     delete _instance;
00040     _instance = NULL;
00041 }
00042 
00043 M2MDevice::M2MDevice()
00044 : M2MObject(M2M_DEVICE_ID)
00045 {
00046     M2MBase::set_register_uri(false);
00047     M2MBase::set_operation(M2MBase::GET_ALLOWED);
00048 
00049     _device_instance = M2MObject::create_object_instance();
00050     _device_instance->set_operation(M2MBase::GET_ALLOWED);
00051     _device_instance->set_register_uri(true);
00052     if(_device_instance) {
00053         _device_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE);        
00054         M2MResource* res = _device_instance->create_dynamic_resource(DEVICE_REBOOT,
00055                                                                      OMA_RESOURCE_TYPE,
00056                                                                      M2MResourceInstance::OPAQUE,
00057                                                                      false);
00058         if(res) {
00059             res->set_operation(M2MBase::POST_ALLOWED);
00060             res->set_register_uri(false);
00061         }
00062 
00063         M2MResourceInstance* instance = _device_instance->create_dynamic_resource_instance(DEVICE_ERROR_CODE,
00064                                                                  OMA_RESOURCE_TYPE,
00065                                                                  M2MResourceInstance::INTEGER,
00066                                                                  true,0);
00067         if(instance) {
00068             M2MResource * dev_res = _device_instance->resource(DEVICE_ERROR_CODE);
00069             if(dev_res) {
00070                 dev_res->set_register_uri(false);
00071             }
00072             instance->set_operation(M2MBase::GET_ALLOWED);
00073 
00074             instance->set_value(0);
00075             
00076             instance->set_register_uri(false);
00077         }
00078         res = _device_instance->create_dynamic_resource(DEVICE_SUPPORTED_BINDING_MODE,
00079                                                         OMA_RESOURCE_TYPE,
00080                                                         M2MResourceInstance::STRING,
00081                                                         true);
00082         if(res) {
00083             res->set_operation(M2MBase::GET_ALLOWED);
00084             res->set_value((const uint8_t*)BINDING_MODE_UDP,sizeof(BINDING_MODE_UDP)-1);
00085             res->set_register_uri(false);
00086         }
00087     }
00088 }
00089 
00090 M2MDevice::~M2MDevice()
00091 {
00092 }
00093 
00094 M2MResource* M2MDevice::create_resource(DeviceResource resource, const String &value)
00095 {
00096     M2MResource* res = NULL;
00097     const char* device_id_ptr = "";
00098     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00099     if(!is_resource_present(resource) && value.size() <= MAX_ALLOWED_STRING_LENGTH) {
00100         switch(resource) {
00101             case Manufacturer:
00102                device_id_ptr = DEVICE_MANUFACTURER;
00103                break;
00104             case DeviceType:
00105                 device_id_ptr = DEVICE_DEVICE_TYPE;
00106                 break;
00107             case ModelNumber:
00108                 device_id_ptr = DEVICE_MODEL_NUMBER;
00109                 break;
00110             case SerialNumber:
00111                 device_id_ptr = DEVICE_SERIAL_NUMBER;
00112                 break;
00113             case HardwareVersion:
00114                 device_id_ptr = DEVICE_HARDWARE_VERSION;
00115                 break;
00116             case FirmwareVersion:
00117                 device_id_ptr = DEVICE_FIRMWARE_VERSION;
00118                 break;
00119             case SoftwareVersion:
00120                 device_id_ptr = DEVICE_SOFTWARE_VERSION;
00121                 break;
00122             case UTCOffset:
00123                 device_id_ptr = DEVICE_UTC_OFFSET;
00124                 operation = M2MBase::GET_PUT_ALLOWED;
00125                 break;
00126             case Timezone:
00127                 device_id_ptr = DEVICE_TIMEZONE;
00128                 operation = M2MBase::GET_PUT_ALLOWED;
00129                 break;
00130             default:
00131                 break;
00132         }
00133     }
00134     const String device_id(device_id_ptr);
00135     
00136     if(!device_id.empty()) {
00137         if(_device_instance) {
00138             res = _device_instance->create_dynamic_resource(device_id,
00139                                                             OMA_RESOURCE_TYPE,
00140                                                             M2MResourceInstance::STRING,
00141                                                             true);
00142 
00143             if(res ) {
00144                 res->set_operation(operation);
00145                 if (value.empty()) {
00146                     res->clear_value();
00147                 } else {
00148                     res->set_value((const uint8_t*)value.c_str(),
00149                                    (uint32_t)value.length());
00150                 }
00151                 res->set_register_uri(false);
00152             }
00153         }
00154     }
00155     return res;
00156 }
00157 
00158 M2MResource* M2MDevice::create_resource(DeviceResource resource, int64_t value)
00159 {
00160     M2MResource* res = NULL;
00161     const char* device_id_ptr = "";
00162     M2MBase::Operation operation = M2MBase::GET_ALLOWED;
00163     if(!is_resource_present(resource)) {
00164         switch(resource) {        
00165         case BatteryLevel:
00166             if(check_value_range(resource, value)) {
00167                 device_id_ptr = DEVICE_BATTERY_LEVEL;
00168             }
00169             break;
00170         case BatteryStatus:
00171             if(check_value_range(resource, value)) {
00172                 device_id_ptr = DEVICE_BATTERY_STATUS;
00173             }
00174             break;
00175         case MemoryFree:
00176             device_id_ptr = DEVICE_MEMORY_FREE;
00177             break;
00178         case MemoryTotal:
00179             device_id_ptr = DEVICE_MEMORY_TOTAL;
00180             break;
00181         case CurrentTime:
00182             device_id_ptr = DEVICE_CURRENT_TIME;
00183             operation = M2MBase::GET_PUT_ALLOWED;
00184             break;
00185         default:
00186             break;
00187         }
00188     }
00189 
00190     const String device_id(device_id_ptr);
00191 
00192     if(!device_id.empty()) {
00193         if(_device_instance) {
00194             res = _device_instance->create_dynamic_resource(device_id,
00195                                                             OMA_RESOURCE_TYPE,
00196                                                             M2MResourceInstance::INTEGER,
00197                                                             true);
00198 
00199             if(res) {
00200 
00201 
00202                 res->set_operation(operation);
00203                 res->set_value(value);
00204 
00205                 res->set_register_uri(false);
00206             }
00207         }
00208     }
00209     return res;
00210 }
00211 
00212 M2MResourceInstance* M2MDevice::create_resource_instance(DeviceResource resource, int64_t value,
00213                                                  uint16_t instance_id)
00214 {
00215     M2MResourceInstance* res = NULL;
00216     const char* device_id_ptr = "";
00217     // For these resources multiple instance can exist
00218     if(AvailablePowerSources == resource) {
00219         if(check_value_range(resource, value)) {
00220             device_id_ptr = DEVICE_AVAILABLE_POWER_SOURCES;
00221         }
00222     } else if(PowerSourceVoltage == resource) {
00223         device_id_ptr = DEVICE_POWER_SOURCE_VOLTAGE;
00224     } else if(PowerSourceCurrent == resource) {
00225         device_id_ptr = DEVICE_POWER_SOURCE_CURRENT;
00226     } else if(ErrorCode == resource) {
00227         if(check_value_range(resource, value)) {
00228             device_id_ptr = DEVICE_ERROR_CODE;
00229         }
00230     }
00231 
00232     const String device_id(device_id_ptr);
00233 
00234     if(!device_id.empty()) {
00235         if(_device_instance) {
00236             res = _device_instance->create_dynamic_resource_instance(device_id,OMA_RESOURCE_TYPE,
00237                                                                      M2MResourceInstance::INTEGER,
00238                                                                      true, instance_id);
00239 
00240             M2MResource *resource = _device_instance->resource(device_id);
00241             if(resource) {
00242                 resource->set_register_uri(false);
00243             }
00244             if(res) {
00245                 res->set_value(value);
00246                 // Only read operation is allowed for above resources
00247                 res->set_operation(M2MBase::GET_ALLOWED);
00248 
00249                 res->set_register_uri(false);
00250             }
00251         }
00252     }
00253     return res;
00254 }
00255 M2MResource* M2MDevice::create_resource(DeviceResource resource)
00256 {
00257     M2MResource* res = NULL;
00258     if(!is_resource_present(resource)) {
00259         const char* device_Id_ptr = "";
00260         if(FactoryReset == resource) {
00261             device_Id_ptr = DEVICE_FACTORY_RESET;
00262         } else if(ResetErrorCode == resource) {
00263             device_Id_ptr = DEVICE_RESET_ERROR_CODE;
00264         }
00265         const String device_Id(device_Id_ptr);
00266         
00267         if(_device_instance && !device_Id.empty()) {
00268             res = _device_instance->create_dynamic_resource(device_Id,
00269                                                             OMA_RESOURCE_TYPE,
00270                                                             M2MResourceInstance::OPAQUE,
00271                                                             true);
00272             M2MResource *resource = _device_instance->resource(device_Id);
00273             if(resource) {
00274                 resource->set_register_uri(false);
00275             }
00276             if(res) {
00277                 res->set_operation(M2MBase::POST_ALLOWED);
00278                 res->set_register_uri(false);
00279             }
00280         }
00281     }
00282     return res;
00283 }
00284 
00285 bool M2MDevice::delete_resource(DeviceResource resource)
00286 {
00287     bool success = false;
00288     if(M2MDevice::Reboot != resource             &&
00289        M2MDevice::ErrorCode != resource          &&
00290        M2MDevice::SupportedBindingMode != resource) {
00291         if(_device_instance) {
00292             success = _device_instance->remove_resource(resource_name(resource));
00293         }
00294     }
00295     return success;
00296 }
00297 
00298 bool M2MDevice::delete_resource_instance(DeviceResource resource,
00299                                          uint16_t instance_id)
00300 {
00301     bool success = false;
00302     if(M2MDevice::Reboot != resource             &&
00303        M2MDevice::ErrorCode != resource          &&
00304        M2MDevice::SupportedBindingMode != resource) {
00305         if(_device_instance) {
00306             success = _device_instance->remove_resource_instance(resource_name(resource),instance_id);
00307         }
00308     }
00309     return success;
00310 }
00311 
00312 bool M2MDevice::set_resource_value(DeviceResource resource,
00313                                    const String &value,
00314                                    uint16_t instance_id)
00315 {
00316     bool success = false;
00317     M2MResourceInstance* res = get_resource_instance(resource,instance_id);
00318     if(res && value.size() <= MAX_ALLOWED_STRING_LENGTH) {
00319         if(M2MDevice::Manufacturer == resource          ||
00320            M2MDevice::ModelNumber == resource           ||
00321            M2MDevice::DeviceType == resource            ||
00322            M2MDevice::SerialNumber == resource          ||
00323            M2MDevice::HardwareVersion == resource       ||
00324            M2MDevice::FirmwareVersion == resource       ||
00325            M2MDevice::SoftwareVersion == resource       ||
00326            M2MDevice::UTCOffset == resource             ||
00327            M2MDevice::Timezone == resource) {
00328                 if (value.empty()) {
00329                     res->clear_value();
00330                     success = true;
00331                 } else {
00332                     success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00333                 }
00334         }
00335     }
00336     return success;
00337 }
00338 
00339 bool M2MDevice::set_resource_value(DeviceResource resource,
00340                                        int64_t value,
00341                                        uint16_t instance_id)
00342 {
00343     bool success = false;
00344     M2MResourceInstance* res = get_resource_instance(resource,instance_id);
00345     if(res) {
00346         if(M2MDevice::BatteryLevel == resource          ||
00347            M2MDevice::BatteryStatus == resource         ||
00348            M2MDevice::MemoryFree == resource            ||
00349            M2MDevice::MemoryTotal == resource           ||
00350            M2MDevice::ErrorCode == resource             ||
00351            M2MDevice::CurrentTime == resource           ||
00352            M2MDevice::AvailablePowerSources == resource ||
00353            M2MDevice::PowerSourceVoltage == resource    ||
00354            M2MDevice::PowerSourceCurrent == resource) {
00355             // If it is any of the above resource
00356             // set the value of the resource.
00357             if (check_value_range(resource, value)) {
00358 
00359                 success = res->set_value(value);
00360             }
00361         }
00362     }
00363     return success;
00364 }
00365 
00366 String M2MDevice::resource_value_string(DeviceResource resource,
00367                                         uint16_t instance_id) const
00368 {
00369     String value = "";
00370     M2MResourceInstance* res = get_resource_instance(resource,instance_id);
00371     if(res) {
00372         if(M2MDevice::Manufacturer == resource          ||
00373            M2MDevice::ModelNumber == resource           ||
00374            M2MDevice::DeviceType == resource            ||
00375            M2MDevice::SerialNumber == resource          ||
00376            M2MDevice::HardwareVersion == resource       ||
00377            M2MDevice::FirmwareVersion == resource       ||
00378            M2MDevice::SoftwareVersion == resource       ||
00379            M2MDevice::UTCOffset == resource             ||
00380            M2MDevice::Timezone == resource) {
00381 
00382             
00383             value = res->get_value_string();
00384         }
00385     }
00386     return value;
00387 }
00388 
00389 int64_t M2MDevice::resource_value_int(DeviceResource resource,
00390                                       uint16_t instance_id) const
00391 {
00392     int64_t value = -1;
00393     M2MResourceInstance* res = get_resource_instance(resource,instance_id);
00394     if(res) {
00395         if(M2MDevice::BatteryLevel == resource          ||
00396            M2MDevice::BatteryStatus == resource         ||
00397            M2MDevice::MemoryFree == resource            ||
00398            M2MDevice::MemoryTotal == resource           ||
00399            M2MDevice::ErrorCode == resource             ||
00400            M2MDevice::CurrentTime == resource           ||
00401            M2MDevice::AvailablePowerSources == resource ||
00402            M2MDevice::PowerSourceVoltage == resource    ||
00403            M2MDevice::PowerSourceCurrent == resource) {
00404 
00405             // note: the value may be 32bit int on 32b archs.
00406             value = res->get_value_int();
00407         }
00408     }
00409     return value;
00410 }
00411 
00412 bool M2MDevice::is_resource_present(DeviceResource resource) const
00413 {
00414     bool success = false;
00415     M2MResourceInstance* res = get_resource_instance(resource,0);
00416     if(res) {
00417         success = true;
00418     }
00419     return success;
00420 }
00421 
00422 uint16_t M2MDevice::per_resource_count(DeviceResource res) const
00423 {
00424     uint16_t count = 0;
00425     if(_device_instance) {
00426         count = _device_instance->resource_count(resource_name(res));
00427     }
00428     return count;
00429 }
00430 
00431 uint16_t M2MDevice::total_resource_count() const
00432 {
00433     uint16_t count = 0;
00434     if(_device_instance) {
00435         count = _device_instance->resources().size();
00436     }
00437     return count;
00438 }
00439 
00440 M2MResourceInstance* M2MDevice::get_resource_instance(DeviceResource dev_res,
00441                                                       uint16_t instance_id) const
00442 {
00443     M2MResource* res = NULL;
00444     M2MResourceInstance* inst = NULL;
00445     if(_device_instance) {
00446         res = _device_instance->resource(resource_name(dev_res));
00447         if(res) {
00448             if(res->supports_multiple_instances()) {
00449                inst = res->resource_instance(instance_id);
00450             } else {
00451                 inst = res;
00452             }
00453         }
00454     }
00455     return inst;
00456 }
00457 
00458 const String M2MDevice::resource_name(DeviceResource resource)
00459 {
00460     const char* res_name = "";
00461     switch(resource) {
00462         case Manufacturer:
00463             res_name = DEVICE_MANUFACTURER;
00464             break;
00465         case DeviceType:
00466             res_name = DEVICE_DEVICE_TYPE;
00467             break;
00468         case ModelNumber:
00469             res_name = DEVICE_MODEL_NUMBER;
00470             break;
00471         case SerialNumber:
00472             res_name = DEVICE_SERIAL_NUMBER;
00473             break;
00474         case HardwareVersion:
00475             res_name = DEVICE_HARDWARE_VERSION;
00476             break;
00477         case FirmwareVersion:
00478             res_name = DEVICE_FIRMWARE_VERSION;
00479             break;
00480         case SoftwareVersion:
00481             res_name = DEVICE_SOFTWARE_VERSION;
00482             break;
00483         case Reboot:
00484             res_name = DEVICE_REBOOT;
00485             break;
00486         case FactoryReset:
00487             res_name = DEVICE_FACTORY_RESET;
00488             break;
00489         case AvailablePowerSources:
00490             res_name = DEVICE_AVAILABLE_POWER_SOURCES;
00491             break;
00492         case PowerSourceVoltage:
00493             res_name = DEVICE_POWER_SOURCE_VOLTAGE;
00494             break;
00495         case PowerSourceCurrent:
00496             res_name = DEVICE_POWER_SOURCE_CURRENT;
00497             break;
00498         case BatteryLevel:
00499             res_name = DEVICE_BATTERY_LEVEL;
00500             break;
00501         case BatteryStatus:
00502             res_name = DEVICE_BATTERY_STATUS;
00503             break;
00504         case MemoryFree:
00505             res_name = DEVICE_MEMORY_FREE;
00506             break;
00507         case MemoryTotal:
00508             res_name = DEVICE_MEMORY_TOTAL;
00509             break;
00510         case ErrorCode:
00511             res_name = DEVICE_ERROR_CODE;
00512             break;
00513         case ResetErrorCode:
00514             res_name = DEVICE_RESET_ERROR_CODE;
00515             break;
00516         case CurrentTime:
00517             res_name = DEVICE_CURRENT_TIME;
00518             break;
00519         case UTCOffset:
00520             res_name = DEVICE_UTC_OFFSET;
00521             break;
00522         case Timezone:
00523             res_name = DEVICE_TIMEZONE;
00524             break;
00525         case SupportedBindingMode:
00526             res_name = DEVICE_SUPPORTED_BINDING_MODE;
00527             break;
00528     }
00529     return String(res_name);
00530 }
00531 
00532 bool M2MDevice::check_value_range(DeviceResource resource, int64_t value) const
00533 {
00534     bool success = false;
00535     switch (resource) {
00536         case AvailablePowerSources:
00537             if(value >= 0 && value <= 7) {
00538                 success = true;
00539             }
00540             break;
00541         case BatteryLevel:
00542             if (value >= 0 && value <= 100) {
00543                 success = true;
00544             }
00545             break;
00546         case BatteryStatus:
00547             if (value >= 0 && value <= 6) {
00548                 success = true;
00549             }
00550             break;
00551         case ErrorCode:
00552             if (value >= 0 && value <= 8) {
00553                 success = true;
00554             }
00555             break;
00556     default:
00557         success = true;
00558         break;
00559     }
00560     return success;
00561 }
00562