le_mcc_interface.h

    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_mcc Modem Call Control
   14  *
   15  * @ref le_mcc_interface.h "API Reference"
   16  *
   17  * <HR>
   18  *
   19  * The Modem Call Control (mcc) API functions of this API are provided by the @b modemService
   20  * service.
   21  *
   22  * @section le_mcc_binding IPC interfaces binding
   23  *
   24  * Here's a code sample binding to modem services:
   25  * @verbatim
   26    bindings:
   27    {
   28       clientExe.clientComponent.le_mcc -> modemService.le_mcc
   29    }
   30    @endverbatim
   31  *
   32  * @section le_mcc_starting_a_call Starting a Call
   33  *
   34  * To initiate a call, create a new call object with a destination telephone
   35  * number calling the le_mcc_Create() function.
   36  *
   37  * le_mcc_Start() must still initiate the call when ready.
   38  *
   39  * The le_mcc_Start() function initiates a call attempt (it's asynchronous because it can take
   40  * time for a call to connect). If function failed, the le_mcc_GetTerminationReason() API can be
   41  * used to retrieve the terminal reason.
   42  *
   43  * It's essential to register a handler function to get the call events. Use
   44  * le_mcc_AddCallEventHandler() API to install that handler function. The handler will be
   45  * called for all calls' events (incoming and outgoing).
   46  *
   47  * The le_mcc_RemoveCallEventHandler() API uninstalls the handler function.
   48  *
   49  * The following APIs can be used to manage incoming or outgoing calls:
   50  * - le_mcc_GetTerminationReason() - termination reason.
   51  * - le_mcc_GetPlatformSpecificTerminationCode() - the platform specific termination code (refer
   52  * to your platform documentation for further details).
   53  * - le_mcc_IsConnected() - connection status.
   54  * - le_mcc_GetRemoteTel() - displays remote party telephone number associated with the call.
   55  * - le_mcc_HangUp() will disconnect this call.
   56  *
   57  * When finished with the call object, call le_mcc_Delete() to free all the allocated resources
   58  * associated with the object.
   59  *
   60  * Multi-threading/multi-application behaviour: the callRef is linked to a specific client
   61  * (i.e. connection with the mcc service). Each client will have its own callRef for a same call.
   62  * That is, if a call event handler is registered by one thread but le_mcc_Create() is called by
   63  * another thread, they will each get different call references for the same call. So, when multiple
   64  * threads are being used to work with the same call, a comparison of the call references themselves
   65  * can't be used to tell whether or not they refer to the same call.
   66  *
   67  *
   68  *
   69  * @section le_mcc_answering_a_call Answering a call
   70  *
   71  * Receiving calls is similar sending calls. Add a handler through le_mcc_AddCallEventHandler()
   72  * to be notified of incoming calls.
   73  *
   74  * To answer, call le_mcc_Answer(). To reject it, call le_mcc_HangUp().
   75  *
   76  *
   77  * @section le_mcc_ending_all_call Ending all calls
   78  *
   79  * A special function can be used to hang-up all the ongoing calls: le_mcc_HangUpAll().
   80  * This function can be used to hang-up any calls that have been initiated through another client
   81  * like AT commands.
   82  *
   83  *
   84  *
   85  * @section le_mcc_ss Supplementary service
   86  *
   87  * Calling Line Identification Restriction (CLIR) can be activated or deactivated by
   88  *  le_mcc_SetCallerIdRestrict API. The status is independent for each call object reference.
   89  *  Status can be read with the le_mcc_GetCallerIdRestrict() API.
   90  * Default value is LE_OFF (Enable presentation of own phone number to remote).
   91  *
   92  * Call waiting supplementary service can be activated or deactivated by
   93  * le_mcc_SetCallWaitingService(). Its status can be given by le_mcc_GetCallWaitingService().
   94  * A call waiting can be answered using le_mcc_ActivateCall() API. This API is also used to
   95  * activate an on hold call (current call is then placed on hold).
   96  * An activated, waiting or on hold call can be released using le_mcc_HangUp() function.
   97  * See 3GPP TS 02.83 / 22.083 for any details concerning call waiting / call hold supplementary
   98  * services.
   99  *
  100  * @todo Other Supplementary services will be available in a future release. Create simpler examples.
  101  *
  102  *  @section le_mcc_samples Sample codes
  103  *
  104  * A sample code that implements a dialing call can be found in \b le_mccTest.c file (please refer
  105  * to @ref c_mccTest page).
  106  *
  107  *
  108  * <HR>
  109  *
  110  * Copyright (C) Sierra Wireless Inc.
  111  */
  112 /**
  113  * @file le_mcc_interface.h
  114  *
  115  * Legato @ref c_mcc include file.
  116  *
  117  * Copyright (C) Sierra Wireless Inc.
  118  */
  119 /**
  120  * @page c_mccTest Sample code of Modem Call control
  121  *
  122  * @include "apps/test/modemServices/mcc/mccIntegrationTest/mccTest/le_mccTest.c"
  123  */
  124 
  125 #ifndef LE_MCC_INTERFACE_H_INCLUDE_GUARD
  126 #define LE_MCC_INTERFACE_H_INCLUDE_GUARD
  127 
  128 
  129 #include "legato.h"
  130 
  131 // Interface specific includes
  132 #include "le_mdmDefs_interface.h"
  133 
  134 
  135 //--------------------------------------------------------------------------------------------------
  136 /**
  137  * Type for handler called when a server disconnects.
  138  */
  139 //--------------------------------------------------------------------------------------------------
  140 typedef void (*le_mcc_DisconnectHandler_t)(void *);
  141 
  142 //--------------------------------------------------------------------------------------------------
  143 /**
  144  *
  145  * Connect the current client thread to the service providing this API. Block until the service is
  146  * available.
  147  *
  148  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  149  * called before any other functions in this API.  Normally, ConnectService is automatically called
  150  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  151  *
  152  * This function is created automatically.
  153  */
  154 //--------------------------------------------------------------------------------------------------
  155 void le_mcc_ConnectService
  156 (
  157     void
  158 );
  159 
  160 //--------------------------------------------------------------------------------------------------
  161 /**
  162  *
  163  * Try to connect the current client thread to the service providing this API. Return with an error
  164  * if the service is not available.
  165  *
  166  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  167  * called before any other functions in this API.  Normally, ConnectService is automatically called
  168  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  169  *
  170  * This function is created automatically.
  171  *
  172  * @return
  173  *  - LE_OK if the client connected successfully to the service.
  174  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  175  *    bound.
  176  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  177  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  178  */
  179 //--------------------------------------------------------------------------------------------------
  180 le_result_t le_mcc_TryConnectService
  181 (
  182     void
  183 );
  184 
  185 //--------------------------------------------------------------------------------------------------
  186 /**
  187  * Set handler called when server disconnection is detected.
  188  *
  189  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  190  * to continue without exiting, it should call longjmp() from inside the handler.
  191  */
  192 //--------------------------------------------------------------------------------------------------
  193 void le_mcc_SetServerDisconnectHandler
  194 (
  195     le_mcc_DisconnectHandler_t disconnectHandler,
  196     void *contextPtr
  197 );
  198 
  199 //--------------------------------------------------------------------------------------------------
  200 /**
  201  *
  202  * Disconnect the current client thread from the service providing this API.
  203  *
  204  * Normally, this function doesn't need to be called. After this function is called, there's no
  205  * longer a connection to the service, and the functions in this API can't be used. For details, see
  206  * @ref apiFilesC_client.
  207  *
  208  * This function is created automatically.
  209  */
  210 //--------------------------------------------------------------------------------------------------
  211 void le_mcc_DisconnectService
  212 (
  213     void
  214 );
  215 
  216 
  217 //--------------------------------------------------------------------------------------------------
  218 /**
  219  *  Enumeration of the possible events that may be reported to a call event handler.
  220  */
  221 //--------------------------------------------------------------------------------------------------
  222 typedef enum
  223 {
  224     LE_MCC_EVENT_SETUP = 0,
  225         ///< Call is being set up.
  226     LE_MCC_EVENT_INCOMING = 1,
  227         ///< Incoming call attempt (new call).
  228     LE_MCC_EVENT_ORIGINATING = 2,
  229         ///< Outgoing call attempt.
  230     LE_MCC_EVENT_ALERTING = 3,
  231         ///< Far end is now alerting its user (outgoing call).
  232     LE_MCC_EVENT_CONNECTED = 4,
  233         ///< Call has been established, and is media is active.
  234     LE_MCC_EVENT_TERMINATED = 5,
  235         ///< Call has terminated.
  236     LE_MCC_EVENT_WAITING = 6,
  237         ///< Call is waiting
  238     LE_MCC_EVENT_ON_HOLD = 7,
  239         ///< Remote party has put the call on hold.
  240     LE_MCC_EVENT_MAX = 8
  241         ///< Enumerate max value.
  242 }
  243 le_mcc_Event_t;
  244 
  245 
  246 //--------------------------------------------------------------------------------------------------
  247 /**
  248  *  Enumeration of the possible reasons for call termination.
  249  */
  250 //--------------------------------------------------------------------------------------------------
  251 typedef enum
  252 {
  253     LE_MCC_TERM_LOCAL_ENDED = 0,
  254         ///< Local party ended the call (Normal Call Clearing).
  255     LE_MCC_TERM_REMOTE_ENDED = 1,
  256         ///< Remote party ended the call (Normal Call Clearing).
  257     LE_MCC_TERM_NETWORK_FAIL = 2,
  258         ///< Network could not complete the call.
  259     LE_MCC_TERM_UNASSIGNED_NUMBER = 3,
  260         ///< cf. 3GPP 24.008 Annex H
  261     LE_MCC_TERM_NO_ROUTE_TO_DESTINATION = 4,
  262         ///< cf. 3GPP 24.008 Annex H
  263     LE_MCC_TERM_CHANNEL_UNACCEPTABLE = 5,
  264         ///< cf. 3GPP 24.008 Annex H
  265     LE_MCC_TERM_OPERATOR_DETERMINED_BARRING = 6,
  266         ///< cf. 3GPP 24.008 Annex H
  267     LE_MCC_TERM_USER_BUSY = 7,
  268         ///< cf. 3GPP 24.008 Annex H
  269     LE_MCC_TERM_NO_USER_RESPONDING = 8,
  270         ///< cf. 3GPP 24.008 Annex H
  271     LE_MCC_TERM_USER_ALERTING_NO_ANSWER = 9,
  272         ///< cf. 3GPP 24.008 Annex H
  273     LE_MCC_TERM_CALL_REJECTED = 10,
  274         ///< cf. 3GPP 24.008 Annex H
  275     LE_MCC_TERM_NUMBER_CHANGED = 11,
  276         ///< cf. 3GPP 24.008 Annex H
  277     LE_MCC_TERM_PREEMPTION = 12,
  278         ///< cf. 3GPP 24.008 Annex H
  279     LE_MCC_TERM_DESTINATION_OUT_OF_ORDER = 13,
  280         ///< cf. 3GPP 24.008 Annex H
  281     LE_MCC_TERM_INVALID_NUMBER_FORMAT = 14,
  282         ///< cf. 3GPP 24.008 Annex H
  283     LE_MCC_TERM_FACILITY_REJECTED = 15,
  284         ///< cf. 3GPP 24.008 Annex H
  285     LE_MCC_TERM_RESP_TO_STATUS_ENQUIRY = 16,
  286         ///< cf. 3GPP 24.008 Annex H
  287     LE_MCC_TERM_NORMAL_UNSPECIFIED = 17,
  288         ///< cf. 3GPP 24.008 Annex H
  289     LE_MCC_TERM_NO_CIRCUIT_OR_CHANNEL_AVAILABLE = 18,
  290         ///< cf. 3GPP 24.008 Annex H
  291     LE_MCC_TERM_NETWORK_OUT_OF_ORDER = 19,
  292         ///< cf. 3GPP 24.008 Annex H
  293     LE_MCC_TERM_TEMPORARY_FAILURE = 20,
  294         ///< cf. 3GPP 24.008 Annex H
  295     LE_MCC_TERM_SWITCHING_EQUIPMENT_CONGESTION = 21,
  296         ///< cf. 3GPP 24.008 Annex H
  297     LE_MCC_TERM_ACCESS_INFORMATION_DISCARDED = 22,
  298         ///< cf. 3GPP 24.008 Annex H
  299     LE_MCC_TERM_REQUESTED_CIRCUIT_OR_CHANNEL_NOT_AVAILABLE = 23,
  300         ///< cf. 3GPP 24.008 Annex H
  301     LE_MCC_TERM_RESOURCES_UNAVAILABLE_OR_UNSPECIFIED = 24,
  302         ///< cf. 3GPP 24.008 Annex H
  303     LE_MCC_TERM_QOS_UNAVAILABLE = 25,
  304         ///< cf. 3GPP 24.008 Annex H
  305     LE_MCC_TERM_REQUESTED_FACILITY_NOT_SUBSCRIBED = 26,
  306         ///< cf. 3GPP 24.008 Annex H
  307     LE_MCC_TERM_INCOMING_CALLS_BARRED_WITHIN_CUG = 27,
  308         ///< cf. 3GPP 24.008 Annex H
  309     LE_MCC_TERM_BEARER_CAPABILITY_NOT_AUTH = 28,
  310         ///< cf. 3GPP 24.008 Annex H
  311     LE_MCC_TERM_BEARER_CAPABILITY_UNAVAILABLE = 29,
  312         ///< cf. 3GPP 24.008 Annex H
  313     LE_MCC_TERM_SERVICE_OPTION_NOT_AVAILABLE = 30,
  314         ///< cf. 3GPP 24.008 Annex H
  315     LE_MCC_TERM_ACM_LIMIT_EXCEEDED = 31,
  316         ///< cf. 3GPP 24.008 Annex H
  317     LE_MCC_TERM_BEARER_SERVICE_NOT_IMPLEMENTED = 32,
  318         ///< cf. 3GPP 24.008 Annex H
  319     LE_MCC_TERM_REQUESTED_FACILITY_NOT_IMPLEMENTED = 33,
  320         ///< cf. 3GPP 24.008 Annex H
  321     LE_MCC_TERM_ONLY_DIGITAL_INFORMATION_BEARER_AVAILABLE = 34,
  322         ///< cf. 3GPP 24.008 Annex H
  323     LE_MCC_TERM_SERVICE_OR_OPTION_NOT_IMPLEMENTED = 35,
  324         ///< cf. 3GPP 24.008 Annex H
  325     LE_MCC_TERM_INVALID_TRANSACTION_IDENTIFIER = 36,
  326         ///< cf. 3GPP 24.008 Annex H
  327     LE_MCC_TERM_USER_NOT_MEMBER_OF_CUG = 37,
  328         ///< cf. 3GPP 24.008 Annex H
  329     LE_MCC_TERM_INCOMPATIBLE_DESTINATION = 38,
  330         ///< cf. 3GPP 24.008 Annex H
  331     LE_MCC_TERM_INVALID_TRANSIT_NW_SELECTION = 39,
  332         ///< cf. 3GPP 24.008 Annex H
  333     LE_MCC_TERM_SEMANTICALLY_INCORRECT_MESSAGE = 40,
  334         ///< cf. 3GPP 24.008 Annex H
  335     LE_MCC_TERM_INVALID_MANDATORY_INFORMATION = 41,
  336         ///< cf. 3GPP 24.008 Annex H
  337     LE_MCC_TERM_MESSAGE_TYPE_NON_IMPLEMENTED = 42,
  338         ///< cf. 3GPP 24.008 Annex H
  339     LE_MCC_TERM_MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 43,
  340         ///< cf. 3GPP 24.008 Annex H
  341     LE_MCC_TERM_INFORMATION_ELEMENT_NON_EXISTENT = 44,
  342         ///< cf. 3GPP 24.008 Annex H
  343     LE_MCC_TERM_CONDITONAL_IE_ERROR = 45,
  344         ///< cf. 3GPP 24.008 Annex H
  345     LE_MCC_TERM_MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 46,
  346         ///< cf. 3GPP 24.008 Annex H
  347     LE_MCC_TERM_RECOVERY_ON_TIMER_EXPIRY = 47,
  348         ///< cf. 3GPP 24.008 Annex H
  349     LE_MCC_TERM_PROTOCOL_ERROR_UNSPECIFIED = 48,
  350         ///< cf. 3GPP 24.008 Annex H
  351     LE_MCC_TERM_INTERWORKING_UNSPECIFIED = 49,
  352         ///< cf. 3GPP 24.008 Annex H
  353     LE_MCC_TERM_SERVICE_TEMPORARILY_OUT_OF_ORDER = 50,
  354         ///< cf. 3GPP 24.008 10.5.3.6
  355     LE_MCC_TERM_NOT_ALLOWED = 51,
  356         ///< Call operations not allowed
  357         ///<  (i.e. Radio off).
  358     LE_MCC_TERM_FDN_ACTIVE = 52,
  359         ///< FDN is active and number is not
  360         ///< in the FDN.
  361     LE_MCC_TERM_NO_SERVICE = 53,
  362         ///< No service or bad signal quality
  363     LE_MCC_TERM_PLATFORM_SPECIFIC = 54,
  364         ///< Platform specific code.
  365     LE_MCC_TERM_UNDEFINED = 55
  366         ///< Undefined reason.
  367 }
  368 le_mcc_TerminationReason_t;
  369 
  370 
  371 //--------------------------------------------------------------------------------------------------
  372 /**
  373  *  Reference type for managing active calls.
  374  */
  375 //--------------------------------------------------------------------------------------------------
  376 typedef struct le_mcc_Call* le_mcc_CallRef_t;
  377 
  378 
  379 //--------------------------------------------------------------------------------------------------
  380 /**
  381  * Reference type used by Add/Remove functions for EVENT 'le_mcc_CallEvent'
  382  */
  383 //--------------------------------------------------------------------------------------------------
  384 typedef struct le_mcc_CallEventHandler* le_mcc_CallEventHandlerRef_t;
  385 
  386 
  387 //--------------------------------------------------------------------------------------------------
  388 /**
  389  * Handler for call state changes.
  390  *
  391  * @note The callRef has to be deleted using le_mcc_Delete() when LE_MCC_TERMINATED event
  392  * is received, except if is has to be used for a future usage (with le_mcc_profile handler for
  393  * instance, or dialing again the same number).
  394  *
  395  */
  396 //--------------------------------------------------------------------------------------------------
  397 typedef void (*le_mcc_CallEventHandlerFunc_t)
  398 (
  399     le_mcc_CallRef_t callRef,
  400         ///< The call reference.
  401     le_mcc_Event_t event,
  402         ///< Call event.
  403     void* contextPtr
  404         ///<
  405 );
  406 
  407 //--------------------------------------------------------------------------------------------------
  408 /**
  409  * Create a call reference.
  410  *
  411  * @note Return NULL if call reference can't be created
  412  *
  413  * @note If destination number is too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN digits),
  414  * it is a fatal error, the function will not return.
  415  *
  416  */
  417 //--------------------------------------------------------------------------------------------------
  418 le_mcc_CallRef_t le_mcc_Create
  419 (
  420     const char* phoneNumPtr
  421         ///< [IN] The target number we are going to
  422         ///< call.
  423 )
  424 __attribute__(( nonnull(1) ));
  425 
  426 //--------------------------------------------------------------------------------------------------
  427 /**
  428  * Call to free up a call reference.
  429  *
  430  * @return
  431  *     - LE_OK        The function succeed.
  432  *     - LE_NOT_FOUND The call reference was not found.
  433  *     - LE_FAULT      The function failed.
  434  *
  435  *
  436  */
  437 //--------------------------------------------------------------------------------------------------
  438 le_result_t le_mcc_Delete
  439 (
  440     le_mcc_CallRef_t callRef
  441         ///< [IN] The call object to free.
  442 );
  443 
  444 //--------------------------------------------------------------------------------------------------
  445 /**
  446  * Start a call attempt.
  447  *
  448  * Asynchronous due to possible time to connect.
  449  *
  450  * As the call attempt proceeds, the profile's registered call event handler receives events.
  451  *
  452  * @return
  453  *      - LE_OK            Function succeed.
  454  *      - LE_BUSY          The call is already in progress
  455  *
  456  * * @note As this is an asynchronous call, a successful only confirms a call has been
  457  *       started. Don't assume a call has been successful yet.
  458  *
  459  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  460  *       function will not return.
  461  */
  462 //--------------------------------------------------------------------------------------------------
  463 le_result_t le_mcc_Start
  464 (
  465     le_mcc_CallRef_t callRef
  466         ///< [IN] Reference to the call object.
  467 );
  468 
  469 //--------------------------------------------------------------------------------------------------
  470 /**
  471  * Allow the caller to know if the given call is actually connected or not.
  472  *
  473  * @return TRUE if the call is connected, FALSE otherwise.
  474  *
  475  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  476  *       function will not return.
  477  */
  478 //--------------------------------------------------------------------------------------------------
  479 bool le_mcc_IsConnected
  480 (
  481     le_mcc_CallRef_t callRef
  482         ///< [IN] The call reference to read.
  483 );
  484 
  485 //--------------------------------------------------------------------------------------------------
  486 /**
  487  * Read out the remote party telephone number associated with the call.
  488  *
  489  * Output parameter is updated with the telephone number. If the Telephone number string length exceeds
  490  * the value of 'len' parameter, the LE_OVERFLOW error code is returned and 'telPtr' is used until
  491  * 'len-1' characters and a null-character is implicitly appended at the end of 'telPtr'.
  492  * Note that 'len' sould be at least equal to LE_MDMDEFS_PHONE_NUM_MAX_BYTES, otherwise LE_OVERFLOW
  493  * error code will be common.
  494  *
  495  * @return LE_OVERFLOW      The Telephone number length exceed the maximum length.
  496  * @return LE_OK            The function succeeded.
  497  *
  498  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  499  *       function will not return.
  500  */
  501 //--------------------------------------------------------------------------------------------------
  502 le_result_t le_mcc_GetRemoteTel
  503 (
  504     le_mcc_CallRef_t callRef,
  505         ///< [IN]  The call reference to read from.
  506     char* telPtr,
  507         ///< [OUT] The telephone number string.
  508     size_t telPtrSize
  509         ///< [IN]
  510 );
  511 
  512 //--------------------------------------------------------------------------------------------------
  513 /**
  514  * Called to get the termination reason.
  515  *
  516  * @return The termination reason.
  517  *
  518  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  519  *       function will not return.
  520  */
  521 //--------------------------------------------------------------------------------------------------
  522 le_mcc_TerminationReason_t le_mcc_GetTerminationReason
  523 (
  524     le_mcc_CallRef_t callRef
  525         ///< [IN] The call reference to read from.
  526 );
  527 
  528 //--------------------------------------------------------------------------------------------------
  529 /**
  530  * Called to get the platform specific termination code.
  531  *
  532  * @return The platform specific termination code.
  533  *
  534  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  535  *       function will not return.
  536  */
  537 //--------------------------------------------------------------------------------------------------
  538 int32_t le_mcc_GetPlatformSpecificTerminationCode
  539 (
  540     le_mcc_CallRef_t callRef
  541         ///< [IN] The call reference to read from.
  542 );
  543 
  544 //--------------------------------------------------------------------------------------------------
  545 /**
  546  *  Answers incoming call.
  547  *
  548  * @return LE_TIMEOUT       No response was received from the Modem.
  549  * @return LE_OK            The function succeeded.
  550  *
  551  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  552  *       function will not return.
  553  * @note A call waiting call must be answered using SetCallActive() API. This API doesn't manage
  554  * call waiting supplementary service.
  555  */
  556 //--------------------------------------------------------------------------------------------------
  557 le_result_t le_mcc_Answer
  558 (
  559     le_mcc_CallRef_t callRef
  560         ///< [IN] The call reference.
  561 );
  562 
  563 //--------------------------------------------------------------------------------------------------
  564 /**
  565  * Disconnect, or hang up, the specifed call. Any active call handlers
  566  * will be notified.
  567  *
  568  * @return LE_FAULT         The function failed.
  569  * @return LE_TIMEOUT       No response was received from the Modem.
  570  * @return LE_OK            Function succeeded.
  571  *
  572  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  573  *       function will not return.
  574  * @note this API can also be used to disconnect a waiting or on hold call.
  575  */
  576 //--------------------------------------------------------------------------------------------------
  577 le_result_t le_mcc_HangUp
  578 (
  579     le_mcc_CallRef_t callRef
  580         ///< [IN] The call to end.
  581 );
  582 
  583 //--------------------------------------------------------------------------------------------------
  584 /**
  585  * This function will disconnect, or hang up all the ongoing calls. Any active call handlers will
  586  * be notified.
  587  *
  588  * @return LE_FAULT         The function failed.
  589  * @return LE_TIMEOUT       No response was received from the Modem.
  590  * @return LE_OK            The function succeeded.
  591  */
  592 //--------------------------------------------------------------------------------------------------
  593 le_result_t le_mcc_HangUpAll
  594 (
  595     void
  596 );
  597 
  598 //--------------------------------------------------------------------------------------------------
  599 /**
  600  * This function return the Calling Line Identification Restriction (CLIR) status on the specific
  601  *  call.
  602  *
  603  * The output parameter is updated with the CLIR status.
  604  *    - LE_ON  Disable presentation of own phone number to remote.
  605  *    - LE_OFF Enable presentation of own phone number to remote.
  606  *
  607  * @return
  608  *    - LE_OK        The function succeed.
  609  *    - LE_NOT_FOUND The call reference was not found.
  610  */
  611 //--------------------------------------------------------------------------------------------------
  612 le_result_t le_mcc_GetCallerIdRestrict
  613 (
  614     le_mcc_CallRef_t callRef,
  615         ///< [IN] The call reference.
  616     le_onoff_t* clirStatusPtrPtr
  617         ///< [OUT] the Calling Line Identification Restriction (CLIR) status
  618 );
  619 
  620 //--------------------------------------------------------------------------------------------------
  621 /**
  622  * This function set the Calling Line Identification Restriction (CLIR) status on the specific call.
  623  * Default value is LE_OFF (Enable presentation of own phone number to remote).
  624  *
  625  * @return
  626  *     - LE_OK        The function succeed.
  627  *     - LE_NOT_FOUND The call reference was not found.
  628  *
  629  */
  630 //--------------------------------------------------------------------------------------------------
  631 le_result_t le_mcc_SetCallerIdRestrict
  632 (
  633     le_mcc_CallRef_t callRef,
  634         ///< [IN] The call reference.
  635     le_onoff_t clirStatus
  636         ///< [IN] The Calling Line Identification Restriction (CLIR) status.
  637 );
  638 
  639 //--------------------------------------------------------------------------------------------------
  640 /**
  641  * Add handler function for EVENT 'le_mcc_CallEvent'
  642  *
  643  * Register an event handler that will be notified when an call's event occurs.
  644  *
  645  * @return A reference to the new event handler object.
  646  *
  647  * @note It is a fatal error if this function does succeed.  If this function fails, it will not
  648  *       return.
  649  *
  650  */
  651 //--------------------------------------------------------------------------------------------------
  652 le_mcc_CallEventHandlerRef_t le_mcc_AddCallEventHandler
  653 (
  654     le_mcc_CallEventHandlerFunc_t handlerPtr,
  655         ///< [IN]
  656     void* contextPtr
  657         ///< [IN]
  658 );
  659 
  660 //--------------------------------------------------------------------------------------------------
  661 /**
  662  * Remove handler function for EVENT 'le_mcc_CallEvent'
  663  */
  664 //--------------------------------------------------------------------------------------------------
  665 void le_mcc_RemoveCallEventHandler
  666 (
  667     le_mcc_CallEventHandlerRef_t handlerRef
  668         ///< [IN]
  669 );
  670 
  671 //--------------------------------------------------------------------------------------------------
  672 /**
  673  * This function activates or deactivates the call waiting service.
  674  *
  675  * @return
  676  *     - LE_OK        The function succeed.
  677  *     - LE_FAULT     The function failed.
  678  *
  679  */
  680 //--------------------------------------------------------------------------------------------------
  681 le_result_t le_mcc_SetCallWaitingService
  682 (
  683     bool active
  684         ///< [IN] The call waiting activation.
  685 );
  686 
  687 //--------------------------------------------------------------------------------------------------
  688 /**
  689  * This function gets the call waiting service status.
  690  *
  691  * @return
  692  *     - LE_OK        The function succeed.
  693  *     - LE_FAULT     The function failed.
  694  *
  695  */
  696 //--------------------------------------------------------------------------------------------------
  697 le_result_t le_mcc_GetCallWaitingService
  698 (
  699     bool* activePtr
  700         ///< [OUT] The call waiting activation.
  701 );
  702 
  703 //--------------------------------------------------------------------------------------------------
  704 /**
  705  * This function activates the specified call. Other calls are placed on hold.
  706  *
  707  * @return
  708  *     - LE_OK        The function succeed.
  709  *     - LE_FAULT     The function failed.
  710  *
  711  */
  712 //--------------------------------------------------------------------------------------------------
  713 le_result_t le_mcc_ActivateCall
  714 (
  715     le_mcc_CallRef_t callRef
  716         ///< [IN] The call reference.
  717 );
  718 
  719 #endif // LE_MCC_INTERFACE_H_INCLUDE_GUARD
