bool M2MLWClient::create_dynamic_resource_instance_string(const char *name,
bool observable,
bool multiple_instance,
uint16_t object_instance,
uint16_t resource_instance,
uint8_t resource_instance_operation)
{
bool success = false;
String name_string;
if(name) {
name_string += name;
}
if(_object) {
M2MObjectInstance *inst = _object->object_instance(object_instance);
if(inst) {
M2MResourceInstance *res = inst->create_dynamic_resource_instance(name,"resource",
M2MResourceInstance::STRING,
observable,
resource_instance);
if( res) {
success = true;
res->set_operation(int_to_operation(resource_instance_operation));
}
}
}
return success;
}
bool M2MDevice::set_resource_value(DeviceResource resource,
const String &value,
uint16_t instance_id)
{
bool success = false;
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res && value.size() <= MAX_ALLOWED_STRING_LENGTH) {
if(M2MDevice::Manufacturer == resource ||
M2MDevice::ModelNumber == resource ||
M2MDevice::DeviceType == resource ||
M2MDevice::SerialNumber == resource ||
M2MDevice::HardwareVersion == resource ||
M2MDevice::FirmwareVersion == resource ||
M2MDevice::SoftwareVersion == resource ||
M2MDevice::UTCOffset == resource ||
M2MDevice::Timezone == resource) {
if (value.empty()) {
res->clear_value();
success = true;
} else {
success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
}
}
}
return success;
}
bool create_generic_object() {
bool success = false;
_object = M2MInterfaceFactory::create_object("10");
if(_object) {
_object->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
M2MObjectInstance* inst = _object->create_object_instance();
if(inst) {
inst->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
inst->set_observable(false);
char buffer[20];
int size = sprintf(buffer,"%d",_value);
inst->create_static_resource("0",
"ResourceTest",
M2MResourceInstance::INTEGER,
STATIC_VALUE,
sizeof(STATIC_VALUE)-1);
M2MResourceInstance* instance = inst->create_dynamic_resource_instance("1",
"ResourceTest",
M2MResourceInstance::INTEGER,
true,0);
if(instance) {
instance->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
instance->set_value((const uint8_t*)buffer,
(const uint32_t)size);
instance->set_execute_function(execute_callback(this,&MbedClient::execute_function));
_value++;
}
}
}
return success;
}
int64_t M2MDevice::resource_value_int(DeviceResource resource,
uint16_t instance_id) const
{
int64_t value = -1;
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res) {
if(M2MDevice::BatteryLevel == resource ||
M2MDevice::BatteryStatus == resource ||
M2MDevice::MemoryFree == resource ||
M2MDevice::MemoryTotal == resource ||
M2MDevice::ErrorCode == resource ||
M2MDevice::CurrentTime == resource ||
M2MDevice::AvailablePowerSources == resource ||
M2MDevice::PowerSourceVoltage == resource ||
M2MDevice::PowerSourceCurrent == resource) {
// Get the value and convert it into integer
uint8_t* buffer = NULL;
uint32_t length = 0;
res->get_value(buffer,length);
if(buffer) {
value = atoi((const char*)buffer);
free(buffer);
}
}
}
return value;
}
bool M2MDevice::set_resource_value(DeviceResource resource,
int64_t value,
uint16_t instance_id)
{
bool success = false;
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res) {
if(M2MDevice::BatteryLevel == resource ||
M2MDevice::BatteryStatus == resource ||
M2MDevice::MemoryFree == resource ||
M2MDevice::MemoryTotal == resource ||
M2MDevice::ErrorCode == resource ||
M2MDevice::CurrentTime == resource ||
M2MDevice::AvailablePowerSources == resource ||
M2MDevice::PowerSourceVoltage == resource ||
M2MDevice::PowerSourceCurrent == resource) {
// If it is any of the above resource
// set the value of the resource.
if (check_value_range(resource, value)) {
char *buffer = (char*)malloc(BUFFER_SIZE);
if(buffer) {
uint32_t size = m2m::itoa_c(value, buffer);
if (size <= BUFFER_SIZE)
success = res->set_value((const uint8_t*)buffer, size);
free(buffer);
}
}
}
}
return success;
}
bool M2MDevice::set_resource_value(DeviceResource resource,
int64_t value,
uint16_t instance_id)
{
bool success = false;
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res) {
if(M2MDevice::BatteryLevel == resource ||
M2MDevice::BatteryStatus == resource ||
M2MDevice::MemoryFree == resource ||
M2MDevice::MemoryTotal == resource ||
M2MDevice::ErrorCode == resource ||
M2MDevice::CurrentTime == resource ||
M2MDevice::AvailablePowerSources == resource ||
M2MDevice::PowerSourceVoltage == resource ||
M2MDevice::PowerSourceCurrent == resource) {
// If it is any of the above resource
// set the value of the resource.
char *buffer = (char*)memory_alloc(20);
if(buffer) {
int size = snprintf(buffer, 20,"%lld",value);
success = res->set_value((const uint8_t*)buffer,
(const uint32_t)size);
memory_free(buffer);
}
}
}
return success;
}
void Test_M2MResourceInstance::test_assignment_constructor()
{
u_int8_t value[] = {"value"};
resource_instance->set_value(value,(u_int32_t)sizeof(value));
M2MResourceInstance* res = new M2MResourceInstance("name",
"resource_type",
M2MResourceInstance::STRING,
*callback);
u_int8_t value1[] = {"value1"};
res->set_value(value1,(u_int32_t)sizeof(value1));
*res = *resource_instance;
u_int8_t* out_value = (u_int8_t*)malloc(sizeof(u_int8_t));
u_int32_t out_size;
res->get_value(out_value,out_size);
CHECK(out_size == sizeof(value));
free(out_value);
delete res;
}
M2MDevice::M2MDevice()
: M2MObject(M2M_DEVICE_ID)
{
M2MBase::set_register_uri(false);
M2MBase::set_operation(M2MBase::GET_ALLOWED);
_device_instance = M2MObject::create_object_instance();
_device_instance->set_operation(M2MBase::GET_ALLOWED);
_device_instance->set_register_uri(true);
if(_device_instance) {
_device_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE);
M2MResource* res = _device_instance->create_dynamic_resource(DEVICE_REBOOT,
OMA_RESOURCE_TYPE,
M2MResourceInstance::OPAQUE,
false);
if(res) {
res->set_operation(M2MBase::POST_ALLOWED);
res->set_register_uri(false);
}
M2MResourceInstance* instance = _device_instance->create_dynamic_resource_instance(DEVICE_ERROR_CODE,
OMA_RESOURCE_TYPE,
M2MResourceInstance::INTEGER,
true,0);
if(instance) {
M2MResource * dev_res = _device_instance->resource(DEVICE_ERROR_CODE);
dev_res->set_register_uri(false);
instance->set_operation(M2MBase::GET_ALLOWED);
uint32_t size = 0;
char *buffer = (char*)malloc(BUFFER_SIZE);
if(buffer) {
size = m2m::itoa_c(0, buffer);
if (size <= BUFFER_SIZE)
instance->set_value((const uint8_t*)buffer, size);
free(buffer);
}
instance->set_register_uri(false);
}
res = _device_instance->create_dynamic_resource(DEVICE_SUPPORTED_BINDING_MODE,
OMA_RESOURCE_TYPE,
M2MResourceInstance::STRING,
true);
if(res) {
res->set_operation(M2MBase::GET_ALLOWED);
res->set_value((const uint8_t*)BINDING_MODE_UDP.c_str(),
(uint32_t)BINDING_MODE_UDP.length());
res->set_register_uri(false);
}
}
}
void Test_M2MResourceInstance::test_copy_constructor()
{
u_int8_t value[] = {"value"};
resource_instance->set_value(value,(u_int32_t)sizeof(value));
M2MResourceInstance* copy = new M2MResourceInstance(*resource_instance);
u_int8_t* out_value = (u_int8_t*)malloc(sizeof(u_int8_t));
u_int32_t out_size;
copy->get_value(out_value,out_size);
CHECK(out_size == sizeof(value));
free(out_value);
delete copy;
}
M2MResourceInstance* M2MDevice::create_resource_instance(DeviceResource resource, int64_t value,
uint16_t instance_id)
{
M2MResourceInstance* res = NULL;
String device_id = "";
// For these resources multiple instance can exist
if(AvailablePowerSources == resource) {
if(check_value_range(resource, value)) {
device_id = DEVICE_AVAILABLE_POWER_SOURCES;
}
} else if(PowerSourceVoltage == resource) {
device_id = DEVICE_POWER_SOURCE_VOLTAGE;
} else if(PowerSourceCurrent == resource) {
device_id = DEVICE_POWER_SOURCE_CURRENT;
} else if(ErrorCode == resource) {
if(check_value_range(resource, value)) {
device_id = DEVICE_ERROR_CODE;
}
}
if(!device_id.empty()) {
if(_device_instance) {
res = _device_instance->create_dynamic_resource_instance(device_id,OMA_RESOURCE_TYPE,
M2MResourceInstance::INTEGER,
true, instance_id);
M2MResource *resource = _device_instance->resource(device_id);
if(resource) {
resource->set_register_uri(false);
}
if(res) {
char *buffer = (char*)malloc(BUFFER_SIZE);
if(buffer) {
uint32_t size = m2m::itoa_c(value, buffer);
if (size <= BUFFER_SIZE) {
res->set_value((const uint8_t*)buffer, size);
// Only read operation is allowed for above resources
res->set_operation(M2MBase::GET_ALLOWED);
}
free(buffer);
}
res->set_register_uri(false);
}
}
}
return res;
}
M2MResourceInstance* M2MDevice::create_resource_instance(DeviceResource resource, int64_t value,
uint16_t instance_id)
{
M2MResourceInstance* res = NULL;
String device_id = "";
// For these resources multiple instance can exist
if(AvailablePowerSources == resource) {
if(0 <= value && value <= 7) {
device_id = DEVICE_AVAILABLE_POWER_SOURCES;
}
} else if(PowerSourceVoltage == resource) {
device_id = DEVICE_POWER_SOURCE_VOLTAGE;
} else if(PowerSourceCurrent == resource) {
device_id = DEVICE_POWER_SOURCE_CURRENT;
} else if(ErrorCode == resource) {
if(0 <= value && value <= 8) {
device_id = DEVICE_ERROR_CODE;
}
}
if(!device_id.empty()) {
if(_device_instance) {
res = _device_instance->create_dynamic_resource_instance(device_id,OMA_RESOURCE_TYPE,
M2MResourceInstance::INTEGER,
false, instance_id);
if(res) {
char *buffer = (char*)memory_alloc(20);
if(buffer) {
int size = snprintf(buffer, 20,"%lld",value);
// Only read operation is allowed for above resources
res->set_operation(M2MBase::GET_ALLOWED);
res->set_value((const uint8_t*)buffer,
(const uint32_t)size);
memory_free(buffer);
}
}
}
}
return res;
}
bool M2MDevice::set_resource_value(DeviceResource resource,
const String &value,
uint16_t instance_id)
{
bool success = false;
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res) {
if(M2MDevice::Manufacturer == resource ||
M2MDevice::ModelNumber == resource ||
M2MDevice::DeviceType == resource ||
M2MDevice::SerialNumber == resource ||
M2MDevice::HardwareVersion == resource ||
M2MDevice::FirmwareVersion == resource ||
M2MDevice::SoftwareVersion == resource ||
M2MDevice::UTCOffset == resource ||
M2MDevice::Timezone == resource) {
success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
}
}
return success;
}
String M2MDevice::resource_value_string(DeviceResource resource,
uint16_t instance_id) const
{
String value = "";
M2MResourceInstance* res = get_resource_instance(resource,instance_id);
if(res) {
if(M2MDevice::Manufacturer == resource ||
M2MDevice::ModelNumber == resource ||
M2MDevice::DeviceType == resource ||
M2MDevice::SerialNumber == resource ||
M2MDevice::HardwareVersion == resource ||
M2MDevice::FirmwareVersion == resource ||
M2MDevice::SoftwareVersion == resource ||
M2MDevice::UTCOffset == resource ||
M2MDevice::Timezone == resource) {
uint8_t* buffer = NULL;
uint32_t length = 0;
res->get_value(buffer,length);
char *char_buffer = (char*)malloc(length+1);
if(char_buffer) {
memset(char_buffer,0,length+1);
memcpy(char_buffer,(char*)buffer,length);
String s_name(char_buffer);
value = s_name;
if(char_buffer) {
free(char_buffer);
}
}
if(buffer) {
free(buffer);
}
}
}
return value;
}
M2MDevice::M2MDevice()
: M2MObject(M2M_DEVICE_ID)
{
_device_instance = M2MObject::create_object_instance();
if(_device_instance) {
_device_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE);
M2MResource* res = _device_instance->create_dynamic_resource(DEVICE_REBOOT,
OMA_RESOURCE_TYPE,
M2MResourceInstance::OPAQUE,
false);
if(res) {
res->set_operation(M2MBase::POST_ALLOWED);
}
M2MResourceInstance* instance = _device_instance->create_dynamic_resource_instance(DEVICE_ERROR_CODE,
OMA_RESOURCE_TYPE,
M2MResourceInstance::INTEGER,
false,0);
if(instance) {
instance->set_operation(M2MBase::GET_ALLOWED);
instance->set_value((const uint8_t*)ERROR_CODE_VALUE.c_str(),
(uint32_t)ERROR_CODE_VALUE.length());
}
res = _device_instance->create_dynamic_resource(DEVICE_SUPPORTED_BINDING_MODE,
OMA_RESOURCE_TYPE,
M2MResourceInstance::STRING,
false);
if(res) {
res->set_operation(M2MBase::GET_ALLOWED);
res->set_value((const uint8_t*)BINDING_MODE_UDP.c_str(),
(uint32_t)BINDING_MODE_UDP.length());
}
}
}
