File content as of revision 5:a929d65eb385:

/**
 * @file    Endpoint.cpp
 * @brief   mbed CoAP Endpoint base class
 * @author  Doug Anson/Chris Paola
 * @version 1.0
 * @see
 *
 * Copyright (c) 2014
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "Endpoint.h"

// support for temporary mbedEndpointLib calls...
#include "mbedEndpointLib.h"

// Tasklet ID
int main_tasklet_id = -1;

// Connector namespace
namespace Connector {

// Constructor
Endpoint::Endpoint(const Logger *logger, const Options *options)
{
    this->m_logger = (Logger *)logger;
    this->m_options = (Options *)options;
}

// Copy Constructor
Endpoint::Endpoint(const Endpoint &ep)
{
    this->m_logger = ep.m_logger;
    this->m_options = ep.m_options;
}

// Destructor
Endpoint::~Endpoint()
{
}

// Plumb the network
void Endpoint::plumbNetwork(bool canActAsRouterNode) {
    // call into mbedEndpointLib directly for now... (TODO: wont be able to (re)set MAC address in OptionsBuilder as its already been plumbed here...)
    init_network(canActAsRouterNode);
}

// initialize the endpoint
void Endpoint::initialize()
{
    // Create the NSDL Resource Pointer...
    this->logger()->log("Endpoint::initialize(): initializing NSP resource pointer...");
    sn_nsdl_resource_info_s *resource_ptr = (sn_nsdl_resource_info_s*)nsdl_alloc(sizeof(sn_nsdl_resource_info_s));
    if(!resource_ptr) return;
    memset(resource_ptr, 0, sizeof(sn_nsdl_resource_info_s));

    resource_ptr->resource_parameters_ptr = (sn_nsdl_resource_parameters_s*)nsdl_alloc(sizeof(sn_nsdl_resource_parameters_s));
    if(!resource_ptr->resource_parameters_ptr) {
        nsdl_free(resource_ptr);
        return;
    }
    memset(resource_ptr->resource_parameters_ptr, 0, sizeof(sn_nsdl_resource_parameters_s));

    // Loop through Static Resources and bind each of them...
    this->logger()->log("Endpoint::initialize(): adding static resources...");
    const StaticResourcesList *static_resources = this->m_options->getStaticResourceList();
    for(int i=0; i<static_resources->size(); ++i) {
        this->logger()->log("Endpoint::initialize(): binding static resource: [%s]...",static_resources->at(i)->getName().c_str());
        static_resources->at(i)->bind(resource_ptr);
    }

    // Loop through Dynamic Resources and bind each of them...
    this->logger()->log("Endpoint::initialize(): adding dynamic resources...");
    const DynamicResourcesList *dynamic_resources = this->m_options->getDynamicResourceList();
    for(int i=0; i<dynamic_resources->size(); ++i) {
        this->logger()->log("Endpoint::initialize(): binding dynamic resource: [%s]...",dynamic_resources->at(i)->getName().c_str());
        dynamic_resources->at(i)->bind(resource_ptr);
    }

    // initialize the Network
    this->initNetwork();

    // clean up
    nsdl_free(resource_ptr->resource_parameters_ptr);
    nsdl_free(resource_ptr);
}

// initialize the NSDL Network
void Endpoint::initNetwork()
{
    // register with NSP
    this->logger()->log("Calling NSP_registration()...");
    NSP_registration();
    this->logger()->log("NSP_registration() completed");
}

// Finalize the endpoint's configuration and begin the endpoint's main even loop (static, not tied into Logger)
void Endpoint::start()
{   
    // mbedEndpointLib tasklet creation...
    main_tasklet_id = arm_ns_tasklet_create(&tasklet_main);
    if(main_tasklet_id < 0) {
        //Tasklet cerate fail
        std::printf("startTasklet: Tasklet creation failed...\r\n");
        return;
    }

    // mbedEndpointLib event dispatching
    std::printf("startTasklet: Beginning event dispatch...\r\n");
    event_dispatch();
    return;
}

// our logger
Logger *Endpoint::logger()
{
    return this->m_logger;
}

} // namespace Connector