Simple interface for Mbed Cloud Client
Embed:
(wiki syntax)
Show/hide line numbers
m2mfirmware.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/m2mfirmware.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 "include/nsdlaccesshelper.h" 00023 00024 #define BUFFER_SIZE 21 00025 #define TRACE_GROUP "mClt" 00026 00027 M2MFirmware* M2MFirmware::_instance = NULL; 00028 00029 M2MFirmware* M2MFirmware::get_instance() 00030 { 00031 if(_instance == NULL) { 00032 _instance = new M2MFirmware(); 00033 } 00034 return _instance; 00035 } 00036 00037 void M2MFirmware::delete_instance() 00038 { 00039 delete _instance; 00040 _instance = NULL; 00041 } 00042 00043 M2MFirmware::M2MFirmware() 00044 : M2MObject(M2M_FIRMWARE_ID, stringdup(M2M_FIRMWARE_ID)) 00045 { 00046 M2MBase::set_register_uri(false); 00047 M2MBase::set_operation(M2MBase::GET_PUT_ALLOWED); 00048 _firmware_instance = M2MObject::create_object_instance(); 00049 if(_firmware_instance) { 00050 _firmware_instance->set_operation(M2MBase::GET_PUT_ALLOWED); 00051 create_mandatory_resources(); 00052 } 00053 } 00054 00055 M2MFirmware::~M2MFirmware() 00056 { 00057 } 00058 00059 // Conditionally put the static part of parameter struct into flash. 00060 // Unfortunately this can't be done yet by default as there is old API which 00061 // may be used to modify the values in sn_nsdl_static_resource_parameters_s. 00062 #ifdef MEMORY_OPTIMIZED_API 00063 #define STATIC_PARAM_TYPE const 00064 #else 00065 #define STATIC_PARAM_TYPE 00066 #endif 00067 00068 #define PACKAGE_PATH FIRMWARE_PATH_PREFIX FIRMWARE_PACKAGE 00069 00070 #ifdef RESOURCE_ATTRIBUTES_LIST 00071 sn_nsdl_attribute_item_s default_attributes[2] = { 00072 {ATTR_RESOURCE_TYPE, OMA_RESOURCE_TYPE}, 00073 {ATTR_END, 0} 00074 }; 00075 #endif 00076 00077 STATIC_PARAM_TYPE 00078 static sn_nsdl_static_resource_parameters_s firmware_package_params_static = { 00079 #ifndef RESOURCE_ATTRIBUTES_LIST 00080 #ifndef DISABLE_RESOURCE_TYPE 00081 (char*)OMA_RESOURCE_TYPE, // resource_type_ptr 00082 #endif 00083 #ifndef DISABLE_INTERFACE_DESCRIPTION 00084 (char*)"", // interface_description_ptr 00085 #endif 00086 #else 00087 default_attributes, 00088 #endif 00089 (char*)PACKAGE_PATH, // path 00090 // (uint8_t*)"", // resource 00091 // 0, // resourcelen 00092 false, // external_memory_block 00093 SN_GRS_DYNAMIC, // mode 00094 false // free_on_delete 00095 }; 00096 00097 #define PACKAGE_URI_PATH FIRMWARE_PATH_PREFIX FIRMWARE_PACKAGE_URI 00098 00099 STATIC_PARAM_TYPE 00100 static sn_nsdl_static_resource_parameters_s firmware_package_uri_params_static = { 00101 #ifndef RESOURCE_ATTRIBUTES_LIST 00102 #ifndef DISABLE_RESOURCE_TYPE 00103 (char*)OMA_RESOURCE_TYPE, // resource_type_ptr 00104 #endif 00105 #ifndef DISABLE_INTERFACE_DESCRIPTION 00106 (char*)"", // interface_description_ptr 00107 #endif 00108 #else 00109 default_attributes, 00110 #endif 00111 (char*)PACKAGE_URI_PATH, // path 00112 // (uint8_t*)"", // resource 00113 // 0, // resourcelen 00114 false, // external_memory_block 00115 SN_GRS_DYNAMIC, // mode 00116 false // free_on_delete 00117 }; 00118 00119 #define UPDATE_PATH FIRMWARE_PATH_PREFIX FIRMWARE_UPDATE 00120 00121 STATIC_PARAM_TYPE 00122 static sn_nsdl_static_resource_parameters_s firmware_update_params_static = { 00123 #ifndef RESOURCE_ATTRIBUTES_LIST 00124 #ifndef DISABLE_RESOURCE_TYPE 00125 (char*)OMA_RESOURCE_TYPE, // resource_type_ptr 00126 #endif 00127 #ifndef DISABLE_INTERFACE_DESCRIPTION 00128 (char*)"", // interface_description_ptr 00129 #endif 00130 #else 00131 default_attributes, 00132 #endif 00133 (char*)UPDATE_PATH, // path 00134 // (uint8_t*)"", // resource 00135 // 0, // resourcelen 00136 false, // external_memory_block 00137 SN_GRS_DYNAMIC, // mode 00138 false // free_on_delete 00139 }; 00140 00141 #define STATE_URI_PATH FIRMWARE_PATH_PREFIX FIRMWARE_STATE 00142 00143 STATIC_PARAM_TYPE 00144 static sn_nsdl_static_resource_parameters_s firmware_state_params_static = { 00145 #ifndef RESOURCE_ATTRIBUTES_LIST 00146 #ifndef DISABLE_RESOURCE_TYPE 00147 (char*)OMA_RESOURCE_TYPE, // resource_type_ptr 00148 #endif 00149 #ifndef DISABLE_INTERFACE_DESCRIPTION 00150 (char*)"", // interface_description_ptr 00151 #endif 00152 #else 00153 default_attributes, 00154 #endif 00155 (char*)STATE_URI_PATH, // path 00156 false, // external_memory_block 00157 SN_GRS_DYNAMIC, // mode 00158 false // free_on_delete 00159 }; 00160 00161 #define UPDATE_RESULT_PATH FIRMWARE_PATH_PREFIX FIRMWARE_UPDATE_RESULT 00162 00163 STATIC_PARAM_TYPE 00164 static sn_nsdl_static_resource_parameters_s firmware_update_result_params_static = { 00165 #ifndef RESOURCE_ATTRIBUTES_LIST 00166 #ifndef DISABLE_RESOURCE_TYPE 00167 (char*)OMA_RESOURCE_TYPE, // resource_type_ptr 00168 #endif 00169 #ifndef DISABLE_INTERFACE_DESCRIPTION 00170 (char*)"", // interface_description_ptr 00171 #endif 00172 #else 00173 default_attributes, 00174 #endif 00175 (char*)UPDATE_RESULT_PATH, // path 00176 false, // external_memory_block 00177 SN_GRS_DYNAMIC, // mode 00178 false // free_on_delete 00179 }; 00180 00181 static sn_nsdl_dynamic_resource_parameters_s firmware_package_params_dynamic = { 00182 __nsdl_c_callback, 00183 &firmware_package_params_static, 00184 NULL, 00185 {NULL, NULL}, // link 00186 0, 00187 COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type 00188 0, // msg_id 00189 M2MBase::PUT_ALLOWED, // access 00190 0, // registered 00191 false, // publish_uri 00192 false, // free_on_delete 00193 true, // observable 00194 false, // auto-observable 00195 NOTIFICATION_STATUS_INIT 00196 }; 00197 00198 static sn_nsdl_dynamic_resource_parameters_s firmware_package_uri_params_dynamic = { 00199 __nsdl_c_callback, 00200 &firmware_package_uri_params_static, 00201 NULL, 00202 {NULL, NULL}, // link 00203 0, 00204 COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type 00205 0, // msg_id 00206 M2MBase::PUT_ALLOWED, // access 00207 0, // registered 00208 false, // publish_uri 00209 false, // free_on_delete 00210 true, // observable 00211 false, // auto-observable 00212 NOTIFICATION_STATUS_INIT 00213 }; 00214 00215 static sn_nsdl_dynamic_resource_parameters_s firmware_update_params_dynamic = { 00216 __nsdl_c_callback, 00217 &firmware_update_params_static, 00218 NULL, 00219 {NULL, NULL}, // link 00220 0, 00221 COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type 00222 0, // msg_id 00223 M2MBase::NOT_ALLOWED, // access 00224 0, // registered 00225 false, // publish_uri 00226 false, // free_on_delete 00227 true, // observable 00228 false, // auto-observable 00229 NOTIFICATION_STATUS_INIT 00230 }; 00231 00232 static sn_nsdl_dynamic_resource_parameters_s firmware_state_params_dynamic = { 00233 __nsdl_c_callback, 00234 &firmware_state_params_static, 00235 NULL, // resource 00236 {NULL, NULL}, // link 00237 0, // resourcelen 00238 COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type 00239 0, // msg_id 00240 M2MBase::GET_ALLOWED, // access 00241 0, // registered 00242 false, // publish_uri 00243 false, // free_on_delete 00244 true, // observable 00245 false, // auto-observable 00246 NOTIFICATION_STATUS_INIT 00247 }; 00248 00249 static sn_nsdl_dynamic_resource_parameters_s firmware_update_result_params_dynamic = { 00250 __nsdl_c_callback, 00251 &firmware_update_result_params_static, 00252 NULL, // resource 00253 {NULL, NULL}, // link 00254 0, // resourcelen 00255 COAP_CONTENT_OMA_PLAIN_TEXT_TYPE, // coap_content_type 00256 0, // msg_id 00257 M2MBase::GET_ALLOWED, // access 00258 0, // registered 00259 false, // publish_uri 00260 false, // free_on_delete 00261 true, // observable 00262 false, // auto-observable 00263 NOTIFICATION_STATUS_INIT 00264 }; 00265 00266 const static M2MBase::lwm2m_parameters firmware_package_params = { 00267 0, // max_age 00268 (char*)FIRMWARE_PACKAGE, 00269 &firmware_package_params_dynamic, 00270 M2MBase::Resource, // base_type 00271 M2MBase::OPAQUE, 00272 false, 00273 false, // free_on_delete 00274 false // identifier_int_type 00275 }; 00276 00277 const static M2MBase::lwm2m_parameters firmware_package_uri_params = { 00278 0, // max_age 00279 (char*)FIRMWARE_PACKAGE_URI, 00280 &firmware_package_uri_params_dynamic, 00281 M2MBase::Resource, // base_type 00282 M2MBase::STRING, 00283 false, 00284 false, // free_on_delete 00285 false // identifier_int_type 00286 }; 00287 00288 const static M2MBase::lwm2m_parameters firmware_update_params = { 00289 0, // max_age 00290 (char*)FIRMWARE_UPDATE, 00291 &firmware_update_params_dynamic, 00292 M2MBase::Resource, // base_type 00293 M2MBase::OPAQUE, 00294 false, 00295 false, // free_on_delete 00296 false // identifier_int_type 00297 }; 00298 00299 const static M2MBase::lwm2m_parameters firmware_state_params = { 00300 0, // max_age 00301 (char*)FIRMWARE_STATE, 00302 &firmware_state_params_dynamic, 00303 M2MBase::Resource, // base_type 00304 M2MBase::INTEGER, 00305 false, 00306 false, // free_on_delete 00307 false // identifier_int_type 00308 }; 00309 00310 const static M2MBase::lwm2m_parameters firmware_update_result_params = { 00311 0, // max_age 00312 (char*)FIRMWARE_UPDATE_RESULT, 00313 &firmware_update_result_params_dynamic, 00314 M2MBase::Resource, // base_type 00315 M2MBase::INTEGER, 00316 false, 00317 false, // free_on_delete 00318 false // identifier_int_type 00319 }; 00320 00321 void M2MFirmware::create_mandatory_resources() 00322 { 00323 _firmware_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE); 00324 00325 M2MResource* res; 00326 00327 // todo: 00328 // perhaps we should have a API for batch creation of objects by using a array 00329 // of lwm2m_parameters. 00330 res = _firmware_instance->create_dynamic_resource(&firmware_package_params, 00331 M2MResourceInstance::OPAQUE, 00332 false); 00333 00334 res = _firmware_instance->create_dynamic_resource(&firmware_package_uri_params, 00335 M2MResourceInstance::STRING, 00336 false); 00337 00338 res = _firmware_instance->create_dynamic_resource(&firmware_update_params, 00339 M2MResourceInstance::OPAQUE, 00340 false); 00341 00342 res = _firmware_instance->create_dynamic_resource(&firmware_state_params, 00343 M2MResourceInstance::INTEGER, 00344 true); 00345 00346 // XXX: some of the tests expect to have some value available here 00347 if (res) { 00348 res->set_value(0); 00349 } 00350 00351 res = _firmware_instance->create_dynamic_resource(&firmware_update_result_params, 00352 M2MResourceInstance::INTEGER, 00353 true); 00354 00355 // XXX: some of the tests expect to have some value available here 00356 if (res) { 00357 res->set_value(0); 00358 } 00359 } 00360 00361 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, const String &value) 00362 { 00363 M2MResource* res = NULL; 00364 const char* firmware_id_ptr = ""; 00365 M2MBase::Operation operation = M2MBase::GET_ALLOWED; 00366 if(!is_resource_present(resource)) { 00367 switch(resource) { 00368 case PackageName: 00369 firmware_id_ptr = FIRMWARE_PACKAGE_NAME; 00370 break; 00371 case PackageVersion: 00372 firmware_id_ptr = FIRMWARE_PACKAGE_VERSION; 00373 break; 00374 default: 00375 break; 00376 } 00377 } 00378 String firmware_id(firmware_id_ptr); 00379 00380 if(!firmware_id.empty() && value.size() < 256) { 00381 if(_firmware_instance) { 00382 res = _firmware_instance->create_dynamic_resource(firmware_id, 00383 OMA_RESOURCE_TYPE, 00384 M2MResourceInstance::STRING, 00385 false); 00386 00387 if(res) { 00388 res->set_register_uri(false); 00389 res->set_operation(operation); 00390 if(value.empty()) { 00391 res->clear_value(); 00392 } else { 00393 res->set_value((const uint8_t*)value.c_str(), 00394 (uint32_t)value.length()); 00395 } 00396 } 00397 } 00398 } 00399 return res; 00400 } 00401 00402 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, int64_t value) 00403 { 00404 M2MResource* res = NULL; 00405 const char* firmware_id_ptr = ""; 00406 M2MBase::Operation operation = M2MBase::GET_ALLOWED; 00407 if(!is_resource_present(resource)) { 00408 switch(resource) { 00409 case UpdateSupportedObjects: 00410 if(check_value_range(resource, value)) { 00411 firmware_id_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00412 operation = M2MBase::GET_PUT_ALLOWED; 00413 } 00414 break; 00415 default: 00416 break; 00417 } 00418 } 00419 00420 const String firmware_id(firmware_id_ptr); 00421 00422 if(!firmware_id.empty()) { 00423 if(_firmware_instance) { 00424 res = _firmware_instance->create_dynamic_resource(firmware_id, 00425 OMA_RESOURCE_TYPE, 00426 M2MResourceInstance::INTEGER, 00427 false); 00428 00429 if(res) { 00430 res->set_register_uri(false); 00431 00432 res->set_operation(operation); 00433 res->set_value(value); 00434 } 00435 } 00436 } 00437 return res; 00438 } 00439 00440 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00441 const String &value) 00442 { 00443 bool success = false; 00444 M2MResource* res = get_resource(resource); 00445 if(res) { 00446 if(M2MFirmware::PackageUri == resource || 00447 M2MFirmware::PackageName == resource || 00448 M2MFirmware::PackageVersion == resource) { 00449 if (value.size() < 256) { 00450 if(value.empty()) { 00451 res->clear_value(); 00452 success = true; 00453 } else { 00454 success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length()); 00455 } 00456 } 00457 } 00458 } 00459 return success; 00460 } 00461 00462 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00463 int64_t value) 00464 { 00465 bool success = false; 00466 M2MResource* res = get_resource(resource); 00467 if(res) { 00468 if(M2MFirmware::State == resource || 00469 M2MFirmware::UpdateSupportedObjects == resource || 00470 M2MFirmware::UpdateResult == resource) { 00471 // If it is any of the above resource 00472 // set the value of the resource. 00473 if (check_value_range(resource, value)) { 00474 00475 success = res->set_value(value); 00476 } 00477 } 00478 } 00479 return success; 00480 } 00481 00482 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00483 const uint8_t *value, 00484 const uint32_t length) 00485 { 00486 bool success = false; 00487 M2MResource* res = get_resource(resource); 00488 if(res) { 00489 if(M2MFirmware::Package == resource) { 00490 success = res->set_value(value,length); 00491 } 00492 } 00493 return success; 00494 } 00495 00496 bool M2MFirmware::is_resource_present(FirmwareResource resource) const 00497 { 00498 bool success = false; 00499 M2MResource* res = get_resource(resource); 00500 if(res) { 00501 success = true; 00502 } 00503 return success; 00504 } 00505 00506 const char* M2MFirmware::resource_name(FirmwareResource resource) 00507 { 00508 const char* res_name = ""; 00509 switch(resource) { 00510 case Package: 00511 res_name = FIRMWARE_PACKAGE; 00512 break; 00513 case PackageUri: 00514 res_name = FIRMWARE_PACKAGE_URI; 00515 break; 00516 case Update: 00517 res_name = FIRMWARE_UPDATE; 00518 break; 00519 case State: 00520 res_name = FIRMWARE_STATE; 00521 break; 00522 case UpdateSupportedObjects: 00523 res_name = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00524 break; 00525 case UpdateResult: 00526 res_name = FIRMWARE_UPDATE_RESULT; 00527 break; 00528 case PackageName: 00529 res_name = FIRMWARE_PACKAGE_NAME; 00530 break; 00531 case PackageVersion: 00532 res_name = FIRMWARE_PACKAGE_VERSION; 00533 break; 00534 } 00535 return res_name; 00536 } 00537 00538 uint16_t M2MFirmware::per_resource_count(FirmwareResource res) const 00539 { 00540 uint16_t count = 0; 00541 if(_firmware_instance) { 00542 count = _firmware_instance->resource_count(resource_name(res)); 00543 } 00544 return count; 00545 } 00546 00547 uint16_t M2MFirmware::total_resource_count() const 00548 { 00549 uint16_t count = 0; 00550 if(_firmware_instance) { 00551 count = _firmware_instance->resources().size(); 00552 } 00553 return count; 00554 } 00555 00556 uint32_t M2MFirmware::resource_value_buffer(FirmwareResource resource, 00557 uint8_t *&data) const 00558 { 00559 uint32_t size = 0; 00560 M2MResource* res = get_resource(resource); 00561 if(res) { 00562 if(M2MFirmware::Package == resource) { 00563 res->get_value(data,size); 00564 } 00565 } 00566 return size; 00567 } 00568 00569 M2MResource* M2MFirmware::get_resource(FirmwareResource res) const 00570 { 00571 M2MResource* res_object = NULL; 00572 if(_firmware_instance) { 00573 const char* res_name_ptr = ""; 00574 switch(res) { 00575 case Package: 00576 res_name_ptr = FIRMWARE_PACKAGE; 00577 break; 00578 case PackageUri: 00579 res_name_ptr = FIRMWARE_PACKAGE_URI; 00580 break; 00581 case Update: 00582 res_name_ptr = FIRMWARE_UPDATE; 00583 break; 00584 case State: 00585 res_name_ptr = FIRMWARE_STATE; 00586 break; 00587 case UpdateSupportedObjects: 00588 res_name_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00589 break; 00590 case UpdateResult: 00591 res_name_ptr = FIRMWARE_UPDATE_RESULT; 00592 break; 00593 case PackageName: 00594 res_name_ptr = FIRMWARE_PACKAGE_NAME; 00595 break; 00596 case PackageVersion: 00597 res_name_ptr = FIRMWARE_PACKAGE_VERSION; 00598 break; 00599 } 00600 00601 res_object = _firmware_instance->resource(res_name_ptr); 00602 } 00603 return res_object; 00604 } 00605 00606 bool M2MFirmware::delete_resource(FirmwareResource resource) 00607 { 00608 bool success = false; 00609 if(M2MFirmware::UpdateSupportedObjects == resource || 00610 M2MFirmware::PackageName == resource || 00611 M2MFirmware::PackageVersion == resource) { 00612 if(_firmware_instance) { 00613 success = _firmware_instance->remove_resource(resource_name(resource)); 00614 } 00615 } 00616 return success; 00617 } 00618 00619 int64_t M2MFirmware::resource_value_int(FirmwareResource resource) const 00620 { 00621 int64_t value = -1; 00622 M2MResource* res = get_resource(resource); 00623 if(res) { 00624 if(M2MFirmware::State == resource || 00625 M2MFirmware::UpdateSupportedObjects == resource || 00626 M2MFirmware::UpdateResult == resource) { 00627 00628 value = res->get_value_int(); 00629 } 00630 } 00631 return value; 00632 } 00633 00634 String M2MFirmware::resource_value_string(FirmwareResource resource) const 00635 { 00636 String value = ""; 00637 M2MResource* res = get_resource(resource); 00638 if(res) { 00639 if(M2MFirmware::PackageUri == resource || 00640 M2MFirmware::PackageName == resource || 00641 M2MFirmware::PackageVersion == resource) { 00642 00643 value = res->get_value_string(); 00644 } 00645 } 00646 return value; 00647 } 00648 00649 bool M2MFirmware::check_value_range(FirmwareResource resource, int64_t value) const 00650 { 00651 bool success = false; 00652 switch (resource) { 00653 case UpdateSupportedObjects: 00654 if(value == 0 || value == 1) { 00655 success = true; 00656 } 00657 break; 00658 case State: 00659 if (value >= 0 && value <= 3) { 00660 success = true; 00661 M2MResource* updateRes = get_resource(M2MFirmware::Update); 00662 if (updateRes){ 00663 if (value == M2MFirmware::Downloaded) { 00664 updateRes->set_operation(M2MBase::POST_ALLOWED); 00665 } 00666 else { 00667 updateRes->set_operation(M2MBase::NOT_ALLOWED); 00668 } 00669 } 00670 } 00671 break; 00672 case UpdateResult: 00673 if (value >= 0 && value <= 7) { 00674 success = true; 00675 } 00676 break; 00677 default: 00678 break; 00679 } 00680 return success; 00681 } 00682 00683 bool M2MFirmware::set_update_execute_callback(execute_callback callback) 00684 { 00685 M2MResource* m2mresource; 00686 00687 m2mresource = get_resource(Update); 00688 00689 if(m2mresource) { 00690 m2mresource->set_execute_function(callback); 00691 return true; 00692 } 00693 00694 return false; 00695 } 00696 00697 bool M2MFirmware::set_resource_value_update_callback(FirmwareResource resource, 00698 value_updated_callback callback) 00699 { 00700 M2MResource* m2mresource; 00701 00702 m2mresource = get_resource(resource); 00703 00704 if(m2mresource) { 00705 m2mresource->set_value_updated_function(callback); 00706 return true; 00707 } 00708 00709 return false; 00710 } 00711 00712 bool M2MFirmware::set_resource_notification_sent_callback(FirmwareResource resource, 00713 notification_sent_callback_2 callback) 00714 { 00715 M2MResource* m2mresource; 00716 00717 m2mresource = get_resource(resource); 00718 00719 if(m2mresource) { 00720 m2mresource->set_notification_sent_callback(callback); 00721 return true; 00722 } 00723 00724 return false; 00725 } 00726 00727 bool M2MFirmware::set_resource_notification_sent_callback(FirmwareResource resource, 00728 notification_delivery_status_cb callback) 00729 { 00730 M2MResource* m2mresource; 00731 00732 m2mresource = get_resource(resource); 00733 00734 if(m2mresource) { 00735 m2mresource->set_notification_delivery_status_cb(callback, 0); 00736 return true; 00737 } 00738 00739 return false; 00740 } 00741 00742 #ifndef DISABLE_BLOCK_MESSAGE 00743 bool M2MFirmware::set_package_block_message_callback(incoming_block_message_callback callback) 00744 { 00745 M2MResource* m2mresource; 00746 00747 m2mresource = get_resource(Package); 00748 00749 if(m2mresource) { 00750 m2mresource->set_incoming_block_message_callback(callback); 00751 return true; 00752 } 00753 00754 return false; 00755 } 00756 #endif // DISABLE_BLOCK_MESSAGE
Generated on Tue Jul 12 2022 19:01:35 by 1.7.2