4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hayoon Ko <hayoon.ko@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
29 #include <core_object.h>
34 #include <user_request.h>
41 #include "atchannel.h"
44 extern struct ATResponse *sp_response;
45 extern char *s_responsePrefix;
46 extern enum ATCommandType s_type;
51 enum telephony_ss_opcode {
52 TIZEN_SS_OPCO_REG=0x01, /* 0x01 : Registration */
53 TIZEN_SS_OPCO_DEREG, /* 0x02 : De-registration( erase ) */
54 TIZEN_SS_OPCO_ACTIVATE, /* 0x03 : Activation */
55 TIZEN_SS_OPCO_DEACTIVATE, /* 0x04 : De-activation */
60 struct ss_confirm_info {
61 enum telephony_ss_class class;
63 enum tcore_response_command resp;
68 #define TIZEN_NUM_TYPE_INTERNATIONAL 0x01
69 #define TIZEN_NUM_PLAN_ISDN 0x01
72 static gboolean _ss_request_message( CoreObject *o,
79 static TReturn _ss_general_response_result(const int result);
82 static TReturn _ss_barring_get( CoreObject *o,
84 enum telephony_ss_class class,
85 enum telephony_ss_barring_mode type,
86 enum tcore_response_command resp );
88 static TReturn _ss_forwarding_get( CoreObject *o,
90 enum telephony_ss_class class,
91 enum telephony_ss_forwarding_mode type,
92 enum tcore_response_command resp );
94 static TReturn _ss_waiting_get( CoreObject *o,
96 enum telephony_ss_class class,
97 enum tcore_response_command resp );
100 static TReturn s_ss_barring_activate( CoreObject *o, UserRequest *ur );
101 static TReturn s_ss_barring_deactivate( CoreObject *o, UserRequest *ur );
102 static TReturn s_ss_barring_change_password( CoreObject *o, UserRequest *ur );
103 static TReturn s_ss_barring_get_status( CoreObject *o, UserRequest *ur );
105 static TReturn s_ss_forwarding_activate( CoreObject *o, UserRequest *ur );
106 static TReturn s_ss_forwarding_deactivate( CoreObject *o, UserRequest *ur );
107 static TReturn s_ss_forwarding_register( CoreObject *o, UserRequest *ur );
108 static TReturn s_ss_forwarding_deregister( CoreObject *o, UserRequest *ur );
109 static TReturn s_ss_forwarding_get_status( CoreObject *o, UserRequest *ur );
111 static TReturn s_ss_waiting_activate( CoreObject *o, UserRequest *ur );
112 static TReturn s_ss_waiting_deactivate( CoreObject *o, UserRequest *ur );
113 static TReturn s_ss_waiting_get_status( CoreObject *o, UserRequest *ur );
115 static TReturn s_ss_cli_activate( CoreObject *o, UserRequest *ur );
116 static TReturn s_ss_cli_deactivate( CoreObject *o, UserRequest *ur );
117 static TReturn s_ss_cli_get_status( CoreObject *o, UserRequest *ur );
119 static TReturn s_ss_send_ussd( CoreObject *o, UserRequest *ur );
121 static TReturn s_ss_set_aoc( CoreObject *o, UserRequest *ur );
122 static TReturn s_ss_get_aoc( CoreObject *o, UserRequest *ur );
124 static TReturn s_ss_manage_call_0_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
125 static TReturn s_ss_manage_call_1_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
126 static TReturn s_ss_manage_call_1x_send( CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data );
127 static TReturn s_ss_manage_call_2_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
128 static TReturn s_ss_manage_call_2x_send( CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data );
129 static TReturn s_ss_manage_call_3_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
130 static TReturn s_ss_manage_call_4_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
131 static TReturn s_ss_manage_call_4dn_send( CoreObject* o, UserRequest* ur, const char* number, ConfirmCallback cb, void* user_data );
133 static TReturn s_ss_manage_call_5_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
134 static TReturn s_ss_manage_call_6_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data );
137 static void on_confirmation_call_control_ss_message_send( TcorePending *p, gboolean result, void *user_data );
139 static void on_confirmation_ss_message_send( TcorePending *p, gboolean result, void *user_data );
142 static gboolean on_notification_ss_info( CoreObject *o, const void *data, void *user_data );
144 static void _ss_ussd_response( UserRequest *ur, const char* ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status );
145 static void _ss_ussd_notification( TcorePlugin *p, const char* ussd_str, enum telephony_ss_ussd_status status );
146 static gboolean on_notification_ss_ussd( CoreObject *o, const void *data, void *user_data );
149 static gboolean _ss_request_message( CoreObject *o,
152 unsigned int cmd_len,
156 TcorePending *pending = 0;
159 UserRequest *ur2 = 0;
161 ur2 = tcore_user_request_ref( ur );
163 pending = tcore_pending_new(o, ID_RESERVED_AT);
164 tcore_pending_set_request_data(pending, cmd_len, cmd);
165 tcore_pending_set_timeout(pending, 0);
168 tcore_pending_set_response_callback(pending, on_resp, user_data);
170 tcore_pending_set_send_callback(pending, on_confirmation_ss_message_send, 0);
173 dbg("[ check ] ur is 0, is this internal request??");
175 tcore_pending_link_user_request(pending, ur2);
178 p = tcore_object_ref_plugin(o);
179 h = tcore_object_get_hal(o);
180 tcore_hal_send_request(h, pending);
186 static TReturn _ss_general_response_result(const int ret)
188 if (ret == 0x8000 || ret == 0x8100) {
189 return TCORE_RETURN_SUCCESS;
192 return TCORE_RETURN_3GPP_ERROR + ret;
196 static void _ss_ussd_response( UserRequest *ur, const char* ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status )
198 struct tresp_ss_ussd resp;
201 dbg("[ error ] ur : (NULL)");
206 resp.status = status;
207 resp.err = SS_ERROR_NONE;
211 int len = strlen( ussd_str );
213 if ( len < MAX_SS_USSD_LEN ) {
214 memcpy( resp.str, ussd_str, len );
215 resp.str[ len ] = '\0';
217 memcpy( resp.str, ussd_str, MAX_SS_USSD_LEN );
218 resp.str[ MAX_SS_USSD_LEN - 1 ] = '\0';
221 dbg("resp.str : %s", resp.str);
225 memset( resp.str, '\0', MAX_SS_USSD_LEN );
229 tcore_user_request_send_response(ur, TRESP_SS_SEND_USSD, sizeof(struct tresp_ss_ussd), &resp);
232 static void _ss_ussd_notification( TcorePlugin *p, const char* ussd_str, enum telephony_ss_ussd_status status )
235 struct tnoti_ss_ussd noti;
238 dbg("[ error ] p : (NULL)");
242 noti.status = status;
246 int len = strlen( ussd_str );
248 if ( len < MAX_SS_USSD_LEN ) {
249 memcpy( noti.str, ussd_str, len );
250 noti.str[ len ] = '\0';
252 memcpy( noti.str, ussd_str, MAX_SS_USSD_LEN );
253 noti.str[ MAX_SS_USSD_LEN - 1 ] = '\0';
258 memset( noti.str, '\0', MAX_SS_USSD_LEN );
262 o = tcore_plugin_ref_core_object(p, "ss");
264 tcore_server_send_notification( tcore_plugin_ref_server(p),
267 sizeof(struct tnoti_ss_ussd),
272 static gboolean on_notification_ss_ussd( CoreObject *o, const void *data, void *user_data )
274 enum telephony_ss_ussd_status status;
275 UssdSession *ussd_session = 0;
276 char *ussd_str = 0, *cmd = 0, *tmp_str=0;
278 int err =0, m=0, dcs=0;
280 p = tcore_object_ref_plugin(o);
282 ussd_session = tcore_ss_ussd_get_session(o);
288 err = at_tok_nextint(&cmd, &m);
293 status = SS_USSD_NO_ACTION_REQUIRE;
297 status = SS_USSD_ACTION_REQUIRE;
301 status = SS_USSD_TERMINATED_BY_NET;
305 status = SS_USSD_OTHER_CLIENT;
309 status = SS_USSD_NOT_SUPPORT;
313 status = SS_USSD_TIME_OUT;
317 dbg("unsupported m : %d", m);
318 status = SS_USSD_MAX;
322 if(at_tok_hasmore(&cmd))
324 err = at_tok_nextstr(&cmd, &tmp_str);
325 err = at_tok_nextint(&cmd, &dcs);
327 dbg("ussdstr: %s, dcs :%d", tmp_str, dcs);
330 switch ( tcore_util_get_cbs_coding_scheme(dcs) ) {
331 case TCORE_DCS_TYPE_7_BIT:
332 case TCORE_DCS_TYPE_UNSPECIFIED: {
333 ussd_str = (char *)tcore_util_unpack_gsm7bit((const unsigned char *)tmp_str, strlen(tmp_str));
336 case TCORE_DCS_TYPE_UCS2:
337 case TCORE_DCS_TYPE_8_BIT: {
338 if ( strlen(tmp_str) > 0 ) {
339 ussd_str = g_new0( char, strlen(tmp_str) + 1);
340 memcpy( ussd_str,tmp_str, strlen(tmp_str) );
341 ussd_str[ strlen(tmp_str) ] = '\0';
345 dbg("[ error ] unknown dcs type. ussd_session : %x", ussd_session);
346 if ( ussd_session ) {
349 enum telephony_ss_ussd_type type;
351 tcore_ss_ussd_get_session_data( ussd_session, (void**)&ur );
353 dbg("[ error ] ur : (0)");
357 type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type( ussd_session );
359 _ss_ussd_response( ur, ussd_str, type, status );
366 case SS_USSD_NO_ACTION_REQUIRE:
367 case SS_USSD_ACTION_REQUIRE:
368 case SS_USSD_OTHER_CLIENT:
369 case SS_USSD_NOT_SUPPORT:
370 case SS_USSD_TIME_OUT: {
372 // UserRequest *ur = 0;
374 if ( ussd_session ) {
377 enum telephony_ss_ussd_type type;
379 tcore_ss_ussd_get_session_data( ussd_session, (void**)&ur );
381 dbg("[ error ] ur : (0)");
385 type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type( ussd_session );
387 _ss_ussd_response( ur, (const char*)ussd_str, type, status );
393 tcore_ss_ussd_create_session( o, TCORE_SS_USSD_TYPE_NETWORK_INITIATED, 0, 0 );
395 _ss_ussd_notification( p, (const char*)ussd_str, status );
401 case SS_USSD_TERMINATED_BY_NET: {
403 if ( ussd_session ) {
406 tcore_ss_ussd_get_session_data( ussd_session, (void**)&ur );
409 tcore_user_request_unref( ur );
411 tcore_ss_ussd_destroy_session( ussd_session );
422 static gboolean on_notification_ss_info( CoreObject *o, const void *data, void *user_data )
426 char* cmd = 0, *number = 0;
427 int code2 =0, err=0, index=0, ton=0;
430 p = tcore_object_ref_plugin( o );
431 co = tcore_plugin_ref_core_object( p, "call" );
433 dbg("[ error ] plugin_ref_core_object : call");
440 err = at_tok_nextint(&cmd, &code2);
441 dbg("code2 : %d",code2);
443 if(at_tok_hasmore(&cmd))
444 err = at_tok_nextint(&cmd, &index); //cug index - skip
445 if(at_tok_hasmore(&cmd)){
446 err = at_tok_nextstr(&cmd, &number);
447 dbg("number : %s",number);
448 err = at_tok_nextint(&cmd, &ton);
452 case 0: //this is a forwarded call (MT call setup)
453 tcore_call_information_mt_forwarded_call( co, number );
456 case 2: //call has been put on hold (during a voice call)
457 tcore_call_information_held( co, number );
460 case 3: //call has been retrieved (during a voice call)
461 tcore_call_information_active( co, number );
464 case 4: //multiparty call entered (during a voice call)
465 tcore_call_information_joined( co, number );
468 case 5: //call on hold has been released
469 tcore_call_information_released_on_hold( co, number );
472 case 6: //forward check SS message received (can be received whenever)
473 tcore_call_information_cf_check_ss_message( co, number );
476 case 7: //call is being connected (alerting) with the remote party in alerting state in explicit call transfer operation (during a voice call)
477 tcore_call_information_transfer_alert( co, number );
480 case 8: //call has been connected with the other remote party in explicit call transfer operation (also number and subaddress parameters may be present) (during a voice call or MT call setup)
481 tcore_call_information_transfered( co, number );
484 case 9: //this is a deflected call (MT call setup):
485 tcore_call_information_mt_deflected_call( co, number );
489 dbg("unsupported cmd2 : %d",code2);
496 static void on_confirmation_ss_message_send( TcorePending *p, gboolean result, void *user_data )
498 UserRequest* ur = NULL;
499 struct ATReqMetaInfo* metainfo = NULL;
500 unsigned int info_len =0;
501 dbg("on_confirmation_ss_message_send - msg out from queue. alloc ATRsp buffer & write rspPrefix if needed\n");
503 ReleaseResponse(); // release leftover
504 //alloc new sp_response
505 sp_response = at_response_new();
508 ur = tcore_pending_ref_user_request(p);
509 metainfo = (struct ATReqMetaInfo*)tcore_user_request_ref_metainfo(ur,&info_len);
511 if((metainfo->type == SINGLELINE)||
512 (metainfo->type == MULTILINE))
515 s_responsePrefix = strdup(metainfo->responsePrefix);
516 dbg("duplicating responsePrefix : %s\n", s_responsePrefix);
520 s_responsePrefix = NULL;
523 //set atcmd type into s_type
524 s_type = metainfo->type;
527 static void on_confirmation_call_control_ss_message_send( TcorePending *p, gboolean result, void *user_data )
529 UserRequest* ur = NULL;
530 struct ATReqMetaInfo* metainfo = NULL;
531 unsigned int info_len =0;
532 dbg("on_confirmation_call_control_ss_message_send - msg out from queue. alloc ATRsp buffer & write rspPrefix if needed\n");
534 ReleaseResponse(); // release leftover
535 //alloc new sp_response
536 sp_response = at_response_new();
539 ur = tcore_pending_ref_user_request(p);
540 metainfo = (struct ATReqMetaInfo*)tcore_user_request_ref_metainfo(ur,&info_len);
542 if((metainfo->type == SINGLELINE)||
543 (metainfo->type == MULTILINE))
546 s_responsePrefix = strdup(metainfo->responsePrefix);
547 dbg("duplicating responsePrefix : %s\n", s_responsePrefix);
551 s_responsePrefix = NULL;
554 //set atcmd type into s_type
555 s_type = metainfo->type;
558 static void on_response_ss_barring_set( TcorePending *p, int data_len, const void *data, void *user_data )
560 struct ss_confirm_info *info = 0;
561 enum telephony_ss_class class;
565 struct tresp_ss_barring resp;
566 UserRequest *ur_dup=0;
568 o = tcore_pending_ref_core_object(p);
569 ur = tcore_pending_ref_user_request(p);
573 info = (struct ss_confirm_info*)user_data;
577 if(sp_response->success > 0){
578 resp.err = SS_ERROR_NONE;
582 resp.err = SS_ERROR_SYSTEMFAILURE;
585 dbg("on_response_ss_barring_set - rsp.err : %d, ur : %x", resp.err, ur);
588 if(sp_response->success > 0)
592 if ( info->class == SS_CLASS_VOICE )
593 class = SS_CLASS_ALL_TELE_BEARER;
595 ur_dup = tcore_user_request_ref(ur);
597 if ( info->flavor_type == SS_BARR_MODE_AB ||
598 info->flavor_type == SS_BARR_MODE_AOB )
599 _ss_barring_get( o, ur_dup, class, SS_BARR_MODE_BAOC, info->resp );
600 else if ( info->flavor_type == SS_BARR_MODE_AIB )
601 _ss_barring_get( o, ur_dup, class, SS_BARR_MODE_BAIC, info->resp );
603 _ss_barring_get( o, ur_dup, class, info->flavor_type, info->resp );
611 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
613 dbg("[ error ] ur is 0");
622 static void on_response_ss_barring_change_pwd( TcorePending *p, int data_len, const void *data, void *user_data )
624 struct ss_confirm_info *info = 0;
626 struct tresp_ss_general resp;
628 ur = tcore_pending_ref_user_request(p);
630 info = (struct ss_confirm_info*)user_data;
634 if(sp_response->success > 0){
635 resp.err = SS_ERROR_NONE;
638 resp.err = SS_ERROR_SYSTEMFAILURE;
643 dbg("on_response_ss_barring_change_pwd: rsp.err : %d, usr : %x", resp.err, ur);
646 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);
648 dbg("[ error ] ur is 0");
654 static void on_response_ss_barring_get( TcorePending *p, int data_len, const void *data, void *user_data )
658 struct ATLine *p_cur;
659 int status=0, classx =0, err=0;
661 struct ss_confirm_info* info = 0;
662 struct tresp_ss_barring resp;
663 int countRecords=0, countValidRecords =0;
665 o = tcore_pending_ref_core_object(p);
666 ur = tcore_pending_ref_user_request(p);
670 info = (struct ss_confirm_info*)user_data;
672 /* count the calls */
673 for (countRecords = 0, p_cur = sp_response->p_intermediates
675 ; p_cur = p_cur->p_next
679 dbg("total records : %d",countRecords);
682 resp.record_num = countRecords;
684 if ( resp.record_num > 0 ) {
687 resp.record = g_new0( struct barring_info, resp.record_num );
689 for (countValidRecords = 0, p_cur = sp_response->p_intermediates
691 ; p_cur = p_cur->p_next)
693 err = at_tok_start(&(p_cur->line));
695 dbg("start line error. skip this line");
698 err = at_tok_nextint(&(p_cur->line), &status);// status
700 dbg("status error. skip this line");
705 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
708 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
711 err = at_tok_nextint(&(p_cur->line), &classx); //class
713 dbg("class error. classx not exist - set to requested one : %d", info->class);
715 case SS_CLASS_ALL_TELE:
721 case SS_CLASS_ALL_DATA_TELE:
730 case SS_CLASS_ALL_CS_SYNC:
736 dbg("unsupported class %d. set to default : 7", info->class);
743 resp.record[countValidRecords].class = SS_CLASS_VOICE;
746 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
749 resp.record[countValidRecords].class = SS_CLASS_FAX;
752 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
755 resp.record[countValidRecords].class = SS_CLASS_SMS;
758 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
761 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
764 dbg("unspoorted class : [%d]\n", classx );
769 resp.record[countValidRecords].mode = (enum telephony_ss_barring_mode)(info->flavor_type);
774 dbg("invalid field found. coutinue");
778 dbg("valid count :%d",countValidRecords);
779 resp.record_num = countValidRecords;
780 resp.err = SS_ERROR_NONE;
785 dbg("no active status - return to user")
788 if(sp_response->success > 0){
789 resp.err = SS_ERROR_NONE;
792 resp.err = SS_ERROR_SYSTEMFAILURE;
795 dbg("on_response_ss_barring_get- rsp.err : %d, ur : %x", resp.err, ur);
800 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
802 dbg("[ error ] ur is 0");
808 static void on_response_ss_forwarding_set( TcorePending *p, int data_len, const void *data, void *user_data )
811 UserRequest* ur = 0, *dup_ur=0;
812 struct ss_confirm_info *info = 0;
813 struct tresp_ss_general resp;
815 o = tcore_pending_ref_core_object(p);
816 ur = tcore_pending_ref_user_request(p);
818 info = (struct ss_confirm_info*)user_data;
822 if(sp_response->success > 0){
823 resp.err = SS_ERROR_NONE;
825 resp.err = SS_ERROR_SYSTEMFAILURE;
828 dbg("[ check ] class : 0x%x", info->class );
829 dbg("[ check ] flavor_type : 0x%x", info->flavor_type );
831 dbg("on_response_ss_forwarding_set - rsp.err : %d, ur : %x", resp.err, ur);
833 if ( sp_response->success > 0) {
837 if ( info->flavor_type == SS_CF_MODE_CF_ALL ||
838 info->flavor_type == SS_CF_MODE_CFC ) {
841 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);
843 dbg("[ error ] ur is 0");
846 dup_ur = tcore_user_request_ref(ur);
847 _ss_forwarding_get( o, dup_ur, info->class, info->flavor_type, info->resp );
854 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);
856 dbg("[ error ] ur is 0");
862 static void on_response_ss_forwarding_get( TcorePending *p, int data_len, const void *data, void *user_data )
866 struct ATLine *p_cur;
867 int status=0, classx =0, err=0, ton =0, time=0;
870 struct ss_confirm_info* info = 0;
871 struct tresp_ss_forwarding resp;
872 int countRecords=0, countValidRecords =0;
874 o = tcore_pending_ref_core_object(p);
875 ur = tcore_pending_ref_user_request(p);
879 info = (struct ss_confirm_info*)user_data;
881 /* count the calls */
882 for (countRecords = 0, p_cur = sp_response->p_intermediates
884 ; p_cur = p_cur->p_next
888 dbg("total records : %d",countRecords);
891 resp.record_num = countRecords;
893 if ( resp.record_num > 0 ) {
896 resp.record = g_new0( struct forwarding_info, resp.record_num );
898 for (countValidRecords = 0, p_cur = sp_response->p_intermediates
900 ; p_cur = p_cur->p_next)
902 err = at_tok_start(&(p_cur->line));
904 dbg("start line error. skip this line");
907 err = at_tok_nextint(&(p_cur->line), &status);// status
909 dbg("status error. skip this line");
914 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
917 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
920 err = at_tok_nextint(&(p_cur->line), &classx); //class
922 dbg("class error. skip this line");
928 resp.record[countValidRecords].class = SS_CLASS_VOICE;
931 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
934 resp.record[countValidRecords].class = SS_CLASS_FAX;
937 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
940 resp.record[countValidRecords].class = SS_CLASS_SMS;
943 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
946 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
949 dbg("unspoorted class : [%d]\n", classx );
954 if(at_tok_hasmore(&(p_cur->line)) ==1){ //more data present
955 err = at_tok_nextstr(&(p_cur->line), &num); //number
956 memcpy((resp.record[countValidRecords].number), num, strlen(num));
957 resp.record[countValidRecords].number_present = TRUE;
959 err = at_tok_nextint(&(p_cur->line), &ton); // type of number - skip
960 resp.record[countValidRecords].number_type = ton;
962 if(at_tok_hasmore(&(p_cur->line)) ==1){
963 err = at_tok_nextstr(&(p_cur->line), &subaddr); //subaddr - skip
964 err =at_tok_nextint(&(p_cur->line), &ton); //ton of subaddr - skip
966 if(at_tok_hasmore(&(p_cur->line)) ==1){
967 err = at_tok_nextint(&(p_cur->line), &time); //time
968 resp.record[countValidRecords].time = (enum telephony_ss_forwarding_no_reply_time)time;
975 resp.record[countValidRecords].mode = (enum telephony_ss_forwarding_mode)(info->flavor_type);
980 dbg("invalid field found. coutinue");
984 dbg("valid count :%d",countValidRecords);
985 resp.record_num = countValidRecords;
986 resp.err = SS_ERROR_NONE;
991 dbg("no active status - return to user")
994 if(sp_response->success > 0){
995 resp.err = SS_ERROR_NONE;
998 resp.err = SS_ERROR_SYSTEMFAILURE;
1002 dbg("on_response_ss_forwarding_get - rsp.err : %d, ur : %x", resp.err, ur);
1005 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
1007 dbg("[ error ] ur is 0");
1009 g_free( user_data );
1013 static void on_response_ss_waiting_set( TcorePending *p, int data_len, const void *data, void *user_data )
1016 UserRequest* ur = 0;
1017 struct ss_confirm_info *info = 0;
1018 struct tresp_ss_general resp;
1020 o = tcore_pending_ref_core_object(p);
1021 ur = tcore_pending_ref_user_request(p);
1023 info = (struct ss_confirm_info*)user_data;
1025 if(sp_response->success > 0){
1026 resp.err = SS_ERROR_NONE;
1028 resp.err = SS_ERROR_SYSTEMFAILURE;
1033 dbg("on_response_ss_waiting_set - rsp.err : %d, ur : %x, class : %d", resp.err, ur, info->class );
1035 if ( resp.err == SS_ERROR_NONE ) {
1037 _ss_waiting_get( o, ur, info->class, info->resp );
1042 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);
1044 dbg("[ error ] ur is 0");
1047 g_free( user_data );
1050 static void on_response_ss_waiting_get( TcorePending *p, int data_len, const void *data, void *user_data )
1053 UserRequest* ur = 0;
1054 struct ATLine *p_cur;
1055 int status=0, classx =0, err=0;
1057 struct ss_confirm_info* info = 0;
1058 struct tresp_ss_waiting resp;
1059 int countRecords=0, countValidRecords =0;
1061 o = tcore_pending_ref_core_object(p);
1062 ur = tcore_pending_ref_user_request(p);
1066 info = (struct ss_confirm_info*)user_data;
1068 /* count the calls */
1069 for (countRecords = 0, p_cur = sp_response->p_intermediates
1071 ; p_cur = p_cur->p_next
1075 dbg("total records : %d",countRecords);
1078 resp.record_num = countRecords;
1080 if ( resp.record_num > 0 ) {
1083 resp.record = g_new0( struct waiting_info, resp.record_num );
1085 for (countValidRecords = 0, p_cur = sp_response->p_intermediates
1087 ; p_cur = p_cur->p_next)
1089 err = at_tok_start(&(p_cur->line));
1091 dbg("start line error. skip this line");
1095 err = at_tok_nextint(&(p_cur->line), &status);// status
1097 dbg("status error. skip this line");
1102 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
1105 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1108 err = at_tok_nextint(&(p_cur->line), &classx); //class
1110 dbg("class error. skip this line");
1116 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1119 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1122 resp.record[countValidRecords].class = SS_CLASS_FAX;
1125 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1128 resp.record[countValidRecords].class = SS_CLASS_SMS;
1131 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1134 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1137 dbg("unspoorted class : [%d]\n", classx );
1142 countValidRecords++;
1145 dbg("invalid field found. coutinue");
1149 dbg("valid count :%d",countValidRecords);
1150 resp.record_num = countValidRecords;
1151 resp.err = SS_ERROR_NONE;
1155 dbg("no active status - return to user")
1158 if(sp_response->success > 0){
1159 resp.err = SS_ERROR_NONE;
1162 resp.err = SS_ERROR_SYSTEMFAILURE;
1165 dbg("on_response_ss_waiting_get - rsp.err : %d, ur : %x", resp.err, ur);
1170 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);
1172 dbg("[ error ] ur is 0");
1174 g_free( user_data );
1178 static void on_confirmation_ss_ussd( TcorePending *p, int data_len, const void *data, void *user_data )
1180 struct ss_confirm_info *info = 0;
1182 struct tresp_ss_ussd resp;
1184 UserRequest* ur = 0;
1186 o = tcore_pending_ref_core_object(p);
1187 ur = tcore_pending_ref_user_request(p);
1192 info = (struct ss_confirm_info*)user_data;
1194 if(sp_response->success > 0){
1195 resp.err = SS_ERROR_NONE;
1198 resp.err = SS_ERROR_SYSTEMFAILURE;
1201 dbg("on_confirmation_ss_ussd - rsp.err : %d, ur : %x", resp.err, ur);
1204 if (sp_response->success > 0) {
1206 UssdSession *ussd_s = 0;
1207 enum tcore_ss_ussd_type type = 0;
1209 ussd_s = tcore_ss_ussd_get_session( o );
1212 type = tcore_ss_ussd_get_session_type( ussd_s );
1214 dbg("[ error ] ussd_s : (0)");
1216 resp.type = (enum telephony_ss_ussd_type)type;
1218 if ( type == TCORE_SS_USSD_TYPE_USER_INITIATED ) {
1219 UserRequest *ur2 = 0;
1221 tcore_ss_ussd_get_session_data( ussd_s, (void**)&ur2 );
1223 tcore_user_request_unref( ur2 );
1225 tcore_ss_ussd_destroy_session( ussd_s );
1229 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_ussd), &resp);
1231 dbg("[ error ] ur : (0)");
1236 g_free( user_data );
1241 static struct tcore_ss_operations ss_ops = {
1242 .barring_activate = s_ss_barring_activate,
1243 .barring_deactivate = s_ss_barring_deactivate,
1244 .barring_change_password= s_ss_barring_change_password,
1245 .barring_get_status = s_ss_barring_get_status,
1246 .forwarding_activate = s_ss_forwarding_activate,
1247 .forwarding_deactivate = s_ss_forwarding_deactivate,
1248 .forwarding_register = s_ss_forwarding_register,
1249 .forwarding_deregister = s_ss_forwarding_deregister,
1250 .forwarding_get_status = s_ss_forwarding_get_status,
1251 .waiting_activate = s_ss_waiting_activate,
1252 .waiting_deactivate = s_ss_waiting_deactivate,
1253 .waiting_get_status = s_ss_waiting_get_status,
1254 .cli_activate = s_ss_cli_activate,
1255 .cli_deactivate = s_ss_cli_deactivate,
1256 .cli_get_status = s_ss_cli_get_status,
1257 .send_ussd = s_ss_send_ussd,
1258 .set_aoc = s_ss_set_aoc,
1259 .get_aoc = s_ss_get_aoc,
1263 static TReturn _ss_barring_set( CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op )
1265 struct treq_ss_barring *barring = 0;
1267 struct ss_confirm_info *user_data = 0;
1268 gboolean ret = FALSE;
1269 char passwd[MAX_SS_BARRING_PASSWORD_LEN+1];
1271 struct ATReqMetaInfo metainfo;
1273 char* cmd_str = NULL;
1276 char* facility = NULL;
1279 barring = (struct treq_ss_barring*)tcore_user_request_ref_data( ur, 0 );
1280 p = tcore_object_ref_plugin( o );
1282 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1283 metainfo.type = NO_RESULT;
1284 metainfo.responsePrefix[0] ='\0';
1285 info_len = sizeof(struct ATReqMetaInfo);
1287 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
1291 case TIZEN_SS_OPCO_ACTIVATE:
1294 case TIZEN_SS_OPCO_DEACTIVATE:
1298 dbg("unsupported opco : %d", op);
1299 return TCORE_RETURN_FAILURE;
1303 switch(barring->mode){
1304 case SS_BARR_MODE_BAOC:
1307 case SS_BARR_MODE_BOIC:
1310 case SS_BARR_MODE_BOIC_NOT_HC:
1313 case SS_BARR_MODE_BAIC:
1316 case SS_BARR_MODE_BIC_ROAM:
1319 case SS_BARR_MODE_AB:
1322 case SS_BARR_MODE_AOB:
1325 case SS_BARR_MODE_AIB:
1328 case SS_BARR_MODE_BIC_NOT_SIM:
1332 dbg("unspported mode %d", barring->mode);
1333 return TCORE_RETURN_FAILURE;
1336 switch(barring->class)
1338 case SS_CLASS_ALL_TELE:
1341 case SS_CLASS_VOICE:
1344 case SS_CLASS_ALL_DATA_TELE:
1353 case SS_CLASS_ALL_CS_SYNC:
1359 dbg("unsupported class %d. set to default : 7", barring->class);
1363 // null-ended pwd handling added - unexpected 0x11 value observed in req string
1364 memcpy(passwd, barring->password, MAX_SS_BARRING_PASSWORD_LEN);
1365 passwd[MAX_SS_BARRING_PASSWORD_LEN]='\0';
1368 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,\"%s\",%d%s", facility, opco, passwd, classx,"\r");
1369 dbg("request command : %s", cmd_str);
1371 user_data = g_new0( struct ss_confirm_info, 1 );
1373 if ( op == TIZEN_SS_OPCO_ACTIVATE) {
1374 user_data->resp = TRESP_SS_BARRING_ACTIVATE;
1376 } else if ( op == TIZEN_SS_OPCO_DEACTIVATE) {
1377 user_data->resp = TRESP_SS_BARRING_DEACTIVATE;
1380 dbg("[ error ] wrong ss opco ( 0x%x )", op );
1381 return TCORE_RETURN_FAILURE;
1384 user_data->flavor_type = (int)(barring->mode);
1385 user_data->class = barring->class;
1387 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_barring_set, user_data );
1392 return TCORE_RETURN_FAILURE;
1394 return TCORE_RETURN_SUCCESS;
1397 static TReturn _ss_barring_get( CoreObject *o,
1399 enum telephony_ss_class class,
1400 enum telephony_ss_barring_mode mode,
1401 enum tcore_response_command resp )
1404 struct ss_confirm_info *user_data = 0;
1405 gboolean ret = FALSE;
1407 struct ATReqMetaInfo metainfo;
1409 char* cmd_str = NULL;
1411 char* facility = NULL;
1413 p = tcore_object_ref_plugin( o );
1415 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1416 metainfo.type = MULTILINE;
1417 memcpy(metainfo.responsePrefix,"+CLCK:",strlen("+CLCK:"));
1418 info_len = sizeof(struct ATReqMetaInfo);
1420 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
1422 //query status - opco is fixed to 2
1427 case SS_BARR_MODE_BAOC:
1430 case SS_BARR_MODE_BOIC:
1433 case SS_BARR_MODE_BOIC_NOT_HC:
1436 case SS_BARR_MODE_BAIC:
1439 case SS_BARR_MODE_BIC_ROAM:
1442 case SS_BARR_MODE_AB:
1445 case SS_BARR_MODE_AOB:
1448 case SS_BARR_MODE_AIB:
1451 case SS_BARR_MODE_BIC_NOT_SIM:
1455 dbg("unspported mode %d", mode);
1456 return TCORE_RETURN_FAILURE;
1461 case SS_CLASS_ALL_TELE:
1464 case SS_CLASS_VOICE:
1467 case SS_CLASS_ALL_DATA_TELE:
1476 case SS_CLASS_ALL_CS_SYNC:
1482 dbg("unsupported class %d. set to default : 7", class);
1488 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d%s", facility, opco,"\r");
1490 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,,%d%s", facility, opco,classx,"\r");
1492 dbg("request command : %s", cmd_str);
1494 user_data = g_new0( struct ss_confirm_info, 1 );
1495 user_data->resp = resp;
1497 user_data->flavor_type = (int)(mode);
1498 user_data->class = class;
1500 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_barring_get, user_data );
1505 return TCORE_RETURN_FAILURE;
1507 return TCORE_RETURN_SUCCESS;
1510 static TReturn s_ss_barring_activate( CoreObject *o, UserRequest *ur )
1512 return _ss_barring_set( o, ur, TIZEN_SS_OPCO_ACTIVATE );
1515 static TReturn s_ss_barring_deactivate( CoreObject *o, UserRequest *ur )
1517 return _ss_barring_set( o, ur, TIZEN_SS_OPCO_DEACTIVATE );
1520 static TReturn s_ss_barring_change_password( CoreObject *o, UserRequest *ur )
1523 struct treq_ss_barring_change_password *barring = 0;
1525 struct ss_confirm_info *user_data = 0;
1527 gboolean ret = FALSE;
1529 // struct ATReqMetaInfo metainfo;
1531 char* cmd_str = NULL;
1533 p = tcore_object_ref_plugin( o );
1534 barring = (struct treq_ss_barring_change_password*)tcore_user_request_ref_data( ur, 0 );
1537 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"%s", "AB", barring->password_old, barring->password_new,"\r");
1538 dbg("request command : %s", cmd_str);
1541 user_data = g_new0( struct ss_confirm_info, 1 );
1542 user_data->resp = TRESP_SS_BARRING_CHANGE_PASSWORD;
1544 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_barring_change_pwd, user_data );
1548 return TCORE_RETURN_FAILURE;
1550 return TCORE_RETURN_SUCCESS;
1553 static TReturn s_ss_barring_get_status( CoreObject *o, UserRequest *ur )
1555 struct treq_ss_barring *barring = 0;
1556 barring = (struct treq_ss_barring*)tcore_user_request_ref_data( ur, 0 );
1558 return _ss_barring_get( o, ur, barring->class, barring->mode, TRESP_SS_BARRING_GET_STATUS );
1561 static TReturn _ss_forwarding_set( CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op )
1564 struct treq_ss_forwarding *forwarding = 0;
1566 struct ss_confirm_info *user_data = 0;
1568 gboolean ret = FALSE;
1571 struct ATReqMetaInfo metainfo;
1573 char* cmd_str = NULL;
1574 char* tmp_str = NULL;
1575 int reason=0,mode=0,num_type=0, classx=0,time=0;
1576 gboolean valid_num = FALSE;
1578 dbg("_ss_forwarding_set with opco %d ", op);
1581 forwarding = (struct treq_ss_forwarding*) tcore_user_request_ref_data( ur, 0 );
1582 p = tcore_object_ref_plugin( o );
1584 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1585 metainfo.type = NO_RESULT;
1586 metainfo.responsePrefix[0] ='\0';
1587 info_len = sizeof(struct ATReqMetaInfo);
1589 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
1591 switch(forwarding->mode)
1593 case SS_CF_MODE_CFU:
1596 case SS_CF_MODE_CFB:
1599 case SS_CF_MODE_CFNRy:
1602 case SS_CF_MODE_CFNRc:
1605 case SS_CF_MODE_CF_ALL:
1608 case SS_CF_MODE_CFC:
1613 dbg("unsupported reason : %d");
1618 case TIZEN_SS_OPCO_DEACTIVATE:
1621 case TIZEN_SS_OPCO_ACTIVATE:
1624 case TIZEN_SS_OPCO_REG:
1627 case TIZEN_SS_OPCO_DEREG:
1632 dbg("unsupported opco : %d", op);
1633 return TCORE_RETURN_FAILURE;
1638 switch(forwarding->class)
1640 case SS_CLASS_ALL_TELE:
1643 case SS_CLASS_VOICE:
1646 case SS_CLASS_ALL_DATA_TELE:
1655 case SS_CLASS_ALL_CS_SYNC:
1661 dbg("unsupported class %d. set to default : 7", forwarding->class);
1666 len = strlen(forwarding->number);
1669 if ( forwarding->number[0] == '+' )
1670 num_type = ((TIZEN_NUM_TYPE_INTERNATIONAL << 4)|TIZEN_NUM_PLAN_ISDN);
1674 user_data = g_new0( struct ss_confirm_info, 1 );
1677 case TIZEN_SS_OPCO_REG:
1678 user_data->resp = TRESP_SS_FORWARDING_REGISTER;
1680 case TIZEN_SS_OPCO_DEREG:
1681 user_data->resp = TRESP_SS_FORWARDING_DEREGISTER;
1683 case TIZEN_SS_OPCO_ACTIVATE:
1684 user_data->resp = TRESP_SS_FORWARDING_ACTIVATE;
1686 case TIZEN_SS_OPCO_DEACTIVATE:
1687 user_data->resp = TRESP_SS_FORWARDING_DEACTIVATE;
1690 dbg("[ error ] unknown op ( 0x%x )", op );
1694 if(op == TIZEN_SS_OPCO_REG)
1695 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,\"%s\",%d,%d", reason, mode, forwarding->number, num_type, classx);
1696 else// other opcode does not need num field
1697 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);
1699 if(forwarding->mode == SS_CF_MODE_CFNRy){
1700 //add time info to 'no reply' case
1701 time = (int)(forwarding->time);
1702 cmd_str = g_strdup_printf("%s,,,%d%s", tmp_str,time,"\r");
1705 cmd_str = g_strdup_printf("%s%s", tmp_str,"\r");
1708 dbg("request command : %s", cmd_str);
1710 user_data->flavor_type = forwarding->mode;
1711 user_data->class = forwarding->class;
1713 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_forwarding_set, user_data );
1718 return TCORE_RETURN_FAILURE;
1720 return TCORE_RETURN_SUCCESS;
1723 static TReturn _ss_forwarding_get( CoreObject *o,
1725 enum telephony_ss_class class,
1726 enum telephony_ss_forwarding_mode type,
1727 enum tcore_response_command resp )
1730 struct ss_confirm_info *user_data = 0;
1732 gboolean ret = FALSE;
1735 struct ATReqMetaInfo metainfo;
1736 int info_len=0, reason=0, mode=0, classx =0;
1737 char* cmd_str = NULL;
1739 p = tcore_object_ref_plugin( o );
1741 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1742 metainfo.type = MULTILINE;
1743 memcpy(metainfo.responsePrefix,"+CCFC:",strlen("+CCFC:"));
1744 info_len = sizeof(struct ATReqMetaInfo);
1746 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
1750 case SS_CF_MODE_CFU:
1753 case SS_CF_MODE_CFB:
1756 case SS_CF_MODE_CFNRy:
1759 case SS_CF_MODE_CFNRc:
1762 case SS_CF_MODE_CF_ALL:
1765 case SS_CF_MODE_CFC:
1770 dbg("unsupported reason : %d");
1776 case SS_CLASS_ALL_TELE:
1779 case SS_CLASS_VOICE:
1782 case SS_CLASS_ALL_DATA_TELE:
1791 case SS_CLASS_ALL_CS_SYNC:
1796 dbg("unsupported class %d. set to default : 7", class);
1800 //query status - mode set to 2
1803 user_data = g_new0( struct ss_confirm_info, 1 );
1804 user_data->resp = resp;
1806 user_data->class = class;
1807 user_data->flavor_type = type;
1810 cmd_str = g_strdup_printf("AT+CCFC=%d,%d%s", reason, mode,"\r");
1812 cmd_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d%s", reason, mode,classx,"\r");
1814 dbg("request command : %s", cmd_str);
1815 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_forwarding_get, user_data );
1819 return TCORE_RETURN_FAILURE;
1821 return TCORE_RETURN_SUCCESS;
1824 static TReturn s_ss_forwarding_activate( CoreObject *o, UserRequest *ur )
1826 return _ss_forwarding_set( o, ur, TIZEN_SS_OPCO_ACTIVATE );
1829 static TReturn s_ss_forwarding_deactivate( CoreObject *o, UserRequest *ur )
1831 return _ss_forwarding_set( o, ur, TIZEN_SS_OPCO_DEACTIVATE );
1834 static TReturn s_ss_forwarding_register( CoreObject *o, UserRequest *ur )
1836 return _ss_forwarding_set( o, ur, TIZEN_SS_OPCO_REG );
1839 static TReturn s_ss_forwarding_deregister( CoreObject *o, UserRequest *ur )
1841 return _ss_forwarding_set( o, ur, TIZEN_SS_OPCO_DEREG );
1844 static TReturn s_ss_forwarding_get_status( CoreObject *o, UserRequest *ur )
1846 struct treq_ss_forwarding *forwarding = 0;
1847 forwarding = (struct treq_ss_forwarding*)tcore_user_request_ref_data( ur, 0 );
1849 return _ss_forwarding_get( o, ur, forwarding->class, forwarding->mode, TRESP_SS_FORWARDING_GET_STATUS );
1852 static TReturn _ss_waiting_set( CoreObject *o, UserRequest *ur, enum telephony_ss_opcode opco )
1855 struct treq_ss_waiting *waiting = 0;
1857 struct ss_confirm_info *user_data = 0;
1859 gboolean ret = FALSE;
1860 int mode=0, classx=0;
1862 struct ATReqMetaInfo metainfo;
1865 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1866 metainfo.type = NO_RESULT;
1867 metainfo.responsePrefix[0] ='\0';
1869 tcore_user_request_set_metainfo(ur, sizeof(struct ATReqMetaInfo), &metainfo);
1871 p = tcore_object_ref_plugin( o );
1873 waiting = (struct treq_ss_waiting*) tcore_user_request_ref_data( ur, 0 );
1875 user_data = g_new0( struct ss_confirm_info, 1 );
1877 if ( opco == TIZEN_SS_OPCO_ACTIVATE ){
1878 user_data->resp = TRESP_SS_WAITING_ACTIVATE;
1881 else if ( opco == TIZEN_SS_OPCO_DEACTIVATE ){
1882 user_data->resp = TRESP_SS_WAITING_DEACTIVATE;
1886 dbg("[ error ] unknown ss mode (0x%x)", opco);
1888 switch(waiting->class)
1890 case SS_CLASS_ALL_TELE:
1893 case SS_CLASS_VOICE:
1896 case SS_CLASS_ALL_DATA_TELE:
1908 dbg("unsupported class %d. set to default : 7", waiting->class);
1913 user_data->class = waiting->class;
1914 user_data->flavor_type = (int)opco;
1916 cmd_str = g_strdup_printf("AT+CCWA=1,%d,%d%s", mode, classx,"\r"); //always enable +CCWA: unsolicited cmd
1917 dbg("request command : %s",cmd_str);
1919 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_waiting_set, user_data );
1923 return TCORE_RETURN_FAILURE;
1925 return TCORE_RETURN_SUCCESS;
1928 static TReturn _ss_waiting_get( CoreObject *o,
1930 enum telephony_ss_class class,
1931 enum tcore_response_command resp )
1935 struct ss_confirm_info *user_data = 0;
1937 gboolean ret = FALSE;
1938 int classx, info_len=0;//mode,
1940 struct ATReqMetaInfo metainfo;
1943 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
1944 metainfo.type = MULTILINE;
1945 memcpy(metainfo.responsePrefix,"+CCWA:",strlen("+CCWA:"));
1946 info_len = sizeof(struct ATReqMetaInfo);
1948 tcore_user_request_set_metainfo(ur, sizeof(struct ATReqMetaInfo), &metainfo);
1950 p = tcore_object_ref_plugin( o );
1954 case SS_CLASS_ALL_TELE:
1957 case SS_CLASS_VOICE:
1960 case SS_CLASS_ALL_DATA_TELE:
1972 dbg("unsupported class %d. set to default : 7", class);
1976 dbg("allocating user data");
1977 user_data = g_new0( struct ss_confirm_info, 1 );
1978 user_data->resp = resp;
1979 user_data->class = class;
1981 cmd_str = g_strdup_printf("AT+CCWA=1,2,%d%s", classx,"\r"); //always enable +CCWA: unsolicited cmd , mode is fixed to 2(query status)
1982 dbg("request cmd : %s", cmd_str);
1984 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_waiting_get, user_data );
1989 return TCORE_RETURN_FAILURE;
1991 return TCORE_RETURN_SUCCESS;
1994 static TReturn s_ss_waiting_activate( CoreObject *o, UserRequest *ur )
1996 return _ss_waiting_set( o, ur, TIZEN_SS_OPCO_ACTIVATE );
1999 static TReturn s_ss_waiting_deactivate( CoreObject *o, UserRequest *ur )
2001 return _ss_waiting_set( o, ur, TIZEN_SS_OPCO_DEACTIVATE );
2004 static TReturn s_ss_waiting_get_status( CoreObject *o, UserRequest *ur )
2006 struct treq_ss_waiting *waiting = 0;
2007 waiting = (struct treq_ss_waiting*)tcore_user_request_ref_data( ur, 0 );
2009 return _ss_waiting_get( o, ur, waiting->class, TRESP_SS_WAITING_GET_STATUS );
2012 static TReturn s_ss_cli_activate( CoreObject *o, UserRequest *ur )
2014 return TCORE_RETURN_SUCCESS;
2017 static TReturn s_ss_cli_deactivate( CoreObject *o, UserRequest *ur )
2019 return TCORE_RETURN_SUCCESS;
2022 static TReturn s_ss_cli_get_status( CoreObject *o, UserRequest *ur )
2026 struct treq_ss_cli *cli = 0;
2027 gboolean ret = FALSE;
2028 char *cmd_prefix = NULL, *rsp_prefix = NULL, *cmd_str = NULL;
2029 struct ATReqMetaInfo metainfo;
2030 enum telephony_ss_cli_type *user_data = 0;
2034 p = tcore_object_ref_plugin(o);
2036 cli = (struct treq_ss_cli*)tcore_user_request_ref_data( ur, 0 );
2039 case SS_CLI_TYPE_CLIP:
2040 cmd_prefix = "+CLIP";
2041 rsp_prefix = "+CLIP:";
2044 case SS_CLI_TYPE_CLIR:
2045 cmd_prefix = "+CLIR";
2046 rsp_prefix = "+CLIR:";
2049 case SS_CLI_TYPE_COLP:
2050 cmd_prefix = "+COLP";
2051 rsp_prefix = "+COLP:";
2054 case SS_CLI_TYPE_CDIP:
2055 cmd_prefix = "+CDIP";
2056 rsp_prefix = "+CDIP:";
2060 dbg("unsupported cli_type : %d", cli->type);
2061 return TCORE_RETURN_FAILURE;
2065 dbg("cmd_prefix : %s",cmd_prefix);
2068 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2069 metainfo.type = SINGLELINE;
2070 memcpy(metainfo.responsePrefix,rsp_prefix,strlen(rsp_prefix));
2071 info_len = sizeof(struct ATReqMetaInfo);
2073 tcore_user_request_set_metainfo(ur, sizeof(struct ATReqMetaInfo), &metainfo);
2077 cmd_str = g_strdup_printf("AT%s?%s", cmd_prefix, "\r");
2078 dbg("request cmd : %s", cmd_str);
2080 // make userinfo for callback
2081 user_data = g_new0( enum telephony_ss_cli_type, 1 );
2082 *user_data = cli->type;
2084 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_response_ss_waiting_get, user_data );
2089 return TCORE_RETURN_FAILURE;
2091 return TCORE_RETURN_SUCCESS;
2094 static TReturn s_ss_send_ussd( CoreObject *o, UserRequest *ur )
2097 UssdSession *ussd_s = 0;
2099 struct treq_ss_ussd *ussd = 0;
2100 struct ss_confirm_info *user_data = 0;
2102 gboolean ret = FALSE;
2104 struct ATReqMetaInfo metainfo;
2107 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2108 metainfo.type = NO_RESULT;
2109 metainfo.responsePrefix[0] ='\0';
2110 tcore_user_request_set_metainfo(ur, sizeof(struct ATReqMetaInfo), &metainfo);
2112 p = tcore_object_ref_plugin(o);
2113 ussd = (struct treq_ss_ussd*)tcore_user_request_ref_data( ur, 0 );
2115 cmd_str = g_strdup_printf("AT+CUSD=1,\"%s\",%d%s", ussd->str, 0x0f,"\r"); //always enable +CUSD: unsolicited cmd. set to dcs to 0x0f. only supports HEX type
2116 dbg("request command : %s",cmd_str);
2119 user_data = g_new0( struct ss_confirm_info, 1 );
2120 user_data->resp = TRESP_SS_SEND_USSD;
2122 ussd_s = tcore_ss_ussd_get_session( o );
2124 tcore_ss_ussd_create_session( o, (enum tcore_ss_ussd_type)ussd->type, (void*)tcore_user_request_ref(ur), 0 );
2127 if ( ussd->type == SS_USSD_TYPE_USER_INITIATED ) {
2128 dbg("[ error ] ussd session is already exist");
2130 g_free( user_data );
2131 return TCORE_RETURN_FAILURE;
2134 tcore_ss_ussd_set_session_type( ussd_s, (enum tcore_ss_ussd_type)ussd->type);
2137 ret = _ss_request_message( o, ur, cmd_str, strlen(cmd_str), on_confirmation_ss_ussd, user_data );
2140 return TCORE_RETURN_FAILURE;
2143 return TCORE_RETURN_SUCCESS;
2146 static TReturn s_ss_set_aoc( CoreObject *o, UserRequest *ur )
2148 dbg("[ error ] unsupported function");
2149 return TCORE_RETURN_SUCCESS;
2152 static TReturn s_ss_get_aoc( CoreObject *o, UserRequest *ur )
2154 dbg("[ error ] unsupported function");
2155 return TCORE_RETURN_SUCCESS;
2158 static struct tcore_call_control_operations call_ops = {
2159 .answer_hold_and_accept = s_ss_manage_call_2_send,
2160 .answer_replace = s_ss_manage_call_1_send,
2161 .answer_reject = s_ss_manage_call_0_send,
2162 .end_specific = s_ss_manage_call_1x_send,
2163 .end_all_active = s_ss_manage_call_1_send,
2164 .end_all_held = s_ss_manage_call_0_send,
2165 .active = s_ss_manage_call_2_send,
2166 .hold = s_ss_manage_call_2_send,
2167 .swap = s_ss_manage_call_2_send,
2168 .join = s_ss_manage_call_3_send,
2169 .split = s_ss_manage_call_2x_send,
2170 .transfer = s_ss_manage_call_4_send,
2171 .deflect = s_ss_manage_call_4dn_send,
2174 static TReturn s_ss_manage_call_0_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2176 TcorePlugin *p = NULL;
2178 TcorePending *pending = NULL;
2179 char* cmd_str = NULL;
2180 struct ATReqMetaInfo metainfo;
2183 p = tcore_object_ref_plugin(o);
2184 h = tcore_object_get_hal(o);
2186 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2187 metainfo.type = NO_RESULT;
2188 metainfo.responsePrefix[0] ='\0';
2189 info_len = sizeof(struct ATReqMetaInfo);
2191 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2193 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=0", "\r");
2194 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2196 pending = tcore_pending_new(o, ID_RESERVED_AT);
2197 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2199 tcore_pending_set_timeout(pending, 0);
2200 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2201 tcore_pending_link_user_request(pending, ur);
2202 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2204 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2207 tcore_hal_send_request(h, pending);
2209 return TCORE_RETURN_SUCCESS;
2212 static TReturn s_ss_manage_call_1_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2214 TcorePlugin *p = NULL;
2216 TcorePending *pending = NULL;
2217 char* cmd_str = NULL;
2218 struct ATReqMetaInfo metainfo;
2221 p = tcore_object_ref_plugin(o);
2222 h = tcore_object_get_hal(o);
2224 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2225 metainfo.type = NO_RESULT;
2226 metainfo.responsePrefix[0] ='\0';
2227 info_len = sizeof(struct ATReqMetaInfo);
2229 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2231 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=1", "\r");
2232 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2234 pending = tcore_pending_new(o, ID_RESERVED_AT);
2235 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2237 tcore_pending_set_timeout(pending, 0);
2238 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2239 tcore_pending_link_user_request(pending, ur);
2240 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2242 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2245 tcore_hal_send_request(h, pending);
2247 return TCORE_RETURN_SUCCESS;
2250 static TReturn s_ss_manage_call_1x_send( CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data )
2252 TcorePlugin *p = NULL;
2254 TcorePending *pending = NULL;
2255 char* cmd_str = NULL;
2256 struct ATReqMetaInfo metainfo;
2259 p = tcore_object_ref_plugin(o);
2260 h = tcore_object_get_hal(o);
2262 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2263 metainfo.type = NO_RESULT;
2264 metainfo.responsePrefix[0] ='\0';
2265 info_len = sizeof(struct ATReqMetaInfo);
2267 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2269 cmd_str = g_strdup_printf("%s%d%s", "AT+CHLD=1", id,"\r");
2270 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2272 pending = tcore_pending_new(o, ID_RESERVED_AT);
2273 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2275 tcore_pending_set_timeout(pending, 0);
2276 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2277 tcore_pending_link_user_request(pending, ur);
2278 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2280 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2283 tcore_hal_send_request(h, pending);
2285 return TCORE_RETURN_SUCCESS;
2288 static TReturn s_ss_manage_call_2_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2290 TcorePlugin *p = NULL;
2292 TcorePending *pending = NULL;
2293 char* cmd_str = NULL;
2294 struct ATReqMetaInfo metainfo;
2297 p = tcore_object_ref_plugin(o);
2298 h = tcore_object_get_hal(o);
2300 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2301 metainfo.type = NO_RESULT;
2302 metainfo.responsePrefix[0] ='\0';
2303 info_len = sizeof(struct ATReqMetaInfo);
2305 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2307 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=2", "\r");
2308 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2310 pending = tcore_pending_new(o, ID_RESERVED_AT);
2311 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2313 tcore_pending_set_timeout(pending, 0);
2314 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2315 tcore_pending_link_user_request(pending, ur);
2316 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2318 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2321 tcore_hal_send_request(h, pending);
2323 return TCORE_RETURN_SUCCESS;
2326 static TReturn s_ss_manage_call_2x_send( CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data )
2328 TcorePlugin *p = NULL;
2330 TcorePending *pending = NULL;
2331 char* cmd_str = NULL;
2332 struct ATReqMetaInfo metainfo;
2335 p = tcore_object_ref_plugin(o);
2336 h = tcore_object_get_hal(o);
2338 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2339 metainfo.type = NO_RESULT;
2340 metainfo.responsePrefix[0] ='\0';
2341 info_len = sizeof(struct ATReqMetaInfo);
2343 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2345 cmd_str = g_strdup_printf("%s%d%s", "AT+CHLD=2", id,"\r");
2346 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2348 pending = tcore_pending_new(o, ID_RESERVED_AT);
2349 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2351 tcore_pending_set_timeout(pending, 0);
2352 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2353 tcore_pending_link_user_request(pending, ur);
2354 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2356 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2359 tcore_hal_send_request(h, pending);
2361 return TCORE_RETURN_SUCCESS;
2364 static TReturn s_ss_manage_call_3_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2366 // gboolean ret = FALSE;
2367 TcorePlugin *p = NULL;
2369 TcorePending *pending = NULL;
2370 char* cmd_str = NULL;
2371 struct ATReqMetaInfo metainfo;
2378 l = tcore_call_object_find_by_status( o, CALL_STATUS_ACTIVE );
2379 if ( !l || !l->data ) {
2380 dbg("[ error ] there is no call status [ call_active ]");
2381 return TCORE_RETURN_FAILURE;
2385 id = tcore_call_object_get_id( co );
2386 dbg("active call id : [ %d ]");
2388 p = tcore_object_ref_plugin(o);
2389 h = tcore_object_get_hal(o);
2391 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2392 metainfo.type = NO_RESULT;
2393 metainfo.responsePrefix[0] ='\0';
2394 info_len = sizeof(struct ATReqMetaInfo);
2396 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2398 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=3","\r");
2400 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2402 pending = tcore_pending_new(o, ID_RESERVED_AT);
2403 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2405 tcore_pending_set_timeout(pending, 0);
2406 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2407 tcore_pending_link_user_request(pending, ur);
2408 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2410 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2413 tcore_hal_send_request(h, pending);
2415 return TCORE_RETURN_SUCCESS;
2418 static TReturn s_ss_manage_call_4_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2420 TcorePlugin *p = NULL;
2422 TcorePending *pending = NULL;
2423 char* cmd_str = NULL;
2424 struct ATReqMetaInfo metainfo;
2427 p = tcore_object_ref_plugin(o);
2428 h = tcore_object_get_hal(o);
2430 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2431 metainfo.type = NO_RESULT;
2432 metainfo.responsePrefix[0] ='\0';
2433 info_len = sizeof(struct ATReqMetaInfo);
2435 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2438 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=4", "\r");
2440 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2442 pending = tcore_pending_new(o, ID_RESERVED_AT);
2443 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2445 tcore_pending_set_timeout(pending, 0);
2446 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2447 tcore_pending_link_user_request(pending, ur);
2448 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2450 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2453 tcore_hal_send_request(h, pending);
2455 return TCORE_RETURN_SUCCESS;
2458 static TReturn s_ss_manage_call_4dn_send( CoreObject* o, UserRequest* ur, const char* number, ConfirmCallback cb, void* user_data )
2460 TcorePlugin *p = NULL;
2462 TcorePending *pending = NULL;
2463 char* cmd_str = NULL;
2464 struct ATReqMetaInfo metainfo;
2467 p = tcore_object_ref_plugin(o);
2468 h = tcore_object_get_hal(o);
2470 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2471 metainfo.type = NO_RESULT;
2472 metainfo.responsePrefix[0] ='\0';
2473 info_len = sizeof(struct ATReqMetaInfo);
2475 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2478 cmd_str = g_strdup_printf("%s%s%s", "AT+CHLD=4", number,"\r");
2480 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2482 pending = tcore_pending_new(o, ID_RESERVED_AT);
2483 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2485 tcore_pending_set_timeout(pending, 0);
2486 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2487 tcore_pending_link_user_request(pending, ur);
2488 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2490 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2493 tcore_hal_send_request(h, pending);
2495 return TCORE_RETURN_SUCCESS;
2499 static TReturn s_ss_manage_call_5_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2501 TcorePlugin *p = NULL;
2503 TcorePending *pending = NULL;
2504 char* cmd_str = NULL;
2505 struct ATReqMetaInfo metainfo;
2508 p = tcore_object_ref_plugin(o);
2509 h = tcore_object_get_hal(o);
2511 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2512 metainfo.type = NO_RESULT;
2513 metainfo.responsePrefix[0] ='\0';
2514 info_len = sizeof(struct ATReqMetaInfo);
2516 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2519 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=5", "\r");
2521 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2523 pending = tcore_pending_new(o, ID_RESERVED_AT);
2524 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2526 tcore_pending_set_timeout(pending, 0);
2527 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2528 tcore_pending_link_user_request(pending, ur);
2529 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2531 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2534 tcore_hal_send_request(h, pending);
2536 return TCORE_RETURN_SUCCESS;
2539 static TReturn s_ss_manage_call_6_send( CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data )
2541 TcorePlugin *p = NULL;
2543 TcorePending *pending = NULL;
2544 char* cmd_str = NULL;
2545 struct ATReqMetaInfo metainfo;
2548 p = tcore_object_ref_plugin(o);
2549 h = tcore_object_get_hal(o);
2551 memset(&metainfo, 0, sizeof(struct ATReqMetaInfo));
2552 metainfo.type = NO_RESULT;
2553 metainfo.responsePrefix[0] ='\0';
2554 info_len = sizeof(struct ATReqMetaInfo);
2556 tcore_user_request_set_metainfo(ur, info_len, &metainfo);
2559 cmd_str= g_strdup_printf("%s%s", "AT+CHLD=6", "\r");
2561 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));
2563 pending = tcore_pending_new(o, ID_RESERVED_AT);
2564 tcore_pending_set_request_data(pending, strlen(cmd_str), cmd_str);
2566 tcore_pending_set_timeout(pending, 0);
2567 tcore_pending_set_response_callback(pending, (TcorePendingResponseCallback)cb, user_data);
2568 tcore_pending_link_user_request(pending, ur);
2569 tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);
2571 tcore_pending_set_send_callback(pending, on_confirmation_call_control_ss_message_send, NULL);
2574 tcore_hal_send_request(h, pending);
2576 return TCORE_RETURN_SUCCESS;
2581 gboolean s_ss_init(TcorePlugin *p, TcoreHal *h)
2583 CoreObject *so = 0, *co = 0;
2584 struct property_call_info *data = 0;
2588 so = tcore_ss_new(p, "ss", &ss_ops, h);
2590 dbg("[ error ] ss_new()");
2594 co = tcore_plugin_ref_core_object(p, "call");
2596 dbg("[ error ] plugin_ref_core_object");
2600 tcore_call_control_set_operations( co, &call_ops );
2602 tcore_object_add_callback( so, EVENT_SS_INFO, on_notification_ss_info, 0 );
2603 tcore_object_add_callback( so, EVENT_SS_USSD, on_notification_ss_ussd, 0 );
2605 data = calloc( sizeof(struct property_call_info *), 1);
2606 tcore_plugin_link_property(p, "SS", data);
2611 void s_ss_exit( TcorePlugin *p )
2615 struct property_network_info *data;
2617 o = tcore_plugin_ref_core_object(p, "ss");
2619 data = tcore_plugin_ref_property(p, "SS");