client.h

Go to the documentation of this file.

//
// Copyright 2016 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "cc_mqttsn_client/common.h"
 
#ifdef __cplusplus
extern "C" {
#endif // #ifdef __cplusplus
 
 
CC_MqttsnClientHandle cc_mqttsn_client_alloc();
 
void cc_mqttsn_client_free(CC_MqttsnClientHandle client);
 
void cc_mqttsn_client_tick(CC_MqttsnClientHandle client, unsigned ms);
 
void cc_mqttsn_client_process_data(CC_MqttsnClientHandle client, const unsigned char* buf, unsigned bufLen, CC_MqttsnDataOrigin origin);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_default_retry_period(CC_MqttsnClientHandle client, unsigned value);
 
unsigned cc_mqttsn_client_get_default_retry_period(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_default_retry_count(CC_MqttsnClientHandle client, unsigned value);
 
unsigned cc_mqttsn_client_get_default_retry_count(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_default_broadcast_radius(CC_MqttsnClientHandle client, unsigned value);
 
unsigned cc_mqttsn_client_get_default_broadcast_radius(CC_MqttsnClientHandle client);
 
unsigned cc_mqttsn_client_get_available_gateways_count(CC_MqttsnClientHandle client);
 
void cc_mqttsn_client_init_gateway_info(CC_MqttsnGatewayInfo* info);
 
CC_MqttsnErrorCode cc_mqttsn_client_get_available_gateway_info(CC_MqttsnClientHandle client, unsigned idx, CC_MqttsnGatewayInfo* info);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_available_gateway_info(CC_MqttsnClientHandle client, const CC_MqttsnGatewayInfo* info);
 
CC_MqttsnErrorCode cc_mqttsn_client_discard_available_gateway_info(CC_MqttsnClientHandle client, unsigned char gwId);
 
void cc_mqttsn_client_discard_all_gateway_infos(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_default_gw_adv_duration(CC_MqttsnClientHandle client, unsigned ms);
 
unsigned cc_mqttsn_client_get_default_gw_adv_duration(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_allowed_adv_losses(CC_MqttsnClientHandle client, unsigned count);
 
unsigned cc_mqttsn_client_get_allowed_adv_losses(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_verify_outgoing_topic_enabled(CC_MqttsnClientHandle client, bool enabled);
 
bool cc_mqttsn_client_get_verify_outgoing_topic_enabled(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_verify_incoming_topic_enabled(CC_MqttsnClientHandle client, bool enabled);
 
bool cc_mqttsn_client_get_verify_incoming_topic_enabled(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_verify_incoming_msg_subscribed(CC_MqttsnClientHandle client, bool enabled);
 
bool cc_mqttsn_client_get_verify_incoming_msg_subscribed(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_outgoing_topic_id_storage_limit(CC_MqttsnClientHandle client, unsigned long long limit);
 
unsigned long long cc_mqttsn_client_get_outgoing_topic_id_storage_limit(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_set_incoming_topic_id_storage_limit(CC_MqttsnClientHandle client, unsigned long long limit);
 
unsigned long long cc_mqttsn_client_get_incoming_topic_id_storage_limit(CC_MqttsnClientHandle client);
 
CC_MqttsnErrorCode cc_mqttsn_client_asleep_check_messages(CC_MqttsnClientHandle client);
 
CC_MqttsnSearchHandle cc_mqttsn_client_search_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);
 
CC_MqttsnErrorCode cc_mqttsn_client_search_set_retry_period(CC_MqttsnSearchHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_search_get_retry_period(CC_MqttsnSearchHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_search_set_retry_count(CC_MqttsnSearchHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_search_get_retry_count(CC_MqttsnSearchHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_search_set_broadcast_radius(CC_MqttsnSearchHandle handle, unsigned broadcastRadius);
 
unsigned cc_mqttsn_client_search_get_broadcast_radius(CC_MqttsnSearchHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_search_send(CC_MqttsnSearchHandle handle, CC_MqttsnSearchCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_search_cancel(CC_MqttsnSearchHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_search(
    CC_MqttsnClientHandle handle,
    CC_MqttsnSearchCompleteCb cb, 
    void* cbData);
 
CC_MqttsnConnectHandle cc_mqttsn_client_connect_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_set_retry_period(CC_MqttsnConnectHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_connect_get_retry_period(CC_MqttsnConnectHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_set_retry_count(CC_MqttsnConnectHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_connect_get_retry_count(CC_MqttsnConnectHandle handle);
 
void cc_mqttsn_client_connect_init_config(CC_MqttsnConnectConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_config(CC_MqttsnConnectHandle handle, const CC_MqttsnConnectConfig* config);
 
void cc_mqttsn_client_connect_init_config_will(CC_MqttsnWillConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_config_will(CC_MqttsnConnectHandle handle, const CC_MqttsnWillConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_send(CC_MqttsnConnectHandle handle, CC_MqttsnConnectCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect_cancel(CC_MqttsnConnectHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_connect(
    CC_MqttsnClientHandle client,
    const CC_MqttsnConnectConfig* config,
    const CC_MqttsnWillConfig* willConfig,
    CC_MqttsnConnectCompleteCb cb, 
    void* cbData);
 
CC_MqttsnConnectionStatus cc_mqttsn_client_get_connection_status(CC_MqttsnClientHandle client);    
 
CC_MqttsnDisconnectHandle cc_mqttsn_client_disconnect_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_disconnect_set_retry_period(CC_MqttsnDisconnectHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_disconnect_get_retry_period(CC_MqttsnDisconnectHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_disconnect_set_retry_count(CC_MqttsnDisconnectHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_disconnect_get_retry_count(CC_MqttsnDisconnectHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_disconnect_send(CC_MqttsnDisconnectHandle handle, CC_MqttsnDisconnectCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_disconnect_cancel(CC_MqttsnDisconnectHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_disconnect(
    CC_MqttsnClientHandle client,
    CC_MqttsnDisconnectCompleteCb cb, 
    void* cbData);
 
CC_MqttsnSubscribeHandle cc_mqttsn_client_subscribe_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe_set_retry_period(CC_MqttsnSubscribeHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_subscribe_get_retry_period(CC_MqttsnSubscribeHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe_set_retry_count(CC_MqttsnSubscribeHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_subscribe_get_retry_count(CC_MqttsnSubscribeHandle handle);
 
void cc_mqttsn_client_subscribe_init_config(CC_MqttsnSubscribeConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe_config(CC_MqttsnSubscribeHandle handle, const CC_MqttsnSubscribeConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe_send(CC_MqttsnSubscribeHandle handle, CC_MqttsnSubscribeCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe_cancel(CC_MqttsnSubscribeHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_subscribe(
    CC_MqttsnClientHandle client,
    const CC_MqttsnSubscribeConfig* config,
    CC_MqttsnSubscribeCompleteCb cb, 
    void* cbData);    
 
CC_MqttsnUnsubscribeHandle cc_mqttsn_client_unsubscribe_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe_set_retry_period(CC_MqttsnUnsubscribeHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_unsubscribe_get_retry_period(CC_MqttsnUnsubscribeHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe_set_retry_count(CC_MqttsnUnsubscribeHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_unsubscribe_get_retry_count(CC_MqttsnUnsubscribeHandle handle);
 
void cc_mqttsn_client_unsubscribe_init_config(CC_MqttsnUnsubscribeConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe_config(CC_MqttsnUnsubscribeHandle handle, const CC_MqttsnUnsubscribeConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe_send(CC_MqttsnUnsubscribeHandle handle, CC_MqttsnUnsubscribeCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe_cancel(CC_MqttsnUnsubscribeHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_unsubscribe(
    CC_MqttsnClientHandle client,
    const CC_MqttsnUnsubscribeConfig* config,
    CC_MqttsnUnsubscribeCompleteCb cb, 
    void* cbData);    
 
CC_MqttsnPublishHandle cc_mqttsn_client_publish_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_publish_set_retry_period(CC_MqttsnPublishHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_publish_get_retry_period(CC_MqttsnPublishHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_publish_set_retry_count(CC_MqttsnPublishHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_publish_get_retry_count(CC_MqttsnPublishHandle handle);
 
void cc_mqttsn_client_publish_init_config(CC_MqttsnPublishConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_publish_config(CC_MqttsnPublishHandle handle, const CC_MqttsnPublishConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_publish_send(CC_MqttsnPublishHandle handle, CC_MqttsnPublishCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_publish_cancel(CC_MqttsnPublishHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_publish(
    CC_MqttsnClientHandle client,
    const CC_MqttsnPublishConfig* config,
    CC_MqttsnPublishCompleteCb cb, 
    void* cbData);    
 
CC_MqttsnWillHandle cc_mqttsn_client_will_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_will_set_retry_period(CC_MqttsnWillHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_will_get_retry_period(CC_MqttsnWillHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_will_set_retry_count(CC_MqttsnWillHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_will_get_retry_count(CC_MqttsnWillHandle handle);
 
void cc_mqttsn_client_will_init_config(CC_MqttsnWillConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_will_config(CC_MqttsnWillHandle handle, const CC_MqttsnWillConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_will_send(CC_MqttsnWillHandle handle, CC_MqttsnWillCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_will_cancel(CC_MqttsnWillHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_will(
    CC_MqttsnClientHandle client,
    const CC_MqttsnWillConfig* config,
    CC_MqttsnWillCompleteCb cb, 
    void* cbData);  
      
CC_MqttsnSleepHandle cc_mqttsn_client_sleep_prepare(CC_MqttsnClientHandle client, CC_MqttsnErrorCode* ec);     
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep_set_retry_period(CC_MqttsnSleepHandle handle, unsigned ms);
 
unsigned cc_mqttsn_client_sleep_get_retry_period(CC_MqttsnSleepHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep_set_retry_count(CC_MqttsnSleepHandle handle, unsigned count);
 
unsigned cc_mqttsn_client_sleep_get_retry_count(CC_MqttsnSleepHandle handle);
 
void cc_mqttsn_client_sleep_init_config(CC_MqttsnSleepConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep_config(CC_MqttsnSleepHandle handle, const CC_MqttsnSleepConfig* config);
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep_send(CC_MqttsnSleepHandle handle, CC_MqttsnSleepCompleteCb cb, void* cbData);
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep_cancel(CC_MqttsnSleepHandle handle);
 
CC_MqttsnErrorCode cc_mqttsn_client_sleep(
    CC_MqttsnClientHandle client,
    const CC_MqttsnSleepConfig* config,
    CC_MqttsnSleepCompleteCb cb, 
    void* cbData); 
 
// --------------------- Callbacks ---------------------
 
void cc_mqttsn_client_set_next_tick_program_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnNextTickProgramCb cb,
    void* data);
    
void cc_mqttsn_client_set_cancel_next_tick_wait_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnCancelNextTickWaitCb cb,
    void* data);
 
void cc_mqttsn_client_set_send_output_data_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnSendOutputDataCb cb,
    void* data);  
 
void cc_mqttsn_client_set_gw_status_report_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnGwStatusReportCb cb,
    void* data);  
 
void cc_mqttsn_client_set_gw_disconnect_report_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnGwDisconnectedReportCb cb,
    void* data); 
 
void cc_mqttsn_client_set_message_report_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnMessageReportCb cb,
    void* data);  
 
void cc_mqttsn_client_set_error_log_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnErrorLogCb cb,
    void* data);     
            
void cc_mqttsn_client_set_gwinfo_delay_request_callback(
    CC_MqttsnClientHandle client,
    CC_MqttsnGwinfoDelayRequestCb cb,
    void* data);
 
#ifdef __cplusplus
}
#endif