LE_MCC_EVENT_ORIGINATING
Outgoing call attempt. 
Definition: le_mcc_interface.h:228
le_mcc_ConnectService
void le_mcc_ConnectService(void)
le_mcc_GetCallerIdRestrict
le_result_t le_mcc_GetCallerIdRestrict(le_mcc_CallRef_t callRef, le_onoff_t *clirStatusPtrPtr)
LE_MCC_TERM_PROTOCOL_ERROR_UNSPECIFIED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:349
le_mcc_ActivateCall
le_result_t le_mcc_ActivateCall(le_mcc_CallRef_t callRef)
LE_MCC_TERM_DESTINATION_OUT_OF_ORDER
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:279
LE_MCC_TERM_USER_NOT_MEMBER_OF_CUG
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:327
LE_MCC_EVENT_ON_HOLD
Remote party has put the call on hold. 
Definition: le_mcc_interface.h:238
LE_MCC_TERM_NO_ROUTE_TO_DESTINATION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:261
LE_MCC_TERM_UNDEFINED
Undefined reason. 
Definition: le_mcc_interface.h:365
LE_MCC_TERM_USER_BUSY
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:267
LE_MCC_TERM_CALL_REJECTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:273
LE_MCC_TERM_REQUESTED_FACILITY_NOT_SUBSCRIBED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:305
le_result_t
le_result_t
Definition: le_basics.h:35
LE_MCC_TERM_UNASSIGNED_NUMBER
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:259
LE_MCC_TERM_INVALID_TRANSIT_NW_SELECTION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:331
LE_MCC_EVENT_TERMINATED
Call has terminated. 
Definition: le_mcc_interface.h:234
le_mcc_AddCallEventHandler
le_mcc_CallEventHandlerRef_t le_mcc_AddCallEventHandler(le_mcc_CallEventHandlerFunc_t handlerPtr, void *contextPtr)
le_mdmDefs_interface.h
LE_MCC_TERM_RECOVERY_ON_TIMER_EXPIRY
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:347
le_mcc_TerminationReason_t
le_mcc_TerminationReason_t
Definition: le_mcc_interface.h:251
LE_MCC_TERM_BEARER_CAPABILITY_UNAVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:311
le_mcc_CallRef_t
struct le_mcc_Call * le_mcc_CallRef_t
Definition: le_mcc_interface.h:376
LE_MCC_TERM_REMOTE_ENDED
Remote party ended the call (Normal Call Clearing). 
Definition: le_mcc_interface.h:255
LE_MCC_TERM_NORMAL_UNSPECIFIED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:287
LE_MCC_TERM_PLATFORM_SPECIFIC
Platform specific code. 
Definition: le_mcc_interface.h:363
le_mcc_GetCallWaitingService
le_result_t le_mcc_GetCallWaitingService(bool *activePtr)
LE_MCC_TERM_NUMBER_CHANGED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:275
LE_MCC_EVENT_ALERTING
Far end is now alerting its user (outgoing call). 
Definition: le_mcc_interface.h:230
LE_MCC_TERM_INVALID_TRANSACTION_IDENTIFIER
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:325
LE_MCC_EVENT_MAX
Enumerate max value. 
Definition: le_mcc_interface.h:240
le_mcc_TryConnectService
le_result_t le_mcc_TryConnectService(void)
le_mcc_Create
le_mcc_CallRef_t le_mcc_Create(const char *phoneNumPtr)
LE_MCC_TERM_NETWORK_OUT_OF_ORDER
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:291
LE_MCC_TERM_INCOMPATIBLE_DESTINATION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:329
le_mcc_Delete
le_result_t le_mcc_Delete(le_mcc_CallRef_t callRef)
LE_MCC_TERM_ONLY_DIGITAL_INFORMATION_BEARER_AVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:321
LE_MCC_TERM_INVALID_MANDATORY_INFORMATION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:335
LE_MCC_EVENT_INCOMING
Incoming call attempt (new call). 
Definition: le_mcc_interface.h:226
le_mcc_SetCallWaitingService
le_result_t le_mcc_SetCallWaitingService(bool active)
LE_MCC_TERM_OPERATOR_DETERMINED_BARRING
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:265
le_mcc_DisconnectService
void le_mcc_DisconnectService(void)
LE_MCC_TERM_LOCAL_ENDED
Local party ended the call (Normal Call Clearing). 
Definition: le_mcc_interface.h:253
le_mcc_HangUpAll
le_result_t le_mcc_HangUpAll(void)
le_mcc_GetPlatformSpecificTerminationCode
int32_t le_mcc_GetPlatformSpecificTerminationCode(le_mcc_CallRef_t callRef)
LE_MCC_TERM_ACM_LIMIT_EXCEEDED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:315
LE_MCC_TERM_PREEMPTION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:277
LE_MCC_TERM_INFORMATION_ELEMENT_NON_EXISTENT
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:341
le_mcc_Start
le_result_t le_mcc_Start(le_mcc_CallRef_t callRef)
LE_MCC_TERM_MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:339
LE_MCC_TERM_NETWORK_FAIL
Network could not complete the call. 
Definition: le_mcc_interface.h:257
LE_MCC_TERM_NO_SERVICE
No service or bad signal quality. 
Definition: le_mcc_interface.h:361
LE_MCC_TERM_INVALID_NUMBER_FORMAT
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:281
LE_MCC_TERM_FDN_ACTIVE
Definition: le_mcc_interface.h:358
LE_MCC_TERM_NO_USER_RESPONDING
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:269
LE_MCC_TERM_CONDITONAL_IE_ERROR
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:343
LE_MCC_TERM_MESSAGE_TYPE_NON_IMPLEMENTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:337
le_mcc_IsConnected
bool le_mcc_IsConnected(le_mcc_CallRef_t callRef)
le_mcc_CallEventHandlerRef_t
struct le_mcc_CallEventHandler * le_mcc_CallEventHandlerRef_t
Definition: le_mcc_interface.h:384
LE_MCC_TERM_FACILITY_REJECTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:283
LE_MCC_TERM_INTERWORKING_UNSPECIFIED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:351
LE_MCC_TERM_RESP_TO_STATUS_ENQUIRY
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:285
LE_MCC_TERM_MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:345
LE_MCC_TERM_ACCESS_INFORMATION_DISCARDED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:297
LE_MCC_TERM_REQUESTED_CIRCUIT_OR_CHANNEL_NOT_AVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:299
LE_MCC_EVENT_WAITING
Call is waiting. 
Definition: le_mcc_interface.h:236
LE_MCC_TERM_SEMANTICALLY_INCORRECT_MESSAGE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:333
le_mcc_RemoveCallEventHandler
void le_mcc_RemoveCallEventHandler(le_mcc_CallEventHandlerRef_t handlerRef)
le_mcc_Event_t
le_mcc_Event_t
Definition: le_mcc_interface.h:222
legato.h
le_mcc_CallEventHandlerFunc_t
void(* le_mcc_CallEventHandlerFunc_t)(le_mcc_CallRef_t callRef, le_mcc_Event_t event, void *contextPtr)
Definition: le_mcc_interface.h:398
LE_MCC_EVENT_CONNECTED
Call has been established, and is media is active. 
Definition: le_mcc_interface.h:232
le_mcc_HangUp
le_result_t le_mcc_HangUp(le_mcc_CallRef_t callRef)
LE_MCC_TERM_SERVICE_OR_OPTION_NOT_IMPLEMENTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:323
LE_MCC_TERM_BEARER_SERVICE_NOT_IMPLEMENTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:317
LE_MCC_TERM_SWITCHING_EQUIPMENT_CONGESTION
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:295
LE_MCC_TERM_USER_ALERTING_NO_ANSWER
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:271
le_mcc_GetTerminationReason
le_mcc_TerminationReason_t le_mcc_GetTerminationReason(le_mcc_CallRef_t callRef)
LE_MCC_TERM_REQUESTED_FACILITY_NOT_IMPLEMENTED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:319
LE_MCC_EVENT_SETUP
Call is being set up. 
Definition: le_mcc_interface.h:224
LE_MCC_TERM_TEMPORARY_FAILURE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:293
le_mcc_Answer
le_result_t le_mcc_Answer(le_mcc_CallRef_t callRef)
LE_MCC_TERM_NOT_ALLOWED
Definition: le_mcc_interface.h:355
LE_MCC_TERM_QOS_UNAVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:303
le_mcc_GetRemoteTel
le_result_t le_mcc_GetRemoteTel(le_mcc_CallRef_t callRef, char *telPtr, size_t telPtrSize)
LE_MCC_TERM_SERVICE_TEMPORARILY_OUT_OF_ORDER
cf. 3GPP 24.008 10.5.3.6 
Definition: le_mcc_interface.h:353
LE_MCC_TERM_INCOMING_CALLS_BARRED_WITHIN_CUG
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:307
LE_MCC_TERM_BEARER_CAPABILITY_NOT_AUTH
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:309
le_mcc_SetServerDisconnectHandler
void le_mcc_SetServerDisconnectHandler(le_mcc_DisconnectHandler_t disconnectHandler, void *contextPtr)
LE_MCC_TERM_SERVICE_OPTION_NOT_AVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:313
LE_MCC_TERM_RESOURCES_UNAVAILABLE_OR_UNSPECIFIED
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:301
le_mcc_SetCallerIdRestrict
le_result_t le_mcc_SetCallerIdRestrict(le_mcc_CallRef_t callRef, le_onoff_t clirStatus)
LE_MCC_TERM_CHANNEL_UNACCEPTABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:263
LE_MCC_TERM_NO_CIRCUIT_OR_CHANNEL_AVAILABLE
cf. 3GPP 24.008 Annex H 
Definition: le_mcc_interface.h:289
le_mcc_DisconnectHandler_t
void(* le_mcc_DisconnectHandler_t)(void *)
Definition: le_mcc_interface.h:140
le_onoff_t
le_onoff_t
Definition: le_basics.h:70