include/ITapiSim.h

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   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
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  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.
  19  */
  20
  21 #ifndef _ITAPI_SIM_H_
  22 #define _ITAPI_SIM_H_
  23
  24 /**
  25  * @file ITapiSim.h
  26  */
  27
  28 /**
  29  * @addtogroup CAPI_TELEPHONY_SERVICE_SIM
  30  * @{
  31  */
  32
  33 #include <tapi_common.h>
  34 #include <TelSim.h>
  35
  36 #ifdef __cplusplus
  37 extern "C"
  38 {
  39 #endif
  40
  41 /**
  42  * @brief Gets SIM card initialization status and SIM card identification.
  43  * @details Most of the modules which require SIM data should definitely check SIM status before using it.\n
  44  *
  45  * <b> Sync (or) Async: </b> This is a Synchronous API.\n
  46  *
  47  * <b> Prospective Clients: </b> External Apps.
  48  *
  49  * @since_tizen 2.3
  50  * @privlevel public
  51  * @privilege %http://tizen.org/privilege/telephony
  52  *
  53  * @remarks Card identification value is available in case of #TAPI_SIM_STATUS_SIM_INIT_COMPLETED only.
  54  *
  55  * @param[in] handle The handle from tel_init()
  56  *
  57  * @param[out] sim_status The SIM initialization status from the Telephony server boot up time \n
  58  *                        First, you can find SIM existence if the returned value is not in #TAPI_SIM_STATUS_CARD_NOT_PRESENT and #TAPI_SIM_STATUS_CARD_REMOVED.
  59  *
  60  * @param[out] card_changed The SIM card identification value when @a sim_status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED \n
  61  *                          The @a card_changed value is present when the current inserted SIM card differs from the previous SIM.
  62  *
  63  * @return The return type (int)
  64  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
  65  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
  66  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
  67  */
  68 int tel_get_sim_init_info(TapiHandle *handle, TelSimCardStatus_t *sim_status, int *card_changed);
  69
  70 /**
  71  * @brief Gets the card type (SIM/USIM).
  72  * @details <b> Sync (or) Async: </b> This is a Synchronous API.\n
  73  *
  74  * <b> Prospective Clients: </b> External Apps.
  75  *
  76  * @since_tizen 2.3
  77  * @privlevel public
  78  * @privilege %http://tizen.org/privilege/telephony
  79  *
  80  * @param[in] handle The handle from tel_init()
  81  *
  82  * @param[out] card_type The SIM card type information such as GSM SIM card, USIM, and other unknown types
  83  *                       TAPI_SIM_CARD_TYPE_UNKNOWN
  84  *                       TAPI_SIM_CARD_TYPE_GSM
  85  *                       TAPI_SIM_CARD_TYPE_USIM
  86  *
  87  * @return The return type (int)
  88  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation is completed successfully
  89  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
  90  *         Positive integer : It provides an error code while actual operations (Refer #TelSimAccessResult_t)
  91  */
  92 int tel_get_sim_type(TapiHandle *handle, TelSimCardType_t *card_type);
  93
  94 /**
  95  * @brief Gets IMSI information.
  96  * @details <b> Sync (or) Async: </b> This is a Synchronous API.\n
  97  *
  98  * <b> Prospective Clients: </b> External Apps.
  99  *
 100  * @since_tizen 2.3
 101  * @privlevel public
 102  * @privilege %http://tizen.org/privilege/telephony
 103  *
 104  * @remarks IMSI value is the value that security requires.
 105  *
 106  * @param[in] handle The handle from tel_init()
 107  *
 108  * @param[out] imsi The IMSI information \n
 109  *                  Refer #TelSimImsiInfo_t.
 110  *
 111  * @return The return type (int)
 112  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 113  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 114  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 115  *
 116  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 117  */
 118 int tel_get_sim_imsi(TapiHandle *handle, TelSimImsiInfo_t *imsi);
 119
 120 /**
 121  * @brief Gets ECC(SIM) or UECC(USIM) data.
 122  * @details <b> Sync (or) Async: </b> This is a Synchronous API.\n
 123  *
 124  * <b> Prospective Clients: </b> External Apps.
 125  *
 126  * @since_tizen 2.3
 127  * @privlevel public
 128  * @privilege %http://tizen.org/privilege/telephony
 129  *
 130  * @param[in] handle The handle from tel_init()
 131  *
 132  * @param[out] ecc The SIM emergency call code information like ECC length, service type, and the number of ECC records
 133  *
 134  * @return The return type (int)
 135  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 136  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 137  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 138  *
 139  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 140  */
 141 int tel_get_sim_ecc(TapiHandle *handle, TelSimEccList_t *ecc);
 142
 143 /**
 144  * @brief Gets the unique identification number of the (U)ICC.
 145  * @details ICC means Integrated Circuit Card.\n
 146  *
 147  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 148  *
 149  * <b> Prospective Clients: </b> External Apps.
 150  *
 151  * @since_tizen 2.3
 152  * @privlevel public
 153  * @privilege %http://tizen.org/privilege/telephony
 154  *
 155  * @remarks ICC number value is the value that security needs.
 156  *
 157  * @param[in] handle The handle from tel_init()
 158  *
 159  * @param[in] callback To register a callback function for result
 160  *
 161  * @param[in] user_data The user data for user specification
 162  *
 163  * @return The return type (int)
 164  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation is completed successfully
 165  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 166  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 167  *
 168  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 169  * @post callback will be invoked and #TelSimIccIdInfo_t will be stored in data on success case.
 170  */
 171 int tel_get_sim_iccid(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 172
 173 /**
 174  * @brief Gets language preference(indication) information.
 175  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 176  *
 177  * <b> Prospective Clients: </b> External Apps.
 178  *
 179  * @since_tizen 2.3
 180  * @privlevel public
 181  * @privilege %http://tizen.org/privilege/telephony
 182  *
 183  * @param[in] handle The handle from tel_init()
 184  *
 185  * @param[in] callback To register a callback function for result
 186  *
 187  * @param[in] user_data The user data for user specification
 188  *
 189  * @return The return type (int)
 190  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 191  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 192  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 193  *
 194  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 195  * @post callback will be invoked and #TelSimLanguagePreferenceCode_t will be stored in data on success case.
 196  */
 197 int tel_get_sim_language(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 198
 199 /**
 200  * @brief Updates language preference information to the SIM card.
 201  *
 202  * @details This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 203  *          However it just means that the API request has been transfered to the CP successfully.
 204  *          The actual operation result is being delivered in the corresponding event asynchronously.\n
 205  *
 206  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 207  *
 208  * <b> Prospective Clients: </b> External Apps.
 209  *
 210  * @since_tizen 2.3
 211  * @privlevel platform
 212  * @privilege %http://tizen.org/privilege/telephony.admin
 213  *
 214  * @remarks This function updates SIM Language information directly and can have an effect on the device language setting. Use carefully.
 215  *
 216  * @param[in] handle The handle from tel_init()
 217  *
 218  * @param[in] language The language preference information
 219  *
 220  * @param[in] callback To register a callback function for result
 221  *
 222  * @param[in] user_data The user data for user specification
 223  *
 224  * @return The return type (int)
 225  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 226  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 227  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 228  * @post callback will be invoked and data is NULL.
 229  */
 230 int tel_set_sim_language(TapiHandle *handle, TelSimLanguagePreferenceCode_t language, tapi_response_cb callback, void *user_data);
 231
 232 /**
 233  * @brief Gets SIM call forwarding indication related data(EF-CFIS and CPHS case).
 234  * @details This data is required for Call forwarding related functionality in the handset.\n
 235  *
 236  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 237  *
 238  * <b> Prospective Clients: </b> External Apps.
 239  *
 240  * @since_tizen 2.3
 241  * @privlevel public
 242  * @privilege %http://tizen.org/privilege/telephony
 243  *
 244  * @param[in] handle The handle from tel_init()
 245  *
 246  * @param[in] callback To register a callback function for result
 247  *
 248  * @param[in] user_data The user data for user specification
 249  *
 250  * @return The return type (int)
 251  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 252  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 253  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 254  *
 255  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 256  * @post callback will be invoked and #TelSimCallForwardingResp_t will be stored in data on success case.
 257  */
 258 int tel_get_sim_callforwarding_info(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 259
 260 /**
 261  * @brief Sets SIM call forwarding indication related data(EF-CFIS and CPHS case).
 262  * @details This data is required for Call forwarding related functionality in the handset.\n
 263  *
 264  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 265  *
 266  * <b> Prospective Clients: </b> External Apps.
 267  *
 268  * @since_tizen 2.3
 269  * @privlevel platform
 270  * @privilege %http://tizen.org/privilege/telephony.admin
 271  *
 272  * @param[in] handle The handle from tel_init()
 273  *
 274  * @param[in] req_cf The data requesting for call forwarding
 275  *
 276  * @param[in] callback To register a callback function for result
 277  *
 278  * @param[in] user_data The user data for user specification
 279  *
 280  * @return The return type (int)
 281  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 282  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 283  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 284  *
 285  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 286  * @post callback will be invoked and data is NULL.
 287  */
 288 int tel_set_sim_callforwarding_info(TapiHandle *handle, TelSimCallForwardingReq_t *req_cf, tapi_response_cb callback, void *user_data);
 289
 290 /**
 291  * @brief Gets SIM message waiting indication related data(EF-MWIS and CPHS case).
 292  * @details This data is required for Message waiting related functionality in the handset.\n
 293  *
 294  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 295  *
 296  * <b> Prospective Clients: </b> External Apps.
 297  *
 298  * @since_tizen 2.3
 299  * @privlevel public
 300  * @privilege %http://tizen.org/privilege/telephony
 301  *
 302  * @param[in] handle The handle from tel_init()
 303  *
 304  * @param[in] callback To register a callback function for result
 305  *
 306  * @param[in] user_data The user data for user specification
 307  *
 308  * @return The return type (int)
 309  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 310  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 311  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 312  *
 313  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 314  * @post callback will be invoked and #TelSimMessageWaitingResp_t will be stored in data on success case.
 315  */
 316 int tel_get_sim_messagewaiting_info(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 317
 318 /**
 319  * @brief Sets SIM message waiting indication related data(EF-MWIS and CPHS case).
 320  * @details This data is required for Message waiting related functionality in the handset.\n
 321  *
 322  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 323  *
 324  * <b> Prospective Clients: </b> External Apps.
 325  *
 326  * @since_tizen 2.3
 327  * @privlevel platform
 328  * @privilege %http://tizen.org/privilege/telephony.admin
 329  *
 330  * @param[in] handle The handle from tel_init()
 331  *
 332  * @param[in] req_mw The data requesting for message waiting
 333  *
 334  * @param[in] callback To register a callback function for result
 335  *
 336  * @param[in] user_data The user data for user specification
 337  *
 338  * @return The return type (int)
 339  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 340  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 341  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 342  *
 343  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 344  * @post callback will be invoked and data is NULL.
 345  */
 346 int tel_set_sim_messagewaiting_info(TapiHandle *handle, TelSimMessageWaitingReq_t *req_mw, tapi_response_cb callback, void *user_data);
 347
 348 /**
 349  * @brief Gets SIM mailbox related data(EF-MBDN, MBDI, and CPHS case).
 350  * @details This data is required for Mailbox related functionality in the handset.\n
 351  *
 352  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 353  *
 354  * <b> Prospective Clients: </b> External Apps.
 355  *
 356  * @since_tizen 2.3
 357  * @privlevel public
 358  * @privilege %http://tizen.org/privilege/telephony
 359  *
 360  * @param[in] handle The handle from tel_init()
 361  *
 362  * @param[in] callback To register a callback function for result
 363  *
 364  * @param[in] user_data The user data for user specification
 365  *
 366  * @return The return type (int)
 367  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 368  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 369  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 370  *
 371  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 372  * @post callback will be invoked and #TelSimMailboxList_t will be stored in data on success case.
 373  */
 374 int tel_get_sim_mailbox_info(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 375
 376 /**
 377  * @brief Sets SIM mailbox related data(EF-MBDN, MBDI and CPHS case).
 378  * @details This data is required for Mailbox related functionality in the handset.\n
 379  *
 380  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 381  *
 382  * <b> Prospective Clients: </b> External Apps.
 383  *
 384  * @since_tizen 2.3
 385  * @privlevel platform
 386  * @privilege %http://tizen.org/privilege/telephony.admin
 387  *
 388  * @param[in] handle The handle from tel_init()
 389  *
 390  * @param[in] req_mb The data requesting for mailbox info
 391  *
 392  * @param[in] callback To register a callback function for result
 393  *
 394  * @param[in] user_data The user data for user specification
 395  *
 396  * @return The return type (int)
 397  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 398  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 399  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 400  *
 401  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 402  * @post callback will be invoked and data is NULL.
 403  */
 404 int tel_set_sim_mailbox_info(TapiHandle *handle, TelSimMailBoxNumber_t *req_mb, tapi_response_cb callback, void *user_data);
 405
 406 /**
 407  * @brief Gets SIM CPHS specific data.
 408  * @details This data is required for CPHS related functionality in the handset.\n
 409  *
 410  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 411  *
 412  * <b> Prospective Clients: </b> External Apps.
 413  *
 414  * @since_tizen 2.3
 415  * @privlevel public
 416  * @privilege %http://tizen.org/privilege/telephony
 417  *
 418  * @param[in] handle The handle from tel_init()
 419  *
 420  * @param[in] callback To register a callback function for result
 421  *
 422  * @param[in] user_data The user data for user specification
 423  *
 424  * @return The return type (int)
 425  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 426  *         Negative integer : it provides an error code before actual operations (Refer #TapiResult_t)
 427  *         Positive integer : it provides an error code during actual operations (Refer #TelSimAccessResult_t)
 428  *
 429  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 430  * @post callback will be invoked and #TelSimCphsInfo_t will be stored in data on success case.
 431  */
 432 int tel_get_sim_cphs_info(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 433
 434 /**
 435  * @brief Gets the SIM Service Table.
 436  * @details This data is required to know which SIM services are enabled or disabled.\n
 437  *
 438  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 439  *
 440  * <b> Prospective Clients: </b> External Apps.
 441  *
 442  * @since_tizen 2.3
 443  * @privlevel public
 444  * @privilege %http://tizen.org/privilege/telephony
 445  *
 446  * @param[in] handle The handle from tel_init()
 447  *
 448  * @param[in] callback To register a callback function for result
 449  *
 450  * @param[in] user_data The user data for user specification
 451  *
 452  * @return The return type (int)
 453  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 454  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 455  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 456  *
 457  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 458  * @post callback will be invoked and #TelSimServiceTable_t will be stored in data on success case.
 459  */
 460 int tel_get_sim_service_table(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 461
 462 /**
 463  * @brief Gets SIM MSISDN data.
 464  * @details Regarding 3GPP specification, the current value is optional.\n
 465  *
 466  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 467  *
 468  * <b> Prospective Clients: </b> External Apps.
 469  *
 470  * @since_tizen 2.3
 471  * @privlevel public
 472  * @privilege %http://tizen.org/privilege/telephony
 473  *
 474  * @param[in] handle The handle from tel_init()
 475  *
 476  * @param[in] callback To register a callback function for result
 477  *
 478  * @param[in] user_data The user data for user specification
 479  *
 480  * @return The return type (int)
 481  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 482  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 483  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 484  *
 485  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 486  * @post callback will be invoked and #TelSimMsisdnList_t will be stored in data on success case.
 487  */
 488 int tel_get_sim_msisdn(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 489
 490 /**
 491  * @brief Gets SIM OPLMNWACT(Operator controlled PLMN Selector with Access Technology) data.
 492  * @details Regarding 3GPP specification, the current value is optional.\n
 493  *
 494  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 495  *
 496  * <b> Prospective Clients: </b> External Apps.
 497  *
 498  * @since_tizen 2.3
 499  * @privlevel public
 500  * @privilege %http://tizen.org/privilege/telephony
 501  *
 502  * @param[in] handle The handle from tel_init()
 503  *
 504  * @param[in] callback To register a callback function for result
 505  *
 506  * @param[in] user_data The user data for user specification
 507  *
 508  * @return The return type (int)
 509  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 510  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 511  *         Positive integer : It provides an error code while actual operations (Refer #TelSimAccessResult_t)
 512  *
 513  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 514  * @post callback will be invoked and #TelSimOplmnwactList_t will be stored in data on success case.
 515  */
 516 int tel_get_sim_oplmnwact(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 517
 518 /**
 519  * @brief Gets SIM PSISMSC(url) data.
 520  * @details Regarding 3GPP specification, the current value is optional.\n
 521  *
 522  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 523  *
 524  * <b> Prospective Clients: </b> External Apps.
 525  *
 526  * @since_tizen 4.0
 527  * @privlevel public
 528  * @privilege %http://tizen.org/privilege/telephony
 529  *
 530  * @param[in] handle The handle from tel_init()
 531  *
 532  * @param[in] callback To register a callback function for result
 533  *
 534  * @param[in] user_data The user data for user specification
 535  *
 536  * @return The return type (int)
 537  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 538  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 539  *         Positive integer : It provides an error code while actual operations (Refer #TelSimAccessResult_t)
 540  *
 541  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 542  * @post callback will be invoked and #TelSimOplmnwactList_t will be stored in data on success case.
 543  */
 544 int tel_get_sim_psismsc(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 545
 546
 547 /**
 548  * @brief Gets SIM SPN data.
 549  * @details Regarding 3GPP specification, the current value is optional.\n
 550  *
 551  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 552  *
 553  * <b> Prospective Clients: </b> External Apps.
 554  *
 555  * @since_tizen 2.3
 556  * @privlevel public
 557  * @privilege %http://tizen.org/privilege/telephony
 558  *
 559  * @param[in] handle The handle from tel_init()
 560  *
 561  * @param[in] callback To register a callback function for result
 562  *
 563  * @param[in] user_data The user data for user specification
 564  *
 565  * @return The return type (int)
 566  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 567  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 568  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 569  *
 570  * @pre The user can get valid return value or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 571  * @post callback will be invoked and #TelSimSpn_t will be stored in data on success case.
 572  */
 573 int tel_get_sim_spn(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 574
 575 /**
 576  * @brief Gets SIM CPHS NETNAME data.
 577  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 578  *
 579  * <b> Prospective Clients: </b> External Apps.
 580  *
 581  * @since_tizen 2.3
 582  * @privlevel public
 583  * @privilege %http://tizen.org/privilege/telephony
 584  *
 585  * @param[in] handle The handle from tel_init()
 586  *
 587  * @param[in] callback To register a callback function for result
 588  *
 589  * @param[in] user_data The user data for user specification
 590  *
 591  * @return The return type (int)
 592  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 593  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 594  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 595  *
 596  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 597  * @post callback will be invoked and #TelSimCphsNetName_t will be stored in data on success case.
 598  */
 599 int tel_get_sim_cphs_netname(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 600
 601 /**
 602  * @brief Executes an authentication procedure by using SIM.
 603  *
 604  * @details This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 605  *          However it just means that the API request has been transfered to the CP successfully.
 606  *          The actual operation result is delivered in the corresponding event asynchronously.\n
 607  *          This function supports IMS, 3G, and GSM authentication.\n
 608  *
 609  * <b> Sync (or) Async: </b> This is an Asynchronous API.\n
 610  *
 611  * <b> Prospective Clients: </b> External Apps.
 612  *
 613  * @since_tizen 2.3
 614  * @privlevel platform
 615  * @privilege %http://tizen.org/privilege/telephony.admin
 616  *
 617  * @param[in] handle The handle from tel_init()
 618  *
 619  * @param[in] authentication_data The authentication code to be validated by the ISIM, 3G, and GSM application in the SIM card \n
 620  *                                Refer #TelSimAuthenticationData_t.
 621  *
 622  * @param[in] callback To register a callback function for result
 623  *
 624  * @param[in] user_data The user data for user specification
 625  *
 626  * @return The return type (int)
 627  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 628  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 629  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 630  * @post callback will be invoked and #TelSimAuthenticationResponse_t will be stored in data on success case.
 631  */
 632 int tel_req_sim_authentication(TapiHandle *handle, TelSimAuthenticationData_t *authentication_data, tapi_response_cb callback, void *user_data);
 633
 634 /**
 635  * @deprecated Deprecated Since 2.4. Use tel_verify_sim_pins().
 636  * @brief Performs PIN1/PIN2/SIM LOCK verification.
 637  * @details This function performs PIN verification based on the PIN type passed along with @a pin_data:\n
 638  *          PIN1 code: The SIM card has its own password to check access permissions.\n
 639  *          SIM Lock code: Between Device and SIM card using a SIM password is only available on certain handsets to authorize.\n
 640  *
 641  *          This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 642  *          However it just means that the API request has been transfered to the CP successfully.
 643  *          The actual operation result is delivered in the corresponding event asynchronously.
 644  *
 645  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 646  *
 647  * <b> Prospective Clients: </b> External Apps.
 648  *
 649  * @since_tizen 2.3
 650  * @privlevel platform
 651  * @privilege %http://tizen.org/privilege/telephony.admin
 652  *
 653  * @remarks If the PIN status (PIN/PUK/SIM LOCK) is blocked, an unsolicited event #TAPI_EVENT_SIM_STATUS_IND will be published to Applications on Device boot time.
 654  *          If the PIN status is PUK, you should use #tel_verify_sim_puks instead of this API.
 655  *
 656  * @param[in] handle The handle from tel_init()
 657  *
 658  * @param[in] pin_data The PIN code, entered by the user \n
 659  *                     You should make all the parameters.
 660  *
 661  * @param[in] callback To register a callback function for result
 662  *
 663  * @param[in] user_data The user data for user specification
 664  *
 665  * @return The return type (int)
 666  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation is completed successfully
 667  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 668  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 669  *
 670  * @pre This API is used when #TelSimCardStatus_t is #TAPI_SIM_STATUS_SIM_PIN_REQUIRED or #TAPI_SIM_STATUS_SIM_LOCK_REQUIRED on boot time.
 671  * @post callback will be invoked and #TelSimSecResult_t will be stored in data on success case.
 672  */
 673 int tel_verifiy_sim_pins(TapiHandle *handle, const TelSimSecPw_t *pin_data, tapi_response_cb callback, void *user_data);
 674
 675 /**
 676  * @brief Performs PIN1/PIN2/SIM LOCK verification.
 677  * @details This function performs PIN verification based on the PIN type passed along with @a pin_data:\n
 678  *          PIN1 code: The SIM card has its own password to check access permissions.\n
 679  *          SIM Lock code: Between Device and SIM card using a SIM password is only available on certain handsets to authorize.\n
 680  *
 681  *          This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 682  *          However it just means that the API request has been transfered to the CP successfully.
 683  *          The actual operation result is delivered in the corresponding event asynchronously.
 684  *
 685  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 686  *
 687  * <b> Prospective Clients: </b> External Apps.
 688  *
 689  * @since_tizen 2.4
 690  * @privlevel platform
 691  * @privilege %http://tizen.org/privilege/telephony.admin
 692  *
 693  * @remarks If the PIN status (PIN/PUK/SIM LOCK) is blocked, an unsolicited event #TAPI_EVENT_SIM_STATUS_IND will be published to Applications on Device boot time.
 694  *          If the PIN status is PUK, you should use #tel_verify_sim_puks instead of this API.
 695  *
 696  * @param[in] handle The handle from tel_init()
 697  *
 698  * @param[in] pin_data The PIN code, entered by the user \n
 699  *                     You should make all the parameters.
 700  *
 701  * @param[in] callback To register a callback function for result
 702  *
 703  * @param[in] user_data The user data for user specification
 704  *
 705  * @return The return type (int)
 706  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation is completed successfully
 707  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 708  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 709  *
 710  * @pre This API is used when #TelSimCardStatus_t is #TAPI_SIM_STATUS_SIM_PIN_REQUIRED or #TAPI_SIM_STATUS_SIM_LOCK_REQUIRED on boot time.
 711  * @post callback will be invoked and #TelSimSecResult_t will be stored in data on success case.
 712  */
 713 int tel_verify_sim_pins(TapiHandle *handle, const TelSimSecPw_t *pin_data, tapi_response_cb callback, void *user_data);
 714
 715 /**
 716  * @brief Performs PIN1/PIN2 unblocking operation based on PUK information passed along with
 717  *        unblock information entered by the user.
 718  *
 719  * @details If you get the SIM card status (#TAPI_SIM_STATUS_SIM_PUK_REQUIRED) using #tel_get_sim_init_info on boot time
 720  *          or (#TAPI_SIM_PIN_STATUS_BLOCKED) using #tel_get_sim_facility after normal initialization for a specific operation,
 721  *          you may unblock PIN1/PIN2.
 722  *
 723  *          This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 724  *          However it just means that the API request has been transfered to the CP successfully.
 725  *          The actual operation result is delivered in the corresponding event asynchronously.
 726  *
 727  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 728  *
 729  * <b> Prospective Clients: </b> External Apps.
 730  *
 731  * @since_tizen 2.3
 732  * @privlevel platform
 733  * @privilege %http://tizen.org/privilege/telephony.admin
 734  *
 735  * @remarks If the PIN status (PIN1/PIN2) is blocked, an unsolicited event #TAPI_EVENT_SIM_STATUS_IND
 736  *          will be published to Applications on boot time.
 737  *          If you exceed the specified number of attempts to unblock PIN, the SIM card will be blocked permanently.
 738  *
 739  * @param[in] handle The handle from tel_init()
 740  *
 741  * @param[in] puk_data The unblocking PIN password #TelSimSecPw_t
 742  *
 743  * @param[in] new_pin_data The PIN password to use after the unblocking operation #TelSimSecPw_t
 744  *
 745  * @param[in] callback To register a callback function for result
 746  *
 747  * @param[in] user_data The user data for user specification
 748  *
 749  * @return The return type (int)
 750  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 751  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 752  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 753  *
 754  * @pre PIN1 or PIN2 status should be #TAPI_SIM_PIN_STATUS_BLOCKED and Card status should be #TAPI_SIM_STATUS_SIM_PUK_REQUIRED on boot time.
 755  *
 756  * @post callback will be invoked and #TelSimSecResult_t will be stored in data on success case.
 757  * @post After success on unblocking for PIN1 or PIN2, each pin check facility is enabled even if the previous facility is disabled.
 758  */
 759 int tel_verify_sim_puks(TapiHandle *handle, const TelSimSecPw_t *puk_data, const TelSimSecPw_t *new_pin_data, tapi_response_cb callback, void *user_data);
 760
 761 /**
 762  * @brief Changes the PIN1/PIN2 code based on the PIN type passed along with old PIN data and new PIN data.
 763  *
 764  * @details This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 765  *          However it just means that the API request has been transfered to the CP successfully.
 766  *          The actual operation result is delivered in the corresponding event asynchronously.
 767  *
 768  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 769  *
 770  * <b> Prospective Clients: </b> External Apps.
 771  *
 772  * @since_tizen 2.3
 773  * @privlevel platform
 774  * @privilege %http://tizen.org/privilege/telephony.admin
 775  *
 776  * @remarks The user should set the same PIN type for both @a old_pin and @a new_pin.
 777  *
 778  * @param[in] handle The handle from tel_init()
 779  *
 780  * @param[in] old_pin The old PIN code entered by the user \n
 781  *                    Refer #TelSimSecPw_t.
 782  *
 783  * @param[in] new_pin The new PIN code entered by the user \n
 784  *                    Refer #TelSimSecPw_t.
 785  *
 786  * @param[in] callback To register a callback function for result
 787  *
 788  * @param[in] user_data The user data for user specification
 789  *
 790  * @return The return type (int)
 791  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation is completed successfully
 792  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 793  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 794  *
 795  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 796  * @post callback will be invoked and #TelSimSecResult_t will be stored in data on success case.
 797  */
 798 int tel_change_sim_pins(TapiHandle *handle, const TelSimSecPw_t *old_pin, const TelSimSecPw_t *new_pin, tapi_response_cb callback, void *user_data);
 799
 800 /**
 801  * @brief Disables the SIM facility.
 802  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.
 803  *
 804  * <b> Prospective Clients: </b> External Apps.
 805  *
 806  * @since_tizen 2.3
 807  * @privlevel platform
 808  * @privilege %http://tizen.org/privilege/telephony.admin
 809  *
 810  * @param[in] handle The handle from tel_init()
 811  *
 812  * @param[in] pw A structure which contains the facility type and password
 813  *
 814  * @param[in] callback To register a callback function for result
 815  *
 816  * @param[in] user_data The user data for user specification
 817  *
 818  * @return The return type (int)
 819  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 820  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 821  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 822  * @post callback will be invoked and #TelSimFacilityResult_t will be stored in data on success case.
 823  */
 824 int tel_disable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw, tapi_response_cb callback, void *user_data);
 825
 826 /**
 827  * @brief Enables the SIM facility.
 828  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.
 829  *
 830  * <b> Prospective Clients: </b> External Apps.
 831  *
 832  * @since_tizen 2.3
 833  * @privlevel platform
 834  * @privilege %http://tizen.org/privilege/telephony.admin
 835  *
 836  * @param[in] handle The handle from tel_init()
 837  *
 838  * @param[in] pw A structure which contains the facility type and password
 839  *
 840  * @param[in] callback To register a callback function for result
 841  *
 842  * @param[in] user_data The user data for user specification
 843  *
 844  * @return The return type (int)
 845  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 846  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 847  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 848  * @post callback will be invoked and #TelSimFacilityResult_t will be stored in data on success case.
 849  */
 850 int tel_enable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw, tapi_response_cb callback, void *user_data);
 851
 852 /**
 853  * @brief Gets the SIM facility.
 854  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.
 855  *
 856  * <b> Prospective Clients: </b> External Apps.
 857  *
 858  * @since_tizen 2.3
 859  * @privlevel public
 860  * @privilege %http://tizen.org/privilege/telephony
 861  *
 862  * @param[in] handle The handle from tel_init()
 863  *
 864  * @param[in] type The type of security lock
 865  *
 866  * @param[in] callback To register a callback function for result
 867  *
 868  * @param[in] user_data The user data for user specification
 869  *
 870  * @return The return type (int)
 871  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 872  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 873  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 874  * @post callback will be invoked and #TelSimFacilityInfo_t will be stored in data on success case.
 875  */
 876 int tel_get_sim_facility(TapiHandle *handle, TelSimLockType_t type, tapi_response_cb callback, void *user_data);
 877
 878 /**
 879  * @brief Gets SIM LOCK TYPE info.
 880  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.
 881  *
 882  * <b> Prospective Clients: </b> External Apps.
 883  *
 884  * @since_tizen 2.3
 885  * @privlevel public
 886  * @privilege %http://tizen.org/privilege/telephony
 887  *
 888  * @param[in] handle The handle from tel_init()
 889  *
 890  * @param[in] type The type of security lock
 891  *
 892  * @param[in] callback To register a callback function for result
 893  *
 894  * @param[in] user_data The user data for user specification
 895  *
 896  * @return The return type (int)
 897  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 898  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 899  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 900  * @post callback will be invoked and #TelSimLockInfo_t will be stored in data on success case.
 901  */
 902 int tel_get_sim_lock_info(TapiHandle *handle, TelSimLockType_t type, tapi_response_cb callback, void *user_data);
 903
 904 /**
 905  * @brief  Sets the SIM power state.
 906  *
 907  * @details <b> Sync (or) Async: </b> This is an Asynchronous API.
 908  *
 909  * <b> Prospective Clients: </b> External Apps.
 910  *
 911  * @since_tizen 2.3
 912  * @privlevel platform
 913  * @privilege %http://tizen.org/privilege/telephony.admin
 914  *
 915  * @param [in] handle The handle from tel_init()
 916  *
 917  * @param[in] state The state of SIM to be set \n
 918  *                  It is either ON or OFF.
 919  *
 920  * @param [in] callback To register a callback function for result
 921  *
 922  * @param [in] user_data The user data for user specification
 923  *
 924  * @return The return type (int)
 925  *         Integer '0' ( same with #TAPI_SIM_POWER_SET_SUCCESS ) - indicates that the operation has completed successfully
 926  *         Positive integer : It provides an error code while actual operations (Refer #TelSimPowerSetResult_t)
 927  * @post callback will be invoked and data is NULL.
 928  */
 929 int tel_set_sim_power_state(TapiHandle *handle, TelSimPowerState_t state, tapi_response_cb callback, void *user_data);
 930
 931 /**
 932  * @brief Provides a common interface for accessing SIM data.
 933  *
 934  * @details This function is based on the USIM generic command in ETSI TS 102 221
 935  *          and 3GPP TS 31.102 Characteristics of the Universal Subscriber Identity Module (USIM) application.
 936  *
 937  *          This API provides only an interface to send APDU. The user should know well how to use APDU.
 938  *
 939  *          This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 940  *          However it just means that the API request has been transfered to the CP successfully.
 941  *          The actual operation result is being delivered in the corresponding event asynchronously.
 942  *
 943  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 944  *
 945  * <b> Prospective Clients: </b> External Apps.
 946  *
 947  * @since_tizen 2.3
 948  * @privlevel platform
 949  * @privilege %http://tizen.org/privilege/telephony.admin
 950  *
 951  * @param[in] handle The handle from tel_init()
 952  *
 953  * @param[in] apdu_data The APDU data
 954  *
 955  * @param[in] callback To register a callback function for result
 956  *
 957  * @param[in] user_data The user data for user specification
 958  *
 959  * @return The return type (int)
 960  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS )  - indicates that the operation has completed successfully
 961  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 962  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 963  *
 964  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 965  * @post callback will be invoked and #TelSimApduResp_t will be stored in data on success case.
 966  */
 967 int tel_req_sim_apdu(TapiHandle *handle, TelSimApdu_t* apdu_data, tapi_response_cb callback, void *user_data);
 968
 969 /**
 970  * @brief Provides a common interface to get the SIM ATR(Answer To Reset) value.
 971  *
 972  * @details This function makes a Dbus method call to the Telephony Server and returns an immediate value.
 973  *          However it just means that the API request has been transfered to the CP successfully.
 974  *          The actual operation result is delivered in the corresponding event asynchronously.
 975  *
 976  * <b> Sync (or) Async: </b> This is an Asynchronous API.
 977  *
 978  * <b> Prospective Clients: </b> External Apps.
 979  *
 980  * @since_tizen 2.3
 981  * @privlevel public
 982  * @privilege %http://tizen.org/privilege/telephony
 983  *
 984  * @param[in] handle The handle from tel_init()
 985  *
 986  * @param[in] callback To register a callback function for result
 987  *
 988  * @param[in] user_data The user data for user specification
 989  *
 990  * @return The return type (int)
 991  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
 992  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
 993  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
 994  *
 995  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
 996  * @post callback will be invoked and #TelSimAtrResp_t will be stored in data on success case.
 997  */
 998 int tel_req_sim_atr(TapiHandle *handle, tapi_response_cb callback, void *user_data);
 999
1000 /**
1001  * @breif Gets the list of application on UICC.
1002  * @details It is possible to have multiple applications on single UICC.
1003  *
1004  * <b> Sync (or) Async: </b> This is a Synchronous API.
1005  *
1006  * @since_tizen 2.4
1007  * @privlevel public
1008  * @privilege %http://tizen.org/privilege/telephony
1009  *
1010  * @param[in] handle The handle from tel_init()
1011  * @param[out] app_list The masking value for below values
1012  *                      #TAPI_SIM_APP_TYPE_SIM 0x01 GSM Application
1013  *                      #TAPI_SIM_APP_TYPE_USIM 0x02 USIM Application
1014  *                      #TAPI_SIM_APP_TYPE_CSIM 0x04 CSIM Application
1015  *                      #TAPI_SIM_APP_TYPE_ISIM 0x08 ISIM Application
1016  *
1017  * @return The return type (int)
1018  *         Integer '0' (same with #TAPI_API_SUCCESS) - indicates that the operation has completed successfully
1019  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1020  *
1021  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1022  */
1023 int tel_get_sim_application_list(TapiHandle *handle, unsigned char *app_list);
1024
1025 /**
1026  * @breif Gets the IMPI(IMS private user identity). (ISIM only)
1027  * @details Private user identity of the user.
1028  *
1029  * <b> Sync (or) Async: </b> This is an Asynchronous API.
1030  *
1031  * @since_tizen 2.4
1032  * @privlevel public
1033  * @privilege %http://tizen.org/privilege/telephony
1034  *
1035  * @param[in] handle The handle from tel_init()
1036  * @param[in] callback To reigster a callback function for result
1037  * @param[in] user_data The user data for user specification
1038  *
1039  * @return The return type (int)
1040  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
1041  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1042  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
1043  *
1044  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1045  * @post callback will be invoked and #TelSimImpi_t will be stored in data on success case.
1046  */
1047 int tel_get_sim_impi(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1048
1049 /**
1050  * @breif Gets the IMPU(IMS public user identity). (ISIM only)
1051  * @details SIP URI by which other parties know the subscriber.
1052  *
1053  * <b> Sync (or) Async: </b> This is an Asynchronous API.
1054  *
1055  * @since_tizen 2.4
1056  * @privlevel public
1057  * @privilege %http://tizen.org/privilege/telephony
1058  *
1059  * @param[in] handle The handle from tel_init()
1060  * @param[in] callback To reigster a callback function for result
1061  * @param[in] user_data The user data for user specification
1062  *
1063  * @return The return type (int)
1064  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
1065  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1066  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
1067  *
1068  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1069  * @post callback will be invoked and #TelSimImpuList_t will be stored in data on success case.
1070  */
1071 int tel_get_sim_impu(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1072
1073 /**
1074  * @breif Gets the Domain(Home Network Domain Name). (ISIM only)
1075  * @details Home Network Domain Name.
1076  *
1077  * <b> Sync (or) Async: </b> This is an Asynchronous API.
1078  *
1079  * @since_tizen 2.4
1080  * @privlevel public
1081  * @privilege %http://tizen.org/privilege/telephony
1082  *
1083  * @param[in] handle The handle from tel_init()
1084  * @param[in] callback To reigster a callback function for result
1085  * @param[in] user_data The user data for user specification
1086  *
1087  * @return The return type (int)
1088  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
1089  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1090  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
1091  *
1092  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1093  * @post callback will be invoked and #TelSimDomain_t will be stored in data on success case.
1094  */
1095 int tel_get_sim_domain(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1096
1097 /**
1098  * @breif Gets the P-CSCF(Proxy Call Session Control Function). (ISIM only)
1099  * @details Address of Proxy Call Session Control Function, in the format of a FQDN, an IPv4 address, or an IPv6 address. \n
1100  *          A UE supporting IMS Local Breakout shall use this EF only if EFIST indicates that service n=5 is "available".
1101  *
1102  * <b> Sync (or) Async: </b> This is an Asynchronous API.
1103  *
1104  * @since_tizen 2.4
1105  * @privlevel public
1106  * @privilege %http://tizen.org/privilege/telephony
1107  *
1108  * @param[in] handle The handle from tel_init()
1109  * @param[in] callback To reigster a callback function for result
1110  * @param[in] user_data The user data for user specification
1111  *
1112  * @return The return type (int)
1113  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
1114  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1115  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
1116  *
1117  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1118  * @post callback will be invoked and #TelSimPcscfList_t will be stored in data on success case.
1119  */
1120 int tel_get_sim_pcscf(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1121
1122 /**
1123  * @breif Gets the ISIM service table. (ISIM only)
1124  * @details This EF indicates which optional services are available. \n
1125  *          If a service is not indicated as available in the ISIM, the ME shall not select this service.
1126  *
1127  * <b> Sync (or) Async: </b> This is an Asynchronous API.
1128  *
1129  * @since_tizen 2.4
1130  * @privlevel public
1131  * @privilege %http://tizen.org/privilege/telephony
1132  *
1133  * @param[in] handle The handle from tel_init()
1134  * @param[in] callback To reigster a callback function for result
1135  * @param[in] user_data The user data for user specification
1136  *
1137  * @return The return type (int)
1138  *         Integer '0' ( same with #TAPI_API_SUCCESS & #TAPI_SIM_ACCESS_SUCCESS ) - indicates that the operation has completed successfully
1139  *         Negative integer : It provides an error code before actual operations (Refer #TapiResult_t)
1140  *         Positive integer : It provides an error code during actual operations (Refer #TelSimAccessResult_t)
1141  *
1142  * @pre The user can get valid return values or make operations after SIM init completes(card status is #TAPI_SIM_STATUS_SIM_INIT_COMPLETED).
1143  * @post callback will be invoked and #TelSimIST_t will be stored in data on success case.
1144  */
1145 int tel_get_sim_isim_service_table(TapiHandle *handle, tapi_response_cb callback, void *user_data);
1146
1147 #ifdef __cplusplus
1148 }
1149 #endif
1150
1151 #endif /* _ITAPI_SIM_H_ */
1152
1153 /**
1154  * @}
1155  */