[Feature][T108][task-view-1499][ril]Modify return value GSW_HAL_FAIL to GSW_HAL_NORMAL_FAIL and rename file name
Only Configure: No
Affected branch: GSW_V1453
Affected module: ril
Is it affected on IC: only ASR
Self-test: yes
Doc Update: no
Change-Id: Icc373f650a429298d4fcf34677d87ac674ae796e
diff --git a/mbtk/libgsw_lib/gsw_voice_interface.c b/mbtk/libgsw_lib/gsw_voice_interface.c
new file mode 100755
index 0000000..1063c79
--- /dev/null
+++ b/mbtk/libgsw_lib/gsw_voice_interface.c
@@ -0,0 +1,1012 @@
+#include "gsw_voice_interface.h"
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// mbtk includes
+
+typedef unsigned int uint32;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
+
+typedef struct
+{
+ int client_fd;
+ pthread_t read_thread_id;
+ int exit_fd[2];
+ bool is_waitting;
+ pthread_cond_t cond;
+ pthread_mutex_t mutex;
+
+ pthread_mutex_t send_mutex;
+
+ // Temp response data.
+ uint16 info_err;
+ uint16 data_len;
+ void *data;
+
+ //mbtk wyq for server_ready_status add start
+ char server_ready_status;
+ //mbtk wyq for server_ready_status add end
+
+ mbtk_info_callback_func net_state_cb;
+ mbtk_info_callback_func call_state_cb;
+ mbtk_info_callback_func sms_state_cb;
+ mbtk_info_callback_func radio_state_cb;
+ mbtk_info_callback_func sim_state_cb;
+ mbtk_info_callback_func pdp_state_cb;
+ //add signal by xr
+ mbtk_info_callback_func signal_state_cb;
+} mbtk_info_handle_t;
+
+typedef struct
+{
+ uint8 call_wait;
+ uint8 dir1;
+ uint8 dir;
+ uint8 state;
+ uint8 mode;
+ uint8 mpty;
+ char phone_number[100];
+ uint8 type;
+ uint8 pas;
+ uint8 disconnected_id;
+ uint8 end_reason[128];
+} __attribute__((packed)) mbtk_call_info_t;
+
+typedef enum {
+ MBTK_CLCC = 1,
+ MBTK_CPAS,
+ MBTK_DISCONNECTED,
+} mbtk_call_enum;
+
+typedef enum {
+ MBTK_CALL_RADY, //MT allows commands from TA/TE
+ MBTK_CALL_UNAVAILABLE, //MT does not allow commands from TA/TE
+ MBTK_CALL_UNKNOWN, //MT is not guaranteed to respond to instructions
+ MBTK_CALL_RINGING, //MT is ready for commands from TA/TE, but the ringer is active
+ MBTK_CALL_PROGRESS, //MT is ready for commands from TA/TE, but a call is in progress
+ MBTK_CALL_ASLEEP, //MT is unable to process commands from TA/TE because it is in a low functionality state
+ MBTK_CALL_ACTIVE,
+} mbtk_call_pas_enum;
+
+
+//----------------end_reason start------------
+//mbtk end_reason define
+#define MBTK_VOICE_END_REASON_UNKNOWN "0 "
+#define MBTK_VOICE_END_REASON_UNASSIGNED_NUMBER "1 "
+#define MBTK_VOICE_END_REASON_NO_ROUTE_DES "3 "
+#define MBTK_VOICE_END_REASON_CHANNEL_UNACCEPTABLE "6 "
+#define MBTK_VOICE_END_REASON_OPERATOR_DETERMINED_BARRING "8 "
+#define MBTK_VOICE_END_REASON_NORMAL_CALL_CLEARING "16 "
+#define MBTK_VOICE_END_REASON_USER_BUSY "17 "
+#define MBTK_VOICE_END_REASON_NO_USER_RESPONDING "18 "
+#define MBTK_VOICE_END_REASON_USER_ALERTING_NO_ANSWER "19 "
+#define MBTK_VOICE_END_REASON_CALL_REJECTED "21 "
+#define MBTK_VOICE_END_REASON_NUMBER_CHANGED "22 "
+#define MBTK_VOICE_END_REASON_PREEMPTION "25 "
+#define MBTK_VOICE_END_REASON_NON_SELECTED_USER_CLEARING "26 "
+#define MBTK_VOICE_END_REASON_DESTINATION_OUT_OF_ORDER "27 "
+#define MBTK_VOICE_END_REASON_INVALID_NUMBER_FORMAT "28 "
+#define MBTK_VOICE_END_REASON_FACILITY_REJECTED "29 "
+#define MBTK_VOICE_END_REASON_STATUS_ENQUIRY "30 "
+#define MBTK_VOICE_END_REASON_NORMAL_UNSPECIFIED "31 "
+#define MBTK_VOICE_END_REASON_NO_CIRCUIT_AVAILABLE "34 "
+#define MBTK_VOICE_END_REASON_NETWORK_OUT_OF_ORDER "38 "
+#define MBTK_VOICE_END_REASON_TEMPORARY_FAILURE "41 "
+#define MBTK_VOICE_END_REASON_SWITCHING_EQUIPMENT_CONGESTION "42 "
+#define MBTK_VOICE_END_REASON_ACCESS_INFORMATION_DISCARDED "43 "
+#define MBTK_VOICE_END_REASON_REQUESTED_CIRCUIT_UNAVAILABLE "44 "
+#define MBTK_VOICE_END_REASON_RESOURCE_UNAVAILABLE "47 "
+#define MBTK_VOICE_END_REASON_QOS_UNAVAILABLE "49 "
+#define MBTK_VOICE_END_REASON_REQUESTED_FACILITY_NOT_SUBSCRIBED "50 "
+#define MBTK_VOICE_END_REASON_INCOMING_CALLS_BARRED_WITHIN_CUG "55 "
+#define MBTK_VOICE_END_REASON_BEARER_CAPABILITY_NOT_AUTHORIZED "57 "
+#define MBTK_VOICE_END_REASON_BEARER_CAPABILITY_NOT_AVAILABLE "58 "
+#define MBTK_VOICE_END_REASON_SERVICE_NOT_AVAILABLE "63 "
+#define MBTK_VOICE_END_REASON_BEARER_SERVICE_NOT_IMPLEMENTED "65 "
+#define MBTK_VOICE_END_REASON_ACM_MAX_REACHED "68 "
+#define MBTK_VOICE_END_REASON_FACILITY_NOT_IMPLEMENTED "69 "
+#define MBTK_VOICE_END_REASON_ONLY_RDI_BEARER_CAPABILITY_AVAILABLE "70 "
+#define MBTK_VOICE_END_REASON_SERVICE_NOT_IMPLEMENTED "79 "
+#define MBTK_VOICE_END_REASON_INVALID_TRANSACTION_ID "81 "
+#define MBTK_VOICE_END_REASON_USER_NOT_MEMBER_OF_CUG "87 "
+#define MBTK_VOICE_END_REASON_INCOMPATIBLE_DESTINATION "88 "
+#define MBTK_VOICE_END_REASON_INVALID_TRANSIT_NETWORK_SELECTION "91 "
+#define MBTK_VOICE_END_REASON_INCORRECT_MESSAGE "95 "
+#define MBTK_VOICE_END_REASON_INVALID_MANDATORY_INFORMATION "96 "
+#define MBTK_VOICE_END_REASON_MESSAGE_TYPE_NON_EXISTENT "97 "
+#define MBTK_VOICE_END_REASON_MESSAGE_TYPE_WRONG_STATE "98 "
+#define MBTK_VOICE_END_REASON_INFORMATION_ELEMENT_NOT_EXISTENT "99 "
+#define MBTK_VOICE_END_REASON_CONDITIONAL_IE_ERROR "100 "
+#define MBTK_VOICE_END_REASON_MESSAGE_WRONG_STATE "101 "
+#define MBTK_VOICE_END_REASON_RECOVERY_AFTER_TIMER_EXPIRY "102 "
+#define MBTK_VOICE_END_REASON_PROTOCOL_ERROR_UNSPECIFIED "111 "
+#define MBTK_VOICE_END_REASON_INERWORKING_UNSPECIFIED "127 "
+#define MBTK_VOICE_END_REASON_CALL_BARRING "224 "
+#define MBTK_VOICE_END_REASON_FDN_BLOCKED "241 "
+#define MBTK_VOICE_END_REASON_END "end"
+
+typedef enum{
+ GSW_LOCAL_END_NORMAL = 0,
+ GSW_PEER_END_NORMAL,
+ GSW_OTHER_END_NORMAL,
+ GSW_END_ABNORMAL,
+} gsw_call_end_reason_enum;
+
+//mbtk end_reason enum define
+typedef struct {
+ char mbtk_end_reason[128];
+ gsw_call_end_reason_enum end_reason;
+}end_reason_t;
+
+end_reason_t g_end_reason[] = {
+{MBTK_VOICE_END_REASON_UNASSIGNED_NUMBER, GSW_PEER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_ROUTE_DES, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_CHANNEL_UNACCEPTABLE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_OPERATOR_DETERMINED_BARRING, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_NORMAL_CALL_CLEARING, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_USER_BUSY, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_USER_RESPONDING, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_USER_ALERTING_NO_ANSWER, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_CALL_REJECTED, GSW_LOCAL_END_NORMAL},
+{MBTK_VOICE_END_REASON_NUMBER_CHANGED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_PREEMPTION, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NON_SELECTED_USER_CLEARING, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_DESTINATION_OUT_OF_ORDER, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_INVALID_NUMBER_FORMAT, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_FACILITY_REJECTED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_STATUS_ENQUIRY, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NORMAL_UNSPECIFIED, GSW_PEER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NO_CIRCUIT_AVAILABLE, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_NETWORK_OUT_OF_ORDER, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_TEMPORARY_FAILURE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_SWITCHING_EQUIPMENT_CONGESTION, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_ACCESS_INFORMATION_DISCARDED, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_REQUESTED_CIRCUIT_UNAVAILABLE, GSW_OTHER_END_NORMAL},
+{MBTK_VOICE_END_REASON_SERVICE_NOT_AVAILABLE, GSW_END_ABNORMAL},
+{MBTK_VOICE_END_REASON_END, GSW_OTHER_END_NORMAL}
+
+};
+
+int gsw_global_end_reason = GSW_OTHER_END_NORMAL;
+
+//----------------end_reason end------------
+
+
+typedef uint32_t voice_client_handle_type;
+
+
+
+static mbtk_info_handle_t* call_info_handle = NULL;
+static int level_call = 0;
+int gsw_voice_init_flag = 0;
+int auto_answer_flag = 0;
+voice_client_handle_type g_call_val = -1;
+CallStateInd gsw_voice_callback = NULL;
+
+
+int state_t = 0;
+char* phone_num_t = NULL;
+char* phone_num_t2 = NULL;
+int call_id_t = 0;
+int call_id_t2 = 0;
+
+#define lib_mbtk_path "/lib/libmbtk_lib.so"
+static void *dlHandle_mbtk;
+
+static mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
+int (*mbtk_call_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
+int (*mbtk_call_start)(mbtk_info_handle_t* handle, char* phone_number);
+int (*mbtk_call_hang)(mbtk_info_handle_t* handle);
+int (*mbtk_a_call_hang)(mbtk_info_handle_t* handle, int phone_id);
+int (*mbtk_call_answer)(mbtk_info_handle_t* handle);
+int (*mbtk_call_reg_get)(mbtk_info_handle_t* handle, mbtk_call_info_t *reg);
+static void (*mbtk_log)(int level, const char *format, ...);
+static void (*mbtk_log_init)(char *path, char *tag);
+
+/*rtp begin*/
+int (*mbtk_rtp_init)();
+int (*mbtk_rtp_deinit)();
+int (*mbtk_rtp_enable)(bool enable);
+int (*mbtk_rtp_remote_ip_set)(const char *ipv4);
+int (*mbtk_rtp_server_port_set)(int port);
+int (*mbtk_rtp_client_port_set)(int port);
+int (*mbtk_rtp_sample_rate_set)(int sample_rate);
+int (*mbtk_rtp_channel_set)(int channel);
+/*rtp end*/
+
+
+#ifndef LOG_ERR_LEVEL
+#define LOG_ERR_LEVEL 3 /* error conditions */
+#endif
+#ifndef LOG_WARN_LEVEL
+#define LOG_WARN_LEVEL 4 /* warning conditions */
+#endif
+#ifndef LOG_INFO_LEVEL
+#define LOG_INFO_LEVEL 6 /* informational */
+#endif
+#ifndef LOG_DEBUG_LEVEL
+#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
+#endif
+#ifndef LOG_VERBOSE_LEVEL
+#define LOG_VERBOSE_LEVEL 8
+#endif
+
+#define GSW_VOICE "[HAL][GSW_VOICE]"
+
+#define LOGV(fmt, args ...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_VERBOSE_LEVEL, "%s#%s: "GSW_VOICE"" fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGI(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_INFO_LEVEL, "%s#%s: "GSW_VOICE"" fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGD(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_DEBUG_LEVEL, "%s#%s: "GSW_VOICE"" fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGW(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_WARN_LEVEL, "%s#%s: "GSW_VOICE"" fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+#define LOGE(fmt, args...) \
+ do{ \
+ char *file_ptr_1001 = __FILE__; \
+ char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
+ char line_1001[10] = {0}; \
+ sprintf(line_1001, "%d", __LINE__); \
+ while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
+ if(*ptr_1001 == '/') \
+ break; \
+ ptr_1001--; \
+ } \
+ mbtk_log(LOG_ERR_LEVEL, "%s#%s: "GSW_VOICE"" fmt, ptr_1001 + 1, line_1001, ##args); \
+ } while(0)
+
+static int mbtk_rtp_api_import()
+{
+ mbtk_rtp_init = (int (*)(void))dlsym(dlHandle_mbtk, "mbtk_rtp_init");
+ if (mbtk_rtp_init == NULL)
+ {
+ LOGE("mbtk_rtp_init dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_deinit = (int (*)(void))dlsym(dlHandle_mbtk, "mbtk_rtp_deinit");
+ if (mbtk_rtp_deinit == NULL)
+ {
+ LOGE("mbtk_rtp_deinit dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_enable = (int (*)(bool enable))dlsym(dlHandle_mbtk, "mbtk_rtp_enable");
+ if (mbtk_rtp_enable == NULL)
+ {
+ LOGE("mbtk_rtp_enable dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_remote_ip_set = (int (*)(const char *ipv4))dlsym(dlHandle_mbtk, "mbtk_rtp_remote_ip_set");
+ if (mbtk_rtp_remote_ip_set == NULL)
+ {
+ LOGE("mbtk_rtp_remote_ip_set dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_server_port_set = (int (*)(int port))dlsym(dlHandle_mbtk, "mbtk_rtp_server_port_set");
+ if (mbtk_rtp_server_port_set == NULL)
+ {
+ LOGE("mbtk_rtp_server_port_set dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_client_port_set = (int (*)(int port))dlsym(dlHandle_mbtk, "mbtk_rtp_client_port_set");
+ if (mbtk_rtp_client_port_set == NULL)
+ {
+ LOGE("mbtk_rtp_client_port_set dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_sample_rate_set = (int (*)(int sample_rate))dlsym(dlHandle_mbtk, "mbtk_rtp_sample_rate_set");
+ if (mbtk_rtp_sample_rate_set == NULL)
+ {
+ LOGE("mbtk_rtp_sample_rate_set dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_rtp_channel_set = (int (*)(int channel))dlsym(dlHandle_mbtk, "mbtk_rtp_channel_set");
+ if (mbtk_rtp_channel_set == NULL)
+ {
+ LOGE("mbtk_rtp_channel_set dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+
+static int mbtk_call_api_import()
+{
+ dlHandle_mbtk = dlopen(lib_mbtk_path, RTLD_NOW);
+ if (dlHandle_mbtk == NULL)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_log_init = (void (*)(char *path, char *tag))dlsym(dlHandle_mbtk, "mbtk_log_init");
+ if (mbtk_log_init == NULL)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_log = (void (*)(int level, const char *format, ...))dlsym(dlHandle_mbtk, "mbtk_log");
+ if (mbtk_log == NULL)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_info_handle_get = (mbtk_info_handle_t* (*)(void))dlsym(dlHandle_mbtk, "mbtk_info_handle_get");
+ if (mbtk_info_handle_get == NULL)
+ {
+ LOGE("mbtk_info_handle_get dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_state_change_cb_reg = (int (*)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb))dlsym(dlHandle_mbtk, "mbtk_call_state_change_cb_reg");
+ if(mbtk_call_state_change_cb_reg == NULL)
+ {
+ LOGE("mbtk_call_state_change_cb_reg dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_start = (int (*)(mbtk_info_handle_t* handle, char* phone_number))dlsym(dlHandle_mbtk, "mbtk_call_start");
+ if(mbtk_call_start == NULL)
+ {
+ LOGE("mbtk_call_start dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_answer = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_call_answer");
+ if(mbtk_call_answer == NULL)
+ {
+ LOGE("mbtk_call_answer dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_hang = (int (*)(mbtk_info_handle_t* handle))dlsym(dlHandle_mbtk, "mbtk_call_hang");
+ if(mbtk_call_hang == NULL)
+ {
+ LOGE("mbtk_call_hang dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_a_call_hang = (int (*)(mbtk_info_handle_t* handle, int phone_id))dlsym(dlHandle_mbtk, "mbtk_a_call_hang");
+ if(mbtk_a_call_hang == NULL)
+ {
+ LOGE("mbtk_a_call_hang dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_reg_get = (int (*)(mbtk_info_handle_t* handle, mbtk_call_info_t *reg))dlsym(dlHandle_mbtk, "mbtk_call_reg_get");
+ if(mbtk_call_reg_get == NULL)
+ {
+ LOGE("mbtk_call_reg_get dlsym fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ return mbtk_rtp_api_import();
+}
+
+static int end_reason_mbtk_to_gsw(char* mbtk_reason)
+{
+ LOGE("mbtk_reason:%s\n", mbtk_reason);
+ gsw_global_end_reason = GSW_OTHER_END_NORMAL;
+ for(int i = 0; 0 != strncmp(g_end_reason[i].mbtk_end_reason, MBTK_VOICE_END_REASON_END, strlen(MBTK_VOICE_END_REASON_END)); i++)
+ {
+ if(0 == strncmp(mbtk_reason, g_end_reason[i].mbtk_end_reason, strlen(g_end_reason[i].mbtk_end_reason)))
+ {
+ gsw_global_end_reason = g_end_reason[i].end_reason;
+ LOGE("gsw_global_end_reason:%d\n", gsw_global_end_reason);
+ break;
+ }
+ }
+
+ return 0;
+}
+
+void gsw_call_state_change_cb(const void *data, int data_len)
+{
+ mbtk_call_info_t *reg = (mbtk_call_info_t *)data;
+ switch (reg->call_wait)
+ {
+ case MBTK_CLCC:
+ {
+ LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d, end_reason:%s", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id, reg->end_reason);
+ switch(reg->state)
+ {
+ case 0:
+ state_t = GSW_VOICE_CALL_CONNECTED;
+ break;
+ case 1:
+ state_t = GSW_VOICE_CALL_HOLDING;
+ break;
+ case 2:
+ state_t = GSW_VOICE_CALL_DIALING;
+ break;
+ case 3:
+ state_t = GSW_VOICE_CALL_ALERTING;
+ break;
+ case 4:
+ state_t = GSW_VOICE_CALL_INCOMING;
+ break;
+ case 5:
+ state_t = GSW_VOICE_CALL_WAITING;
+ break;
+ case 6:
+ {
+ state_t = GSW_VOICE_CALL_END;
+ call_id_t = reg->dir1;
+ end_reason_mbtk_to_gsw((char *)reg->end_reason);
+ break;
+ }
+
+ }
+
+ if(gsw_voice_callback)
+ {
+ gsw_voice_callback(reg->dir1, state_t);
+ }
+
+ }
+ break;
+ case MBTK_DISCONNECTED:
+ {
+ LOGD("RING : call dis connected!");
+ LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d, end_reason:%s", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id, reg->end_reason);
+ state_t = GSW_VOICE_CALL_END;
+ call_id_t = reg->dir1;
+ end_reason_mbtk_to_gsw((char *)reg->end_reason);
+ if(gsw_voice_callback)
+ {
+ gsw_voice_callback(reg->disconnected_id, state_t);
+ }
+ }
+ break;
+ case MBTK_CPAS:
+ LOGD("CALL : Call state = %d", reg->pas);
+ switch (reg->pas)
+ {
+ case MBTK_CALL_RADY:
+ LOGD("CALL: call READY");
+ break;
+ case MBTK_CALL_UNAVAILABLE:
+ LOGD("CALL: call unavaliable");
+ break;
+ case MBTK_CALL_UNKNOWN:
+ LOGD("CALL: call unknown");
+ break;
+ case MBTK_CALL_RINGING:
+ LOGD("CALL: call ringing");
+ break;
+ case MBTK_CALL_PROGRESS:
+ LOGD("CALL: call progress");
+ break;
+ case MBTK_CALL_ASLEEP:
+ LOGD("CALL: call asleep");
+ break;
+ case MBTK_CALL_ACTIVE:
+ LOGD("CALL: call active");
+ break;
+ default:
+ //LOGE("\r\n");
+ break;
+ }
+ break;
+ default:
+ LOGE("RING : None call_wait = %d", reg->call_wait);
+ break;
+ }
+}
+
+
+/**
+* @brief init voice sdk,and register the status indicated callback function
+* @param [in] CallStateInd ind: status indicated callback function
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_sdk_init(CallStateInd ind)
+{
+ int ret;
+
+ if (gsw_voice_init_flag == 1 && call_info_handle != NULL)
+ {
+ return GSW_HAL_SUCCESS;
+ }
+
+ if(ind == NULL)
+ {
+ LOGE("parameter is null\n");
+ return GSW_HAL_ARG_INVALID;
+ }
+
+ ret = mbtk_call_api_import();
+ if(ret != 0)
+ {
+ if(mbtk_log != NULL)
+ {
+ LOGE("[gsw_voice_sdk_init]mbtk_call_api_import fail\n");
+ }
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_log_init("syslog", "MBTK_RIL");
+
+
+ if(ret < 0)
+ {
+ LOGE("mbtk_call_api_import fail,ret = %d\n",ret);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ ret=mbtk_rtp_init();
+
+ if(ret!=0)
+ {
+ LOGE("[gsw_voice_sdk_init]mbtk_rtp_init fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ if(call_info_handle == NULL)
+ {
+ call_info_handle = mbtk_info_handle_get();
+ if(call_info_handle != NULL)
+ {
+ LOGE("create gsw_voice_sdk_init success\n");
+
+ ret = mbtk_call_state_change_cb_reg(call_info_handle, gsw_call_state_change_cb);
+ if(ret)
+ {
+ LOGE("mbtk_call_state_change_cb_reg fail,ret = %d\n",ret);
+ (void) mbtk_rtp_deinit();
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ else
+ {
+ gsw_voice_init_flag = 1;
+ gsw_voice_callback = ind;
+ LOGE("create gsw_voice_sdk_init success\n");
+ return GSW_HAL_SUCCESS;
+ }
+
+ }
+
+ else
+ {
+ (void) mbtk_rtp_deinit();
+ LOGE("create gsw_voice_sdk_init fail\n");
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set speaker_volume
+* @param [in] int32_t volume：1(Min)-7(Max)
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_speaker_volume(int32_t volume)
+{
+ //UNUSED(volume);
+
+#if 0
+
+ if(volume < 0 || volume > 5)
+ {
+ level_call = 0;
+ }
+ else
+ {
+ //支持-36~12
+ switch(volume)
+ {
+ case 0 :
+ level_call = -20;
+ break;
+ case 1 :
+ level_call = -14;
+ break;
+ case 2 :
+ level_call = -8;
+ break;
+ case 3 :
+ level_call = 0;
+ break;
+ case 4 :
+ level_call = 5;
+ break;
+ case 5 :
+ level_call = 12;
+ break;
+ default:
+ break;
+ }
+ }
+
+ mbtk_audio_dsp_set(1, level_call);
+ if(err)
+ {
+ LOGE("Error : %d\n", err);
+ return -1;
+ }
+ else
+ {
+ LOGE("Set success.\n");
+ }
+#endif
+
+ char cmd[128] = {0};
+ int lv = 0;
+
+ memset(cmd ,0x00, sizeof(cmd));
+
+ if(volume < 1 || volume > 7)
+ {
+ LOGE("Error volume : %d", volume);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ else
+ {
+ switch(volume)
+ {
+ case 1 :
+ lv = -36;
+ break;
+ case 2 :
+ lv = -36;
+ break;
+ case 3 :
+ lv = -27;
+ break;
+ case 4 :
+ lv = -18;
+ break;
+ case 5 :
+ lv = -9;
+ break;
+ case 6 :
+ lv = 0;
+ break;
+ case 7:
+ lv = 12;
+ break;
+ default:
+ break;
+ }
+ }
+
+ sprintf(cmd, "ubus call audio_if config_dspgain \"{\'type\':%d,\'gain\':%d}\"", 1, lv);
+// sLOGE(cmd, "ubus call audio_if volume_set \'{\"param0\":%d}\'", lv);
+ int err = system(cmd);
+ if ((err != -1) && (err != 127))
+ {
+ LOGE("Set success.");
+ level_call = volume;
+ }
+ else
+ {
+ LOGE("Error : %d", err);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief start a voice call
+* @param [in] char *callNumber
+* @param [out] CallHandle *handle
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_normal_voice_start(CallHandle *handle, const char *callNumber)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ mbtk_call_info_t reg = {0};
+ int ret = -1;
+
+
+ if(handle == NULL)
+ {
+ LOGE("handle is null\n");
+ return GSW_HAL_ARG_INVALID;
+ }
+
+ if(callNumber == NULL)
+ {
+ LOGE("callNumber is null\n");
+ return GSW_HAL_ARG_INVALID;
+ }
+
+
+ ret = mbtk_call_start(call_info_handle, (char *)callNumber);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_start fail,ret = %d\n",ret);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ //get call id
+ mbtk_call_reg_get(call_info_handle, ®);
+ LOGE("call id = %d\n",reg.dir1);
+ *handle = reg.dir1;
+ LOGE("gsw_voice_normal_voice_start id = %d\n", (int)*handle);
+
+
+ return GSW_HAL_SUCCESS;
+
+}
+
+/**
+* @brief answer a voice call
+* @param [in] CallHandle handle
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_answer(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret = -1;
+
+
+ ret = mbtk_call_answer(call_info_handle);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_answer fail,ret = %d\n", ret);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_call_answer success\n");
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+
+/**
+* @brief hangup a voice call
+* @param [in] CallHandle handle
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_hangup(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret = -1;
+
+ ret = mbtk_a_call_hang(call_info_handle,handle);
+
+ if(ret != 0)
+ {
+ LOGE("mbtk_a_call_hang fail,ret = %d\n", ret);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_a_call_hang success\n");
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set auto answer mode
+* @param [in] int32_t mode:0-1, 0:NO(close auto answer), 1:YES(auto answer)
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_auto_answer_mode(int32_t mode)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ if(mode == 1)
+ {
+ int ret = -1;
+
+ ret = mbtk_call_answer(call_info_handle);
+ if(ret != 0)
+ {
+ LOGE("mbtk_call_answer fail,ret = %d\n", ret);
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ else
+ {
+ LOGE("mbtk_call_answer success\n");
+ }
+ }
+
+ return GSW_HAL_SUCCESS;
+}
+
+int32_t gsw_voice_get_current_call_end_reason(CallHandle handle)
+{
+ if(gsw_voice_init_flag == 0 || call_info_handle == NULL)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int reason = gsw_global_end_reason;
+
+ return reason;
+}
+
+
+
+/*##########################################rtp begin*/
+/**
+* @brief set audio mode
+* @param [in] AudioMode audioMode
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_audio_mode(AudioMode audioMode)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_enable(audioMode);
+ if(ret !=0 )
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp ip address of remote
+* @param [in] char *ip :ip address
+* @param [in] int32_t len: length
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_remote_rtp_ip(const char *ip, int32_t len)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_remote_ip_set(ip);
+ if(ret !=0 )
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp mode and port
+* @param [in] RTPMode rtpMode: rtp mode
+* @param [in] int32_t port:rtp port
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_rtp_port(RTPMode rtpMode, int32_t port)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret;
+ if(rtpMode==GSW_RTP_CLIENT)
+ {
+ ret = mbtk_rtp_client_port_set(port);
+ }
+ else
+ {
+ ret = mbtk_rtp_server_port_set(port);
+ }
+ if(ret !=0 )
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+
+/**
+* @brief set rtp mode and port
+* @param [in] int32_t clockRate: clock rate
+* @param [in] int32_t channel:channel
+* @param [in] int32_t latency:latency
+* @param [out] None
+* @retval GSW_HAL_SUCCESS\GSW_HAL_NORMAL_FAIL
+*/
+int32_t gsw_voice_set_rtp_param(int32_t clockRate, int32_t channel, int32_t latency)
+{
+ if(gsw_voice_init_flag == 0)
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+
+ int ret=mbtk_rtp_channel_set(channel);
+ if(ret==0)
+ {
+ ret=mbtk_rtp_sample_rate_set(clockRate);
+ }
+ if(ret !=0 )
+ {
+ return GSW_HAL_NORMAL_FAIL;
+ }
+ return GSW_HAL_SUCCESS;
+}
+/*##########################################rtp end*/
+