Gitiles
Code Review Sign In
192.168.1.100 / T108 / 68a94c9ae46b22f00260d3a9609d586c4ebffd98 / . / mbtk / libgsw_lib / gsw_ecall.c
blob: e2c6d8fac91e44ccc50a8bcf7e9620e09245c94d [file] [log] [blame]
b.liu68a94c92025-05-24 12:53:41 +0800[diff] [blame^]1#include <stdlib.h>
2#include <stdio.h>
3#include <string.h>
4#include <sys/stat.h>
5#include <sys/types.h>
6#include <unistd.h>
7#include <dlfcn.h>
8#include <stdint.h>
9
10#include <errno.h>
11#include <stdbool.h>
12#include <pthread.h>
13
14#include "gsw_ecall.h"
15
16#define RIL_MAX_NUMBER_LEN 40
17#define MBTK_ECALL_MSD_LEN_MAX 600
18
19#ifndef LOG_ERR_LEVEL
20#define LOG_ERR_LEVEL 3 /* error conditions */
21#endif
22#ifndef LOG_WARN_LEVEL
23#define LOG_WARN_LEVEL 4 /* warning conditions */
24#endif
25#ifndef LOG_INFO_LEVEL
26#define LOG_INFO_LEVEL 6 /* informational */
27#endif
28#ifndef LOG_DEBUG_LEVEL
29#define LOG_DEBUG_LEVEL 7 /* debug-level messages */
30#endif
31#ifndef LOG_VERBOSE_LEVEL
32#define LOG_VERBOSE_LEVEL 8
33#endif
34
35#define LOGV(fmt, args ...) \
36 do{ \
37 char *file_ptr_1001 = __FILE__; \
38 char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
39 char line_1001[10] = {0}; \
40 sprintf(line_1001, "%d", __LINE__); \
41 while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
42 if(*ptr_1001 == '/') \
43 break; \
44 ptr_1001--; \
45 } \
46 fun_ptr_log(LOG_VERBOSE_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
47 } while(0)
48
49#define LOGI(fmt, args...) \
50 do{ \
51 char *file_ptr_1001 = __FILE__; \
52 char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
53 char line_1001[10] = {0}; \
54 sprintf(line_1001, "%d", __LINE__); \
55 while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
56 if(*ptr_1001 == '/') \
57 break; \
58 ptr_1001--; \
59 } \
60 fun_ptr_log(LOG_INFO_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
61 } while(0)
62
63#define LOGD(fmt, args...) \
64 do{ \
65 char *file_ptr_1001 = __FILE__; \
66 char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
67 char line_1001[10] = {0}; \
68 sprintf(line_1001, "%d", __LINE__); \
69 while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
70 if(*ptr_1001 == '/') \
71 break; \
72 ptr_1001--; \
73 } \
74 fun_ptr_log(LOG_DEBUG_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
75 } while(0)
76
77#define LOGW(fmt, args...) \
78 do{ \
79 char *file_ptr_1001 = __FILE__; \
80 char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
81 char line_1001[10] = {0}; \
82 sprintf(line_1001, "%d", __LINE__); \
83 while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
84 if(*ptr_1001 == '/') \
85 break; \
86 ptr_1001--; \
87 } \
88 fun_ptr_log(LOG_WARN_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
89 } while(0)
90
91#define LOGE(fmt, args...) \
92 do{ \
93 char *file_ptr_1001 = __FILE__; \
94 char *ptr_1001 = file_ptr_1001 + strlen(file_ptr_1001) - 1; \
95 char line_1001[10] = {0}; \
96 sprintf(line_1001, "%d", __LINE__); \
97 while(ptr_1001 >= file_ptr_1001 && *ptr_1001){ \
98 if(*ptr_1001 == '/') \
99 break; \
100 ptr_1001--; \
101 } \
102 fun_ptr_log(LOG_ERR_LEVEL, "%s#%s: " fmt, ptr_1001 + 1, line_1001, ##args); \
103 } while(0)
104
105typedef void (*mbtk_log)(int level, const char *format,...);
106
107
108typedef unsigned int uint32;
109typedef unsigned char uint8;
110typedef unsigned short uint16;
111
112typedef enum {
113 MBTK_ECALL_URC_ID_ALACK = 0, // AL-ACK signal received (refer to : urc_data)
114 MBTK_ECALL_URC_ID_SYNC_LOST, // eIM lost synchronization with PSAP
115 // (A resynch occurs after the synchronization is lost.)
116 MBTK_ECALL_URC_ID_NACK, // NACK signal received
117 MBTK_ECALL_URC_ID_RESERVED_3,
118 MBTK_ECALL_URC_ID_RESERVED_4,
119 MBTK_ECALL_URC_ID_RESERVED_5, // 5
120 MBTK_ECALL_URC_ID_3GPP_FATAL, // eIM is terminated: fatal error (3GPP Abort function)
121 MBTK_ECALL_URC_ID_CALL_DROP, // eIM is terminated: call drop
122 MBTK_ECALL_URC_ID_GENERIC, // Generic error
123 MBTK_ECALL_URC_ID_MSD_REQ, // PSAP request MSD (Only for PULL modem)
124 MBTK_ECALL_URC_ID_MSD_SEND_START, // 10 : eIM starts sending MSD
125 MBTK_ECALL_URC_ID_INITIATION, // The eIM starts sending the Initiation signal (Only for PUSH modem).
126 // It also indicates that the call setup is completed.
127 MBTK_ECALL_URC_ID_SEND_MSD, // PUSH: SEND_MSD -> MSD_SEND_START
128 // PULL: SEND_MSD -> MSD_REQ -> MSD_SEND_START
129 MBTK_ECALL_URC_ID_SEND_MSD_FULL,// SEND MSD signal received too often, PSAP sync failure assumed
130 MBTK_ECALL_URC_ID_SYNCED_PSAP, // IVS eIM is synced with PSAP
131 MBTK_ECALL_URC_ID_SYNCED_PSAP_EIM, // 15: IVS eIM is synced with PSAP eIM
132 MBTK_ECALL_URC_ID_LLACK, // Link layer ACK received
133 MBTK_ECALL_URC_ID_HLACK, // Higher Layer ACK received (similar to AL-ACK (#0) but without data)
134 MBTK_ECALL_URC_ID_EIM_RESET, // The eIM transmitter idles after a full reset. The eIM transmitter is reset after sync loss
135 // (for example, because of the end of PSAP transmission).
136 MBTK_ECALL_URC_ID_EIM_IDLES, // The eIM transmitter idles after the transmission of the Initiation signal (push mode)
137 MBTK_ECALL_URC_ID_MSD_UPDATE, // 20 : MSD update request is received.
138 MBTK_ECALL_URC_ID_MSD_UPDATE_DONE, // MSD update is done.
139 MBTK_ECALL_URC_ID_MSD_UPDATE_ERR, // MSD update request cannot be processed.
140 MBTK_ECALL_URC_ID_T3_EXPIRED, // T3 expired
141 MBTK_ECALL_URC_ID_T5_EXPIRED, // T5 expired
142 MBTK_ECALL_URC_ID_T6_EXPIRED, // 25 : T6 expired
143 MBTK_ECALL_URC_ID_T7_EXPIRED, // T7 expired
144 MBTK_ECALL_URC_ID_TH_EXPIRED, // TH expired
145 MBTK_ECALL_URC_ID_RESERVED_28,
146 MBTK_ECALL_URC_ID_RESERVED_29,
147 MBTK_ECALL_URC_ID_RESERVED_30, // 30
148 MBTK_ECALL_URC_ID_IVS_EVENT_TIMEOUT,
149 MBTK_ECALL_URC_ID_PSAP_REQ, // Only for ERA
150 MBTK_ECALL_URC_ID_MSD_SEND_FAIL_FOR_NG // NG-eCall fail to transfer MSD
151} mbtk_ecall_urc_id_enum;
152
153typedef enum {
154 MBTK_CLCC = 1,
155 MBTK_CPAS,
156 MBTK_DISCONNECTED,
157} mbtk_call_enum;
158
159typedef enum {
160 MBTK_CALL_RADY, //MT allows commands from TA/TE
161 MBTK_CALL_UNAVAILABLE, //MT does not allow commands from TA/TE
162 MBTK_CALL_UNKNOWN, //MT is not guaranteed to respond to instructions
163 MBTK_CALL_RINGING, //MT is ready for commands from TA/TE, but the ringer is active
164 MBTK_CALL_PROGRESS, //MT is ready for commands from TA/TE, but a call is in progress
165 MBTK_CALL_ASLEEP, //MT is unable to process commands from TA/TE because it is in a low functionality state
166 MBTK_CALL_ACTIVE,
167} mbtk_call_pas_enum;
168
169#define MBTK_ECALL_CFG_T3 (1 << MBTK_ECALL_CFG_ITEM_T3) // ms
170#define MBTK_ECALL_CFG_T5 (1 << MBTK_ECALL_CFG_ITEM_T5) // ms
171#define MBTK_ECALL_CFG_T6 (1 << MBTK_ECALL_CFG_ITEM_T6) // ms
172#define MBTK_ECALL_CFG_T7 (1 << MBTK_ECALL_CFG_ITEM_T7) // ms
173#define MBTK_ECALL_CFG_TH (1 << MBTK_ECALL_CFG_ITEM_TH) // ms
174#define MBTK_ECALL_CFG_TIMER_CALLBACK (1 << MBTK_ECALL_CFG_ITEM_TIMER_CALLBACK) // T9
175#define MBTK_ECALL_CFG_TIMER_CLEARDOWN (1 << MBTK_ECALL_CFG_ITEM_TIMER_CLEARDOWN) // T2
176#define MBTK_ECALL_CFG_TIMER_DEREG (1 << MBTK_ECALL_CFG_ITEM_TIMER_DEREG) // T10
177#define MBTK_ECALL_CFG_TIMER_DIAL (1 << MBTK_ECALL_CFG_ITEM_TIMER_DIAL) // "dial"
178#define MBTK_ECALL_CFG_TIMER_REDIAL (1 << MBTK_ECALL_CFG_ITEM_TIMER_REDIAL) // "redialtmr"
179#define MBTK_ECALL_CFG_TIMER_SMS (1 << MBTK_ECALL_CFG_ITEM_TIMER_SMS) // "sms" // 10
180#define MBTK_ECALL_CFG_REDIALCNT (1 << MBTK_ECALL_CFG_ITEM_REDIALCNT) // "redialcnt"
181#define MBTK_ECALL_CFG_SMSPROCESS (1 << MBTK_ECALL_CFG_ITEM_SMSPROCESS) // "smsprocess"
182#define MBTK_ECALL_CFG_SMSMSDCNT (1 << MBTK_ECALL_CFG_ITEM_SMSMSDCNT) // "smsmsdcnt"
183
184
185typedef void (*mbtk_info_callback_func)(const void* data, int data_len);
186
187typedef struct
188{
189 int client_fd;
190 pthread_t read_thread_id;
191 int exit_fd[2];
192 bool is_waitting;
193 pthread_cond_t cond;
194 pthread_mutex_t mutex;
195
196 pthread_mutex_t send_mutex;
197
198 // Temp response data.
199 uint16 info_err;
200 uint16 data_len;
201 void *data;
202
203 //mbtk wyq for server_ready_status add start
204 char server_ready_status;
205 //mbtk wyq for server_ready_status add end
206
207 mbtk_info_callback_func net_state_cb;
208 mbtk_info_callback_func call_state_cb;
209 mbtk_info_callback_func sms_state_cb;
210 mbtk_info_callback_func radio_state_cb;
211 mbtk_info_callback_func sim_state_cb;
212 mbtk_info_callback_func pdp_state_cb;
213 //add signal by xr
214 mbtk_info_callback_func signal_state_cb;
215} mbtk_info_handle_t;
216
217typedef enum {
218 MBTK_ECALL_CFG_ITEM_T3 = 0, // ms
219 MBTK_ECALL_CFG_ITEM_T5, // ms
220 MBTK_ECALL_CFG_ITEM_T6, // ms
221 MBTK_ECALL_CFG_ITEM_T7, // ms
222 MBTK_ECALL_CFG_ITEM_TH, // ms
223 MBTK_ECALL_CFG_ITEM_TIMER_CALLBACK, // T9 // 5
224 MBTK_ECALL_CFG_ITEM_TIMER_CLEARDOWN, // T2
225 MBTK_ECALL_CFG_ITEM_TIMER_DEREG, // T10
226 MBTK_ECALL_CFG_ITEM_TIMER_DIAL, // "dial"
227 MBTK_ECALL_CFG_ITEM_TIMER_REDIAL, // "redialtmr"
228 MBTK_ECALL_CFG_ITEM_TIMER_SMS, // "sms" // 10
229 MBTK_ECALL_CFG_ITEM_REDIALCNT, // "redialcnt"
230 MBTK_ECALL_CFG_ITEM_SMSPROCESS, // "smsprocess"
231 MBTK_ECALL_CFG_ITEM_SMSMSDCNT, // "smsmsdcnt"
232
233 MBTK_ECALL_CFG_ITEM_MAX
234} mbtk_ecall_cfg_item_enum;
235
236
237typedef enum {
238 MBTK_ECALL_MSD_ITEM_VERSION = 0,
239 MBTK_ECALL_MSD_ITEM_MSG_ID,
240 MBTK_ECALL_MSD_ITEM_CONTROLTYPE,
241 MBTK_ECALL_MSD_ITEM_VIN,
242 MBTK_ECALL_MSD_ITEM_STORAGETYPE,
243 MBTK_ECALL_MSD_ITEM_TIMESTAMP,
244 MBTK_ECALL_MSD_ITEM_LOCATION,
245 MBTK_ECALL_MSD_ITEM_DIRECTION,
246 MBTK_ECALL_MSD_ITEM_LOCATIONN1,
247 MBTK_ECALL_MSD_ITEM_LOCATIONN2,
248 MBTK_ECALL_MSD_ITEM_NUMBEROFOCCUPANTS,
249 MBTK_ECALL_MSD_ITEM_ADDITIONALDATA,
250 MBTK_ECALL_MSD_ITEM_ALL_IN_ONE,
251 MBTK_ECALL_MSD_ITEM_ASI,
252 MBTK_ECALL_MSD_ITEM_VEHICLE_DIAGNOSTIC,
253 MBTK_ECALL_MSD_ITEM_CRASH_INFO,
254 MBTK_ECALL_MSD_ITEM_GNSS_TYPE
255} mbtk_ecall_msd_item_enum;
256
257typedef enum {
258 MBTK_ECALL_ONLY_TYPE_DISABLE = 0,
259 MBTK_ECALL_ONLY_TYPE_ENABLE_ECALL,
260 MBTK_ECALL_ONLY_TYPE_ENABLE_NG_ECALL,
261 MBTK_ECALL_ONLY_TYPE_ENABLE_ALL,
262 MBTK_ECALL_ONLY_TYPE_CONF_NUM,
263 MBTK_ECALL_ONLY_TYPE_NORMAL
264} mbtk_ecall_only_type_enum;
265
266typedef struct
267{
268 mbtk_ecall_msd_item_enum item_type;
269
270 uint8 data[64];
271} mbtk_ecall_msd_cfg_info_t;
272
273typedef enum {
274 MBTK_ECALL_SIM_TYPE_NO_SUPPORT = 0,
275 MBTK_ECALL_SIM_TYPE_SUPPORT_ECALL,
276 MBTK_ECALL_SIM_TYPE_SUPPORT_ECALL_ONLY
277} mbtk_ecall_sim_type_enum;
278
279
280typedef struct {
281 mbtk_ecall_only_type_enum active : 8;
282 mbtk_ecall_sim_type_enum sim_type : 8; // Only for GET.
283 uint8 test_num[RIL_MAX_NUMBER_LEN];
284 uint8 reconfig_num[RIL_MAX_NUMBER_LEN];
285} mbtk_ecall_only_info_t;
286
287typedef enum {
288 MBTK_ECALL_MODE_TYPE_EU = 0,
289 MBTK_ECALL_MODE_TYPE_ERA
290} mbtk_ecall_mode_type_enum;
291
292
293typedef enum {
294 MBTK_ECALL_DIAL_TYPE_TEST = 0,
295 MBTK_ECALL_DIAL_TYPE_RECONFIG,
296 MBTK_ECALL_DIAL_TYPE_MANUALLY,
297 MBTK_ECALL_DIAL_TYPE_AUTO,
298 MBTK_ECALL_DIAL_TYPE_NOT_ACTIVATED,
299 MBTK_ECALL_DIAL_TYPE_RELEASE
300} mbtk_ecall_dial_type_enum;
301
302typedef struct {
303 uint32 type; // mbtk_ecall_cfg_item_enum
304
305#if 0
306 uint32 timer_t3; // ms
307 uint32 timer_t5; // ms
308 uint32 timer_t6; // ms
309 uint32 timer_t7; // ms
310 uint32 timer_th; // ms
311
312 uint32 timer_callback; // s (T9)
313 uint32 timer_cleardown; // s (T2)
314 uint32 timer_dereg; // s (T10)
315 uint32 timer_dial; // s
316 uint32 timer_redialtmr; // s
317 uint32 timer_sms; // s
318
319 uint32 redialcnt;
320 uint32 smsprocess;
321 uint32 smsmsdcnt;
322#else
323 uint8 data_valid[MBTK_ECALL_CFG_ITEM_MAX];
324 uint32 data[MBTK_ECALL_CFG_ITEM_MAX];
325#endif
326} mbtk_ecall_cfg_info_t;
327
328
329typedef struct
330{
331 uint8 urc_id;
332 uint8 urc_data[5];
333} mbtk_ril_ecall_state_info_t;
334
335
336typedef mbtk_info_handle_t* (*mbtk_info_handle_get)(void);
337static mbtk_info_handle_get mbtk_info_handle_get_ptr = NULL;
338
339typedef int (*mbtk_info_handle_free)(mbtk_info_handle_t** handle);
340static mbtk_info_handle_free mbtk_info_handle_free_ptr = NULL;
341
342static gsw_eu_ecall_status_cb_f gsw_eu_ecall_status_cb;
343
344static pthread_t gsw_ecall_status_cb_thread;
345static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
346static pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
347static bool g_thread_running = false;
348
349static uint32_t g_sta_cb_id = 0;
350static gsw_eu_ecall_msd_trans_status_e g_msd_send_status = 0;
351
352#define LIB_PATH "/lib/libmbtk_lib.so"
353
354
355
356
357
358
359typedef int (*mbtk_ecall_msd_set)(mbtk_info_handle_t* handle, const void* msd);
360static mbtk_ecall_msd_set mbtk_ecall_msd_set_ptr = NULL;
361
362typedef int (*mbtk_ecall_push)(mbtk_info_handle_t* handle);
363static mbtk_ecall_push mbtk_ecall_push_ptr = NULL;
364
365typedef int (*mbtk_ecall_only_set)(mbtk_info_handle_t* handle, const mbtk_ecall_only_info_t* info);
366static mbtk_ecall_only_set mbtk_ecall_only_set_ptr = NULL;
367
368
369typedef int (*mbtk_ecall_reg_set)(mbtk_info_handle_t* handle, int reg);
370static mbtk_ecall_reg_set mbtk_ecall_reg_set_ptr = NULL;
371
372typedef int (*mbtk_ecall_dial_start)(mbtk_info_handle_t* handle, mbtk_ecall_dial_type_enum type);
373static mbtk_ecall_dial_start mbtk_ecall_dial_start_ptr = NULL;
374
375typedef int (*mbtk_ecall_mode_set)(mbtk_info_handle_t* handle, mbtk_ecall_mode_type_enum mode);
376static mbtk_ecall_mode_set mbtk_ecall_mode_set_ptr = NULL;
377
378
379typedef int (*mbtk_ecall_cfg_set)(mbtk_info_handle_t* handle, const mbtk_ecall_cfg_info_t *cfg);
380static mbtk_ecall_cfg_set mbtk_ecall_cfg_set_ptr = NULL;
381
382typedef int (*mbtk_ecall_cfg_get)(mbtk_info_handle_t* handle, mbtk_ecall_cfg_info_t* cfg);
383static mbtk_ecall_cfg_get mbtk_ecall_cfg_get_ptr = NULL;
384
385typedef int (*mbtk_ecall_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
386static mbtk_ecall_state_change_cb_reg mbtk_ecall_state_change_cb_reg_ptr = NULL;
387
388typedef int (*mbtk_call_state_change_cb_reg)(mbtk_info_handle_t* handle, mbtk_info_callback_func cb);
389static mbtk_call_state_change_cb_reg mbtk_call_state_change_cb_reg_ptr = NULL;
390
391
392
393static int state_t = -1;
394
395
396
397typedef struct
398{
399 uint8 call_wait;
400 uint8 dir1;
401 uint8 dir;
402 uint8 state;
403 uint8 mode;
404 uint8 mpty;
405 char phone_number[100];
406 uint8 type;
407 uint8 pas;
408 uint8 disconnected_id;
409 uint8 end_reason[128];
410} __attribute__((packed)) mbtk_call_info_t;
411
412
413//static mbtk_info_handle_t* ecall_info_handle = NULL;
414
415
416typedef void (*mbtk_log_init)(char *path, char *tag);
417static mbtk_log_init mbtk_log_init_ptr = NULL;
418
419static void *handle = NULL;
420typedef void (*mbtk_log)(int level, const char *format,...);
421static mbtk_log fun_ptr_log = NULL;
422static int ecall_init_flag = 0;
423static mbtk_info_handle_t* ecall_info_handle = NULL;
424
425
426
427static uint8_t fail_redial = 1;
428
429static gsw_eu_ecall_event_cb_f gsw_eu_ecall_event_cb = NULL;
430static bool g_setevent_cb = false;
431
432static void mbtk_send_singnal()
433{
434 pthread_mutex_lock(&g_mutex);
435 pthread_cond_signal(&g_cond);
436 pthread_mutex_unlock(&g_mutex);
437
438}
439
440static void mbtk_wait_signal()
441{
442
443 pthread_mutex_lock(&g_mutex);
444 pthread_cond_wait(&g_cond, &g_mutex);
445 pthread_mutex_unlock(&g_mutex);
446}
447
448static void mbtk_ecall_api_ptr_deinit()
449{
450 dlclose(handle);
451 handle = NULL;
452 mbtk_log_init_ptr = NULL;
453 mbtk_info_handle_get_ptr=NULL;
454 mbtk_info_handle_free_ptr=NULL;
455 mbtk_ecall_msd_set_ptr=NULL;
456 mbtk_ecall_push_ptr=NULL;
457 mbtk_ecall_only_set_ptr=NULL;
458 mbtk_ecall_reg_set_ptr=NULL;
459 mbtk_ecall_dial_start_ptr=NULL;
460 mbtk_ecall_mode_set_ptr=NULL;
461 mbtk_ecall_cfg_set_ptr=NULL;
462 mbtk_ecall_cfg_get_ptr=NULL;
463 mbtk_ecall_state_change_cb_reg_ptr=NULL;
464 gsw_eu_ecall_status_cb=NULL;
465 gsw_eu_ecall_event_cb=NULL;
466 g_setevent_cb=false;
467 mbtk_ecall_only_set_ptr = NULL;
468 fun_ptr_log=NULL;
469
470}
471
472
473static int mbtk_ecall_api_import()
474{
475 handle = dlopen(LIB_PATH, RTLD_NOW);
476 if (handle == NULL)
477 {
478 return GSW_HAL_FAIL;
479 }
480
481 if(fun_ptr_log == NULL)
482 {
483 fun_ptr_log = (mbtk_log)dlsym(handle, "mbtk_log");
484 if(fun_ptr_log == NULL)
485 {
486 return GSW_HAL_FAIL;
487 }
488 }
489
490 if(mbtk_log_init_ptr == NULL)
491 {
492 mbtk_log_init_ptr = (mbtk_log_init)dlsym(handle, "mbtk_log_init");
493 if(mbtk_log_init_ptr == NULL)
494 {
495 return GSW_HAL_FAIL;
496 }
497 }
498
499 if(mbtk_info_handle_get_ptr == NULL)
500 {
501 mbtk_info_handle_get_ptr = (mbtk_info_handle_get)dlsym(handle, "mbtk_info_handle_get");
502 if(mbtk_info_handle_get_ptr == NULL)
503 {
504 return GSW_HAL_FAIL;
505 }
506 }
507
508 if(mbtk_info_handle_free_ptr == NULL)
509 {
510 mbtk_info_handle_free_ptr = (mbtk_info_handle_free)dlsym(handle, "mbtk_info_handle_free");
511 if(mbtk_info_handle_free_ptr == NULL)
512 {
513 return GSW_HAL_FAIL;
514 }
515 }
516
517
518
519 if(mbtk_ecall_msd_set_ptr == NULL)
520 {
521 mbtk_ecall_msd_set_ptr = (mbtk_ecall_msd_set)dlsym(handle, "mbtk_ecall_msd_set");
522 if(mbtk_ecall_msd_set_ptr == NULL)
523 {
524 return GSW_HAL_FAIL;
525 }
526 }
527
528 if(mbtk_ecall_push_ptr == NULL)
529 {
530 mbtk_ecall_push_ptr = (mbtk_ecall_push)dlsym(handle, "mbtk_ecall_push");
531 if(mbtk_ecall_push_ptr == NULL)
532 {
533 return GSW_HAL_FAIL;
534 }
535 }
536 if(mbtk_ecall_only_set_ptr == NULL)
537 {
538 mbtk_ecall_only_set_ptr = (mbtk_ecall_only_set)dlsym(handle, "mbtk_ecall_only_set");
539 if(mbtk_ecall_only_set_ptr == NULL)
540 {
541 return GSW_HAL_FAIL;
542 }
543 }
544
545 if(mbtk_ecall_reg_set_ptr == NULL)
546 {
547 mbtk_ecall_reg_set_ptr = (mbtk_ecall_reg_set)dlsym(handle, "mbtk_ecall_reg_set");
548 if(mbtk_ecall_reg_set_ptr == NULL)
549 {
550 return GSW_HAL_FAIL;
551 }
552 }
553 if(mbtk_ecall_dial_start_ptr == NULL)
554 {
555 mbtk_ecall_dial_start_ptr = (mbtk_ecall_dial_start)dlsym(handle, "mbtk_ecall_dial_start");
556 if(mbtk_ecall_dial_start_ptr == NULL)
557 {
558 return GSW_HAL_FAIL;
559 }
560 }
561
562 if(mbtk_ecall_mode_set_ptr == NULL)
563 {
564 mbtk_ecall_mode_set_ptr = (mbtk_ecall_mode_set)dlsym(handle, "mbtk_ecall_mode_set");
565 if(mbtk_ecall_mode_set_ptr == NULL)
566 {
567 return GSW_HAL_FAIL;
568 }
569 }
570
571 if(mbtk_ecall_cfg_set_ptr == NULL)
572 {
573 mbtk_ecall_cfg_set_ptr = (mbtk_ecall_cfg_set)dlsym(handle, "mbtk_ecall_cfg_set");
574 if(mbtk_ecall_cfg_set_ptr == NULL)
575 {
576 return GSW_HAL_FAIL;
577 }
578 }
579 if(mbtk_ecall_cfg_get_ptr == NULL)
580 {
581 mbtk_ecall_cfg_get_ptr = (mbtk_ecall_cfg_get)dlsym(handle, "mbtk_ecall_cfg_get");
582 if(mbtk_ecall_cfg_get_ptr == NULL)
583 {
584 return GSW_HAL_FAIL;
585 }
586 }
587 if(mbtk_ecall_state_change_cb_reg_ptr == NULL)
588 {
589 mbtk_ecall_state_change_cb_reg_ptr = (mbtk_ecall_state_change_cb_reg)dlsym(handle, "mbtk_ecall_state_change_cb_reg");
590 if(mbtk_ecall_state_change_cb_reg_ptr == NULL)
591 {
592 return GSW_HAL_FAIL;
593 }
594 }
595
596 if(mbtk_call_state_change_cb_reg_ptr == NULL)
597 {
598 mbtk_call_state_change_cb_reg_ptr = (mbtk_call_state_change_cb_reg)dlsym(handle, "mbtk_call_state_change_cb_reg");
599 if(mbtk_call_state_change_cb_reg_ptr == NULL)
600 {
601 return GSW_HAL_FAIL;
602 }
603 }
604
605 return GSW_HAL_SUCCESS;
606}
607
608
609static void gsw_call_state_change_cb(const void *data, int data_len)
610{
611 mbtk_call_info_t *reg = (mbtk_call_info_t *)data;
612 switch (reg->call_wait)
613 {
614 case MBTK_CLCC:
615 {
616 LOGD("RING : %d, %d, %d, %d, %d, %s, %d, %d", reg->dir1, reg->dir, reg->state, reg->mode, reg->mpty, reg->phone_number, reg->type, reg->disconnected_id);
617 switch(reg->state)
618 {
619 case 0:
620 state_t = 0;
621 LOGD("reg->state = GSW_VOICE_CALL_CONNECTED ");
622 break;
623 case 1:
624 //state_t = GSW_VOICE_CALL_HOLDING;
625 LOGD("reg->state = GSW_VOICE_CALL_HOLDING ");
626 break;
627 case 2:
628 //state_t = GSW_VOICE_CALL_DIALING;
629 LOGD("reg->state = GSW_VOICE_CALL_DIALING ");
630 break;
631 case 3:
632 //state_t = GSW_VOICE_CALL_ALERTING;
633 LOGD("reg->state = GSW_VOICE_CALL_ALERTING ");
634 break;
635 case 4:
636 //state_t = GSW_VOICE_CALL_INCOMING;
637
638 LOGD("reg->state = GSW_VOICE_CALL_INCOMING ");
639 break;
640 case 5:
641 //state_t = GSW_VOICE_CALL_WAITING;
642 LOGD("reg->state = GSW_VOICE_CALL_WAITING ");
643 break;
644 case 6:
645 //state_t = GSW_VOICE_CALL_END;
646 LOGD("reg->state = GSW_VOICE_CALL_END ");
647 break;
648 }
649
650 g_sta_cb_id = reg->dir1;
651 }
652
653 break;
654 default:
655 LOGE("RING : None call_wait = %d", reg->call_wait);
656 break;
657 }
658}
659
660
661/**
662* @brief init the Europe Ecall voice
663* @param [in] None
664* @param [out] None
665* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
666*/
667
668int32_t gsw_eu_ecall_voice_init(void)
669{
670 int ret =-1;
671 ret = mbtk_ecall_api_import();
672 if(ret <0)
673 {
674 return GSW_HAL_FAIL;
675 }
676
677 mbtk_log_init_ptr("syslog", "GSW_ECALL");
678
679 ecall_info_handle = mbtk_info_handle_get_ptr();
680 if(ecall_info_handle == NULL)
681 {
682 LOGE("mbtk_info_handle_get_ptr fail!!!");
683 return GSW_HAL_FAIL;
684 }
685
686 if(ecall_init_flag == 0)
687 {
688 ecall_init_flag = 1;
689 }
690 ret = mbtk_call_state_change_cb_reg_ptr(ecall_info_handle, gsw_call_state_change_cb);
691 if(ret < 0)
692 {
693 LOGE("mbtk_call_state_change_cb_reg_ptr failed");
694 return GSW_HAL_FAIL;
695 }
696 return GSW_HAL_SUCCESS;
697
698}
699
700
701/**
702* @brief deinit the Europe Ecall voice
703* @param [in] None
704* @param [out] None
705* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
706*/
707int32_t gsw_eu_ecall_voice_deinit(void)
708{
709 int ret = -1;
710 if(ecall_info_handle == NULL || ecall_init_flag ==0)
711 {
712 LOGE("No init can not deinit");
713 return GSW_HAL_FAIL;
714 }
715
716 g_thread_running = false;
717 mbtk_send_singnal();
718 if (gsw_ecall_status_cb_thread != 0)
719 {
720 pthread_cancel(gsw_ecall_status_cb_thread);
721 pthread_join(gsw_ecall_status_cb_thread, NULL);
722 gsw_ecall_status_cb_thread = 0;
723 }
724
725 ret = mbtk_info_handle_free_ptr(&ecall_info_handle);
726 if(ret < 0 )
727 {
728 LOGE("mbtk_info_handle_free handle faile");
729 }
730 ecall_info_handle = NULL;
731 ecall_init_flag = 0;
732
733 mbtk_ecall_api_ptr_deinit();
734 return GSW_HAL_SUCCESS;
735
736}
737
738
739/**
740* @brief start a Europe Ecall
741* @param [in] gsw_eu_ecall_info_t *p_info: ecall info
742* @param [out] None
743* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
744*/
745int32_t gsw_eu_ecall_start(gsw_eu_ecall_info_t *p_info)
746{
747 int ret = -1;
748 mbtk_ecall_dial_type_enum ecall_type= -1;
749 mbtk_ecall_only_info_t only_info;
750
751
752 char tmp_number[GSW_EU_ECALL_MAX_PHONE_NUMBER] = {0};
753
754 char msd_data[500] = {0};
755
756 memset(&only_info, 0, sizeof(mbtk_ecall_only_info_t));
757
758 if(ecall_init_flag !=1)
759 {
760 return GSW_HAL_FAIL;
761 }
762
763 if(p_info == NULL || p_info->msd_len > GSW_EU_ECALL_MAX_MSD )
764 {
765 return GSW_HAL_FAIL;
766 }
767
768
769 if(p_info->type == GSW_EU_ECALL_TYPE_TEST)
770 {
771 //AT+CECALL =0
772 ecall_type = MBTK_ECALL_DIAL_TYPE_TEST;
773 snprintf(tmp_number,sizeof(tmp_number),"%s",p_info->ecall_number);
774 strncpy((char *)only_info.test_num,tmp_number,RIL_MAX_NUMBER_LEN);
775 //snprintf((char*)only_info.test_num,sizeof(only_info.test_num),"%s",p_info->ecall_number);
776 }
777
778 if(p_info->type == GSW_EU_ECALL_TYPE_RECONFIG )
779 {
780 //AT+CECALL =1
781 ecall_type = MBTK_ECALL_DIAL_TYPE_RECONFIG;
782 snprintf(tmp_number,sizeof(tmp_number),"%s",p_info->ecall_number);
783 strncpy((char *)only_info.test_num,tmp_number,RIL_MAX_NUMBER_LEN);
784 }
785
786 if(p_info->type == GSW_EU_ECALL_TYPE_EMERGENCY )
787 {
788 if(p_info->auto_trigger)
789 {
790 //AT+CECALL =1
791 ecall_type = MBTK_ECALL_DIAL_TYPE_AUTO;
792 }
793 else
794 {
795 //AT+CECALL =1
796 ecall_type = MBTK_ECALL_DIAL_TYPE_MANUALLY;//手动
797 }
798
799 }
800
801 //msd
802 for (int i = 0; i < p_info->msd_len; i++)
803 {
804 sprintf(msd_data + (i * 2), "%02x", p_info->msd[i]);
805 }
806
807 //
808 only_info.active = MBTK_ECALL_ONLY_TYPE_DISABLE ;
809
810 ret=mbtk_ecall_only_set_ptr(ecall_info_handle,&only_info);
811 if (ret != 0)
812 {
813 LOGE("mbtk_ecall_only_set_success failed");
814 return GSW_HAL_FAIL;
815 }
816
817 //set msd
818 ret= mbtk_ecall_msd_set_ptr(ecall_info_handle,(const void*)msd_data);
819 if (ret != 0)
820 {
821 LOGE("mbtk_ecall_msd_set_ptr failed");
822 return GSW_HAL_FAIL;
823 }
824
825 //dial
826 ret= mbtk_ecall_dial_start_ptr(ecall_info_handle,ecall_type);
827 if (ret != 0)
828 {
829 LOGE("mbtk_ecall_dial_start_ptr failed");
830 return GSW_HAL_FAIL;
831 }
832
833 //push mst
834 ret= mbtk_ecall_push_ptr(ecall_info_handle);
835 if (ret != 0)
836 {
837 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
838 mbtk_send_singnal();
839 LOGE("mbtk_ecall_push_ptr failed");
840 return GSW_HAL_FAIL;
841 }
842
843 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
844 mbtk_send_singnal();
845 return GSW_HAL_SUCCESS;
846
847}
848
849
850/**
851* @brief hangup a Europe Ecall
852* @param [in] None
853* @param [out] None
854* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
855*/
856int32_t gsw_eu_ecall_hangup(void)
857{
858 int32_t ret = -1;
859 if(ecall_info_handle == NULL)
860 {
861 return GSW_HAL_FAIL;
862 }
863
864 ret = mbtk_ecall_dial_start_ptr(ecall_info_handle,MBTK_ECALL_DIAL_TYPE_RELEASE);
865 if(ret != 0)
866 {
867 LOGE("hangup ecall faile ");
868 return GSW_HAL_FAIL;
869 }
870
871 return GSW_HAL_SUCCESS;
872}
873
874/**
875* @brief using push mode send msd data
876* @param [in] GSW_EU_ECALL_STATE_E state: ecall state
877* @param [out] None
878* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
879*/
880
881int32_t gsw_eu_ecall_updateMsd(const uint8_t *msd, uint32_t msd_len)
882{
883 int ret = -1;
884 char msd_data[500] = {0};
885
886 if(msd == NULL || msd_len == 0 ||ecall_info_handle == NULL)
887 {
888 return GSW_HAL_MEM_INVAILD;
889 }
890
891 //msd
892 for (int i = 0; i < msd_len; i++)
893 {
894 sprintf(msd_data + i * 2, "%02x", *(msd + i));
895 }
896 ret = mbtk_ecall_msd_set_ptr(ecall_info_handle,(const void*)msd_data);
897 if (ret != 0)
898 {
899 LOGE("mbtk_ecall_msd_get_ptr failed");
900 return GSW_HAL_FAIL;
901 }
902 return GSW_HAL_SUCCESS;
903
904}
905
906
907int32_t gsw_eu_ecall_pushMsd(gsw_eu_ecall_state_e state)
908{
909 int ret = -1;
910 if(ecall_info_handle == NULL)
911 {
912 return GSW_HAL_FAIL;
913 }
914
915 ret = mbtk_ecall_push_ptr(ecall_info_handle);
916 if(ret != 0)
917 {
918 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
919 mbtk_send_singnal();
920 return GSW_HAL_FAIL;
921 }
922 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
923 mbtk_send_singnal();
924 return GSW_HAL_SUCCESS;
925
926
927}
928
929/**
930* @brief get ecall config
931* @param [in] None
932* @param [out] gsw_eu_ecall_config_t *p_config: ecall config
933* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
934*/
935int32_t gsw_eu_ecall_getConfig(gsw_eu_ecall_config_t *p_config)
936{
937
938 if(ecall_info_handle==NULL || p_config == NULL)
939 {
940 LOGE("mbtk_ecall_cfg_get() fail.");
941 return GSW_HAL_MEM_INVAILD;
942 }
943
944 p_config->fail_redial = fail_redial;
945
946 return GSW_HAL_SUCCESS;
947}
948
949/**
950* @brief set ecall config
951* @param [in] int32_t item: config item
952* @param [in] gsw_eu_ecall_config_t *p_config: config info
953* @param [out] None
954* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
955*/
956
957int32_t gsw_eu_ecall_setConfig(int32_t item, gsw_eu_ecall_config_t *p_config)
958{
959 if(ecall_info_handle == NULL || p_config == NULL)
960 {
961 LOGE("gsw_eu_ecall_setConfig no init");
962 return GSW_HAL_MEM_INVAILD;
963 }
964
965 mbtk_ecall_cfg_info_t cfg_info = {0};
966
967 int ret =-1;
968 cfg_info.type = 0;
969
970 if(item & GSW_EU_ECALL_CONFIG_FAIL_REDIAL)
971 {
972 fail_redial = p_config->fail_redial;
973 if(p_config->fail_redial)
974 {
975 cfg_info.type |= MBTK_ECALL_CFG_TIMER_DIAL;
976 cfg_info.data[MBTK_ECALL_CFG_ITEM_TIMER_DIAL] = 60000;//timer 60s
977
978 }
979 else
980 {
981 cfg_info.type |= MBTK_ECALL_CFG_TIMER_DIAL;
982 cfg_info.data[MBTK_ECALL_CFG_ITEM_TIMER_DIAL] = 0;
983 }
984 }
985
986 ret = mbtk_ecall_cfg_set_ptr(ecall_info_handle, &cfg_info);
987 if (ret < 0)
988 {
989 LOGE("mbtk_ecall_cfg_set_ptr fail");
990 return GSW_HAL_FAIL;
991 }
992 return GSW_HAL_SUCCESS;
993
994}
995
996
997
998static void mbtk_ecall_state_change_cb(const void* data, int data_len)
999{
1000 static gsw_eu_ecall_event_t event;
1001 if(data)
1002 {
1003 mbtk_ril_ecall_state_info_t *ecall_data = (mbtk_ril_ecall_state_info_t*)data;
1004 switch(ecall_data->urc_id)
1005 {
1006 case MBTK_ECALL_URC_ID_MSD_REQ:
1007 {
1008 LOGD("MBTK_ECALL_URC_ID_MSD_REQ");
1009 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_START_RECEIVED_MSD;
1010 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_PSAP_REQURE_UPDATE_MSD;
1011 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1012 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
1013 break;
1014 }
1015 case MBTK_ECALL_URC_ID_MSD_SEND_START:
1016 {
1017 LOGD("MBTK_ECALL_URC_ID_MSD_SEND_START");
1018
1019 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_START_RECEIVED_MSD;
1020 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_PSAP_REQURE_UPDATE_MSD;
1021 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1022 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
1023 break;
1024 }
1025 case MBTK_ECALL_URC_ID_NACK:
1026 {
1027 LOGD("MBTK_ECALL_URC_ID_NACK");
1028
1029 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_NACK_RECEIVED;
1030 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
1031 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1032 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_NONE;
1033 break;
1034 }
1035 case MBTK_ECALL_URC_ID_LLACK:
1036 {
1037 LOGD("MBTK_ECALL_URC_ID_LLACK");
1038
1039 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_ACK_RECEIVED;
1040 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
1041 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_LLACK_RECEIVED;
1042 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
1043 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
1044 mbtk_send_singnal();
1045 break;
1046 }
1047 case MBTK_ECALL_URC_ID_HLACK:
1048 {
1049 LOGD("MBTK_ECALL_URC_ID_HLACK");
1050 event.fail = GSW_EU_ECALL_EVENT_FAIL_NONE;
1051 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_HLACK_RECEIVED;
1052
1053 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
1054 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1055 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
1056 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_SUCCESS;
1057 mbtk_send_singnal();
1058 break;
1059 }
1060 case MBTK_ECALL_URC_ID_ALACK:
1061 {
1062 LOGD("MBTK_ECALL_URC_ID_ALACK");
1063 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_IVS_ALACK_RECEIVED;
1064 }
1065 case MBTK_ECALL_URC_ID_MSD_UPDATE_DONE:
1066 {
1067 LOGD("MBTK_ECALL_URC_ID_MSD_UPDATE_DONE");
1068 event.process = GSW_EU_ECALL_EVENT_PROCESS_IVS_NONE;
1069 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPADTE_NONE;
1070 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1071 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
1072
1073 }
1074 case MBTK_ECALL_URC_ID_T5_EXPIRED:
1075 case MBTK_ECALL_URC_ID_T6_EXPIRED:
1076 case MBTK_ECALL_URC_ID_T7_EXPIRED:
1077 {
1078 LOGD("MBTK_ECALL_URC_ID_T5_EXPIRED | MBTK_ECALL_URC_ID_T5_EXPIRED | MBTK_ECALL_URC_ID_T7_EXPIRED");
1079 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATE_MSD_TIMEOUT;
1080 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1081 event.establish = GSW_EU_ECALL_EVENT_ESTABLISH_SUCCESS;
1082 g_msd_send_status = GSW_EU_ECALL_MSD_TRANS_STATUS_FAILURE;
1083 mbtk_send_singnal();
1084 break;
1085 }
1086 case MBTK_ECALL_URC_ID_3GPP_FATAL:
1087 case MBTK_ECALL_URC_ID_GENERIC:
1088 {
1089 LOGD("MBTK_ECALL_URC_ID_GENERIC|MBTK_ECALL_URC_ID_3GPP_FATAL");
1090 event.extend_state = GSW_EU_ECALL_EVENT_EXTEND_STATE_NONE;
1091 }
1092 case MBTK_ECALL_URC_ID_MSD_UPDATE_ERR:
1093 {
1094 LOGD("MBTK_ECALL_URC_ID_MSD_UPDATE_ERR");
1095 event.msdupdate = GSW_EU_ECALL_EVENT_MSDUPDATE_IVS_UPDATE_MSD_TIMEOUT;
1096
1097 }
1098 default:
1099 {
1100
1101 LOGE("No process urc_id : %d", ecall_data->urc_id);
1102 break;
1103 }
1104 }
1105
1106 }
1107 if(gsw_eu_ecall_event_cb)
1108 {
1109 gsw_eu_ecall_event_cb(&event);
1110 }
1111}
1112
1113
1114/**
1115 * @brief register the ecall status callback
1116* @param [in] gsw_eu_ecall_status_cb_f cb:callback
1117* @param [out] None
1118* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
1119*/
1120int32_t gsw_eu_ecall_setEventCB(gsw_eu_ecall_event_cb_f cb)
1121{
1122 int ret = -1;
1123 if(ecall_info_handle==NULL)
1124 {
1125 return GSW_HAL_MEM_INVAILD;
1126 }
1127
1128 gsw_eu_ecall_event_cb = cb;
1129 if(!g_setevent_cb)
1130 {
1131 ret = mbtk_ecall_state_change_cb_reg_ptr(ecall_info_handle, mbtk_ecall_state_change_cb);
1132 if(ret < 0)
1133 {
1134
1135 LOGE("mbtk_ecall_state_change_cb_reg_ptr failed");
1136 return GSW_HAL_FAIL;
1137 }
1138 g_setevent_cb = true;
1139 }
1140
1141 return GSW_HAL_SUCCESS;
1142
1143}
1144
1145
1146
1147static void* ecall_msd_status_cb_thread(void* arg)
1148{
1149 while(g_thread_running)
1150 {
1151 mbtk_wait_signal();
1152 if(g_thread_running == false)
1153 {
1154 return NULL;
1155 }
1156 if(gsw_eu_ecall_status_cb)
1157 {
1158 gsw_eu_ecall_status_cb(g_sta_cb_id,g_msd_send_status);
1159 }
1160
1161 }
1162 return NULL;
1163}
1164
1165/**
1166* @brief register the ecall status callback
1167* @param [in] gsw_eu_ecall_status_cb_f cb:callback
1168* @param [out] None
1169* @retval GSW_HAL_SUCCESS\GSW_HAL_FAIL
1170*/
1171int32_t gsw_eu_ecall_setStatusCB(gsw_eu_ecall_status_cb_f cb)
1172{
1173 int ret = -1;
1174 if(ecall_info_handle==NULL)
1175 {
1176 return GSW_HAL_FAIL;
1177 }
1178 gsw_eu_ecall_status_cb = cb;
1179 if (!g_thread_running)
1180 {
1181 ret = pthread_create(&gsw_ecall_status_cb_thread, NULL, ecall_msd_status_cb_thread, NULL);
1182 if(ret < 0)
1183 {
1184 LOGE("pthread_create failed");
1185 g_thread_running = false;
1186 return GSW_HAL_FAIL;
1187 }
1188 g_thread_running = true;
1189 }
1190
1191 return GSW_HAL_SUCCESS;
1192
1193}