Maggie Mei / mbedConnectorInterfaceWithDM

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbedConnectorInterfaceWithDM by Doug Anson

source/ConnectorEndpoint.cpp@82:e085176f6719, 2016-11-04 (annotated)

Committer:
ansond
Date:
Fri Nov 04 23:22:01 2016 +0000
Revision:
82:e085176f6719
Parent:
81:a2441163a06e
Child:
83:8d856fa24fda
updated

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ansond 0:1f1f55e73248 1 /**
ansond 0:1f1f55e73248 2 * @file ConnectorEndpoint.cpp
ansond 0:1f1f55e73248 3 * @brief mbed CoAP Endpoint base class
ansond 0:1f1f55e73248 4 * @author Doug Anson/Chris Paola
ansond 0:1f1f55e73248 5 * @version 1.0
ansond 0:1f1f55e73248 6 * @see
ansond 0:1f1f55e73248 7 *
ansond 0:1f1f55e73248 8 * Copyright (c) 2014
ansond 0:1f1f55e73248 9 *
ansond 0:1f1f55e73248 10 * Licensed under the Apache License, Version 2.0 (the "License");
ansond 0:1f1f55e73248 11 * you may not use this file except in compliance with the License.
ansond 0:1f1f55e73248 12 * You may obtain a copy of the License at
ansond 0:1f1f55e73248 13 *
ansond 0:1f1f55e73248 14 * http://www.apache.org/licenses/LICENSE-2.0
ansond 0:1f1f55e73248 15 *
ansond 0:1f1f55e73248 16 * Unless required by applicable law or agreed to in writing, software
ansond 0:1f1f55e73248 17 * distributed under the License is distributed on an "AS IS" BASIS,
ansond 0:1f1f55e73248 18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
ansond 0:1f1f55e73248 19 * See the License for the specific language governing permissions and
ansond 0:1f1f55e73248 20 * limitations under the License.
ansond 0:1f1f55e73248 21 */
ansond 0:1f1f55e73248 22
ansond 0:1f1f55e73248 23 // Lower level Network
ansond 0:1f1f55e73248 24 #include "mbed-connector-interface/mbedEndpointNetwork.h"
ansond 0:1f1f55e73248 25
ansond 0:1f1f55e73248 26 // ConnectorEndpoint
ansond 0:1f1f55e73248 27 #include "mbed-connector-interface/ConnectorEndpoint.h"
ansond 0:1f1f55e73248 28
ansond 0:1f1f55e73248 29 // Utils support
ansond 0:1f1f55e73248 30 #include "mbed-connector-interface/Utils.h"
ansond 0:1f1f55e73248 31
ansond 27:b8aaf7dc7023 32 // Device Manager support
ansond 27:b8aaf7dc7023 33 #include "mbed-connector-interface/DeviceManager.h"
ansond 27:b8aaf7dc7023 34
ansond 1:16f0fb5b8d97 35 // our endpoint instance
ansond 1:16f0fb5b8d97 36 static Connector::Endpoint *__endpoint = NULL;
ansond 0:1f1f55e73248 37
ansond 54:dfee8691c83a 38 // LWIP Network interface instance
ansond 60:0d9e607dd678 39 NetworkInterface *__network_interface = NULL;
ansond 27:b8aaf7dc7023 40
ansond 74:6abfb2a03020 41 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 74:6abfb2a03020 42 // Static mbed endpoint
ansond 74:6abfb2a03020 43 static MbedCloudClient __mbed_cloud_client;
ansond 74:6abfb2a03020 44 #endif
ansond 74:6abfb2a03020 45
ansond 0:1f1f55e73248 46 // Connector namespace
ansond 0:1f1f55e73248 47 namespace Connector {
ansond 0:1f1f55e73248 48
ansond 0:1f1f55e73248 49 // STATIC: Plumb the network
ansond 13:9edad7677211 50 void Endpoint::plumbNetwork(void *device_manager,bool canActAsRouterNode) {
ansond 54:dfee8691c83a 51 // create our endpoint instance...
ansond 1:16f0fb5b8d97 52 if (__endpoint == NULL) {
ansond 1:16f0fb5b8d97 53 // initialize our endpoint instance
ansond 54:dfee8691c83a 54 printf("Connector::Endpoint::plumbNetwork: initializing endpoint instance...\r\n");
ansond 1:16f0fb5b8d97 55 __endpoint = (Connector::Endpoint *)utils_init_endpoint(canActAsRouterNode);
ansond 1:16f0fb5b8d97 56 }
ansond 13:9edad7677211 57
ansond 13:9edad7677211 58 // set the device manager
ansond 13:9edad7677211 59 if (device_manager != NULL) {
ansond 13:9edad7677211 60 // device manager has been supplied
ansond 54:dfee8691c83a 61 printf("Connector::Endpoint::plumbNetwork: setting a device manager...\r\n");
ansond 13:9edad7677211 62 __endpoint->setDeviceManager(device_manager);
ansond 13:9edad7677211 63 }
ansond 13:9edad7677211 64 else {
ansond 13:9edad7677211 65 // no device manager supplied
ansond 54:dfee8691c83a 66 printf("Connector::Endpoint::plumbNetwork: no device manager supplied (OK)\r\n");
ansond 13:9edad7677211 67 }
ansond 8:f950fb1b78c0 68
ansond 54:dfee8691c83a 69 // configure the endpoint...
ansond 54:dfee8691c83a 70 printf("Connector::Endpoint::plumbNetwork: configuring endpoint...\r\n");
ansond 1:16f0fb5b8d97 71 utils_configure_endpoint((void *)__endpoint);
ansond 2:1a7a292555d1 72
ansond 54:dfee8691c83a 73 // plumb the endpoint's network...
ansond 54:dfee8691c83a 74 printf("Connector::Endpoint::plumbNetwork: plumbing network...\r\n");
ansond 8:f950fb1b78c0 75 net_plumb_network((void *)__endpoint);
ansond 0:1f1f55e73248 76 }
ansond 0:1f1f55e73248 77
ansond 0:1f1f55e73248 78 // STATIC: Finalize the endpoint's configuration and begin the endpoint's main even loop (static, not tied into Logger)
ansond 8:f950fb1b78c0 79 void Endpoint::start()
ansond 8:f950fb1b78c0 80 {
ansond 54:dfee8691c83a 81 // build out the endpoint with its configuration...
ansond 54:dfee8691c83a 82 printf("Connector::Endpoint::start: building out endpoint...\r\n");
ansond 8:f950fb1b78c0 83 utils_build_endpoint((void *)__endpoint);
ansond 0:1f1f55e73248 84
ansond 54:dfee8691c83a 85 // finalize the endpoint and start its main loop
ansond 54:dfee8691c83a 86 printf("Endpoint::start: finalize and run the endpoint main loop..\r\n");
ansond 54:dfee8691c83a 87 net_finalize_and_run_endpoint_main_loop((void *)__endpoint);
ansond 0:1f1f55e73248 88 }
ansond 0:1f1f55e73248 89
ansond 43:3fb57c4fba34 90 // STATIC: Set the ConnectionStatusInterface Implementation instance
ansond 43:3fb57c4fba34 91 void Endpoint::setConnectionStatusInterface(ConnectionStatusInterface *csi) {
ansond 43:3fb57c4fba34 92 if (__endpoint != NULL) {
ansond 44:7c73baf9f4c1 93 __endpoint->setConnectionStatusInterfaceImpl(csi);
ansond 43:3fb57c4fba34 94 }
ansond 43:3fb57c4fba34 95 }
ansond 43:3fb57c4fba34 96
ansond 0:1f1f55e73248 97 // Constructor
ansond 0:1f1f55e73248 98 Endpoint::Endpoint(const Logger *logger, const Options *options) : M2MInterfaceObserver()
ansond 0:1f1f55e73248 99 {
ansond 0:1f1f55e73248 100 this->m_logger = (Logger *)logger;
ansond 0:1f1f55e73248 101 this->m_options = (Options *)options;
ansond 13:9edad7677211 102 this->m_device_manager = NULL;
ansond 13:9edad7677211 103 this->m_connected = false;
ansond 15:c11dbe4d354c 104 this->m_registered = false;
ansond 27:b8aaf7dc7023 105 this->m_csi = NULL;
ansond 27:b8aaf7dc7023 106 this->m_oim = NULL;
ansond 81:a2441163a06e 107 this->m_endpoint_security = NULL;
ansond 74:6abfb2a03020 108 this->m_endpoint_interface = NULL;
ansond 0:1f1f55e73248 109 }
ansond 0:1f1f55e73248 110
ansond 0:1f1f55e73248 111 // Copy Constructor
ansond 0:1f1f55e73248 112 Endpoint::Endpoint(const Endpoint &ep)
ansond 0:1f1f55e73248 113 {
ansond 0:1f1f55e73248 114 this->m_logger = ep.m_logger;
ansond 0:1f1f55e73248 115 this->m_options = ep.m_options;
ansond 46:62da4ce20276 116 this->m_endpoint_interface = ep.m_endpoint_interface;
ansond 46:62da4ce20276 117 this->m_endpoint_security = ep.m_endpoint_security;
ansond 46:62da4ce20276 118 this->m_endpoint_object_list = ep.m_endpoint_object_list;
ansond 13:9edad7677211 119 this->m_device_manager = ep.m_device_manager;
ansond 13:9edad7677211 120 this->m_connected = ep.m_connected;
ansond 15:c11dbe4d354c 121 this->m_registered = ep.m_registered;
ansond 27:b8aaf7dc7023 122 this->m_csi = ep.m_csi;
ansond 27:b8aaf7dc7023 123 this->m_oim = ep.m_oim;
ansond 0:1f1f55e73248 124 }
ansond 0:1f1f55e73248 125
ansond 0:1f1f55e73248 126 // Destructor
ansond 0:1f1f55e73248 127 Endpoint::~Endpoint() {
ansond 75:9152ea6b4c59 128 #ifndef ENABLE_MBED_CLOUD_SUPPORT
ansond 46:62da4ce20276 129 if (this->m_endpoint_interface != NULL)
ansond 46:62da4ce20276 130 delete this->m_endpoint_interface;
ansond 73:f12a767bc300 131
ansond 46:62da4ce20276 132 if (this->m_endpoint_security != NULL)
ansond 46:62da4ce20276 133 delete this->m_endpoint_security;
ansond 73:f12a767bc300 134 #endif
ansond 0:1f1f55e73248 135 }
ansond 0:1f1f55e73248 136
ansond 13:9edad7677211 137 // set the device manager
ansond 13:9edad7677211 138 void Endpoint::setDeviceManager(void *device_manager) {
ansond 13:9edad7677211 139 this->m_device_manager = device_manager;
ansond 13:9edad7677211 140 }
ansond 13:9edad7677211 141
ansond 13:9edad7677211 142 // get the device manager
ansond 13:9edad7677211 143 void *Endpoint::getDeviceManager(void) {
ansond 13:9edad7677211 144 return this->m_device_manager;
ansond 13:9edad7677211 145 }
ansond 13:9edad7677211 146
ansond 1:16f0fb5b8d97 147 // router node behavior setting
ansond 1:16f0fb5b8d97 148 void Endpoint::asRouterNode(bool canActAsRouterNode) {
ansond 1:16f0fb5b8d97 149 this->m_canActAsRouterNode = canActAsRouterNode;
ansond 1:16f0fb5b8d97 150 }
ansond 1:16f0fb5b8d97 151
ansond 1:16f0fb5b8d97 152 // set our Options
ansond 1:16f0fb5b8d97 153 void Endpoint::setOptions(Options *options) {
ansond 1:16f0fb5b8d97 154 this->m_options = options;
ansond 1:16f0fb5b8d97 155 }
ansond 1:16f0fb5b8d97 156
ansond 0:1f1f55e73248 157 // get our Options
ansond 0:1f1f55e73248 158 Options *Endpoint::getOptions() {
ansond 0:1f1f55e73248 159 return this->m_options;
ansond 0:1f1f55e73248 160 }
ansond 0:1f1f55e73248 161
ansond 81:a2441163a06e 162 // get our endpoint security instance
ansond 81:a2441163a06e 163 M2MSecurity *Endpoint::getSecurityInstance() {
ansond 46:62da4ce20276 164 return this->m_endpoint_security;
ansond 0:1f1f55e73248 165 }
ansond 81:a2441163a06e 166
ansond 81:a2441163a06e 167 // set our endpoint security instance
ansond 81:a2441163a06e 168 void Endpoint::setSecurityInstance(M2MSecurity *security) {
ansond 81:a2441163a06e 169 if (security != NULL) {
ansond 81:a2441163a06e 170 this->m_endpoint_security = security;
ansond 81:a2441163a06e 171 }
ansond 81:a2441163a06e 172 }
ansond 0:1f1f55e73248 173
ansond 0:1f1f55e73248 174 // get our ObjectList
ansond 46:62da4ce20276 175 M2MObjectList Endpoint::getEndpointObjectList() {
ansond 46:62da4ce20276 176 return this->m_endpoint_object_list;
ansond 46:62da4ce20276 177 }
ansond 46:62da4ce20276 178
ansond 73:f12a767bc300 179 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 73:f12a767bc300 180 // get our endpoint interface
ansond 73:f12a767bc300 181 MbedCloudClient *Endpoint::getEndpointInterface() {
ansond 73:f12a767bc300 182 return this->m_endpoint_interface;
ansond 73:f12a767bc300 183 }
ansond 73:f12a767bc300 184 #else
ansond 46:62da4ce20276 185 // get our endpoint interface
ansond 46:62da4ce20276 186 M2MInterface *Endpoint::getEndpointInterface() {
ansond 46:62da4ce20276 187 return this->m_endpoint_interface;
ansond 0:1f1f55e73248 188 }
ansond 73:f12a767bc300 189 #endif
ansond 0:1f1f55e73248 190
ansond 71:5069a202e892 191 // Connector::Endpoint: create our interface
ansond 71:5069a202e892 192 void Endpoint::createEndpointInterface() {
ansond 71:5069a202e892 193 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 72:6b1d37b5420a 194 this->createCloudEndpointInterface();
ansond 71:5069a202e892 195 #else
ansond 72:6b1d37b5420a 196 this->createConnectorEndpointInterface();
ansond 71:5069a202e892 197 #endif
ansond 71:5069a202e892 198 }
ansond 71:5069a202e892 199
ansond 71:5069a202e892 200 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 71:5069a202e892 201 // mbedCloudClient: create our interface
ansond 71:5069a202e892 202 void Endpoint::createCloudEndpointInterface() {
ansond 74:6abfb2a03020 203 if (this->m_endpoint_interface == NULL) {
ansond 74:6abfb2a03020 204 this->m_endpoint_interface = &__mbed_cloud_client;
ansond 74:6abfb2a03020 205 }
ansond 74:6abfb2a03020 206
ansond 71:5069a202e892 207 // bind LWIP network interface pointer...
ansond 71:5069a202e892 208 if (__network_interface != NULL && this->m_endpoint_interface != NULL) {
ansond 71:5069a202e892 209 this->logger()->log("Connector::Endpoint: binding LWIP network instance (Cloud)...");
ansond 81:a2441163a06e 210 this->m_endpoint_interface->on_registered(&Connector::Endpoint::on_registered);
ansond 81:a2441163a06e 211 this->m_endpoint_interface->on_unregistered(&Connector::Endpoint::on_unregistered);
ansond 81:a2441163a06e 212 this->m_endpoint_interface->on_error(&Connector::Endpoint::on_error);
ansond 81:a2441163a06e 213 this->m_endpoint_interface->set_update_callback(this);
ansond 71:5069a202e892 214 this->m_endpoint_interface->setup(__network_interface);
ansond 71:5069a202e892 215 }
ansond 71:5069a202e892 216 }
ansond 81:a2441163a06e 217 #else
ansond 0:1f1f55e73248 218 // mbed-client: create our interface
ansond 71:5069a202e892 219 void Endpoint::createConnectorEndpointInterface() {
ansond 10:3f79b5e67c22 220 // get the CoAP listening port
ansond 10:3f79b5e67c22 221 uint16_t listening_port = (uint16_t)this->m_options->getConnectorPort();
ansond 10:3f79b5e67c22 222
ansond 10:3f79b5e67c22 223 // randomize the port if we are using certificates...
ansond 10:3f79b5e67c22 224 if (this->m_options->getServerCertificateSize() > 0) {
ansond 0:1f1f55e73248 225 // Randomizing listening port for Certificate mode connectivity
ansond 0:1f1f55e73248 226 srand(time(NULL));
ansond 10:3f79b5e67c22 227 listening_port = rand() % 65535 + 12345;
ansond 10:3f79b5e67c22 228 }
ansond 10:3f79b5e67c22 229
ansond 60:0d9e607dd678 230 // DEBUG
ansond 61:d02cd5e2bb26 231 //this->logger()->log("Connector::Endpoint: listening port: %d",listening_port);
ansond 60:0d9e607dd678 232
ansond 61:d02cd5e2bb26 233 // Socket protocol type: TCP or UDP
ansond 61:d02cd5e2bb26 234 M2MInterface::BindingMode socket_protocol_type = M2MInterface::UDP;
ansond 61:d02cd5e2bb26 235 if (this->m_options->getCoAPConnectionType() == COAP_TCP) socket_protocol_type = M2MInterface::TCP;
ansond 10:3f79b5e67c22 236
ansond 61:d02cd5e2bb26 237 // Socket address type: IPv4 or IPv6
ansond 61:d02cd5e2bb26 238 M2MInterface::NetworkStack socket_address_type = M2MInterface::LwIP_IPv4;
ansond 62:e5882bd28210 239 if (this->m_options->getIPAddressType() == IP_ADDRESS_TYPE_IPV6) {
ansond 61:d02cd5e2bb26 240 // IPv6 mode for the socket addressing type...
ansond 61:d02cd5e2bb26 241 socket_address_type = M2MInterface::LwIP_IPv6;
ansond 59:dd395412bd19 242
ansond 59:dd395412bd19 243 #if defined (IPV4_OVERRIDE)
ansond 61:d02cd5e2bb26 244 // OVERRIDE (until patched...)
ansond 61:d02cd5e2bb26 245 this->logger()->log("Connector::Endpoint: Socket Address Type: IPv4 (IPv6 OVERRIDE)");
ansond 61:d02cd5e2bb26 246 socket_address_type = M2MInterface::LwIP_IPv4;
ansond 59:dd395412bd19 247 #endif
ansond 59:dd395412bd19 248 }
ansond 10:3f79b5e67c22 249
ansond 10:3f79b5e67c22 250 // DEBUG
ansond 61:d02cd5e2bb26 251 if (socket_protocol_type == M2MInterface::TCP) this->logger()->log("Connector::Endpoint: Socket Protocol: TCP");
ansond 61:d02cd5e2bb26 252 if (socket_protocol_type == M2MInterface::UDP) this->logger()->log("Connector::Endpoint: Socket Protocol: UDP");
ansond 61:d02cd5e2bb26 253 if (socket_address_type == M2MInterface::LwIP_IPv4) this->logger()->log("Connector::Endpoint: Socket Address Type: IPv4");
ansond 61:d02cd5e2bb26 254 if (socket_address_type == M2MInterface::LwIP_IPv6) this->logger()->log("Connector::Endpoint: Socket Address Type: IPv6");
ansond 10:3f79b5e67c22 255
ansond 61:d02cd5e2bb26 256 // Create the endpoint M2MInterface instance
ansond 46:62da4ce20276 257 this->m_endpoint_interface = M2MInterfaceFactory::create_interface(*this,
ansond 61:d02cd5e2bb26 258 (char *)this->m_options->getEndpointNodename().c_str(), // endpoint name
ansond 61:d02cd5e2bb26 259 (char *)this->m_options->getEndpointType().c_str(), // endpoint type
ansond 61:d02cd5e2bb26 260 (int32_t)this->m_options->getLifetime(), // registration lifetime (in seconds)
ansond 61:d02cd5e2bb26 261 listening_port, // listening port (ephemeral...)
ansond 61:d02cd5e2bb26 262 (char *)this->m_options->getDomain().c_str(), // endpoint domain
ansond 61:d02cd5e2bb26 263 socket_protocol_type, // Socket protocol type: UDP or TCP...
ansond 61:d02cd5e2bb26 264 socket_address_type, // Socket addressing type: IPv4 or IPv6
ansond 61:d02cd5e2bb26 265 CONTEXT_ADDRESS_STRING // context address string (mbedConnectorInterface.h)
ansond 60:0d9e607dd678 266 );
ansond 61:d02cd5e2bb26 267
ansond 61:d02cd5e2bb26 268 // bind LWIP network interface pointer...
ansond 46:62da4ce20276 269 if (__network_interface != NULL && this->m_endpoint_interface != NULL) {
ansond 71:5069a202e892 270 this->logger()->log("Connector::Endpoint: binding LWIP network instance (Connector)...");
ansond 60:0d9e607dd678 271 this->m_endpoint_interface->set_platform_network_handler((void *)__network_interface);
ansond 27:b8aaf7dc7023 272 }
ansond 0:1f1f55e73248 273 }
ansond 81:a2441163a06e 274 #endif
ansond 0:1f1f55e73248 275
ansond 81:a2441163a06e 276 // mbed-client: createEndpointSecurityInstance()
ansond 81:a2441163a06e 277 M2MSecurity *Endpoint::createEndpointSecurityInstance() {
ansond 81:a2441163a06e 278 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 81:a2441163a06e 279 // internalized... not used.
ansond 81:a2441163a06e 280 return NULL;
ansond 81:a2441163a06e 281 #else
ansond 0:1f1f55e73248 282 // Creates register server object with mbed device server address and other parameters
ansond 0:1f1f55e73248 283 M2MSecurity *server = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer);
ansond 0:1f1f55e73248 284 if (server != NULL) {
ansond 0:1f1f55e73248 285 const String url = this->m_options->getConnectorURL();
ansond 0:1f1f55e73248 286 server->set_resource_value(M2MSecurity::M2MServerUri, url);
ansond 38:bb6d2be4d54c 287 server->set_resource_value(M2MSecurity::BootstrapServer, false);
ansond 0:1f1f55e73248 288 server->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::Certificate);
ansond 0:1f1f55e73248 289 server->set_resource_value(M2MSecurity::ServerPublicKey,this->m_options->getServerCertificate(),this->m_options->getServerCertificateSize());
ansond 0:1f1f55e73248 290 server->set_resource_value(M2MSecurity::PublicKey,this->m_options->getClientCertificate(),this->m_options->getClientCertificateSize());
ansond 0:1f1f55e73248 291 server->set_resource_value(M2MSecurity::Secretkey,this->m_options->getClientKey(),this->m_options->getClientKeySize());
ansond 0:1f1f55e73248 292 }
ansond 0:1f1f55e73248 293 return server;
ansond 81:a2441163a06e 294 #endif
ansond 0:1f1f55e73248 295 }
ansond 0:1f1f55e73248 296
ansond 81:a2441163a06e 297 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 81:a2441163a06e 298 // mbed-cloud-client: Callback from mbed client stack if any error is encountered
ansond 82:e085176f6719 299 void Endpoint::on_error(int error_code) {
ansond 81:a2441163a06e 300 char *error = "No Error";
ansond 81:a2441163a06e 301 switch(error_code) {
ansond 81:a2441163a06e 302 case 0x01:
ansond 81:a2441163a06e 303 error = "MbedCloudClient::IdentityError";
ansond 81:a2441163a06e 304 break;
ansond 81:a2441163a06e 305 case 0x02:
ansond 81:a2441163a06e 306 error = "MbedCloudClient::IdentityInvalidParameter";
ansond 81:a2441163a06e 307 break;
ansond 81:a2441163a06e 308 case 0x03:
ansond 81:a2441163a06e 309 error = "MbedCloudClient::IdentityOutofMemory";
ansond 81:a2441163a06e 310 break;
ansond 81:a2441163a06e 311 case 0x04:
ansond 81:a2441163a06e 312 error = "MbedCloudClient::IdentityProvisioningError";
ansond 81:a2441163a06e 313 break;
ansond 81:a2441163a06e 314 case 0x05:
ansond 81:a2441163a06e 315 error = "MbedCloudClient::IdentityInvalidSessionID";
ansond 81:a2441163a06e 316 break;
ansond 81:a2441163a06e 317 case 0x06:
ansond 81:a2441163a06e 318 error = "MbedCloudClient::IdentityNetworkError";
ansond 81:a2441163a06e 319 break;
ansond 81:a2441163a06e 320 case 0x07:
ansond 81:a2441163a06e 321 error = "MbedCloudClient::IdentityInvalidMessageType";
ansond 81:a2441163a06e 322 break;
ansond 81:a2441163a06e 323 case 0x08:
ansond 81:a2441163a06e 324 error = "MbedCloudClient::IdentityInvalidMessageSize";
ansond 81:a2441163a06e 325 break;
ansond 81:a2441163a06e 326 case 0x09:
ansond 81:a2441163a06e 327 error = "MbedCloudClient::IdentityCertOrKeyNotFound";
ansond 81:a2441163a06e 328 break;
ansond 81:a2441163a06e 329 case 0x0A:
ansond 81:a2441163a06e 330 error = "MbedCloudClient::IdentityRetransmissionError";
ansond 81:a2441163a06e 331 break;
ansond 81:a2441163a06e 332 case 0x30:
ansond 81:a2441163a06e 333 error = "MbedCloudClient::ConnectErrorNone";
ansond 81:a2441163a06e 334 break;
ansond 81:a2441163a06e 335 case 0x31:
ansond 81:a2441163a06e 336 error = "MbedCloudClient::ConnectAlreadyExists";
ansond 81:a2441163a06e 337 break;
ansond 81:a2441163a06e 338 case 0x32:
ansond 81:a2441163a06e 339 error = "MbedCloudClient::ConnectBootstrapFailed";
ansond 81:a2441163a06e 340 break;
ansond 81:a2441163a06e 341 case 0x33:
ansond 81:a2441163a06e 342 error = "MbedCloudClient::ConnectInvalidParameters";
ansond 81:a2441163a06e 343 break;
ansond 81:a2441163a06e 344 case 0x34:
ansond 81:a2441163a06e 345 error = "MbedCloudClient::ConnectNotRegistered";
ansond 81:a2441163a06e 346 break;
ansond 81:a2441163a06e 347 case 0x35:
ansond 81:a2441163a06e 348 error = "MbedCloudClient::ConnectTimeout";
ansond 81:a2441163a06e 349 break;
ansond 81:a2441163a06e 350 case 0x36:
ansond 81:a2441163a06e 351 error = "MbedCloudClient::ConnectNetworkError";
ansond 81:a2441163a06e 352 break;
ansond 81:a2441163a06e 353 case 0x37:
ansond 81:a2441163a06e 354 error = "MbedCloudClient::ConnectResponseParseFailed";
ansond 81:a2441163a06e 355 break;
ansond 81:a2441163a06e 356 case 0x38:
ansond 81:a2441163a06e 357 error = "MbedCloudClient::ConnectUnknownError";
ansond 81:a2441163a06e 358 break;
ansond 81:a2441163a06e 359 case 0x39:
ansond 81:a2441163a06e 360 error = "MbedCloudClient::ConnectMemoryFail";
ansond 81:a2441163a06e 361 break;
ansond 81:a2441163a06e 362 case 0x3A:
ansond 81:a2441163a06e 363 error = "MbedCloudClient::ConnectNotAllowed";
ansond 81:a2441163a06e 364 break;
ansond 81:a2441163a06e 365 case 0x3B:
ansond 81:a2441163a06e 366 error = "MbedCloudClient::ConnectSecureConnectionFailed";
ansond 81:a2441163a06e 367 break;
ansond 81:a2441163a06e 368 case 0x3C:
ansond 81:a2441163a06e 369 error = "MbedCloudClient::ConnectDnsResolvingFailed";
ansond 81:a2441163a06e 370 break;
ansond 81:a2441163a06e 371 default:
ansond 81:a2441163a06e 372 error = "UNKNOWN";
ansond 81:a2441163a06e 373 }
ansond 81:a2441163a06e 374 this->logger()->log("Connector::Endpoint(Cloud) Error(%x): %s",error_code,error);
ansond 81:a2441163a06e 375 }
ansond 81:a2441163a06e 376 #else
ansond 0:1f1f55e73248 377 // mbed-client: Callback from mbed client stack if any error is encountered
ansond 0:1f1f55e73248 378 void Endpoint::error(M2MInterface::Error error) {
ansond 0:1f1f55e73248 379 switch(error){
ansond 0:1f1f55e73248 380 case M2MInterface::AlreadyExists:
ansond 54:dfee8691c83a 381 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::AlreadyExists");
ansond 0:1f1f55e73248 382 break;
ansond 0:1f1f55e73248 383 case M2MInterface::BootstrapFailed:
ansond 54:dfee8691c83a 384 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::BootstrapFailed");
ansond 0:1f1f55e73248 385 break;
ansond 0:1f1f55e73248 386 case M2MInterface::InvalidParameters:
ansond 54:dfee8691c83a 387 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::InvalidParameters");
ansond 0:1f1f55e73248 388 break;
ansond 0:1f1f55e73248 389 case M2MInterface::NotRegistered:
ansond 54:dfee8691c83a 390 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::NotRegistered");
ansond 0:1f1f55e73248 391 break;
ansond 0:1f1f55e73248 392 case M2MInterface::Timeout:
ansond 54:dfee8691c83a 393 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::Timeout");
ansond 0:1f1f55e73248 394 break;
ansond 0:1f1f55e73248 395 case M2MInterface::NetworkError:
ansond 54:dfee8691c83a 396 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::NetworkError");
ansond 0:1f1f55e73248 397 break;
ansond 0:1f1f55e73248 398 case M2MInterface::ResponseParseFailed:
ansond 54:dfee8691c83a 399 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::ResponseParseFailed");
ansond 0:1f1f55e73248 400 break;
ansond 0:1f1f55e73248 401 case M2MInterface::UnknownError:
ansond 54:dfee8691c83a 402 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::UnknownError");
ansond 0:1f1f55e73248 403 break;
ansond 0:1f1f55e73248 404 case M2MInterface::MemoryFail:
ansond 54:dfee8691c83a 405 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::MemoryFail");
ansond 0:1f1f55e73248 406 break;
ansond 0:1f1f55e73248 407 case M2MInterface::NotAllowed:
ansond 54:dfee8691c83a 408 this->logger()->log("Connector::Endpoint(ERROR): M2MInterface::NotAllowed");
ansond 0:1f1f55e73248 409 break;
ansond 0:1f1f55e73248 410 default:
ansond 0:1f1f55e73248 411 break;
ansond 0:1f1f55e73248 412 }
ansond 0:1f1f55e73248 413 }
ansond 81:a2441163a06e 414 #endif
ansond 81:a2441163a06e 415
ansond 76:7f55e1c0635d 416 // re-register the endpoint
ansond 76:7f55e1c0635d 417 void Endpoint::re_register_endpoint() {
ansond 76:7f55e1c0635d 418 if (this->m_endpoint_interface != NULL) {
ansond 76:7f55e1c0635d 419 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 81:a2441163a06e 420 // DEBUG
ansond 81:a2441163a06e 421 this->logger()->log("Connector::Endpoint(Cloud): re-register endpoint...");
ansond 76:7f55e1c0635d 422 #else
ansond 76:7f55e1c0635d 423 this->m_endpoint_interface->update_registration(this->m_endpoint_security,this->m_options->getLifetime());
ansond 76:7f55e1c0635d 424 #endif
ansond 76:7f55e1c0635d 425 }
ansond 76:7f55e1c0635d 426 }
ansond 76:7f55e1c0635d 427
ansond 76:7f55e1c0635d 428 // de-register endpoint
ansond 76:7f55e1c0635d 429 void Endpoint::de_register_endpoint(void) {
ansond 76:7f55e1c0635d 430 if (this->m_endpoint_interface != NULL) {
ansond 76:7f55e1c0635d 431 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 81:a2441163a06e 432 // DEBUG
ansond 81:a2441163a06e 433 this->logger()->log("Connector::Endpoint(Cloud): de-registering endpoint...");
ansond 76:7f55e1c0635d 434 this->m_endpoint_interface->close();
ansond 76:7f55e1c0635d 435 #else
ansond 76:7f55e1c0635d 436 // de-register endpoint
ansond 76:7f55e1c0635d 437 this->logger()->log("Connector::Endpoint: de-registering endpoint...");
ansond 76:7f55e1c0635d 438 if (this->m_csi != NULL) {
ansond 76:7f55e1c0635d 439 this->m_csi->begin_object_unregistering((void *)this);
ansond 76:7f55e1c0635d 440 }
ansond 76:7f55e1c0635d 441 else {
ansond 76:7f55e1c0635d 442 this->m_endpoint_interface->unregister_object(NULL);
ansond 76:7f55e1c0635d 443 }
ansond 76:7f55e1c0635d 444 #endif
ansond 76:7f55e1c0635d 445 }
ansond 76:7f55e1c0635d 446 }
ansond 76:7f55e1c0635d 447
ansond 77:cee832ba6dd0 448 // register the endpoint
ansond 77:cee832ba6dd0 449 void Endpoint::register_endpoint(M2MSecurity *endpoint_security, M2MObjectList endpoint_objects) {
ansond 76:7f55e1c0635d 450 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 76:7f55e1c0635d 451 if (this->m_endpoint_interface != NULL) {
ansond 81:a2441163a06e 452 this->logger()->log("Connector::Endpoint(Cloud): registering endpoint...");
ansond 76:7f55e1c0635d 453 this->m_endpoint_interface->add_objects(endpoint_objects);
ansond 76:7f55e1c0635d 454 }
ansond 76:7f55e1c0635d 455 #else
ansond 46:62da4ce20276 456 if (this->m_endpoint_interface != NULL && endpoint_security != NULL && endpoint_objects.size() > 0) {
ansond 23:5852c0884714 457 // register endpoint
ansond 54:dfee8691c83a 458 this->logger()->log("Connector::Endpoint: registering endpoint...");
ansond 46:62da4ce20276 459 this->m_endpoint_interface->register_object(endpoint_security, endpoint_objects);
ansond 23:5852c0884714 460 }
ansond 77:cee832ba6dd0 461 #endif
ansond 0:1f1f55e73248 462 }
ansond 0:1f1f55e73248 463
ansond 81:a2441163a06e 464 #ifdef ENABLE_MBED_CLOUD_SUPPORT
ansond 81:a2441163a06e 465 // object registered
ansond 82:e085176f6719 466 void Endpoint::on_registered() {
ansond 81:a2441163a06e 467 this->logger()->log("Connector::Endpoint(Cloud): endpoint registered.");
ansond 81:a2441163a06e 468 this->m_connected = true;
ansond 81:a2441163a06e 469 this->m_registered = true;
ansond 81:a2441163a06e 470 if (this->m_csi != NULL) {
ansond 81:a2441163a06e 471 this->m_csi->object_registered((void *)this);
ansond 81:a2441163a06e 472 }
ansond 81:a2441163a06e 473 }
ansond 81:a2441163a06e 474
ansond 81:a2441163a06e 475 // registration updated
ansond 82:e085176f6719 476 void Endpoint::on_registration_updated() {
ansond 81:a2441163a06e 477 this->logger()->log("Connector::Endpoint(Cloud): endpoint re-registered.");
ansond 81:a2441163a06e 478 this->m_connected = true;
ansond 81:a2441163a06e 479 this->m_registered = true;
ansond 81:a2441163a06e 480 if (this->m_csi != NULL) {
ansond 81:a2441163a06e 481 this->m_csi->registration_updated((void *)this);
ansond 81:a2441163a06e 482 }
ansond 81:a2441163a06e 483 }
ansond 81:a2441163a06e 484
ansond 81:a2441163a06e 485 // object unregistered
ansond 82:e085176f6719 486 void Endpoint::on_unregistered() {
ansond 81:a2441163a06e 487 // DEBUG
ansond 81:a2441163a06e 488 this->logger()->log("Connector::Endpoint(Cloud): endpoint de-registered.");
ansond 81:a2441163a06e 489
ansond 81:a2441163a06e 490 // no longer connected/registered
ansond 81:a2441163a06e 491 this->m_registered = false;
ansond 81:a2441163a06e 492 this->m_connected = false;
ansond 81:a2441163a06e 493
ansond 81:a2441163a06e 494 // stop all observers...
ansond 81:a2441163a06e 495 this->stopObservations();
ansond 81:a2441163a06e 496
ansond 81:a2441163a06e 497 // invoke ConnectionHandler if we have one...
ansond 81:a2441163a06e 498 if (this->m_csi != NULL) {
ansond 81:a2441163a06e 499 this->m_csi->object_unregistered((void *)this);
ansond 81:a2441163a06e 500 }
ansond 81:a2441163a06e 501
ansond 81:a2441163a06e 502 // halt the main event loop... we are done.
ansond 81:a2441163a06e 503 net_shutdown_endpoint();
ansond 81:a2441163a06e 504 }
ansond 82:e085176f6719 505 #endif
ansond 81:a2441163a06e 506
ansond 8:f950fb1b78c0 507 // object registered
ansond 27:b8aaf7dc7023 508 void Endpoint::object_registered(M2MSecurity *security, const M2MServer &server) {
ansond 54:dfee8691c83a 509 this->logger()->log("Connector::Endpoint: endpoint registered.");
ansond 15:c11dbe4d354c 510 this->m_connected = true;
ansond 15:c11dbe4d354c 511 this->m_registered = true;
ansond 27:b8aaf7dc7023 512 if (this->m_csi != NULL) {
ansond 27:b8aaf7dc7023 513 this->m_csi->object_registered((void *)this,(void *)security,(void *)&server);
ansond 27:b8aaf7dc7023 514 }
ansond 8:f950fb1b78c0 515 }
ansond 8:f950fb1b78c0 516
ansond 8:f950fb1b78c0 517 // registration updated
ansond 27:b8aaf7dc7023 518 void Endpoint::registration_updated(M2MSecurity *security, const M2MServer &server) {
ansond 54:dfee8691c83a 519 this->logger()->log("Connector::Endpoint: endpoint re-registered.");
ansond 15:c11dbe4d354c 520 this->m_connected = true;
ansond 15:c11dbe4d354c 521 this->m_registered = true;
ansond 27:b8aaf7dc7023 522 if (this->m_csi != NULL) {
ansond 27:b8aaf7dc7023 523 this->m_csi->registration_updated((void *)this,(void *)security,(void *)&server);
ansond 27:b8aaf7dc7023 524 }
ansond 8:f950fb1b78c0 525 }
ansond 8:f950fb1b78c0 526
ansond 8:f950fb1b78c0 527 // object unregistered
ansond 27:b8aaf7dc7023 528 void Endpoint::object_unregistered(M2MSecurity *server) {
ansond 54:dfee8691c83a 529 // DEBUG
ansond 54:dfee8691c83a 530 this->logger()->log("Connector::Endpoint: endpoint de-registered.");
ansond 54:dfee8691c83a 531
ansond 54:dfee8691c83a 532 // no longer connected/registered
ansond 15:c11dbe4d354c 533 this->m_registered = false;
ansond 54:dfee8691c83a 534 this->m_connected = false;
ansond 54:dfee8691c83a 535
ansond 54:dfee8691c83a 536 // stop all observers...
ansond 54:dfee8691c83a 537 this->stopObservations();
ansond 54:dfee8691c83a 538
ansond 54:dfee8691c83a 539 // invoke ConnectionHandler if we have one...
ansond 27:b8aaf7dc7023 540 if (this->m_csi != NULL) {
ansond 27:b8aaf7dc7023 541 this->m_csi->object_unregistered((void *)this,(void *)server);
ansond 27:b8aaf7dc7023 542 }
ansond 54:dfee8691c83a 543
ansond 54:dfee8691c83a 544 // halt the main event loop... we are done.
ansond 54:dfee8691c83a 545 net_shutdown_endpoint();
ansond 0:1f1f55e73248 546 }
ansond 0:1f1f55e73248 547
ansond 0:1f1f55e73248 548 // bootstrap done
ansond 27:b8aaf7dc7023 549 void Endpoint::bootstrap_done(M2MSecurity *server) {
ansond 54:dfee8691c83a 550 this->logger()->log("Connector::Endpoint: endpoint bootstrapped.");
ansond 27:b8aaf7dc7023 551 if (this->m_csi != NULL) {
ansond 27:b8aaf7dc7023 552 this->m_csi->bootstrapped((void *)this,(void *)server);
ansond 27:b8aaf7dc7023 553 }
ansond 0:1f1f55e73248 554 }
ansond 0:1f1f55e73248 555
ansond 0:1f1f55e73248 556 // resource value updated
ansond 0:1f1f55e73248 557 void Endpoint::value_updated(M2MBase *base, M2MBase::BaseType type) {
ansond 29:be035befb437 558 // Lookup the resource and invoke process() on it...
ansond 0:1f1f55e73248 559 DynamicResource *target_res = this->lookupDynamicResource(base);
ansond 29:be035befb437 560 if (target_res != NULL) {
ansond 29:be035befb437 561 // DEBUG
ansond 43:3fb57c4fba34 562 //this->logger()->log("Value Updated (Custom Resource)");
ansond 29:be035befb437 563
ansond 29:be035befb437 564 // its a custom resource...
ansond 29:be035befb437 565 target_res->process(base->operation(),type);
ansond 29:be035befb437 566 }
ansond 29:be035befb437 567 else {
ansond 29:be035befb437 568 // DEBUG
ansond 43:3fb57c4fba34 569 //this->logger()->log("Value Updated (Device Manager)");
ansond 29:be035befb437 570
ansond 29:be035befb437 571 // let DeviceManager handle it
ansond 29:be035befb437 572 ((DeviceManager *)this->m_device_manager)->process(base,type);
ansond 29:be035befb437 573 }
ansond 29:be035befb437 574
ansond 29:be035befb437 575 // CSI
ansond 27:b8aaf7dc7023 576 if (this->m_csi != NULL) {
ansond 27:b8aaf7dc7023 577 this->m_csi->value_updated((void *)this,(void *)base,(int)type);
ansond 27:b8aaf7dc7023 578 }
ansond 0:1f1f55e73248 579 }
ansond 0:1f1f55e73248 580
ansond 0:1f1f55e73248 581 // lookup which DynamicResource cooresponds to a given M2MBase instance...
ansond 0:1f1f55e73248 582 DynamicResource *Endpoint::lookupDynamicResource(M2MBase *base) {
ansond 0:1f1f55e73248 583 const DynamicResourcesList *dynamic_resources = this->m_options->getDynamicResourceList();
ansond 29:be035befb437 584 for(int i=0; i<(int)dynamic_resources->size(); ++i) {
ansond 29:be035befb437 585 M2MBase *t = (M2MBase *)dynamic_resources->at(i)->getResource();
ansond 0:1f1f55e73248 586 if (t == base) {
ansond 29:be035befb437 587 return dynamic_resources->at(i);
ansond 0:1f1f55e73248 588 }
ansond 0:1f1f55e73248 589 }
ansond 29:be035befb437 590 return NULL;
ansond 0:1f1f55e73248 591 }
ansond 0:1f1f55e73248 592
ansond 8:f950fb1b78c0 593 // build out the endpoint
ansond 46:62da4ce20276 594 void Endpoint::buildEndpoint()
ansond 0:1f1f55e73248 595 {
ansond 27:b8aaf7dc7023 596 // initialize as an mbed-client
ansond 46:62da4ce20276 597 this->createEndpointInterface();
ansond 81:a2441163a06e 598
ansond 27:b8aaf7dc7023 599 // Create our server instance
ansond 81:a2441163a06e 600 this->setSecurityInstance(this->createEndpointSecurityInstance());
ansond 27:b8aaf7dc7023 601
ansond 27:b8aaf7dc7023 602 // We now have to bind our device resources
ansond 27:b8aaf7dc7023 603 if (this->m_device_manager != NULL) {
ansond 40:5c039dcbd7b2 604 // DEBUG
ansond 54:dfee8691c83a 605 this->logger()->log("Connector::Endpoint::build(): plumbing the device management objects and resources...");
ansond 40:5c039dcbd7b2 606
ansond 27:b8aaf7dc7023 607 // bind the device manager
ansond 27:b8aaf7dc7023 608 ((DeviceManager *)this->m_device_manager)->bind();
ansond 27:b8aaf7dc7023 609
ansond 27:b8aaf7dc7023 610 // push back the Device Resources Object
ansond 27:b8aaf7dc7023 611 if (this->m_options->getDeviceResourcesObject() != NULL) {
ansond 27:b8aaf7dc7023 612 // DEBUG
ansond 54:dfee8691c83a 613 this->logger()->log("Connector::Endpoint::build(): plumbing device resources object...");
ansond 27:b8aaf7dc7023 614
ansond 27:b8aaf7dc7023 615 // push back the device resources object
ansond 46:62da4ce20276 616 this->m_endpoint_object_list.push_back((M2MObject *)this->m_options->getDeviceResourcesObject());
ansond 27:b8aaf7dc7023 617 }
ansond 27:b8aaf7dc7023 618 else {
ansond 27:b8aaf7dc7023 619 // unable to plumb device manager
ansond 54:dfee8691c83a 620 this->logger()->log("Connector::Endpoint::build(): Unable to plumb device resources. Not installing device resource object...");
ansond 27:b8aaf7dc7023 621 }
ansond 27:b8aaf7dc7023 622
ansond 27:b8aaf7dc7023 623 // push back the Firmware Resources Object
ansond 27:b8aaf7dc7023 624 if (this->m_options->getFirmwareResourcesObject() != NULL) {
ansond 27:b8aaf7dc7023 625 // DEBUG
ansond 54:dfee8691c83a 626 this->logger()->log("Connector::Endpoint::build(): plumbing firmware resources object...");
ansond 27:b8aaf7dc7023 627
ansond 27:b8aaf7dc7023 628 // push back the firmware resources object
ansond 46:62da4ce20276 629 this->m_endpoint_object_list.push_back((M2MObject *)this->m_options->getFirmwareResourcesObject());
ansond 27:b8aaf7dc7023 630 }
ansond 27:b8aaf7dc7023 631 else {
ansond 27:b8aaf7dc7023 632 // unable to plumb firmware manager
ansond 54:dfee8691c83a 633 this->logger()->log("Connector::Endpoint::build(): Unable to plumb firmware resources. Not installing firmware resource object...");
ansond 27:b8aaf7dc7023 634 }
ansond 27:b8aaf7dc7023 635 }
ansond 27:b8aaf7dc7023 636 else {
ansond 27:b8aaf7dc7023 637 // no device manager installed
ansond 54:dfee8691c83a 638 this->logger()->log("Connector::Endpoint::build(): No device manager installed.");
ansond 0:1f1f55e73248 639 }
ansond 0:1f1f55e73248 640
ansond 0:1f1f55e73248 641 // Loop through Static Resources and bind each of them...
ansond 54:dfee8691c83a 642 this->logger()->log("Connector::Endpoint::build(): adding static resources...");
ansond 0:1f1f55e73248 643 const StaticResourcesList *static_resources = this->m_options->getStaticResourceList();
ansond 0:1f1f55e73248 644 for(int i=0; i<(int)static_resources->size(); ++i) {
ansond 54:dfee8691c83a 645 this->logger()->log("Connector::Endpoint::build(): binding static resource: [%s]...",static_resources->at(i)->getFullName().c_str());
ansond 27:b8aaf7dc7023 646 static_resources->at(i)->bind(this);
ansond 0:1f1f55e73248 647 }
ansond 0:1f1f55e73248 648
ansond 0:1f1f55e73248 649 // Loop through Dynamic Resources and bind each of them...
ansond 54:dfee8691c83a 650 this->logger()->log("Connector::Endpoint::build(): adding dynamic resources...");
ansond 0:1f1f55e73248 651 const DynamicResourcesList *dynamic_resources = this->m_options->getDynamicResourceList();
ansond 0:1f1f55e73248 652 for(int i=0; i<(int)dynamic_resources->size(); ++i) {
ansond 54:dfee8691c83a 653 this->logger()->log("Connector::Endpoint::build(): binding dynamic resource: [%s]...",dynamic_resources->at(i)->getFullName().c_str());
ansond 27:b8aaf7dc7023 654 dynamic_resources->at(i)->bind(this);
ansond 27:b8aaf7dc7023 655 }
ansond 27:b8aaf7dc7023 656
ansond 27:b8aaf7dc7023 657 // Get the ObjectList from the ObjectInstanceManager...
ansond 27:b8aaf7dc7023 658 NamedPointerList list = this->getObjectInstanceManager()->getObjectList();
ansond 27:b8aaf7dc7023 659
ansond 27:b8aaf7dc7023 660 // DEBUG
ansond 45:db754b994deb 661 //this->logger()->log("Endpoint::build(): All Resources bound. Number of Objects in list: %d",list.size());
ansond 27:b8aaf7dc7023 662
ansond 27:b8aaf7dc7023 663 // add all of the object instances we have created...
ansond 38:bb6d2be4d54c 664 for(int i=0;i<(int)list.size();++i) {
ansond 27:b8aaf7dc7023 665 // DEBUG
ansond 45:db754b994deb 666 //this->logger()->log("Endpoint::build(): adding Object Instance with ObjID: %s...",list.at(i).name().c_str());
ansond 27:b8aaf7dc7023 667
ansond 27:b8aaf7dc7023 668 // push back the object instance...
ansond 46:62da4ce20276 669 this->m_endpoint_object_list.push_back((M2MObject *)(list.at(i).ptr()));
ansond 0:1f1f55e73248 670 }
ansond 0:1f1f55e73248 671 }
ansond 0:1f1f55e73248 672
ansond 54:dfee8691c83a 673 // stop underlying observation mechanisms
ansond 54:dfee8691c83a 674 void Endpoint::stopObservations() {
ansond 54:dfee8691c83a 675 const DynamicResourcesList *dynamic_resources = this->m_options->getDynamicResourceList();
ansond 54:dfee8691c83a 676 for(int i=0; i<(int)dynamic_resources->size(); ++i) {
ansond 54:dfee8691c83a 677 if (dynamic_resources->at(i)->isObservable() == true) {
ansond 54:dfee8691c83a 678 ResourceObserver *observer = (ResourceObserver *)dynamic_resources->at(i)->getObserver();
ansond 54:dfee8691c83a 679 if (observer != NULL) {
ansond 54:dfee8691c83a 680 this->logger()->log("Connector::Endpoint::stopObservations(): stopping resource observer for: [%s]...",dynamic_resources->at(i)->getFullName().c_str());
ansond 54:dfee8691c83a 681 observer->halt();
ansond 54:dfee8691c83a 682 }
ansond 54:dfee8691c83a 683 }
ansond 54:dfee8691c83a 684 }
ansond 54:dfee8691c83a 685 }
ansond 54:dfee8691c83a 686
ansond 13:9edad7677211 687 // underlying network is connected (SET)
ansond 13:9edad7677211 688 void Endpoint::isConnected(bool connected) {
ansond 13:9edad7677211 689 this->m_connected = connected;
ansond 13:9edad7677211 690 }
ansond 13:9edad7677211 691
ansond 13:9edad7677211 692 // underlying network is connected (GET)
ansond 13:9edad7677211 693 bool Endpoint::isConnected() {
ansond 13:9edad7677211 694 return this->m_connected;
ansond 13:9edad7677211 695 }
ansond 13:9edad7677211 696
ansond 15:c11dbe4d354c 697 // Registered with mDC/mDS
ansond 15:c11dbe4d354c 698 bool Endpoint::isRegistered() {
ansond 15:c11dbe4d354c 699 return this->m_registered;
ansond 15:c11dbe4d354c 700 }
ansond 15:c11dbe4d354c 701
ansond 43:3fb57c4fba34 702 // Set the ConnectionStatusInterface
ansond 27:b8aaf7dc7023 703 void Endpoint::setConnectionStatusInterfaceImpl(ConnectionStatusInterface *csi) {
ansond 43:3fb57c4fba34 704 this->m_csi = csi;
ansond 27:b8aaf7dc7023 705 }
ansond 27:b8aaf7dc7023 706
ansond 27:b8aaf7dc7023 707 // Set our ObjectInstanceManager
ansond 27:b8aaf7dc7023 708 void Endpoint::setObjectInstanceManager(ObjectInstanceManager *oim) {
ansond 27:b8aaf7dc7023 709 this->m_oim = oim;
ansond 27:b8aaf7dc7023 710 }
ansond 27:b8aaf7dc7023 711
ansond 27:b8aaf7dc7023 712 // Get our ObjectInstanceManager
ansond 27:b8aaf7dc7023 713 ObjectInstanceManager *Endpoint::getObjectInstanceManager() {
ansond 27:b8aaf7dc7023 714 return this->m_oim;
ansond 27:b8aaf7dc7023 715 }
ansond 27:b8aaf7dc7023 716
ansond 0:1f1f55e73248 717 // our logger
ansond 0:1f1f55e73248 718 Logger *Endpoint::logger()
ansond 0:1f1f55e73248 719 {
ansond 0:1f1f55e73248 720 return this->m_logger;
ansond 0:1f1f55e73248 721 }
ansond 0:1f1f55e73248 722
ansond 0:1f1f55e73248 723 } // namespace Connector