m2minterface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2021 Pelion. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 * 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.
 */
#ifndef M2M_INTERFACE_H
#define M2M_INTERFACE_H

#include "mbed-client/m2mvector.h"
#include "mbed-client/m2mconfig.h"
#include "mbed-client/functionpointer.h"

#include "sn_coap_protocol.h"
#include "nsdl-c/sn_nsdl_lib.h"

#include <stdint.h>

//FORWARD DECLARATION
class M2MSecurity;
class M2MObject;
class M2MBase;
class M2MInterfaceObserver;
class M2MServer;

typedef Vector<M2MObject *> M2MObjectList;
typedef Vector<M2MBase *> M2MBaseList;
typedef FP callback_handler;

typedef enum request_error_e {
    FAILED_TO_SEND_MSG = 0, // Message sending has failed
    FAILED_TO_ALLOCATE_MEMORY = 1, // Can't allocate memory for the request
    ERROR_NOT_REGISTERED = 2 // Not registered, request will NOT to be stored for resending purposes
} request_error_t;

typedef request_error_e get_data_req_error_e;
typedef request_error_t get_data_req_error_t;

typedef void (*request_data_cb)(const uint8_t *buffer,
                                size_t buffer_size,
                                size_t total_size,
                                bool last_block,
                                void *context);
typedef request_data_cb get_data_cb; // For backward compatibility

typedef void (*request_error_cb)(request_error_t error_code, void *context);
typedef request_error_cb get_data_error_cb; // For backward compatibility


class M2MInterface {

public:

    typedef enum {
        ErrorNone = 0,
        AlreadyExists,
        BootstrapFailed,
        InvalidParameters,
        InvalidCertificates,
        NotRegistered,
        Timeout,
        NetworkError,
        ResponseParseFailed,
        UnknownError,
        MemoryFail,
        NotAllowed,
        SecureConnectionFailed,
        DnsResolvingFailed,
        UnregistrationFailed,
        ESTEnrollmentFailed,
        FailedToStoreCredentials,
        FailedToReadCredentials
    } Error;

    typedef enum {
        NOT_SET = 0,
        UDP = 0x01,
        UDP_QUEUE = 0x03,
        SMS = 0x04,
        SMS_QUEUE = 0x06,
        UDP_SMS_QUEUE = 0x07,
        TCP = 0x09, //not real value, spec does not have one!
        //this has nsdl binding mode bit UDP set
        TCP_QUEUE = 0x0b //not real value, spec does not have one!
                    //this has nsdl binding mode bits, UDP and UDP_QUEUE set
    } BindingMode;

    typedef enum {
        Uninitialized = 0,
        LwIP_IPv4,
        LwIP_IPv6,
        Reserved,
        Nanostack_IPv6,
        ATWINC_IPv4,
        Unknown
    } NetworkStack;

public:

    virtual ~M2MInterface() {}

#ifndef MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE

    virtual void bootstrap(M2MSecurity *security_object) = 0;

    virtual void cancel_bootstrap() = 0;

    virtual void finish_bootstrap() = 0;
#endif //MBED_CLIENT_DISABLE_BOOTSTRAP_FEATURE

    virtual void register_object(M2MSecurity *security_object, const M2MBaseList &list, bool full_registration = false) = 0;

    virtual void register_object(M2MSecurity *security_object, const M2MObjectList &object_list) = 0;

    virtual bool remove_object(M2MBase *base) = 0;

    virtual void update_registration(M2MSecurity *security_object, const uint32_t lifetime = 0) = 0;

    virtual void update_registration(M2MSecurity *security_object, const M2MBaseList &list,
                                     const uint32_t lifetime = 0) = 0;

    virtual void update_registration(M2MSecurity *security_object, const M2MObjectList &object_list,
                                     const uint32_t lifetime = 0) = 0;

    virtual void unregister_object(M2MSecurity *security_object = NULL) = 0;

    virtual void set_queue_sleep_handler(callback_handler handler) = 0;

    virtual void set_random_number_callback(random_number_cb callback) = 0;

    virtual void set_entropy_callback(entropy_cb callback) = 0;

    virtual void set_platform_network_handler(void *handler = NULL) = 0;

    virtual void set_platform_network_handler(void *handler = NULL, bool credentials_available = 0) = 0;

    virtual void update_endpoint(const String &name) = 0;

    virtual void update_domain(const String &domain) = 0;


    virtual const String internal_endpoint_name() const = 0;

    virtual const char *error_description() const = 0;

    virtual void get_data_request(DownloadType type,
                                  const char *uri,
                                  const size_t offset,
                                  const bool async,
                                  get_data_cb,
                                  get_data_error_cb,
                                  void *context) = 0;

    virtual void post_data_request(const char *uri,
                                   const bool async,
                                   const uint16_t payload_len,
                                   uint8_t *payload_ptr,
                                   get_data_cb data_cb,
                                   get_data_error_cb error_cb,
                                   void *context) = 0;

    virtual bool set_uri_query_parameters(const char *uri_query_params) = 0;

    virtual void pause() = 0;

    virtual void alert() = 0;

    virtual nsdl_s *get_nsdl_handle() const = 0;

    virtual M2MServer *get_m2mserver() const = 0;

    virtual uint16_t stagger_wait_time(bool boostrap) const = 0;

    virtual void set_cid_value(const uint8_t *data_ptr, const size_t data_len) = 0;
};

#endif // M2M_INTERFACE_H