__check_privilege_deinitialize();
}
- g_privilege_allowed = 1;
return VC_ERROR_NONE;
}
return ret;
}
+ ret = vc_mgr_client_set_audio_streaming_mode(g_vc_m, VC_AUDIO_STREAMING_MODE_VC_SERVICE);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set audio streaming mode : %d", ret);
+ vc_config_mgr_finalize(g_vc_m->handle + VC_MANAGER_CONFIG_HANDLE);
+ vc_mgr_client_destroy(g_vc_m);
+ return ret;
+ }
+
/* for TTS feedback */
/* ret = vc_mgr_player_init();
if (0 != ret) {
g_m_connect_timer = NULL;
- ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, &service_state, &foreground, &g_daemon_pid);
+ vc_audio_streaming_mode_e streaming_mode;
+ vc_mgr_client_get_audio_streaming_mode(g_vc_m, &streaming_mode);
+
+ ret = vc_mgr_dbus_request_initialize(g_vc_m->handle, (int)streaming_mode, &service_state, &foreground, &g_daemon_pid);
if (VC_ERROR_ENGINE_NOT_FOUND == ret) {
SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to initialize : %s", __vc_mgr_get_error_code(ret));
return 0;
}
+int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Send audio streaming to the engine service");
+
+ if (NULL == buffer) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid parameter");
+ return VC_ERROR_INVALID_PARAMETER;
+ }
+
+ if (0 != __vc_mgr_get_feature_enabled()) {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
+ if (0 != __vc_mgr_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_READY) {
+
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'READY'");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* Check service state */
+ vc_service_state_e service_state = -1;
+ vc_mgr_client_get_service_state(g_vc_m, &service_state);
+ if (VC_SERVICE_STATE_READY != service_state && VC_SERVICE_STATE_RECORDING != service_state) {
+
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: service state is not 'READY' and 'RECORDING', state(%d)", service_state);
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* send audio streaming */
+ int ret = vc_mgr_dbus_send_audio_streaming(g_vc_m->handle, event, buffer, len);
+ if (0 != ret) {
+ SLOG(LOG_WARN, TAG_VCM, "[WARNING] retry to send audio streaming data");
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[DEBUG] Success to send");
+ }
+
+ return ret;
+}
+
+int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e streaming_mode)
+{
+ SLOG(LOG_DEBUG, TAG_VCM, "[Manager] Set multi assistant mode");
+
+ if (0 != __vc_mgr_get_feature_enabled()) {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@ [Manager] not supported");
+ return VC_ERROR_NOT_SUPPORTED;
+ }
+
+ if (0 != __vc_mgr_check_privilege()) {
+ return VC_ERROR_PERMISSION_DENIED;
+ }
+
+ vc_state_e state;
+ if (0 != vc_mgr_client_get_client_state(g_vc_m, &state)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] A handle is not available");
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ /* check state */
+ if (state != VC_STATE_INITIALIZED) {
+
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Invalid State: Current state is not 'INITIALIZED', state(%d)", state);
+ SLOG(LOG_DEBUG, TAG_VCM, "@@@");
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ int ret = vc_mgr_client_set_audio_streaming_mode(g_vc_m, streaming_mode);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCM, "[ERROR] Fail to set multi assistant mode, ret(%d)", ret);
+ return VC_ERROR_INVALID_STATE;
+ }
+
+ return ret;
+}
/* foreground pid */
int foreground_pid;
+
+ /* multi-assistant */
+ vc_audio_streaming_mode_e streaming_mode;
} vc_mgr_client_s;
typedef struct {
client->foreground_pid = VC_RUNTIME_INFO_NO_FOREGROUND;
+ client->streaming_mode = VC_AUDIO_STREAMING_MODE_VC_SERVICE;
+
g_mgr_client_list = g_slist_append(g_mgr_client_list, client);
*vc = temp;
return 0;
}
+
+int vc_mgr_client_set_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e streaming_mode)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ client->streaming_mode = streaming_mode;
+
+ return 0;
+}
+
+int vc_mgr_client_get_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e* streaming_mode)
+{
+ vc_mgr_client_s* client = __mgr_client_get(vc);
+
+ /* check handle */
+ if (NULL == client)
+ return VC_ERROR_INVALID_PARAMETER;
+
+ *streaming_mode = client->streaming_mode;
+
+ return 0;
+}
#include "vc_info_parser.h"
#include "voice_control_manager.h"
+#include "voice_control_manager_internal.h"
#ifdef __cplusplus
extern "C" {
int vc_mgr_client_get_vc_tts_streaming_cb(vc_h vc, vc_mgr_vc_tts_streaming_cb* callback, void** user_data);
-
/*
* set/get option
*/
int vc_mgr_client_get_foreground(vc_h vc, int* pid);
+int vc_mgr_client_set_multi_assistant(vc_h vc, bool use_multi_assistant);
+
+int vc_mgr_client_get_multi_assistant(vc_h vc, bool* use_multi_assistant);
+
+
/* utils */
int vc_mgr_client_get_count();
int vc_mgr_client_get_start_by_client(vc_h vc, bool* option);
+/* multi assistant */
+int vc_mgr_client_set_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e streaming_mode);
+
+int vc_mgr_client_get_audio_streaming_mode(vc_h vc, vc_audio_streaming_mode_e* streaming_mode);
+
+
#ifdef __cplusplus
}
#endif
return ret;
}
-int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid)
+int vc_mgr_dbus_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid)
{
DBusError err;
dbus_error_init(&err);
dbus_message_append_args(msg,
DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &audio_streaming_mode,
DBUS_TYPE_INVALID);
DBusMessage* result_msg;
int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, int utt_status)
{
DBusMessage* msg;
-
- /* create a signal & check for errors */
msg = __get_message(pid, VC_MANAGER_METHOD_UTTERANCE_STATUS, VC_COMMAND_TYPE_FOREGROUND);
if (NULL == msg) {
return 0;
}
+
+int vc_mgr_dbus_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len)
+{
+ DBusMessage* msg;
+ msg = dbus_message_new_method_call(
+ VC_SERVER_SERVICE_NAME,
+ VC_SERVER_SERVICE_OBJECT_PATH,
+ VC_SERVER_SERVICE_INTERFACE,
+ VC_MANAGER_METHOD_SEND_AUDIO_STREAMING);
+
+ if (NULL == msg) {
+ SLOG(LOG_ERROR, TAG_VCM, "@@ vc send audio streaming : Fail to make message");
+ return VC_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "@@ vc send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
+ }
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &event,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+ &buffer, len,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ /* send dbus message and flush the connection */
+ if (!dbus_connection_send(g_m_conn_sender, msg, NULL)) {
+ SLOG(LOG_ERROR, TAG_VCM, "[Dbus ERROR] Fail to send audio streaming");
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCM, "[Dbus DEBUG] Success to send audio streaming");
+ dbus_connection_flush(g_m_conn_sender);
+ }
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
+
#ifndef __VC_DBUS_H_
#define __VC_DBUS_H_
+#include "voice_control_manager_internal.h"
+
#ifdef __cplusplus
extern "C" {
int vc_mgr_dbus_request_hello();
-int vc_mgr_dbus_request_initialize(int pid, int* service_state, int* foreground, int* daemon_pid);
+int vc_mgr_dbus_request_initialize(int pid, int audio_streaming_mode, int* service_state, int* foreground, int* daemon_pid);
int vc_mgr_dbus_request_finalize(int pid);
int vc_mgr_dbus_send_utterance_status(int pid, int utt_id, int utt_status);
+int vc_mgr_dbus_send_audio_streaming(int pid, vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len);
#ifdef __cplusplus
}
#define VC_MANAGER_METHOD_STOP_FEEDBACK "vc_manager_method_request_stop_feedback"
#define VC_MANAGER_METHOD_UTTERANCE_STATUS "vc_manager_method_utterance_status"
+#define VC_MANAGER_METHOD_SEND_AUDIO_STREAMING "vc_manager_method_send_audio_streaming"
+
#define VCD_MANAGER_METHOD_HELLO "vcd_manager_method_hello"
#define VCD_MANAGER_METHOD_SPEECH_DETECTED "vcd_manager_method_speech_detected"
#define VCD_MANAGER_METHOD_ALL_RESULT "vcd_manager_method_all_result"
{
#endif
+typedef enum {
+ VC_AUDIO_STREAMING_EVENT_FAIL = -1, /**< Failed */
+ VC_AUDIO_STREAMING_EVENT_START = 1, /**< Start event */
+ VC_AUDIO_STREAMING_EVENT_CONTINUE = 2, /**< Continue event */
+ VC_AUDIO_STREAMING_EVENT_FINISH = 3 /**< Finish event */
+} vc_audio_streaming_event_e;
+
+typedef enum {
+ VC_AUDIO_STREAMING_MODE_VC_SERVICE = 0, /**< Use audio recording from vc service */
+ VC_AUDIO_STREAMING_MODE_MULTI_ASSISTANT = 1, /**< Use audio streaming from multi-assistant */
+ VC_AUDIO_STREAMING_MODE_OUTSIDE = 2, /**< Use audio streaming from outside */
+} vc_audio_streaming_mode_e;
/**
* @brief Sets demandable client list.
*/
int vc_mgr_set_domain(const char* domain);
+/**
+ * @brief Sends audio streaming to the engine service.
+ * @since_tizen 5.0
+ *
+ */
+int vc_mgr_send_audio_streaming(vc_audio_streaming_event_e event, unsigned char* buffer, unsigned int len);
+
+int vc_mgr_set_audio_streaming_mode(vc_audio_streaming_mode_e streaming_mode);
+
#ifdef __cplusplus
}
static int g_foreground_pid;
+static int g_audio_streaming_mode;
+
#define COMMAND_TYPE_MAX 7
static int g_enabled_command_type[COMMAND_TYPE_MAX] = {
0, /* NONE */
return g_enabled_command_type[cmd_type];
}
+
+int vcd_config_get_audio_streaming_mode(vcd_audio_streaming_mode_e* streaming_mode)
+{
+ *streaming_mode = g_audio_streaming_mode;
+ return 0;
+}
+
+int vcd_config_set_audio_streaming_mode(vcd_audio_streaming_mode_e streaming_mode)
+{
+ g_audio_streaming_mode = streaming_mode;
+ return 0;
+}
int vcd_config_get_command_type_enabled(int cmd_type);
+int vcd_config_get_audio_streaming_mode(vcd_audio_streaming_mode_e* streaming_mode);
+
+int vcd_config_set_audio_streaming_mode(vcd_audio_streaming_mode_e streaming_mode);
+
+
#ifdef __cplusplus
}
#endif
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_STOP_FEEDBACK))
vcd_dbus_server_mgr_stop_feedback(g_conn_listener, msg);
+ else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_MANAGER_METHOD_SEND_AUDIO_STREAMING))
+ vcd_dbus_server_mgr_send_audio_streaming(g_conn_listener, msg);
+
/* client event */
else if (dbus_message_is_method_call(msg, VC_SERVER_SERVICE_INTERFACE, VC_METHOD_INITIALIZE))
vcd_dbus_server_initialize(g_conn_listener, msg);
#include "vcd_dbus_server.h"
#include "vcd_main.h"
#include "vcd_server.h"
-
+#include "vcd_config.h"
int __dbus_error_return(DBusConnection* conn, DBusMessage* msg, int ret)
{
dbus_error_init(&err);
int pid;
+ int streaming_mode;
int service_state;
int foreground;
int daemon_pid;
dbus_message_get_args(msg, &err,
DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &streaming_mode,
DBUS_TYPE_INVALID);
SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager Initialize");
dbus_error_free(&err);
ret = VCD_ERROR_OPERATION_FAILED;
} else {
+ vcd_config_set_audio_streaming_mode((vcd_audio_streaming_mode_e)streaming_mode);
ret = vcd_server_mgr_initialize(pid);
service_state = vcd_server_get_service_state();
foreground = vcd_server_get_foreground();
return 0;
}
+int vcd_dbus_server_mgr_send_audio_streaming(DBusConnection* conn, DBusMessage* msg)
+{
+ DBusError err;
+ dbus_error_init(&err);
+
+ int pid = 0;
+ int event = 0;
+ unsigned char* buffer = NULL;
+ unsigned int len = 0;
+
+ int ret = VCD_ERROR_OPERATION_FAILED;
+
+ SLOG(LOG_DEBUG, TAG_VCD, "@@@ VCD Manager send audio streaming");
+
+ dbus_message_get_args(msg, &err,
+ DBUS_TYPE_INT32, &pid,
+ DBUS_TYPE_INT32, &event,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+ &buffer, &len,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_error_is_set(&err)) {
+ SLOG(LOG_ERROR, TAG_VCD, "[IN ERROR] vcd mgr send audio streaming : get arguments error (%s)", err.message);
+ dbus_error_free(&err);
+ ret = VCD_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, TAG_VCD, "[IN] vcd mgr send audio streaming : pid(%d), event(%d), buffer(%p), len(%d)", pid, event, buffer, len);
+ ret = vcd_server_mgr_send_audio_streaming(pid, event, buffer, len);
+ }
+
+ return ret;
+}
+
/*
* Dbus Server functions for client
return 0;
}
+
int vcd_dbus_server_request_tts(DBusConnection* conn, DBusMessage* msg)
{
DBusError err;
int vcd_dbus_server_mgr_stop_feedback(DBusConnection* conn, DBusMessage* msg);
+/* for Multi-assistant */
+int vcd_dbus_server_mgr_send_audio_streaming(DBusConnection* conn, DBusMessage* msg);
+
/*
* Dbus Server functions for client
VCD_STATE_PROCESSING = 3
} vcd_state_e;
+typedef enum {
+ VCD_AUDIO_STREAMING_EVENT_FAIL = -1, /**< Failed */
+ VCD_AUDIO_STREAMING_EVENT_START = 1, /**< Start event */
+ VCD_AUDIO_STREAMING_EVENT_CONTINUE = 2, /**< Continue event */
+ VCD_AUDIO_STREAMING_EVENT_FINISH = 3 /**< Finish event */
+} vcd_audio_streaming_event_e;
+
+typedef enum {
+ VCD_AUDIO_STREAMING_MODE_VC_SERVICE = 0, /**< Use audio recording from vc service */
+ VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT = 1, /**< Use audio streaming from multi-assistant */
+ VCD_AUDIO_STREAMING_MODE_OUTSIDE = 2, /**< Use audio streaming from outside */
+} vcd_audio_streaming_mode_e;
+
struct vce_cmd_s {
int index;
};
static int g_device_id = -1;
/* Sound buf save */
-/*
+#if 0
#define BUF_SAVE_MODE
- */
+#endif
#ifdef BUF_SAVE_MODE
static FILE* g_normal_file;
int vcd_recorder_set(const char* audio_type, vce_audio_type_e type, int rate, int channel)
{
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
if (NULL == audio_type) {
return VCD_ERROR_INVALID_PARAMETER;
}
int vcd_recorder_get(char** audio_type)
{
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
if (NULL == audio_type) {
return VCD_ERROR_INVALID_PARAMETER;
}
}
}
+int vcd_recorder_start_streaming()
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] start streaming");
+
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
+#ifdef BUF_SAVE_MODE
+ char normal_file_name[128] = {'\0',};
+ g_count++;
+
+ while (1) {
+ snprintf(normal_file_name, sizeof(normal_file_name), "/tmp/vc_streaming_%d_%d", getpid(), g_count);
+ int ret = access(normal_file_name, 0);
+
+ if (0 == ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] File is already exist");
+ if (0 == remove(normal_file_name)) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Remove file");
+ break;
+ } else {
+ g_count++;
+ }
+ } else {
+ break;
+ }
+ }
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] File normal name : %s", normal_file_name);
+
+ /* open test file */
+ g_normal_file = fopen(normal_file_name, "wb+x");
+ if (!g_normal_file) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] File not found!");
+ }
+#endif
+
+ return 0;
+}
+
+int vcd_recorder_send_streaming(const void* buffer, const unsigned int length)
+{
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
+ if (NULL != g_audio_cb) {
+ int ret = g_audio_cb(buffer, length);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[Recorder ERROR] Fail to start streaming : %d", ret);
+ vcd_recorder_stop();
+ return ret;
+ }
+ }
+
+#ifdef BUF_SAVE_MODE
+ /* write pcm buffer */
+ if (g_normal_file)
+ fwrite(buffer, 1, length, g_normal_file);
+#endif
+
+ return 0;
+}
+
+int vcd_recorder_stop_streaming()
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] stop streaming");
+
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_VC_SERVICE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
+#ifdef BUF_SAVE_MODE
+ if (g_normal_file)
+ fclose(g_normal_file);
+#endif
+
+ return 0;
+}
int vcd_recorder_start()
{
int ret = -1;
+
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
g_buffer_count = 0;
SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Enter, recorder state(%d)", g_recorder_state);
{
int ret = -1;
+ vcd_audio_streaming_mode_e streaming_mode;
+ vcd_config_get_audio_streaming_mode(&streaming_mode);
+ if (VCD_AUDIO_STREAMING_MODE_MULTI_ASSISTANT == streaming_mode || VCD_AUDIO_STREAMING_MODE_OUTSIDE == streaming_mode) {
+ SLOG(LOG_DEBUG, TAG_VCD, "[Recorder] Current audio streaming mode(%d)", streaming_mode);
+ return VCD_ERROR_NONE;
+ }
+
if (VCD_RECORDER_STATE_READY == g_recorder_state)
return 0;
int vcd_recorder_get(char** audio_type);
+int vcd_recorder_start_streaming();
+
+int vcd_recorder_send_streaming(const void* buffer, const unsigned int length);
+
+int vcd_recorder_stop_streaming();
+
int vcd_recorder_start();
int vcd_recorder_read();
return VCD_ERROR_NONE;
}
+int vcd_server_mgr_send_audio_streaming(int pid, int event, unsigned char* buffer, unsigned int len)
+{
+ SLOG(LOG_DEBUG, TAG_VCD, "[DEBUG] Send Audio Streaming from Multi-assistant. event(%d), buffer(%p), len(%d)", event, &buffer, len);
+
+ int ret = 0;
+ if (VCD_AUDIO_STREAMING_EVENT_START == event) {
+ ret = vcd_recorder_start_streaming();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to start streaming, ret(%d)", ret);
+ return ret;
+ }
+ }
+
+ ret = vcd_recorder_send_streaming((const void*)buffer, (const unsigned int)len);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to start streaming, ret(%d)", ret);
+ return ret;
+ }
+
+ if (VCD_AUDIO_STREAMING_EVENT_FINISH == event) {
+ ret = vcd_recorder_stop_streaming();
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_VCD, "[ERROR] Fail to stop streaming, ret(%d)", ret);
+ return ret;
+ }
+ }
+
+ return VCD_ERROR_NONE;
+}
+
/*
* VC Server Functions for Client
int vcd_server_mgr_stop_feedback(void);
+/* for Multi-assistant */
+int vcd_server_mgr_send_audio_streaming(int pid, int event, unsigned char* buffer, unsigned int len);
+
/*
* For client
projects / platform / core / uifw / voice-control.git / commitdiff