le_sim_interface.h

Go to the documentation of this file.
1 
2 
3 /*
4  * ====================== WARNING ======================
5  *
6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
7  * DO NOT MODIFY IN ANY WAY.
8  *
9  * ====================== WARNING ======================
10  */
11 
12 /**
13  * @page c_sim SIM
14  *
15  * @ref le_sim_interface.h "API Reference" <br>
16  * @ref platformConstraintsSim "SIM constraints"
17  *
18  * <HR>
19  *
20  * This file contains prototype definitions for SIM API.
21  *
22  * A subscriber identity module or subscriber identification module (SIM) is an integrated circuit
23  * that securely stores the international mobile subscriber identity (IMSI) and related key used
24  * to identify and authenticate subscribers on M2M devices.
25  *
26  * Most SIM cards can store a number of SMS messages and phone book contacts.
27  *
28  * le_sim_GetSelectedCard() returns the selected SIM card number.
29  *
30  * @section le_sim_binding IPC interfaces binding
31  *
32  * All the functions of this API are provided by the @b modemService.
33  *
34  * Here's a code sample binding to modem services:
35  * @verbatim
36  bindings:
37  {
38  clientExe.clientComponent.le_sim -> modemService.le_sim
39  }
40  @endverbatim
41  *
42  *
43  * @section le_sim_SelectCard Select a card to use
44  * le_sim_SelectCard() function is used to select the SIM. By default, the SIM in slot 1 is used.
45  * @note The SIM selection is not reset persistent; this function has to be called at each start-up.
46  *
47  * @note: It is recommended to wait for a SIM handler notification after a new SIM selection before
48  * calling le_sim API functions.
49  *
50  * A sample code can be seen in the following page:
51  * - @subpage c_simTestSelect
52  *
53  * @section le_sim_id SIM identification information
54  * \b ICCID:
55  * Each SIM is internationally identified by its integrated circuit card identifier (ICCID). ICCIDs
56  * are stored in the SIM cards and engraved or printed on the SIM card body.
57  * The ICCID is defined by the ITU-T recommendation E.118 as the
58  * Primary Account Number. According to E.118, the number is up to 19 digits long, including a
59  * single check digit calculated using the Luhn algorithm. However, the GSM Phase 1 (ETSI
60  * Recommendation GSM 11.11) defined the ICCID length as 10 octets (20 digits) with
61  * operator-specific structure.
62  *
63  * le_sim_GetICCID() API reads the identification number (ICCID).
64  *
65  * Using this API selects the requested SIM.
66  *
67  * \b IMSI:
68  * The International Mobile Subscriber Identity or IMSI is a unique identification associated with
69  * all cellular networks. The IMSI is used in any mobile network that connects with other
70  * networks. For GSM, UMTS and LTE network, this number is provisioned in the SIM card.
71  *
72  * An IMSI is usually presented as a 15 digit long number, but can be shorter. The first 3 digits
73  * are the mobile country code (MCC), are followed by the mobile network code (MNC), either 2
74  * digits (European standard) or 3 digits (North American standard). The length of the MNC depends
75  * on the value of the MCC. The remaining digits are the mobile subscription identification number
76  * (MSIN) within the network's customer base.
77  *
78  * \b Home \b Network \b Name:
79  * le_sim_GetHomeNetworkOperator() retrieves the Home Network Name.
80  *
81  * le_sim_GetIMSI() API reads the international mobile subscriber identity (IMSI).
82  *
83  * Using this API selects the requested SIM.
84  *
85  * \b Phone \b Number:
86  * le_sim_GetSubscriberPhoneNumber() API reads the Phone Number associated to the SIM.
87  * If the phone number has not been provisioned, it will return the empty string.
88  *
89  * Using this API selects the requested SIM.
90  *
91  * \b Home \b Network \b Information:
92  * - le_sim_GetHomeNetworkOperator()function retrieves the Home Network Name.
93  * - le_sim_GetHomeNetworkMccMnc()function retrieves the Home Network MCC (Mobile Country Code)
94  * and MNC (Mobile Network Code).
95  *
96  * A sample code can be seen in the following page:
97  * - @subpage c_simTestIdentification
98  *
99  * @section le_sim_auth SIM Authentication
100  * le_sim_EnterPIN() enters the PIN (Personal Identification Number) code that's
101  * required before any Mobile equipment functionality can be used.
102  *
103  * Using this API selects the requested SIM.
104  *
105  * le_sim_GetRemainingPINTries() returns the number of remaining PIN entry attempts
106  * before the SIM will become blocked.
107  *
108  * Using this API selects the requested SIM.
109  *
110  * le_sim_GetRemainingPUKTries() returns the number of remaining PUK entry attempts
111  * before the SIM will become blocked.
112  *
113  * Using this API selects the requested SIM.
114  *
115  * le_sim_ChangePIN() must be called to change the PIN code.
116  *
117  * Using this API selects the requested SIM.
118  *
119  * le_sim_Lock() locks the SIM card: it enables requests for the PIN code.
120  *
121  * Using this API selects the requested SIM.
122  *
123  * le_sim_Unlock() unlocks the SIM card: it disables requests for the PIN code.
124  *
125  * Using this API selects the requested SIM.
126  *
127  * le_sim_Unblock() unblocks the SIM card. The SIM card is blocked after X unsuccessful
128  * attempts to enter the PIN. le_sim_Unblock() requires the PUK (Personal Unblocking) code
129  * to set a new PIN code.
130  *
131  * A sample code can be seen in the following page:
132  * - @subpage c_simTestAuthentication
133  *
134  * @section le_sim_state SIM states
135  * le_sim_IsPresent() API advises the SIM is inserted (and locked) or removed.
136  *
137  * Using this API selects the requested SIM.
138  *
139  * le_sim_IsReady() API advises the SIM is ready (PIN code correctly entered
140  * or not required).
141  *
142  * Using this API selects the requested SIM.
143  *
144  * The le_sim_GetState() API retrieves the SIM state:
145  * - LE_SIM_INSERTED : SIM card is inserted and locked.
146  * - LE_SIM_ABSENT : SIM card is absent.
147  * - LE_SIM_READY : SIM card is inserted and unlocked.
148  * - LE_SIM_BLOCKED : SIM card is blocked.
149  * - LE_SIM_BUSY : SIM card is busy.
150  * - LE_SIM_STATE_UNKNOWN : Unknown SIM state.
151  *
152  * Using this API selects the requested SIM.
153  *
154  * A handler function must be registered to receive SIM's state notifications.
155  * le_sim_AddNewStateHandler() API allows the User to register that handler.
156  *
157  * The handler must satisfy the following prototype:
158  * typedef void(*le_sim_NewStateHandlerFunc_t)(@ref le_sim_Id_t simId, @c le_sim_States_t simState);
159  *
160  * When a new SIM's state is notified, the handler is called.
161  *
162  * Call le_sim_GetState() to retrieve the new state of the SIM.
163  *
164  * @note If two (or more) applications have registered a handler function for notifications, they
165  * will all receive it and will be passed the same SIM.
166  *
167  * The application can uninstall the handler function by calling le_sim_RemoveNewStateHandler() API.
168  *
169  * @warning Your platform might need a reboot to detect a SIM insertion or removal.
170  * Please refer to the @ref platformConstraintsSim "SIM constraints" page or your platform
171  * documentation for further details.
172  *
173  * A sample code can be seen in the following page:
174  * - @subpage c_simTestStates
175  *
176  * @section le_sim_profile_switch Local SIM profile switch
177  *
178  * As soon as there are several subscriptions/profiles in the eUICC (multi-profile), and one of
179  * them is dedicated to emergency calls (ex: eCall, ERA-Glonass), local swap is needed to swap as
180  * quickly as possible to the emergency profile in case of need.
181  *
182  * “Local swap” means that the User's application must be able to directly request the eUICC to
183  * swap to Emergency Call Subscription (ECS).
184  *
185  * Local swap puts the eUICC in a temporary state, meaning the commercial subscription is replaced
186  * by emergency subscription for a limited time, event triggering the swap back to commercial
187  * subscription being controlled by the User's application.
188  *
189  * The le_sim_LocalSwapToEmergencyCallSubscription() function requests the multi-profile eUICC to
190  * swap to ECS and to refresh. The User's application must wait for eUICC reboot to be finished and
191  * network connection available.
192  *
193  * The le_sim_LocalSwapToCommercialSubscription() function requests the multi-profile eUICC to swap
194  * back to commercial subscription and to refresh. The User's application must wait for eUICC reboot
195  * to be finished and network connection available.
196  *
197  * The User's application can install an handler with le_sim_AddNewStateHandler() to receive eUICC's
198  * state notifications.
199  *
200  * @warning
201  * - If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be accepted with
202  * le_sim_AcceptSimToolkitCommand() in order to complete the profile swap procedure.
203  * - If you use a Giesecke & Devrient (G&D) card, be sure that your platform has disabled
204  * security restrictions for channel management APDU commands, otherwise local SIM profile switch
205  * could not work.
206  *
207  * The le_sim_IsEmergencyCallSubscriptionSelected() function must be called to get the current
208  * subscription.
209  *
210  * @warning There is no standard method to interrogate the current selected subscription. The
211  * returned value of this function is based on the last executed local swap command. This means
212  * that this function will always return LE_NOT_FOUND error at Legato startup.
213  *
214  * A sample code can be seen in the following page:
215  * - @subpage c_simTestProfileSwitch
216  *
217  * @section le_sim_stk SIM Toolkit
218  *
219  * The SIM application Toolkit allows the SIM card to initiates commands or asking input from the
220  * modem to accept/reject SIM operations. See @ref platformConstraintsStk Constraints.
221  *
222  * One of the use case is the remote provisioning of an embedded UICC (eUICC).
223  *
224  * The embedded UICC (eUICC) format supports multiple subscription profiles, which can be remotely
225  * provisioned, updated or selected through SIM tool kit procedures (Bearer Independent Protocol
226  * -BIP-, SIM refresh).
227  *
228  * It is mainly used for in-vehicle emergency call service (eCall).
229  *
230  * An eUICC can be remotely managed to change the Mobile Network Operator subscription.
231  *
232  * The le_sim_AddSimToolkitEventHandler() function registers a handler to be notified of SIM
233  * Toolkit events.
234  *
235  * The le_sim_RemoveSimToolkitEventHandler() function unregisters the handler.
236  *
237  * The le_sim_AcceptSimToolkitCommand() allows the device to accept the last SIM Toolkit command.
238  *
239  * The le_sim_RejectSimToolkitCommand() forbids the device to accept the last SIM Toolkit command.
240  *
241  * A sample code can be seen in the following page:
242  * - @subpage c_simTestSimToolkit
243  *
244  * Information related to SIM Toolkit platform constraints can be seen in the
245  * @subpage platformConstraintsStk page.
246  *
247  * @section le_sim_access SIM access
248  *
249  * The application can send an APDU (Application Protocol Data Unit) to the SIM using
250  * le_sim_SendApdu() API. The user must encode the APDU as specified by in recommendation 3GPP
251  * 11.11, 3GPP 51.011, 3GPP 31.102, 3GPP 31.103 or ETSI TS 102 221.
252  * @note Between two successive call to le_sim_SendApdu() API, there is no locking
253  * protection. In this situation, some command types and parameters can modify SIM files
254  * incorrectly.
255  *
256  * Using le_sim_SendCommand(), the application has easier but more limited access to the
257  * SIM database. The command is transmitted to the SIM, which gives information through swi1 and
258  * swi2 about the execution of the command (see 3GPP recommendation previously mentioned for
259  * their coding).
260  * Some parameters are platform dependent, see @subpage platformConstraintsSim "SIM constraints" for
261  * their coding.
262  *
263  * A sample code can be seen in the following page:
264  * - @subpage c_simTestApdu
265  *
266  * <HR>
267  *
268  * Copyright (C) Sierra Wireless Inc.
269  */
270 /**
271  * @file le_sim_interface.h
272  *
273  * Legato @ref c_sim include file.
274  *
275  * Copyright (C) Sierra Wireless Inc.
276  */
277 /**
278  * @page c_simTestProfileSwitch Sample code for Local SIM profile switch
279  *
280  * @include "apps/test/modemServices/sim/simProfileSwap/simTestComp/simTest.c"
281  */
282 /**
283  * @page c_simTestSimToolkit Sample code for Local SIM Toolkit
284  *
285  * @include "apps/test/modemServices/sim/simToolkit/simToolkitComp/simToolkitTest.c"
286  */
287 /**
288  * @page c_simTestAuthentication Sample code for SIM Authentication
289  *
290  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Define
291  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
292  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Authentication
293  */
294 /**
295  * @page c_simTestIdentification Sample code for SIM Identification
296  *
297  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
298  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Identification
299  */
300 /**
301  * @page c_simTestSelect Sample code for SIM Select
302  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Select
303  */
304 /**
305  * @page c_simTestStates Sample code for SIM States
306  *
307  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
308  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Display
309  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" State handler
310  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" State
311  */
312 /**
313  * @page c_simTestApdu Sample code for SIM access
314  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Apdu
315  */
316 
317 #ifndef LE_SIM_INTERFACE_H_INCLUDE_GUARD
318 #define LE_SIM_INTERFACE_H_INCLUDE_GUARD
319 
320 
321 #include "legato.h"
322 
323 // Interface specific includes
324 #include "le_mdmDefs_interface.h"
325 
326 
327 //--------------------------------------------------------------------------------------------------
328 /**
329  * Type for handler called when a server disconnects.
330  */
331 //--------------------------------------------------------------------------------------------------
332 typedef void (*le_sim_DisconnectHandler_t)(void *);
333 
334 //--------------------------------------------------------------------------------------------------
335 /**
336  *
337  * Connect the current client thread to the service providing this API. Block until the service is
338  * available.
339  *
340  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
341  * called before any other functions in this API. Normally, ConnectService is automatically called
342  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
343  *
344  * This function is created automatically.
345  */
346 //--------------------------------------------------------------------------------------------------
348 (
349  void
350 );
351 
352 //--------------------------------------------------------------------------------------------------
353 /**
354  *
355  * Try to connect the current client thread to the service providing this API. Return with an error
356  * if the service is not available.
357  *
358  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
359  * called before any other functions in this API. Normally, ConnectService is automatically called
360  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
361  *
362  * This function is created automatically.
363  *
364  * @return
365  * - LE_OK if the client connected successfully to the service.
366  * - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
367  * bound.
368  * - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
369  * - LE_COMM_ERROR if the Service Directory cannot be reached.
370  */
371 //--------------------------------------------------------------------------------------------------
373 (
374  void
375 );
376 
377 //--------------------------------------------------------------------------------------------------
378 /**
379  * Set handler called when server disconnection is detected.
380  *
381  * When a server connection is lost, call this handler then exit with LE_FATAL. If a program wants
382  * to continue without exiting, it should call longjmp() from inside the handler.
383  */
384 //--------------------------------------------------------------------------------------------------
386 (
387  le_sim_DisconnectHandler_t disconnectHandler,
388  void *contextPtr
389 );
390 
391 //--------------------------------------------------------------------------------------------------
392 /**
393  *
394  * Disconnect the current client thread from the service providing this API.
395  *
396  * Normally, this function doesn't need to be called. After this function is called, there's no
397  * longer a connection to the service, and the functions in this API can't be used. For details, see
398  * @ref apiFilesC_client.
399  *
400  * This function is created automatically.
401  */
402 //--------------------------------------------------------------------------------------------------
404 (
405  void
406 );
407 
408 
409 //--------------------------------------------------------------------------------------------------
410 /**
411  * Minimum PIN length (4 digits)
412  */
413 //--------------------------------------------------------------------------------------------------
414 #define LE_SIM_PIN_MIN_LEN 4
415 
416 //--------------------------------------------------------------------------------------------------
417 /**
418  * Maximum PIN length (8 digits)
419  */
420 //--------------------------------------------------------------------------------------------------
421 #define LE_SIM_PIN_MAX_LEN 8
422 
423 //--------------------------------------------------------------------------------------------------
424 /**
425  * Maximum PIN length (8 digits)
426  * One extra byte is added for the null character.
427  */
428 //--------------------------------------------------------------------------------------------------
429 #define LE_SIM_PIN_MAX_BYTES 9
430 
431 //--------------------------------------------------------------------------------------------------
432 /**
433  * PUK length (8 digits)
434  */
435 //--------------------------------------------------------------------------------------------------
436 #define LE_SIM_PUK_MAX_LEN 8
437 
438 //--------------------------------------------------------------------------------------------------
439 /**
440  * PUK length (8 digits)
441  * One extra byte is added for the null character.
442  */
443 //--------------------------------------------------------------------------------------------------
444 #define LE_SIM_PUK_MAX_BYTES 9
445 
446 //--------------------------------------------------------------------------------------------------
447 /**
448  * ICCID length
449  * According to GSM Phase 1
450  */
451 //--------------------------------------------------------------------------------------------------
452 #define LE_SIM_ICCID_LEN 20
453 
454 //--------------------------------------------------------------------------------------------------
455 /**
456  * ICCID length
457  * One extra byte is added for the null character.
458  */
459 //--------------------------------------------------------------------------------------------------
460 #define LE_SIM_ICCID_BYTES 21
461 
462 //--------------------------------------------------------------------------------------------------
463 /**
464  * IMSI length
465  */
466 //--------------------------------------------------------------------------------------------------
467 #define LE_SIM_IMSI_LEN 15
468 
469 //--------------------------------------------------------------------------------------------------
470 /**
471  * IMSI length
472  * One extra byte is added for the null character.
473  */
474 //--------------------------------------------------------------------------------------------------
475 #define LE_SIM_IMSI_BYTES 16
476 
477 //--------------------------------------------------------------------------------------------------
478 /**
479  * APDU length
480  */
481 //--------------------------------------------------------------------------------------------------
482 #define LE_SIM_APDU_MAX_BYTES 255
483 
484 //--------------------------------------------------------------------------------------------------
485 /**
486  * SIM response length
487  */
488 //--------------------------------------------------------------------------------------------------
489 #define LE_SIM_RESPONSE_MAX_BYTES 256
490 
491 //--------------------------------------------------------------------------------------------------
492 /**
493  * SIM file identifier length
494  */
495 //--------------------------------------------------------------------------------------------------
496 #define LE_SIM_FILE_ID_LEN 4
497 
498 //--------------------------------------------------------------------------------------------------
499 /**
500  * SIM file identifier length
501  * One extra byte is added for the null character.
502  */
503 //--------------------------------------------------------------------------------------------------
504 #define LE_SIM_FILE_ID_BYTES 5
505 
506 //--------------------------------------------------------------------------------------------------
507 /**
508  * SIM data command length
509  *
510  */
511 //--------------------------------------------------------------------------------------------------
512 #define LE_SIM_DATA_MAX_BYTES 100
513 
514 //--------------------------------------------------------------------------------------------------
515 /**
516  * SIM file path length
517  */
518 //--------------------------------------------------------------------------------------------------
519 #define LE_SIM_PATH_MAX_LEN 100
520 
521 //--------------------------------------------------------------------------------------------------
522 /**
523  * SIM file path length
524  * One extra byte is added for the null character.
525  */
526 //--------------------------------------------------------------------------------------------------
527 #define LE_SIM_PATH_MAX_BYTES 101
528 
529 //--------------------------------------------------------------------------------------------------
530 /**
531  * SIM states.
532  *
533  */
534 //--------------------------------------------------------------------------------------------------
535 typedef enum
536 {
538  ///< SIM card is inserted and locked.
540  ///< SIM card is absent.
542  ///< SIM card is inserted and unlocked.
544  ///< SIM card is blocked.
546  ///< SIM card is busy.
548  ///< Unknown SIM state.
549 }
551 
552 
553 //--------------------------------------------------------------------------------------------------
554 /**
555  * SIM identifiers.
556  *
557  */
558 //--------------------------------------------------------------------------------------------------
559 typedef enum
560 {
562  ///< Embedded SIM
564  ///< SIM inserted in external slot 1
566  ///< SIM inserted in external slot 2
568  ///< Remote SIM
569  LE_SIM_ID_MAX = 4
570  ///<
571 }
573 
574 
575 //--------------------------------------------------------------------------------------------------
576 /**
577  * Card Manufacturer.
578  *
579  */
580 //--------------------------------------------------------------------------------------------------
581 typedef enum
582 {
584  ///< Oberthur.
586  ///< Gemalto.
588  ///< G&D.
590  ///< Morpho.
592  ///< Valid.
593  LE_SIM_MANUFACTURER_MAX = 5
594  ///<
595 }
597 
598 
599 //--------------------------------------------------------------------------------------------------
600 /**
601  * SIM commands.
602  */
603 //--------------------------------------------------------------------------------------------------
604 typedef enum
605 {
607  ///< Read a file record.
609  ///< Read a transparent elementary file.
611  ///< Update a file record.
613  ///< Update a transparent elementary file.
615  ///< Max value
616 }
618 
619 
620 //--------------------------------------------------------------------------------------------------
621 /**
622  * SIM Toolkit events.
623  */
624 //--------------------------------------------------------------------------------------------------
625 typedef enum
626 {
628  ///< SIM card ask to open a logical channel.
630  ///< SIM card ask for a refresh.
632  ///< Unknown SIM Toolkit event.
633 }
635 
636 
637 //--------------------------------------------------------------------------------------------------
638 /**
639  * Reference type used by Add/Remove functions for EVENT 'le_sim_NewState'
640  */
641 //--------------------------------------------------------------------------------------------------
642 typedef struct le_sim_NewStateHandler* le_sim_NewStateHandlerRef_t;
643 
644 
645 //--------------------------------------------------------------------------------------------------
646 /**
647  * Reference type used by Add/Remove functions for EVENT 'le_sim_SimToolkitEvent'
648  */
649 //--------------------------------------------------------------------------------------------------
650 typedef struct le_sim_SimToolkitEventHandler* le_sim_SimToolkitEventHandlerRef_t;
651 
652 
653 //--------------------------------------------------------------------------------------------------
654 /**
655  * Handler for sim state changes.
656  *
657  */
658 //--------------------------------------------------------------------------------------------------
659 typedef void (*le_sim_NewStateHandlerFunc_t)
660 (
661  le_sim_Id_t simId,
662  ///< The SIM identifier.
663  le_sim_States_t simState,
664  ///< The SIM state.
665  void* contextPtr
666  ///<
667 );
668 
669 //--------------------------------------------------------------------------------------------------
670 /**
671  * Handler for Sim Toolkit Events.
672  *
673  */
674 //--------------------------------------------------------------------------------------------------
676 (
677  le_sim_Id_t simId,
678  ///< The SIM identifier.
679  le_sim_StkEvent_t stkEvent,
680  ///< The SIM state.
681  void* contextPtr
682  ///<
683 );
684 
685 //--------------------------------------------------------------------------------------------------
686 /**
687  * Add handler function for EVENT 'le_sim_NewState'
688  *
689  * This event provides information on sim state changes.
690  *
691  */
692 //--------------------------------------------------------------------------------------------------
694 (
695  le_sim_NewStateHandlerFunc_t handlerPtr,
696  ///< [IN]
697  void* contextPtr
698  ///< [IN]
699 );
700 
701 //--------------------------------------------------------------------------------------------------
702 /**
703  * Remove handler function for EVENT 'le_sim_NewState'
704  */
705 //--------------------------------------------------------------------------------------------------
707 (
708  le_sim_NewStateHandlerRef_t handlerRef
709  ///< [IN]
710 );
711 
712 //--------------------------------------------------------------------------------------------------
713 /**
714  * Add handler function for EVENT 'le_sim_SimToolkitEvent'
715  *
716  * This event provides information on Sim Toolkit application.
717  *
718  */
719 //--------------------------------------------------------------------------------------------------
721 (
723  ///< [IN]
724  void* contextPtr
725  ///< [IN]
726 );
727 
728 //--------------------------------------------------------------------------------------------------
729 /**
730  * Remove handler function for EVENT 'le_sim_SimToolkitEvent'
731  */
732 //--------------------------------------------------------------------------------------------------
734 (
736  ///< [IN]
737 );
738 
739 //--------------------------------------------------------------------------------------------------
740 /**
741  * Get the current selected card.
742  *
743  * @return Number of the current selected SIM card.
744  */
745 //--------------------------------------------------------------------------------------------------
747 (
748  void
749 );
750 
751 //--------------------------------------------------------------------------------------------------
752 /**
753  * Select a SIM.
754  *
755  * @return LE_FAULT Function failed to select the requested SIM
756  * @return LE_OK Function succeeded.
757  *
758  */
759 //--------------------------------------------------------------------------------------------------
761 (
762  le_sim_Id_t simId
763  ///< [IN] The SIM identifier.
764 );
765 
766 //--------------------------------------------------------------------------------------------------
767 /**
768  * Retrieves the integrated circuit card identifier (ICCID) of the SIM card (20 digits)
769  *
770  * @return LE_OK ICCID was successfully retrieved.
771  * @return LE_OVERFLOW iccidPtr buffer was too small for the ICCID.
772  * @return LE_BAD_PARAMETER if a parameter is invalid
773  * @return LE_FAULT The ICCID could not be retrieved.
774  *
775  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
776  * function will not return.
777  */
778 //--------------------------------------------------------------------------------------------------
780 (
781  le_sim_Id_t simId,
782  ///< [IN] The SIM identifier.
783  char* iccid,
784  ///< [OUT] ICCID
785  size_t iccidSize
786  ///< [IN]
787 );
788 
789 //--------------------------------------------------------------------------------------------------
790 /**
791  * Retrieves the identification number (IMSI) of the SIM card. (max 15 digits)
792  *
793  * @return LE_OVERFLOW The imsiPtr buffer was too small for the IMSI.
794  * @return LE_BAD_PARAMETER The parameters are invalid.
795  * @return LE_FAULT The function failed.
796  * @return LE_TIMEOUT No response was received.
797  * @return LE_OK The function succeeded.
798  *
799  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
800  * function will not return.
801  */
802 //--------------------------------------------------------------------------------------------------
804 (
805  le_sim_Id_t simId,
806  ///< [IN] The SIM identifier.
807  char* imsi,
808  ///< [OUT] IMSI
809  size_t imsiSize
810  ///< [IN]
811 );
812 
813 //--------------------------------------------------------------------------------------------------
814 /**
815  * Verify if the SIM card is present or not.
816  *
817  * @return true SIM card is present.
818  * @return false SIM card is absent
819  *
820  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
821  * function will not return.
822  */
823 //--------------------------------------------------------------------------------------------------
824 bool le_sim_IsPresent
825 (
826  le_sim_Id_t simId
827  ///< [IN] The SIM identifier.
828 );
829 
830 //--------------------------------------------------------------------------------------------------
831 /**
832  * Verify if the SIM is ready (PIN code correctly inserted or not
833  * required).
834  *
835  * @return true PIN is correctly inserted or not required.
836  * @return false PIN must be inserted
837  *
838  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
839  * function will not return.
840  */
841 //--------------------------------------------------------------------------------------------------
842 bool le_sim_IsReady
843 (
844  le_sim_Id_t simId
845  ///< [IN] The SIM identifier.
846 );
847 
848 //--------------------------------------------------------------------------------------------------
849 /**
850  * This function must be called to enter the PIN code.
851  *
852  * @return LE_BAD_PARAMETER The parameters are invalid.
853  * @return LE_NOT_FOUND The function failed to select the SIM card for this operation.
854  * @return LE_UNDERFLOW The PIN code is not long enough (min 4 digits).
855  * @return LE_FAULT The function failed to enter the PIN code.
856  * @return LE_OK The function succeeded.
857  *
858  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
859  * function will not return.
860  *
861  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
862  * function will not return.
863  */
864 //--------------------------------------------------------------------------------------------------
866 (
867  le_sim_Id_t simId,
868  ///< [IN] The SIM identifier.
869  const char* pin
870  ///< [IN] The PIN code.
871 )
872 __attribute__(( nonnull(2) ));
873 
874 //--------------------------------------------------------------------------------------------------
875 /**
876  * Change the PIN code.
877  *
878  * @return LE_NOT_FOUND Function failed to select the SIM card for this operation.
879  * @return LE_UNDERFLOW PIN code is/are not long enough (min 4 digits).
880  * @return LE_FAULT Function failed to change the PIN code.
881  * @return LE_OK Function succeeded.
882  *
883  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
884  * function will not return.
885  *
886  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
887  * function will not return.
888  */
889 //--------------------------------------------------------------------------------------------------
891 (
892  le_sim_Id_t simId,
893  ///< [IN] The SIM identifier.
894  const char* oldpin,
895  ///< [IN] The old PIN code.
896  const char* newpin
897  ///< [IN] The new PIN code.
898 )
899 __attribute__(( nonnull(2,3) ));
900 
901 //--------------------------------------------------------------------------------------------------
902 /**
903  * Get the number of remaining PIN insertion tries.
904  *
905  * @return LE_NOT_FOUND The function failed to select the SIM card for this operation.
906  * @return LE_BAD_PARAMETER Invalid SIM identifier.
907  * @return LE_FAULT The function failed to get the number of remaining PIN insertion tries.
908  * @return A positive value The function succeeded. The number of remaining PIN insertion tries.
909  *
910  */
911 //--------------------------------------------------------------------------------------------------
913 (
914  le_sim_Id_t simId
915  ///< [IN] The SIM identifier.
916 );
917 
918 //--------------------------------------------------------------------------------------------------
919 /**
920  * Get the number of remaining PUK insertion tries.
921  *
922  * @return LE_OK On success.
923  * @return LE_NOT_FOUND The function failed to select the SIM card for this operation.
924  * @return LE_BAD_PARAMETER Invalid SIM identifier.
925  * @return LE_FAULT The function failed to get the number of remaining PUK insertion tries.
926  *
927  * @note If the caller is passing an null pointer to this function, it is a fatal error
928  * and the function will not return.
929  *
930  */
931 //--------------------------------------------------------------------------------------------------
933 (
934  le_sim_Id_t simId,
935  ///< [IN] The SIM identifier.
936  uint32_t* remainingPukTriesPtrPtr
937  ///< [OUT] The number of remaining PUK insertion tries.
938 );
939 
940 //--------------------------------------------------------------------------------------------------
941 /**
942  * Unlock the SIM card: it disables the request of the PIN code.
943  *
944  * @return LE_NOT_FOUND Function failed to select the SIM card for this operation.
945  * @return LE_UNDERFLOW PIN code is not long enough (min 4 digits).
946  * @return LE_FAULT The function failed to unlock the SIM card.
947  * @return LE_OK Function succeeded.
948  *
949  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
950  * function will not return.
951  *
952  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
953  * function will not return.
954  */
955 //--------------------------------------------------------------------------------------------------
957 (
958  le_sim_Id_t simId,
959  ///< [IN] The SIM identifier.
960  const char* pin
961  ///< [IN] The PIN code.
962 )
963 __attribute__(( nonnull(2) ));
964 
965 //--------------------------------------------------------------------------------------------------
966 /**
967  * Lock the SIM card: it enables the request of the PIN code.
968  *
969  * @return LE_NOT_FOUND Function failed to select the SIM card for this operation.
970  * @return LE_UNDERFLOW PIN code is not long enough (min 4 digits).
971  * @return LE_FAULT The function failed to unlock the SIM card.
972  * @return LE_OK Function succeeded.
973  *
974  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
975  * function will not return.
976  *
977  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
978  * function will not return.
979  */
980 //--------------------------------------------------------------------------------------------------
982 (
983  le_sim_Id_t simId,
984  ///< [IN] The SIM identifier.
985  const char* pin
986  ///< [IN] The PIN code.
987 )
988 __attribute__(( nonnull(2) ));
989 
990 //--------------------------------------------------------------------------------------------------
991 /**
992  * Unblock the SIM card.
993  *
994  * @return LE_NOT_FOUND Function failed to select the SIM card for this operation.
995  * @return LE_UNDERFLOW PIN code is not long enough (min 4 digits).
996  * @return LE_BAD_PARAMETER Invalid SIM identifier.
997  * @return LE_OUT_OF_RANGE PUK code length is not correct (8 digits).
998  * @return LE_FAULT The function failed to unlock the SIM card.
999  * @return LE_OK Function succeeded.
1000  *
1001  * @note If new PIN or puk code are too long (max 8 digits), it is a fatal error, the
1002  * function will not return.
1003  *
1004  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1005  * function will not return.
1006  */
1007 //--------------------------------------------------------------------------------------------------
1009 (
1010  le_sim_Id_t simId,
1011  ///< [IN] The SIM identifier.
1012  const char* puk,
1013  ///< [IN] The PUK code.
1014  const char* newpin
1015  ///< [IN] The PIN code.
1016 )
1017 __attribute__(( nonnull(2,3) ));
1018 
1019 //--------------------------------------------------------------------------------------------------
1020 /**
1021  * Get the SIM state.
1022  *
1023  * @return Current SIM state.
1024  *
1025  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1026  * function will not return.
1027  */
1028 //--------------------------------------------------------------------------------------------------
1030 (
1031  le_sim_Id_t simId
1032  ///< [IN] The SIM identifier.
1033 );
1034 
1035 //--------------------------------------------------------------------------------------------------
1036 /**
1037  * Get the SIM Phone Number.
1038  *
1039  * @return
1040  * - LE_OK on success
1041  * - LE_OVERFLOW if the Phone Number can't fit in phoneNumberStr
1042  * - LE_BAD_PARAMETER if a parameter is invalid
1043  * - LE_FAULT on any other failure
1044  *
1045  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1046  * function will not return.
1047  */
1048 //--------------------------------------------------------------------------------------------------
1050 (
1051  le_sim_Id_t simId,
1052  ///< [IN] The SIM identifier.
1053  char* phoneNumberStr,
1054  ///< [OUT] The phone Number.
1055  size_t phoneNumberStrSize
1056  ///< [IN]
1057 );
1058 
1059 //--------------------------------------------------------------------------------------------------
1060 /**
1061  * This function must be called to get the Home Network Name information.
1062  *
1063  * @return
1064  * - LE_OK on success
1065  * - LE_OVERFLOW if the Home Network Name can't fit in nameStr
1066  * - LE_NOT_FOUND if the network is not found
1067  * - LE_BAD_PARAMETER if a parameter is invalid
1068  * - LE_FAULT on any other failure
1069  *
1070  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1071  * function will not return.
1072  */
1073 //--------------------------------------------------------------------------------------------------
1075 (
1076  le_sim_Id_t simId,
1077  ///< [IN] The SIM identifier.
1078  char* nameStr,
1079  ///< [OUT] the home network Name
1080  size_t nameStrSize
1081  ///< [IN]
1082 );
1083 
1084 //--------------------------------------------------------------------------------------------------
1085 /**
1086  * This function must be called to get the Home Network MCC MNC.
1087  *
1088  * @return
1089  * - LE_OK on success
1090  * - LE_NOT_FOUND if Home Network has not been provisioned
1091  * - LE_FAULT for unexpected error
1092  *
1093  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
1094  * function will not return.
1095  */
1096 //--------------------------------------------------------------------------------------------------
1098 (
1099  le_sim_Id_t simId,
1100  ///< [IN] The SIM identifier.
1101  char* mccPtr,
1102  ///< [OUT] Mobile Country Code
1103  size_t mccPtrSize,
1104  ///< [IN]
1105  char* mncPtr,
1106  ///< [OUT] Mobile Network Code
1107  size_t mncPtrSize
1108  ///< [IN]
1109 );
1110 
1111 //--------------------------------------------------------------------------------------------------
1112 /**
1113  * This function must be called to request the multi-profile eUICC to swap to ECS and to refresh.
1114  * The User's application must wait for eUICC reboot to be finished and network connection
1115  * available.
1116  *
1117  * @return
1118  * - LE_OK on success
1119  * - LE_BAD_PARAMETER invalid SIM identifier
1120  * - LE_BUSY when a profile swap is already in progress
1121  * - LE_FAULT for unexpected error
1122  *
1123  * @warning If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be
1124  * accepted with le_sim_AcceptSimToolkitCommand() in order to complete the profile swap
1125  * procedure.
1126  */
1127 //--------------------------------------------------------------------------------------------------
1129 (
1130  le_sim_Id_t simId,
1131  ///< [IN] The SIM identifier.
1132  le_sim_Manufacturer_t manufacturer
1133  ///< [IN] The card manufacturer.
1134 );
1135 
1136 //--------------------------------------------------------------------------------------------------
1137 /**
1138  * This function must be called to request the multi-profile eUICC to swap back to commercial
1139  * subscription and to refresh.
1140  * The User's application must wait for eUICC reboot to be finished and network connection
1141  * available.
1142  *
1143  * @return
1144  * - LE_OK on success
1145  * - LE_BAD_PARAMETER invalid SIM identifier
1146  * - LE_BUSY when a profile swap is already in progress
1147  * - LE_FAULT for unexpected error
1148  *
1149  * @warning If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be
1150  * accepted with le_sim_AcceptSimToolkitCommand() in order to complete the profile swap
1151  * procedure.
1152  */
1153 //--------------------------------------------------------------------------------------------------
1155 (
1156  le_sim_Id_t simId,
1157  ///< [IN] The SIM identifier.
1158  le_sim_Manufacturer_t manufacturer
1159  ///< [IN] The card manufacturer.
1160 );
1161 
1162 //--------------------------------------------------------------------------------------------------
1163 /**
1164  * This function must be called to get the current subscription.
1165  *
1166  * @return
1167  * - LE_OK on success
1168  * - LE_BAD_PARAMETER invalid SIM identifier
1169  * - LE_NOT_FOUND cannot determine the current selected subscription
1170  * - LE_FAULT for unexpected errors
1171  *
1172  * @warning There is no standard method to interrogate the current selected subscription. The
1173  * returned value of this function is based on the last executed local swap command. This means
1174  * that this function will always return LE_NOT_FOUND error at Legato startup.
1175  */
1176 //--------------------------------------------------------------------------------------------------
1178 (
1179  le_sim_Id_t simId,
1180  ///< [IN] The SIM identifier
1181  bool* isEcsPtr
1182  ///< [OUT] true if Emergency Call Subscription (ECS) is selected,
1183  ///< false if Commercial Subscription is selected
1184 );
1185 
1186 //--------------------------------------------------------------------------------------------------
1187 /**
1188  * Accept the last SIM Toolkit command.
1189  *
1190  * @return LE_FAULT Function failed.
1191  * @return LE_OK Function succeeded.
1192  */
1193 //--------------------------------------------------------------------------------------------------
1195 (
1196  le_sim_Id_t simId
1197  ///< [IN] The SIM identifier.
1198 );
1199 
1200 //--------------------------------------------------------------------------------------------------
1201 /**
1202  * Reject the last SIM Toolkit command.
1203  *
1204  * @return LE_FAULT Function failed.
1205  * @return LE_OK Function succeeded.
1206  */
1207 //--------------------------------------------------------------------------------------------------
1209 (
1210  le_sim_Id_t simId
1211  ///< [IN] The SIM identifier.
1212 );
1213 
1214 //--------------------------------------------------------------------------------------------------
1215 /**
1216  * Send APDU command to the SIM.
1217  *
1218  * @return
1219  * - LE_OK Function succeeded.
1220  * - LE_FAULT The function failed.
1221  * - LE_BAD_PARAMETER A parameter is invalid.
1222  * - LE_NOT_FOUND The function failed to select the SIM card for this operation.
1223  */
1224 //--------------------------------------------------------------------------------------------------
1226 (
1227  le_sim_Id_t simId,
1228  ///< [IN] The SIM identifier.
1229  const uint8_t* commandApduPtr,
1230  ///< [IN] APDU command.
1231  size_t commandApduSize,
1232  ///< [IN]
1233  uint8_t* responseApduPtr,
1234  ///< [OUT] SIM response.
1235  size_t* responseApduSizePtr
1236  ///< [INOUT]
1237 );
1238 
1239 //--------------------------------------------------------------------------------------------------
1240 /**
1241  * Send a command to the SIM.
1242  *
1243  * @return
1244  * - LE_OK Function succeeded.
1245  * - LE_FAULT The function failed.
1246  * - LE_BAD_PARAMETER A parameter is invalid.
1247  * - LE_NOT_FOUND - The function failed to select the SIM card for this operation
1248  * - The requested SIM file is not found
1249  * - LE_OVERFLOW Response buffer is too small to copy the SIM answer.
1250  * - LE_UNSUPPORTED The platform does not support this operation.
1251  */
1252 //--------------------------------------------------------------------------------------------------
1254 (
1255  le_sim_Id_t simId,
1256  ///< [IN] The SIM identifier.
1257  le_sim_Command_t command,
1258  ///< [IN] The SIM command.
1259  const char* fileIdentifier,
1260  ///< [IN] File identifier
1261  uint8_t p1,
1262  ///< [IN] Parameter P1 passed to the SIM
1263  uint8_t p2,
1264  ///< [IN] Parameter P2 passed to the SIM
1265  uint8_t p3,
1266  ///< [IN] Parameter P3 passed to the SIM
1267  const uint8_t* dataPtr,
1268  ///< [IN] data command.
1269  size_t dataSize,
1270  ///< [IN]
1271  const char* path,
1272  ///< [IN] path of the elementary file
1273  uint8_t* sw1Ptr,
1274  ///< [OUT] Status Word 1 received from the SIM
1275  uint8_t* sw2Ptr,
1276  ///< [OUT] Status Word 2 received from the SIM
1277  uint8_t* responsePtr,
1278  ///< [OUT] SIM response.
1279  size_t* responseSizePtr
1280  ///< [INOUT]
1281 )
1282 __attribute__(( nonnull(3,9) ));
1283 
1284 #endif // LE_SIM_INTERFACE_H_INCLUDE_GUARD
le_sim_NewStateHandlerRef_t le_sim_AddNewStateHandler(le_sim_NewStateHandlerFunc_t handlerPtr, void *contextPtr)
Read a transparent elementary file.
Definition: le_sim_interface.h:608
bool le_sim_IsPresent(le_sim_Id_t simId)
le_result_t le_sim_GetHomeNetworkOperator(le_sim_Id_t simId, char *nameStr, size_t nameStrSize)
le_sim_Id_t
Definition: le_sim_interface.h:559
le_result_t le_sim_GetRemainingPUKTries(le_sim_Id_t simId, uint32_t *remainingPukTriesPtrPtr)
void(* le_sim_SimToolkitEventHandlerFunc_t)(le_sim_Id_t simId, le_sim_StkEvent_t stkEvent, void *contextPtr)
Definition: le_sim_interface.h:676
le_result_t
Definition: le_basics.h:35
le_result_t le_sim_Lock(le_sim_Id_t simId, const char *pin)
le_result_t le_sim_LocalSwapToEmergencyCallSubscription(le_sim_Id_t simId, le_sim_Manufacturer_t manufacturer)
le_result_t le_sim_SendApdu(le_sim_Id_t simId, const uint8_t *commandApduPtr, size_t commandApduSize, uint8_t *responseApduPtr, size_t *responseApduSizePtr)
SIM card is busy.
Definition: le_sim_interface.h:545
le_sim_StkEvent_t
Definition: le_sim_interface.h:625
le_result_t le_sim_GetHomeNetworkMccMnc(le_sim_Id_t simId, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)
Update a transparent elementary file.
Definition: le_sim_interface.h:612
le_result_t le_sim_Unblock(le_sim_Id_t simId, const char *puk, const char *newpin)
Embedded SIM.
Definition: le_sim_interface.h:561
Oberthur.
Definition: le_sim_interface.h:583
le_sim_States_t
Definition: le_sim_interface.h:535
le_result_t le_sim_SendCommand(le_sim_Id_t simId, le_sim_Command_t command, const char *fileIdentifier, uint8_t p1, uint8_t p2, uint8_t p3, const uint8_t *dataPtr, size_t dataSize, const char *path, uint8_t *sw1Ptr, uint8_t *sw2Ptr, uint8_t *responsePtr, size_t *responseSizePtr)
struct le_sim_SimToolkitEventHandler * le_sim_SimToolkitEventHandlerRef_t
Definition: le_sim_interface.h:650
le_result_t le_sim_Unlock(le_sim_Id_t simId, const char *pin)
SIM card is absent.
Definition: le_sim_interface.h:539
SIM card is inserted and locked.
Definition: le_sim_interface.h:537
Read a file record.
Definition: le_sim_interface.h:606
void(* le_sim_NewStateHandlerFunc_t)(le_sim_Id_t simId, le_sim_States_t simState, void *contextPtr)
Definition: le_sim_interface.h:660
le_result_t le_sim_GetICCID(le_sim_Id_t simId, char *iccid, size_t iccidSize)
void le_sim_SetServerDisconnectHandler(le_sim_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_result_t le_sim_AcceptSimToolkitCommand(le_sim_Id_t simId)
Max value.
Definition: le_sim_interface.h:614
Unknown SIM Toolkit event.
Definition: le_sim_interface.h:631
void le_sim_ConnectService(void)
SIM card ask to open a logical channel.
Definition: le_sim_interface.h:627
le_result_t le_sim_GetIMSI(le_sim_Id_t simId, char *imsi, size_t imsiSize)
Gemalto.
Definition: le_sim_interface.h:585
SIM card ask for a refresh.
Definition: le_sim_interface.h:629
SIM inserted in external slot 1.
Definition: le_sim_interface.h:563
void le_sim_DisconnectService(void)
struct le_sim_NewStateHandler * le_sim_NewStateHandlerRef_t
Definition: le_sim_interface.h:642
le_result_t le_sim_ChangePIN(le_sim_Id_t simId, const char *oldpin, const char *newpin)
le_result_t le_sim_SelectCard(le_sim_Id_t simId)
le_sim_Manufacturer_t
Definition: le_sim_interface.h:581
void(* le_sim_DisconnectHandler_t)(void *)
Definition: le_sim_interface.h:332
Remote SIM.
Definition: le_sim_interface.h:567
Valid.
Definition: le_sim_interface.h:591
int32_t le_sim_GetRemainingPINTries(le_sim_Id_t simId)
bool le_sim_IsReady(le_sim_Id_t simId)
le_sim_SimToolkitEventHandlerRef_t le_sim_AddSimToolkitEventHandler(le_sim_SimToolkitEventHandlerFunc_t handlerPtr, void *contextPtr)
void le_sim_RemoveSimToolkitEventHandler(le_sim_SimToolkitEventHandlerRef_t handlerRef)
void le_sim_RemoveNewStateHandler(le_sim_NewStateHandlerRef_t handlerRef)
le_result_t le_sim_RejectSimToolkitCommand(le_sim_Id_t simId)
le_result_t le_sim_GetSubscriberPhoneNumber(le_sim_Id_t simId, char *phoneNumberStr, size_t phoneNumberStrSize)
SIM card is blocked.
Definition: le_sim_interface.h:543
le_result_t le_sim_EnterPIN(le_sim_Id_t simId, const char *pin)
le_result_t le_sim_IsEmergencyCallSubscriptionSelected(le_sim_Id_t simId, bool *isEcsPtr)
G&D.
Definition: le_sim_interface.h:587
Morpho.
Definition: le_sim_interface.h:589
le_sim_Command_t
Definition: le_sim_interface.h:604
le_sim_Id_t le_sim_GetSelectedCard(void)
le_sim_States_t le_sim_GetState(le_sim_Id_t simId)
le_result_t le_sim_LocalSwapToCommercialSubscription(le_sim_Id_t simId, le_sim_Manufacturer_t manufacturer)
SIM inserted in external slot 2.
Definition: le_sim_interface.h:565
le_result_t le_sim_TryConnectService(void)
Unknown SIM state.
Definition: le_sim_interface.h:547
SIM card is inserted and unlocked.
Definition: le_sim_interface.h:541
Update a file record.
Definition: le_sim_interface.h:610