4 * Copyright (c) 2013 Samsung Electronics Co. Ltd. All rights reserved.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
28 #include <core_object.h>
37 #include "imc_common.h"
40 #define STATUS_INCOMING 4
41 #define STATUS_WAITING 5
42 #define STATUS_CONNECTED 7
44 #define find_call_object(co, call_id, call_obj) \
46 call_obj = tcore_call_object_find_by_id(co, call_id); \
48 err("unable to find call object"); \
53 struct imc_set_volume_info {
58 static gchar *xdrv_set_volume[] = {
66 /*Forward Declarations*/
67 static void on_response_imc_call_default(TcorePending *p,
68 guint data_len, const void *data, void *user_data);
70 static TelReturn __call_list_get(CoreObject *co, gboolean flag);
72 static TelCallType __call_type(int type)
78 return TEL_CALL_TYPE_VOICE;
81 return TEL_CALL_TYPE_VIDEO;
84 err("invalid call type, returning default call type as voice");
85 return TEL_CALL_TYPE_VOICE;
89 static TelCallState __call_state(int state)
95 return TEL_CALL_STATE_ACTIVE;
98 return TEL_CALL_STATE_HELD;
101 return TEL_CALL_STATE_DIALING;
104 return TEL_CALL_STATE_ALERT;
108 return TEL_CALL_STATE_INCOMING;
111 return TEL_CALL_STATE_IDLE;
115 static void __call_branch_by_status(CoreObject *co, CallObject *call_obj,
116 TelCallState call_state)
118 unsigned int call_id;
119 TelCallType call_type;
121 TcoreNotification command = TCORE_NOTIFICATION_UNKNOWN;
122 dbg("Call State[%d]", call_state);
124 if (tcore_call_object_get_state(call_obj, &state) == FALSE) {
125 err("unable to get call status");
129 if (call_state == state) {
130 dbg("current call state and existing call state are same");
134 if (tcore_call_object_get_call_type(call_obj, &call_type) == FALSE) {
135 err("unable to get call type");
139 if (tcore_call_object_get_id(call_obj, &call_id) == FALSE) {
140 err("unable to get call id");
145 tcore_call_object_set_state(call_obj, call_state);
147 if (call_type == TEL_CALL_TYPE_VOICE) {
148 /* voice call notification */
149 switch (call_state) {
150 case TEL_CALL_STATE_ACTIVE:
151 command = TCORE_NOTIFICATION_CALL_STATUS_ACTIVE;
154 case TEL_CALL_STATE_HELD:
155 command = TCORE_NOTIFICATION_CALL_STATUS_HELD;
158 case TEL_CALL_STATE_DIALING:
159 command = TCORE_NOTIFICATION_CALL_STATUS_DIALING;
162 case TEL_CALL_STATE_ALERT:
163 command = TCORE_NOTIFICATION_CALL_STATUS_ALERT;
166 case TEL_CALL_STATE_INCOMING:
167 case TEL_CALL_STATE_WAITING: {
168 TelCallIncomingInfo incoming = {0,};
169 command = TCORE_NOTIFICATION_CALL_STATUS_INCOMING;
170 incoming.call_id = call_id;
171 tcore_call_object_get_cli_validity(call_obj, &incoming.cli_validity);
172 tcore_call_object_get_number(call_obj, incoming.number);
173 tcore_call_object_get_cni_validity(call_obj, &incoming.cni_validity);
174 tcore_call_object_get_name(call_obj, incoming.name);
175 tcore_call_object_get_mt_forward(call_obj, &incoming.forward);
176 tcore_call_object_get_active_line(call_obj, &incoming.active_line);
178 /* Send notification */
179 tcore_object_send_notification(co, command,
180 sizeof(TelCallIncomingInfo), &incoming);
184 case TEL_CALL_STATE_IDLE: {
185 TelCallStatusIdleNoti idle;
186 command = TCORE_NOTIFICATION_CALL_STATUS_IDLE;
187 idle.call_id = call_id;
189 /* TODO - get proper call end cause. */
190 idle.cause = TEL_CALL_END_CAUSE_NONE;
192 /* Send notification */
193 tcore_object_send_notification(co, command,
194 sizeof(TelCallStatusIdleNoti), &idle);
196 /* Free Call object */
197 tcore_call_object_free(co, call_obj);
203 else if (call_type == TEL_CALL_TYPE_VIDEO) {
204 /* video call notification */
205 switch (call_state) {
206 case TEL_CALL_STATE_ACTIVE:
207 command = TCORE_NOTIFICATION_VIDEO_CALL_STATUS_ACTIVE;
210 case TEL_CALL_STATE_HELD:
211 err("invalid state");
214 case TEL_CALL_STATE_DIALING:
215 command = TCORE_NOTIFICATION_VIDEO_CALL_STATUS_DIALING;
218 case TEL_CALL_STATE_ALERT:
219 command = TCORE_NOTIFICATION_VIDEO_CALL_STATUS_ALERT;
222 case TEL_CALL_STATE_INCOMING:
223 case TEL_CALL_STATE_WAITING:
224 command = TCORE_NOTIFICATION_VIDEO_CALL_STATUS_INCOMING;
227 case TEL_CALL_STATE_IDLE: {
228 TelCallStatusIdleNoti idle;
229 command = TCORE_NOTIFICATION_VIDEO_CALL_STATUS_IDLE;
230 idle.call_id = call_id;
232 /* TODO - get proper call end cause. */
233 idle.cause = TEL_CALL_END_CAUSE_NONE;
235 /* Send notification */
236 tcore_object_send_notification(co, command,
237 sizeof(TelCallStatusIdleNoti), &idle);
239 /* Free Call object */
240 tcore_call_object_free(co, call_obj);
246 err("Unknown Call type: [%d]", call_type);
249 if (command != TCORE_NOTIFICATION_UNKNOWN)
250 tcore_object_send_notification(co, command, sizeof(call_id), &call_id);
253 static void __handle_call_list_get(CoreObject *co, gboolean flag, void *data)
261 GSList *tokens = NULL;
266 char number[TEL_CALL_CALLING_NUMBER_LEN_MAX +1] = {0,};
267 GSList *lines = data;
268 CallObject *call_obj = NULL;
270 while (lines != NULL) {
271 line = (char *)lines->data;
272 /* point to next node */
274 /* free previous tokens*/
275 tcore_at_tok_free(tokens);
277 tokens = tcore_at_tok_new(line);
280 resp = g_slist_nth_data(tokens, 0);
282 err("Invalid call_id");
285 call_id = atoi(resp);
288 resp = g_slist_nth_data(tokens, 1);
290 err("Invalid direction");
293 direction = (atoi(resp) == 0) ? 1 : 0;
296 resp = g_slist_nth_data(tokens, 2);
298 err("Invalid state");
301 state = __call_state(atoi(resp));
304 resp = g_slist_nth_data(tokens, 3);
306 err("Invalid call_type");
309 call_type = __call_type(atoi(resp));
312 resp = g_slist_nth_data(tokens, 4);
320 resp = g_slist_nth_data(tokens, 5);
322 err("Number is NULL");
324 /* Strike off double quotes */
325 num = tcore_at_tok_extract(resp);
326 dbg("Number: [%s]", num);
329 resp = g_slist_nth_data(tokens, 6);
331 err("Invalid num type");
333 num_type = atoi(resp);
334 /* check number is international or national. */
335 ton = ((num_type) >> 4) & 0x07;
336 if (ton == 1 && num[0] != '+') {
337 /* international number */
339 memcpy(&number[1], num, strlen(num));
341 memcpy(number, num, strlen(num));
347 dbg("Call ID: [%d] Direction: [%s] Call Type: [%d] Multi-party: [%s] "
348 "Number: [%s] TON: [%d] State: [%d]",
349 call_id, (direction ? "Outgoing" : "Incoming"), call_type,
350 (mpty ? "YES" : "NO"), number, ton, state);
352 call_obj = tcore_call_object_find_by_id(co, call_id);
353 if (NULL == call_obj) {
354 call_obj = tcore_call_object_new(co, call_id);
355 if (NULL == call_obj) {
356 err("unable to create call object");
361 /* Set Call parameters */
362 tcore_call_object_set_type(call_obj, call_type);
363 tcore_call_object_set_direction(call_obj, direction);
364 tcore_call_object_set_multiparty_state(call_obj, mpty);
365 tcore_call_object_set_cli_info(call_obj, TEL_CALL_CLI_VALIDITY_VALID, number);
366 tcore_call_object_set_active_line(call_obj, TEL_CALL_ACTIVE_LINE1);
368 __call_branch_by_status(co, call_obj, state);
370 tcore_call_object_set_state(call_obj, state);
374 /* internal notification operation */
375 static void __on_notification_imc_call_incoming(CoreObject *co, unsigned int call_id,
379 CallObject *call_obj = NULL;
382 /* check call with incoming status already exist */
383 list = tcore_call_object_find_by_status(co, TEL_CALL_STATE_INCOMING);
385 err("Incoming call already exist! Skip...");
390 call_obj = tcore_call_object_find_by_id(co, call_id);
391 if (call_obj != NULL) {
392 err("Call object for Call ID [%d] already exist! Skip...", call_id);
396 /* Create new Call object */
397 call_obj = tcore_call_object_new(co, (unsigned int)call_id);
398 if (NULL == call_obj) {
399 err("Failed to create Call object");
403 /* Make request to get current Call list */
404 __call_list_get(co, TRUE);
407 static void __on_notification_imc_call_status(CoreObject *co, unsigned int call_id,
408 unsigned int call_state, void *user_data)
410 CallObject *call_obj = NULL;
413 state = __call_state(call_state);
414 dbg("state [%d]", state);
417 case TEL_CALL_STATE_ACTIVE: {
418 find_call_object(co, call_id, call_obj);
419 /* Send notification to application */
420 __call_branch_by_status(co, call_obj, state);
424 case TEL_CALL_STATE_HELD: {
425 find_call_object(co, call_id, call_obj);
426 /* Send notification to application */
427 __call_branch_by_status(co, call_obj, state);
431 case TEL_CALL_STATE_DIALING: {
432 call_obj = tcore_call_object_find_by_id(co, call_id);
434 call_obj = tcore_call_object_new(co, call_id);
436 err("unable to create call object");
440 /* Make request to get current call list.Update CallObject with <number>
441 * and send notification to application */
442 __call_list_get(co, TRUE);
446 case TEL_CALL_STATE_ALERT: {
447 find_call_object(co, call_id, call_obj);
448 /* Send notification to application */
449 __call_branch_by_status(co, call_obj, TEL_CALL_STATE_ALERT);
453 case TEL_CALL_STATE_IDLE: {
454 find_call_object(co, call_id, call_obj);
455 /* Send notification to application */
456 __call_branch_by_status(co, call_obj, state);
461 err("invalid call status");
466 /*internal response operation */
467 static void __on_response_imc_call_list_get(TcorePending *p, guint data_len, const void *data,
470 const TcoreAtResponse *at_resp = data;
471 CoreObject *co = tcore_pending_ref_core_object(p);
472 ImcRespCbData *resp_cb_data = user_data;
473 GSList *lines = NULL;
474 TelCallResult result = TEL_CALL_RESULT_FAILURE; //TODO - CME error mapping required
475 gboolean *flag = IMC_GET_DATA_FROM_RESP_CB_DATA(resp_cb_data);
479 tcore_check_return_assert(co != NULL);
480 tcore_check_return_assert(resp_cb_data != NULL);
482 if (at_resp && at_resp->success) {
483 if (NULL == at_resp->lines) {
484 err("invalid response received");
488 lines = (GSList *) at_resp->lines;
489 count = g_slist_length(lines);
490 dbg("Total records : %d", count);
492 err("Call count is zero");
495 result = TEL_CALL_RESULT_SUCCESS;
498 /* parse +CLCC notification parameter */
499 __handle_call_list_get(co, *flag, lines);
506 /*internal request operation */
507 static TelReturn __send_call_request(CoreObject *co, TcoreObjectResponseCallback cb,
508 void *cb_data, gchar *at_cmd, gchar *func_name)
510 ImcRespCbData *resp_cb_data;
513 /* Response callback data */
514 resp_cb_data = imc_create_resp_cb_data(cb, cb_data, func_name,
515 strlen(func_name) + 1);
517 /* Send Request to modem */
518 ret = tcore_at_prepare_and_send_request(co,
520 TCORE_AT_COMMAND_TYPE_NO_RESULT,
522 on_response_imc_call_default, resp_cb_data,
523 on_send_imc_request, NULL);
524 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, func_name);
532 * Operation - Get current call list.
535 * AT-Command: AT+CLCC
539 *[+CLCC: <id1>, <dir>, <stat>, <mode>,<mpty>[,<number>,<type>[,<alpha>[,<priority>]]]
543 * +CME ERROR: <error>
545 static TelReturn __call_list_get(CoreObject *co, gboolean flag)
547 ImcRespCbData *resp_cb_data;
548 TelReturn ret = TEL_RETURN_FAILURE;
552 err("Core Object is NULL");
556 /* Response callback data */
557 resp_cb_data = imc_create_resp_cb_data(NULL, NULL, &flag, sizeof(gboolean));
559 /* Send Request to modem */
560 ret = tcore_at_prepare_and_send_request(co,
562 TCORE_AT_COMMAND_TYPE_MULTILINE,
564 __on_response_imc_call_list_get, resp_cb_data,
565 on_send_imc_request, NULL);
566 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, "Get current call list");
574 * Operation - call status notification from network.
575 * notification message format:
576 * +XCALLSTAT: <call_id><stat>
579 * indicates the call identification (GSM02.30 4.5.5.1)
583 * 2 dialling (MO call)
584 * 3 alerting (MO call; ringing for the remote party)
585 * 4 ringing (MT call)
586 * 5 waiting (MT call)
588 * 7 connected (indicates the completion of a call setup first time for MT and MO calls
589 * this is reported in addition to state active)
591 static gboolean on_notification_imc_call_status(CoreObject *co, const void *data,
594 GSList *tokens = NULL;
595 GSList *lines = NULL;
596 const char *line = NULL;
597 char *state = NULL, *call_handle = NULL;
598 unsigned int status, call_id;
602 lines = (GSList *) data;
604 err("Invalid response received");
607 line = (char *) (lines->data);
608 tokens = tcore_at_tok_new(line);
610 call_handle = g_slist_nth_data(tokens, 0);
611 if (NULL == call_handle) {
612 err("call id missing from %XCALLSTAT indication");
615 call_id = atoi(call_handle);
616 state = g_slist_nth_data(tokens, 1);
618 err("call state is missing from %XCALLSTAT indication");
621 status = atoi(state);
622 dbg("call id[%d], status[%d]", call_id, status);
625 case STATUS_INCOMING:
627 __on_notification_imc_call_incoming(co, call_id, user_data);
630 case STATUS_CONNECTED: /* ignore Connected state. */
631 dbg("ignore connected state");
635 __on_notification_imc_call_status(co, call_id, status, user_data);
640 tcore_at_tok_free(tokens);
645 * Operation - SS network initiated notification.
647 * notification message format:
648 * +CSSU: <code2>[<index> [,<number>,<type>]]
650 * (it is manufacturer specific, which of these codes are supported):
651 * 0 this is a forwarded call (MT call setup)
652 * 1 this is a CUG call (<index> present) (MT call setup)
653 * 2 call has been put on hold (during a voice call)
654 * 3 call has been retrieved (during a voice call)
655 * 4 multiparty call entered (during a voice call)
656 * 5 Call has been released - not a SS notification (during a voice call)
657 * 6 forward check SS message received (can be received whenever)
658 * 7 call is being connected (alerting) with the remote party in alerting state
659 * in explicit call transfer operation
660 * (during a voice call)
661 * 8 call has been connected with the other remote party in explicit call transfer
662 * operation (during a voice call or MT call setup)
663 * 9 this is a deflected call (MT call setup)
664 * 10 additional incoming call forwarded
666 * refer Closed user group +CCUG
668 * string type phone of format specified by <type>
670 * type of address octet in integer format.
672 static gboolean on_notification_imc_call_ss_cssu_info(CoreObject *co, const void *event_data,
675 GSList *tokens = NULL;
676 TcoreNotification command = TCORE_NOTIFICATION_UNKNOWN;
685 if (1 != g_slist_length((GSList *) event_data)) {
686 err("unsolicited msg but multiple line");
690 cmd = (char *) ((GSList *) event_data)->data;
691 dbg("ss notification message[%s]", cmd);
693 tokens = tcore_at_tok_new(cmd);
696 resp = g_slist_nth_data(tokens, 0);
698 err("Code2 is missing from +CSSU indication");
699 tcore_at_tok_free(tokens);
705 /* parse [ <index>, <number> <type>] */
706 if ((resp = g_slist_nth_data(tokens, 1)))
709 if ((resp = g_slist_nth_data(tokens, 2))) {
710 /* Strike off double quotes */
711 number = tcore_at_tok_extract(resp);
714 dbg("+CSSU: <code2> = %d <index> = %d <number> = %s ", code2, index, number);
716 /* <code2> - other values will be ignored */
719 command = TCORE_NOTIFICATION_CALL_INFO_MT_FORWARDED;
722 command = TCORE_NOTIFICATION_CALL_INFO_HELD;
725 command = TCORE_NOTIFICATION_CALL_INFO_ACTIVE;
728 command = TCORE_NOTIFICATION_CALL_INFO_JOINED;
732 command = TCORE_NOTIFICATION_CALL_INFO_TRANSFERED;
735 command = TCORE_NOTIFICATION_CALL_INFO_MT_DEFLECTED;
738 dbg("Unsupported +CSSU notification : %d", code2);
742 if (command != TCORE_NOTIFICATION_UNKNOWN)
743 tcore_object_send_notification(co, command, 0, NULL);
744 tcore_at_tok_free(tokens);
751 * Operation - SS network initiated notification.
752 * notification message format:
753 * +CSSI : <code1>[,<index>]
756 * 0 unconditional call forwarding is active
757 * 1 some of the conditional call forwarding are active
758 * 2 call has been forwarded
760 * 4 this is a CUG call (also <index> present)
761 * 5 outgoing calls are barred
762 * 6 incoming calls are barred
763 * 7 CLIR suppression rejected
764 * 8 call has been deflected
767 * refer Closed user group +CCUG.
769 static gboolean on_notification_imc_call_ss_cssi_info(CoreObject *co, const void *event_data,
772 GSList *tokens = NULL;
773 TcoreNotification command = TCORE_NOTIFICATION_UNKNOWN;
781 if (1 != g_slist_length((GSList *) event_data)) {
782 err("unsolicited msg but multiple line");
785 cmd = (char *) ((GSList *) event_data)->data;
786 dbg("ss notification message[%s]", cmd);
788 tokens = tcore_at_tok_new(cmd);
790 resp = g_slist_nth_data(tokens, 0);
792 err("<code1> is missing from %CSSI indication");
793 tcore_at_tok_free(tokens);
799 /* parse [ <index>] */
800 if ((resp = g_slist_nth_data(tokens, 1)))
803 dbg("+CSSI: <code1> = %d <index> = %d ", code1, index);
805 /* <code1> - other values will be ignored */
808 command = TCORE_NOTIFICATION_CALL_INFO_MO_FORWARD_UNCONDITIONAL;
811 command = TCORE_NOTIFICATION_CALL_INFO_MO_FORWARD_CONDITIONAL;
814 command = TCORE_NOTIFICATION_CALL_INFO_MO_FORWARDED;
817 command = TCORE_NOTIFICATION_CALL_INFO_MO_WAITING;
820 command = TCORE_NOTIFICATION_CALL_INFO_MO_BARRED_OUTGOING;
823 command = TCORE_NOTIFICATION_CALL_INFO_MO_BARRED_INCOMING;
826 command = TCORE_NOTIFICATION_CALL_INFO_MO_DEFLECTED;
829 dbg("Unsupported +CSSI notification : %d", code1);
833 if (command != TCORE_NOTIFICATION_UNKNOWN)
834 tcore_object_send_notification(co, command, 0, NULL);
835 tcore_at_tok_free(tokens);
840 static gboolean on_notification_imc_call_clip_info(CoreObject *co, const void *data,
844 /* TODO - handle +CLIP notification*/
849 static void on_response_imc_call_default(TcorePending *p,
850 guint data_len, const void *data, void *user_data)
852 const TcoreAtResponse *at_resp = data;
853 CoreObject *co = tcore_pending_ref_core_object(p);
854 ImcRespCbData *resp_cb_data = user_data;
856 TelCallResult result = TEL_CALL_RESULT_FAILURE;
859 tcore_check_return_assert(co != NULL);
860 tcore_check_return_assert(resp_cb_data != NULL);
862 if (at_resp && at_resp->success) {
863 result = TEL_CALL_RESULT_SUCCESS;
866 err("ERROR[%s]", at_resp->final_response);
869 err("CME error[%s]", at_resp->lines->data);
872 * TODO - need to map CME error and final
873 * response error to TelCallResult
877 dbg("%s: [%s]", IMC_GET_DATA_FROM_RESP_CB_DATA(resp_cb_data),
878 (result == TEL_CALL_RESULT_SUCCESS ? "SUCCESS" : "FAIL"));
880 /* Invoke callback */
881 if (resp_cb_data->cb)
882 resp_cb_data->cb(co, (gint)result, NULL, resp_cb_data->cb_data);
884 /* Free callback data */
885 imc_destroy_resp_cb_data(resp_cb_data);
888 static void on_response_imc_call_set_volume_info(TcorePending *p,
889 guint data_len, const void *data, void *user_data)
891 const TcoreAtResponse *at_resp = data;
892 CoreObject *co = tcore_pending_ref_core_object(p);
893 ImcRespCbData *resp_cb_data = user_data;
894 GSList *tokens = NULL;
896 char *resp_str = NULL;
899 /* TODO: XDRV error mapping required */
900 TelCallResult result = TEL_CALL_RESULT_FAILURE;
903 tcore_check_return_assert(co != NULL);
904 tcore_check_return_assert(resp_cb_data != NULL);
906 if (at_resp && at_resp->success) {
907 line = at_resp->lines;
908 tokens = tcore_at_tok_new(line->data);
910 if (!g_slist_nth_data(tokens, 0)) {
911 err("group_id missing");
915 if (!g_slist_nth_data(tokens, 1)) {
916 err(" function_id missing");
920 resp_str = g_slist_nth_data(tokens, 2);
922 err("xdrv result missing");
925 struct imc_set_volume_info *volume_info;
930 error = atoi(resp_str);
936 /* Fetch volume_info from resp_cb_data */
937 volume_info = (struct imc_set_volume_info *)
938 IMC_GET_DATA_FROM_RESP_CB_DATA(resp_cb_data);
939 dbg("volume info index[%d]", volume_info->next_index);
941 if (xdrv_set_volume[volume_info->next_index] == NULL) {
942 /*Processing of xdrv commands completed */
944 result = TEL_CALL_RESULT_SUCCESS;
946 } else if (volume_info->next_index == 3) {
947 switch ((volume_info->volume) / 10) {
981 at_cmd = g_strdup_printf("%s%s",
982 xdrv_set_volume[volume_info->next_index], vol);
984 /* Increment index to point to next xdrv command */
985 volume_info->next_index += 1;
987 /* Send Request to modem */
988 ret = tcore_at_prepare_and_send_request(co,
990 TCORE_AT_COMMAND_TYPE_SINGLELINE,
992 on_response_imc_call_set_volume_info,
993 resp_cb_data, on_send_imc_request, NULL);
994 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, "imc_call_set_volume_info");
1002 dbg("Set Volume Info: [%s]",
1003 (result == TEL_CALL_RESULT_SUCCESS ? "SUCCESS" : "FAIL"));
1005 /* Invoke callback */
1006 if (resp_cb_data->cb)
1007 resp_cb_data->cb(co, (gint)result, NULL, resp_cb_data->cb_data);
1009 imc_destroy_resp_cb_data(resp_cb_data);
1010 tcore_at_tok_free(tokens);
1013 static void on_response_imc_call_set_sound_path(TcorePending *p,
1014 guint data_len, const void *data, void *user_data)
1016 const TcoreAtResponse *at_resp = data;
1017 CoreObject *co = tcore_pending_ref_core_object(p);
1018 ImcRespCbData *resp_cb_data = user_data;
1019 GSList *tokens = NULL;
1020 GSList *line = NULL;
1021 char *resp_str = NULL;
1023 gint xdrv_func_id = -1;
1025 TelCallResult result = TEL_CALL_RESULT_FAILURE; // TODO: XDRV error mapping is required
1028 tcore_check_return_assert(co != NULL);
1029 tcore_check_return_assert(resp_cb_data != NULL);
1031 if (at_resp && at_resp->success) {
1032 line = at_resp->lines;
1033 tokens = tcore_at_tok_new(line->data);
1034 if (!g_slist_nth_data(tokens, 0)) {
1035 err("group_id missing");
1039 if (!(resp_str = g_slist_nth_data(tokens, 1))) {
1040 err("function_id missing");
1043 xdrv_func_id = atoi(resp_str);
1045 if (!(resp_str = g_slist_nth_data(tokens, 2))) {
1046 err("RESPONSE NOK");
1049 error = atoi(resp_str);
1051 err("RESPONSE NOK");
1055 if (xdrv_func_id == 4) {
1056 /* Send next command to configure destination device type */
1059 gint *device_type = IMC_GET_DATA_FROM_RESP_CB_DATA(resp_cb_data);
1061 at_cmd = g_strdup_printf("AT+XDRV=40,5,2,0,0,0,0,0,1,0,1,0,%d",
1064 ret = tcore_at_prepare_and_send_request(co,
1066 TCORE_AT_COMMAND_TYPE_SINGLELINE,
1068 on_response_imc_call_set_sound_path, resp_cb_data,
1069 on_send_imc_request, NULL);
1070 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, "imc_call_set_sound_path");
1076 result = TEL_CALL_RESULT_SUCCESS;
1080 dbg("Set Sound Path: [%s]",
1081 (result == TEL_CALL_RESULT_SUCCESS ? "SUCCESS" : "FAIL"));
1083 tcore_at_tok_free(tokens);
1085 /* Invoke callback */
1086 if (resp_cb_data->cb)
1087 resp_cb_data->cb(co, (gint)result, NULL, resp_cb_data->cb_data);
1089 imc_destroy_resp_cb_data(resp_cb_data);
1092 static void on_response_set_sound_path(TcorePending *p, guint data_len,
1093 const void *data, void *user_data)
1095 const TcoreAtResponse *at_resp = data;
1096 ImcRespCbData *resp_cb_data = user_data;
1097 TelCallResult result = TEL_CALL_RESULT_FAILURE;
1098 CoreObject *co_call = tcore_pending_ref_core_object(p);
1100 if (at_resp && at_resp->success)
1101 result = TEL_CALL_RESULT_SUCCESS;
1103 if(resp_cb_data->cb)
1104 resp_cb_data->cb(co_call, (gint)result, NULL, resp_cb_data->cb_data);
1106 imc_destroy_resp_cb_data(resp_cb_data);
1109 static void on_response_imc_call_set_mute(TcorePending *p, guint data_len,
1110 const void *data, void *user_data)
1112 const TcoreAtResponse *at_resp = data;
1113 CoreObject *co = tcore_pending_ref_core_object(p);
1114 ImcRespCbData *resp_cb_data = user_data;
1115 GSList *tokens = NULL;
1116 const char *line = NULL;
1117 char *resp_str = NULL;
1120 TelCallResult result = TEL_CALL_RESULT_FAILURE; // TODO: XDRV error mapping is required
1123 tcore_check_return_assert(co != NULL);
1124 tcore_check_return_assert(resp_cb_data != NULL);
1126 if (at_resp && at_resp->success) {
1127 line = (((GSList *)at_resp->lines)->data);
1128 tokens = tcore_at_tok_new(line);
1130 resp_str = g_slist_nth_data(tokens, 0);
1131 if (!g_slist_nth_data(tokens, 0)) {
1132 err("group_id missing");
1136 if (!g_slist_nth_data(tokens, 1)) {
1137 err("function_id missing");
1141 resp_str = g_slist_nth_data(tokens, 2);
1142 if (!(resp_str = g_slist_nth_data(tokens, 1))) {
1143 err("xdrv_result missing");
1146 error = atoi(resp_str);
1148 err(" RESPONSE NOK [%d]", error);
1151 result = TEL_CALL_RESULT_SUCCESS;
1155 dbg("Set Mute: [%s]",
1156 (result == TEL_CALL_RESULT_SUCCESS ? "SUCCESS" : "FAIL"));
1157 tcore_at_tok_free(tokens);
1159 /* Invoke callback */
1160 if (resp_cb_data->cb)
1161 resp_cb_data->cb(co, (gint)result, NULL, resp_cb_data->cb_data);
1163 imc_destroy_resp_cb_data(resp_cb_data);
1172 * AT-Command: ATD <num> [I] [G] [;]
1173 * <num> - dialed number
1174 * [I][i] - CLI presentation(supression or invocation)
1175 * [G] - control the CUG supplementary service information for this call.
1186 * +CME ERROR: <error>
1188 static TelReturn imc_call_dial(CoreObject *co, const TelCallDial *dial_info,
1189 TcoreObjectResponseCallback cb, void *cb_data)
1197 if (dial_info->call_type == TEL_CALL_TYPE_VIDEO) {
1198 err("Video call is not supported in imc modem");
1199 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1202 if (!strncmp(dial_info->number, "*31#", 4)) {
1203 dbg("clir suppression");
1205 num = (gchar *)&(dial_info->number[4]);
1206 } else if (!strncmp(dial_info->number, "#31#", 4)) {
1207 dbg("clir invocation");
1209 num = (gchar *)&(dial_info->number[4]);
1213 dbg("no clir string in number");
1215 /* it will be removed when setting application use tapi_ss_set_cli()
1216 * instead of his own vconfkey. (0 : By network, 1 : Show, 2 : Hide)
1218 vconf_get_int("db/ciss/show_my_number", &cli);
1220 dbg("clir invocation from setting application");
1223 dbg("set clir state to default");
1226 num = (gchar *)dial_info->number;
1230 at_cmd = g_strdup_printf("ATD%s%s;", num, clir);
1231 dbg(" at command : %s", at_cmd);
1233 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_dial");
1237 * Operation - Answer/Reject/Replace/hold(current call) & accept incoming call.
1241 * 1. AT-Command: ATA
1246 * +CME ERROR: <error>
1248 * 2. AT-Command: AT+CHLD=[<n>]
1250 * 0 - (deafult)release all held calls or set User Determined User Busy for a waiting/incoming
1251 * call; if both exists then only the waiting call will be rejected.
1252 * 1 - release all active calls and accepts the other (held or waiting)
1253 * Note: In the scenario: An active call, a waiting call and held call, when the active call is
1254 * terminated, we will make the Waiting call as active.
1255 * 2 - place all active calls (if exist) on hold and accepts the other call (held or waiting/in-coming).
1256 * If only one call exists which is active, place it on hold and if only held call exists make it active call.
1261 * +CME ERROR: <error>
1262 * For more informatiion refer 3GPP TS 27.007.
1264 static TelReturn imc_call_answer(CoreObject *co, TelCallAnswerType ans_type,
1265 TcoreObjectResponseCallback cb, void *cb_data)
1270 if (ans_type == TEL_CALL_ANSWER_ACCEPT) {
1272 at_cmd = g_strdup_printf("%s", "ATA");
1273 }else if (ans_type == TEL_CALL_ANSWER_REJECT) {
1275 at_cmd = g_strdup_printf("%s", "AT+CHLD=0");
1276 } else if (ans_type == TEL_CALL_ANSWER_REPLACE) {
1278 at_cmd = g_strdup_printf("%s", "AT+CHLD=1");
1279 } else if (ans_type == TEL_CALL_ANSWER_HOLD_AND_ACCEPT) {
1281 at_cmd = g_strdup_printf("%s", "AT+CHLD=2");
1283 err("Unsupported call answer type");
1284 return TEL_RETURN_FAILURE;
1287 dbg("at command : %s", at_cmd);
1289 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_answer");
1293 * Operation - release all calls/release specific call/release all active
1294 * call/release all held calls.
1297 * 1. AT-Command: AT+CHLD=[<n>]
1299 * 0 - (defualt)release all held calls or set User Determined User -
1300 * Busy for a waiting/incoming.
1301 * call; if both exists then only the waiting call will be rejected.
1302 * 1 - release all active calls and accepts the other (held or waiting).
1303 * 1x - release a specific call (x specific call number as indicated by call id).
1304 * 8 - release all calls.
1309 * +CME ERROR: <error>
1311 static TelReturn imc_call_end(CoreObject *co, const TelCallEnd *end_info,
1312 TcoreObjectResponseCallback cb, void *cb_data)
1317 if (end_info->end_type == TEL_CALL_END_ALL) {
1319 at_cmd = g_strdup_printf("%s", "AT+CHLD=8");
1320 }else if (end_info->end_type == TEL_CALL_END) {
1322 at_cmd = g_strdup_printf("%s%d", "AT+CHLD=1",end_info->call_id);
1323 } else if (end_info->end_type == TEL_CALL_END_ACTIVE_ALL) {
1325 at_cmd = g_strdup_printf("%s", "AT+CHLD=1");
1326 } else if (end_info->end_type == TEL_CALL_END_HOLD_ALL) {
1328 at_cmd = g_strdup_printf("%s", "AT+CHLD=0");
1330 err("Unsupported call end type");
1331 return TEL_RETURN_FAILURE;
1334 dbg("at command : %s", at_cmd);
1336 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_end");
1340 * Operation - send dtmf.
1343 * 1. AT-Command: AT+VTS=<DTMF>,{<DTMF>,<duration>}.
1346 * is a single ASCII character in the set 0-9, #, *, A-D. Even it will support string DTMF.
1348 * integer in range 0-255, meaning 1/10(10 millisec) seconds multiples. The string parameter
1349 * of the command consists of combinations of the following separated by commas:
1350 * NOTE : There is a limit of 50 dtmf tones can be requested through a single VTS command.
1355 * +CME ERROR: <error>
1357 static TelReturn imc_call_send_dtmf(CoreObject *co, const char *dtmf_str,
1358 TcoreObjectResponseCallback cb, void *cb_data)
1361 char *tmp_dtmf = NULL, *dtmf;
1366 //(void) _set_dtmf_tone_duration(o, dup);
1368 /* DTMF digits + comma for each dtmf digit */
1369 tmp_dtmf = tcore_malloc0((strlen(dtmf_str) * 2) + 1);
1370 tcore_check_return_value_assert(tmp_dtmf != NULL, TEL_RETURN_FAILURE);
1371 /* Save initial pointer */
1374 for (count = 0; count < strlen(dtmf_str); count++) {
1375 *tmp_dtmf = dtmf_str[count];
1382 /* last digit is having COMMA , overwrite it with '\0'*/
1383 *(--tmp_dtmf) = '\0';
1385 /* (AT+VTS = <d1>,<d2>,<d3>,<d4>,<d5>,<d6>, ..... <d32> */
1386 at_cmd = g_strdup_printf("AT+VTS=%s", dtmf);
1387 dbg("at command : %s", at_cmd);
1391 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_send_dtmf");
1395 * Operation - call hold.
1398 * 1. AT-Command: AT+CHLD=[<n>]
1401 * 2 - place all active calls (if exist) on hold and accepts the other call (held or waiting/incoming).
1402 * If only one call exists which is active, place it on hold and if only held call exists
1403 * make it active call
1408 * +CME ERROR: <error>
1410 static TelReturn imc_call_hold(CoreObject *co, TcoreObjectResponseCallback cb,
1417 at_cmd = g_strdup_printf("%s", "AT+CHLD=2");
1418 dbg("at command : %s", at_cmd);
1420 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_hold");
1424 * Operation - call active.
1427 * 1. AT-Command: AT+CHLD=[<n>]
1430 * 2 - place all active calls (if exist) on hold and accepts the other call (held or waiting/incoming).
1431 * If only one call exists which is active, place it on hold and if only held call exists
1432 * make it active call
1437 * +CME ERROR: <error>
1439 static TelReturn imc_call_active(CoreObject *co, TcoreObjectResponseCallback cb,
1445 at_cmd = g_strdup_printf("%s", "AT+CHLD=2");
1446 dbg("at command : %s", at_cmd);
1448 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_active");
1452 * Operation - call swap.
1455 * 1. AT-Command: AT+CHLD=[<n>]
1458 * 2 - place all active calls (if exist) on hold and accepts the other call (held or waiting/incoming).
1459 * If only one call exists which is active, place it on hold and if only held call exists
1460 * make it active call
1465 * +CME ERROR: <error>
1467 static TelReturn imc_call_swap(CoreObject *co, TcoreObjectResponseCallback cb,
1473 at_cmd = g_strdup_printf("%s", "AT+CHLD=2");
1474 dbg("at command : %s", at_cmd);
1476 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_swap");
1480 * Operation - call join.
1483 * 1. AT-Command: AT+CHLD=[<n>]
1486 * 3 - adds a held call to the conversation
1491 * +CME ERROR: <error>
1493 static TelReturn imc_call_join(CoreObject *co, TcoreObjectResponseCallback cb,
1499 at_cmd = g_strdup_printf("%s", "AT+CHLD=3");
1500 dbg("at command : %s", at_cmd);
1502 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_join");
1506 * Operation - call split.
1509 * 1. AT-Command: AT+CHLD=[<n>]
1512 * 2x - place all active calls on hold except call x with which communication is supported
1517 * +CME ERROR: <error>
1519 static TelReturn imc_call_split(CoreObject *co, unsigned int call_id,
1520 TcoreObjectResponseCallback cb, void *cb_data)
1525 at_cmd = g_strdup_printf("%s%d", "AT+CHLD=2", call_id);
1526 dbg("at command : %s", at_cmd);
1528 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_split");
1532 * Operation - call transfer.
1535 * 1. AT-Command: AT+CHLD=[<n>]
1538 * 4 connects the two calls and disconnects the subscriber from both calls (Explicit Call Transfer)
1543 * +CME ERROR: <error>
1545 static TelReturn imc_call_transfer(CoreObject *co, TcoreObjectResponseCallback cb,
1551 at_cmd = g_strdup_printf("%s", "AT+CHLD=4");
1552 dbg("at command : %s", at_cmd);
1554 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_transfer");
1558 * Operation - call deflect.
1561 * 1. AT-Command: AT+CTFR= <number>[,<type>]
1564 * string type phone number
1566 * type of address octet in integer format. It is optional parameter.
1572 * +CME ERROR: <error>
1574 static TelReturn imc_call_deflect(CoreObject *co, const char *deflect_to,
1575 TcoreObjectResponseCallback cb, void *cb_data)
1580 at_cmd = g_strdup_printf("AT+CTFR=%s", deflect_to);
1581 dbg("at command : %s", at_cmd);
1583 return __send_call_request(co, cb, cb_data, at_cmd, "imc_call_deflect");
1586 static TelReturn imc_call_set_active_line(CoreObject *co, TelCallActiveLine active_line,
1587 TcoreObjectResponseCallback cb, void *cb_data)
1592 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1595 static TelReturn imc_call_get_active_line(CoreObject *co, TcoreObjectResponseCallback cb,
1601 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1605 * Operation - Set voule info.
1608 * AT-Command: AT+XDRV=<group_id>,<function_id>[,<param_n>]
1609 * The first command parameter defines the involved driver group.
1610 * The second command parameter defines a certain function in the selected driver group.
1611 * Other parameters are dependent on the first two parameters.
1612 * Nearly all parameters are integer values, also if they are represented by literals.
1613 * Only very few are strings or
1617 * +XDRV: <group_id>,<function_id>,<xdrv_result>[,<response_n>]
1618 * The first response parameter defines the involved driver group.
1619 * The second response parameter defines the current function in the selected driver group.
1620 * The third response parameter defines the xdrv_result of the operation.
1621 * Additional response parameters dependent on the first two parameters.
1623 static TelReturn imc_call_set_volume_info(CoreObject *co, const TelCallVolumeInfo *volume_info,
1624 TcoreObjectResponseCallback cb, void *cb_data)
1626 ImcRespCbData *resp_cb_data = NULL;
1629 struct imc_set_volume_info cb_volume_info;
1633 cb_volume_info.next_index = 1;
1634 cb_volume_info.volume = volume_info->volume;
1636 /* Response callback data */
1637 resp_cb_data = imc_create_resp_cb_data(cb, cb_data,
1638 &cb_volume_info, sizeof(struct imc_set_volume_info));
1640 at_cmd = g_strdup_printf("%s", xdrv_set_volume[0]);
1642 /* Send Request to modem */
1643 ret = tcore_at_prepare_and_send_request(co,
1645 TCORE_AT_COMMAND_TYPE_SINGLELINE,
1647 on_response_imc_call_set_volume_info, resp_cb_data,
1648 on_send_imc_request, NULL);
1649 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, "imc_call_set_volume_info");
1656 static TelReturn imc_call_get_volume_info(CoreObject *co, TelCallSoundDevice sound_device,
1657 TcoreObjectResponseCallback cb, void *cb_data)
1662 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1666 * Operation - Set sound path.
1669 * AT-Command: AT+XDRV=<group_id>,<function_id>[,<param_n>]
1670 * The first command parameter defines the involved driver group.
1671 * The second command parameter defines a certain function in the selected driver group.
1672 * Other parameters are dependent on the first two parameters.
1673 * Nearly all parameters are integer values, also if they are represented by literals.
1674 * Only very few are strings or
1678 * +XDRV: <group_id>,<function_id>,<xdrv_result>[,<response_n>]
1679 * The first response parameter defines the involved driver group.
1680 * The second response parameter defines the current function in the selected driver group.
1681 * The third response parameter defines the xdrv_result of the operation.
1682 * Additional response parameters dependent on the first two parameters.
1685 static TelReturn imc_call_set_sound_path(CoreObject *co, const TelCallSoundPathInfo *sound_path_info,
1686 TcoreObjectResponseCallback cb, void *cb_data)
1688 ImcRespCbData *resp_cb_data = NULL;
1691 gint device_type = -1;
1692 TcorePlugin *plugin = tcore_object_ref_plugin(co);
1693 const char *cp_name = tcore_server_get_cp_name_by_plugin(plugin);
1695 dbg("audio device type - 0x%x", sound_path_info->path);
1697 switch (sound_path_info->path) {
1698 case TEL_SOUND_PATH_HANDSET:
1701 case TEL_SOUND_PATH_HEADSET:
1704 case TEL_SOUND_PATH_HEADSET_3_5PI:
1707 case TEL_SOUND_PATH_SPK_PHONE:
1710 case TEL_SOUND_PATH_HANDSFREE:
1713 case TEL_SOUND_PATH_HEADSET_HAC:
1716 case TEL_SOUND_PATH_BLUETOOTH:
1717 case TEL_SOUND_PATH_STEREO_BLUETOOTH:
1720 case TEL_SOUND_PATH_BT_NSEC_OFF:
1721 case TEL_SOUND_PATH_MIC1:
1722 case TEL_SOUND_PATH_MIC2:
1724 dbg("unsupported device type");
1725 return TEL_RETURN_INVALID_PARAMETER;
1728 if (g_str_has_prefix(cp_name, "imcmodem")) {
1729 /* Response callback data */
1730 resp_cb_data = imc_create_resp_cb_data(cb, cb_data, &device_type, sizeof(gint));
1732 at_cmd = g_strdup_printf("AT+XDRV=40,4,3,0,0,0,0,0,1,0,1,0,%d", device_type);
1734 ret = tcore_at_prepare_and_send_request(co,
1736 TCORE_AT_COMMAND_TYPE_SINGLELINE,
1738 on_response_imc_call_set_sound_path, resp_cb_data,
1739 on_send_imc_request, NULL);
1740 IMC_CHECK_REQUEST_RET(ret, NULL, "imc_call_set_sound_path");
1743 /* Response callback data */
1744 resp_cb_data = imc_create_resp_cb_data(cb, cb_data, NULL, 0);
1746 /* Configure modem I2S1 to 8khz, mono, PCM if routing to bluetooth */
1747 if (sound_path_info->path == TEL_SOUND_PATH_BLUETOOTH ||
1748 sound_path_info->path == TEL_SOUND_PATH_STEREO_BLUETOOTH) {
1749 tcore_at_prepare_and_send_request(co,
1750 "AT+XDRV=40,4,3,0,1,0,0,0,0,0,0,0,21",
1751 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1752 NULL, NULL, NULL, NULL, NULL);
1754 tcore_at_prepare_and_send_request(co,
1755 "AT+XDRV=40,5,2,0,1,0,0,0,0,0,0,0,22",
1756 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1757 NULL, NULL, NULL, NULL, NULL);
1759 tcore_at_prepare_and_send_request(co,
1760 "AT+XDRV=40,4,3,0,1,0,8,0,1,0,2,0,21",
1761 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1762 NULL, NULL, NULL, NULL, NULL);
1764 tcore_at_prepare_and_send_request(co,
1765 "AT+XDRV=40,5,2,0,1,0,8,0,1,0,2,0,22",
1766 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1767 NULL, NULL, NULL, NULL, NULL);
1770 /* Configure modem I2S2 and do the modem routing */
1771 tcore_at_prepare_and_send_request(co,
1772 "AT+XDRV=40,4,4,0,0,0,8,0,1,0,2,0,21",
1773 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1774 NULL, NULL, NULL, NULL, NULL);
1776 tcore_at_prepare_and_send_request(co,
1777 "AT+XDRV=40,5,3,0,0,0,8,0,1,0,2,0,22",
1778 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1779 NULL, NULL, NULL, NULL, NULL);
1781 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,6,0,4",
1782 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1783 NULL, NULL, NULL, NULL, NULL);
1785 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,6,3,0",
1786 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1787 NULL, NULL, NULL, NULL, NULL);
1789 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,6,4,2",
1790 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1791 NULL, NULL, NULL, NULL, NULL);
1793 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,6,5,2",
1794 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1795 NULL, NULL, NULL, NULL, NULL);
1798 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,2,4",
1799 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1800 NULL, NULL, NULL, NULL, NULL);
1802 tcore_at_prepare_and_send_request(co, "AT+XDRV=40,2,3",
1803 NULL, TCORE_AT_COMMAND_TYPE_NO_RESULT,
1804 NULL, NULL, NULL, NULL, NULL);
1806 /* amc route: AMC_RADIO_RX => AMC_I2S1_TX */
1807 ret = tcore_at_prepare_and_send_request(co, "AT+XDRV=40,6,0,2",
1808 "+XDRV", TCORE_AT_COMMAND_TYPE_SINGLELINE, NULL,
1809 on_response_set_sound_path, resp_cb_data, NULL, NULL);
1811 IMC_CHECK_REQUEST_RET(ret, NULL, "imc_call_set_sound_path");
1818 * Operation - Set/Unset mute status.
1821 * AT-Command: AT+XDRV=<group_id>,<function_id>[,<param_n>]
1822 * The first command parameter defines the involved driver group.
1823 * The second command parameter defines a certain function in the selected driver group.
1824 * Other parameters are dependent on the first two parameters.
1825 * Nearly all parameters are integer values, also if they are represented by literals.
1826 * Only very few are strings or
1830 * +XDRV: <group_id>,<function_id>,<xdrv_result>[,<response_n>]
1831 * The first response parameter defines the involved driver group.
1832 * The second response parameter defines the current function in the selected driver group.
1833 * The third response parameter defines the xdrv_result of the operation.
1834 * Additional response parameters dependent on the first two parameters.
1836 static TelReturn imc_call_set_mute(CoreObject *co, gboolean mute, TcoreObjectResponseCallback cb,
1839 ImcRespCbData *resp_cb_data = NULL;
1845 /* Response callback data */
1846 resp_cb_data = imc_create_resp_cb_data(cb, cb_data, NULL, 0);
1850 at_cmd = g_strdup_printf("%s", "AT+XDRV=40,8,0,0,0"); /*MUTE*/
1852 at_cmd = g_strdup_printf("%s", "AT+XDRV=40,8,0,0,88"); /*UNMUTE*/
1854 /* Send Request to modem */
1855 ret = tcore_at_prepare_and_send_request(co,
1857 TCORE_AT_COMMAND_TYPE_SINGLELINE,
1859 on_response_imc_call_set_mute, resp_cb_data,
1860 on_send_imc_request, NULL);
1861 IMC_CHECK_REQUEST_RET(ret, resp_cb_data, "imc_call_set_mute");
1868 static TelReturn imc_call_get_mute_status(CoreObject *co, TcoreObjectResponseCallback cb,
1874 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1878 static TelReturn imc_call_set_sound_recording(CoreObject *co, TelCallSoundRecording sound_rec,
1879 TcoreObjectResponseCallback cb, void *cb_data)
1884 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1887 static TelReturn imc_call_set_sound_equalization(CoreObject *co, const TelCallSoundEqualization *sound_eq,
1888 TcoreObjectResponseCallback cb, void *cb_data)
1893 return TEL_RETURN_OPERATION_NOT_SUPPORTED;
1896 /* Call Operations */
1897 static TcoreCallOps imc_call_ops = {
1898 .dial = imc_call_dial,
1899 .answer = imc_call_answer,
1900 .end = imc_call_end,
1901 .send_dtmf = imc_call_send_dtmf,
1902 .hold = imc_call_hold,
1903 .active = imc_call_active,
1904 .swap = imc_call_swap,
1905 .join = imc_call_join,
1906 .split = imc_call_split,
1907 .transfer = imc_call_transfer,
1908 .deflect = imc_call_deflect,
1909 .set_active_line = imc_call_set_active_line,
1910 .get_active_line = imc_call_get_active_line,
1911 .set_volume_info = imc_call_set_volume_info,
1912 .get_volume_info = imc_call_get_volume_info,
1913 .set_sound_path = imc_call_set_sound_path,
1914 .set_mute = imc_call_set_mute,
1915 .get_mute_status = imc_call_get_mute_status,
1916 .set_sound_recording = imc_call_set_sound_recording,
1917 .set_sound_equalization = imc_call_set_sound_equalization,
1920 gboolean imc_call_init(TcorePlugin *p, CoreObject *co)
1924 /* Set operations */
1925 tcore_call_set_ops(co, &imc_call_ops);
1928 tcore_object_add_callback(co, "+XCALLSTAT", on_notification_imc_call_status, NULL);
1929 tcore_object_add_callback(co, "+CLIP", on_notification_imc_call_clip_info, NULL);
1930 tcore_object_add_callback(co, "+CSSU", on_notification_imc_call_ss_cssu_info, NULL);
1931 tcore_object_add_callback(co, "+CSSI", on_notification_imc_call_ss_cssi_info, NULL);
1936 void imc_call_exit(TcorePlugin *p, CoreObject *co)