Пример #1
0
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;
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
0
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;
}