nugu_network_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 SK Telecom Co., Ltd. All rights reserved.
 *
 * 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 __NUGU_NETWORK_MANAGER_H__
#define __NUGU_NETWORK_MANAGER_H__
 
#include <nugu.h>
#include <base/nugu_event.h>
#include <base/nugu_directive.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum nugu_network_status {
        NUGU_NETWORK_DISCONNECTED, 
        NUGU_NETWORK_CONNECTING, 
        NUGU_NETWORK_READY, 
        NUGU_NETWORK_CONNECTED, 
        NUGU_NETWORK_FAILED, 
        NUGU_NETWORK_TOKEN_ERROR 
} NuguNetworkStatus;
 
typedef enum nugu_network_connection_type {
        NUGU_NETWORK_CONNECTION_ORIENTED, 
        NUGU_NETWORK_CONNECTION_ONDEMAND 
} NuguNetworkConnectionType;
 
typedef void (*NuguNetworkManagerStatusCallback)(NuguNetworkStatus status,
                                                 void *userdata);
 
typedef enum nugu_network_handoff_status {
        NUGU_NETWORK_HANDOFF_FAILED,
        NUGU_NETWORK_HANDOFF_READY,
        NUGU_NETWORK_HANDOFF_COMPLETED
} NuguNetworkHandoffStatus;
 
typedef void (*NuguNetworkManagerHandoffStatusCallback)(
        NuguNetworkHandoffStatus status, void *userdata);
 
typedef void (*NuguNetworkManagerEventSendNotifyCallback)(NuguEvent *nev,
                                                          void *userdata);
 
typedef void (*NuguNetworkManagerEventDataSendNotifyCallback)(
        NuguEvent *nev, int is_end, size_t length, unsigned char *data,
        void *userdata);
 
typedef void (*NuguNetworkManagerEventResultCallback)(int success,
                                                      const char *msg_id,
                                                      const char *dialog_id,
                                                      int code, void *userdata);
 
typedef void (*NuguNetworkManagerEventResponseCallback)(
        int success, const char *event_msg_id, const char *event_dialog_id,
        const char *json, void *userdata);
 
typedef void (*NuguNetworkManagerDirectiveCallback)(NuguDirective *ndir,
                                                    void *userdata);
 
typedef void (*NuguNetworkManagerAttachmentCallback)(
        const char *parent_msg_id, int seq, int is_end, const char *media_type,
        size_t length, const void *data, void *userdata);
 
enum nugu_network_protocol {
        NUGU_NETWORK_PROTOCOL_H2, 
        NUGU_NETWORK_PROTOCOL_H2C, 
        NUGU_NETWORK_PROTOCOL_UNKNOWN 
};
 
#define NUGU_NETWORK_MAX_ADDRESS 255
 
typedef struct nugu_network_server_policy {
        enum nugu_network_protocol protocol; 
        char hostname[NUGU_NETWORK_MAX_ADDRESS + 1]; 
        int port; 
        int retry_count_limit; 
        int connection_timeout_ms; 
        int is_charge; 
} NuguNetworkServerPolicy;
 
NUGU_API int nugu_network_manager_set_status_callback(
        NuguNetworkManagerStatusCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_handoff_status_callback(
        NuguNetworkManagerHandoffStatusCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_event_send_notify_callback(
        NuguNetworkManagerEventSendNotifyCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_event_data_send_notify_callback(
        NuguNetworkManagerEventDataSendNotifyCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_event_result_callback(
        NuguNetworkManagerEventResultCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_event_response_callback(
        NuguNetworkManagerEventResponseCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_directive_callback(
        NuguNetworkManagerDirectiveCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_attachment_callback(
        NuguNetworkManagerAttachmentCallback callback, void *userdata);
 
NUGU_API int nugu_network_manager_set_status(NuguNetworkStatus network_status);
 
NUGU_API NuguNetworkStatus nugu_network_manager_get_status(void);
 
NUGU_API int nugu_network_manager_send_event(NuguEvent *nev);
 
NUGU_API int nugu_network_manager_send_event_data(NuguEvent *nev, int is_end,
                                                  size_t length,
                                                  unsigned char *data);
 
NUGU_API int nugu_network_manager_force_close_event(NuguEvent *nev);
 
NUGU_API int nugu_network_manager_initialize(void);
 
NUGU_API void nugu_network_manager_deinitialize(void);
 
NUGU_API int nugu_network_manager_connect(void);
 
NUGU_API int nugu_network_manager_disconnect(void);
 
NUGU_API int
nugu_network_manager_handoff(const NuguNetworkServerPolicy *policy);
 
NUGU_API int nugu_network_manager_reset_connection(void);
 
NUGU_API int nugu_network_manager_set_token(const char *token);
 
NUGU_API const char *nugu_network_manager_peek_token(void);
 
NUGU_API int nugu_network_manager_set_registry_url(const char *urlname);
 
NUGU_API const char *nugu_network_manager_peek_registry_url(void);
 
NUGU_API int nugu_network_manager_set_useragent(const char *app_version,
                                                const char *additional_info);
 
NUGU_API const char *nugu_network_manager_peek_useragent(void);
 
NUGU_API const char *nugu_network_manager_peek_last_asr_time(void);
 
NUGU_API int
nugu_network_manager_set_connection_type(NuguNetworkConnectionType ctype);
 
NUGU_API NuguNetworkConnectionType
nugu_network_manager_get_connection_type(void);
 
#ifdef __cplusplus
}
#endif
 
#endif