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* LE_NONNULL phoneNumPtr
  421         ///< [IN] The target number we are going to
  422         ///< call.
  423 );
  424 
  425 //--------------------------------------------------------------------------------------------------
  426 /**
  427  * Call to free up a call reference.
  428  *
  429  * @return
  430  *     - LE_OK        The function succeed.
  431  *     - LE_NOT_FOUND The call reference was not found.
  432  *     - LE_FAULT      The function failed.
  433  *
  434  *
  435  */
  436 //--------------------------------------------------------------------------------------------------
  437 le_result_t le_mcc_Delete
  438 (
  439     le_mcc_CallRef_t callRef
  440         ///< [IN] The call object to free.
  441 );
  442 
  443 //--------------------------------------------------------------------------------------------------
  444 /**
  445  * Start a call attempt.
  446  *
  447  * Asynchronous due to possible time to connect.
  448  *
  449  * As the call attempt proceeds, the profile's registered call event handler receives events.
  450  *
  451  * @return
  452  *      - LE_OK            Function succeed.
  453  *      - LE_BUSY          The call is already in progress
  454  *
  455  * * @note As this is an asynchronous call, a successful only confirms a call has been
  456  *       started. Don't assume a call has been successful yet.
  457  *
  458  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  459  *       function will not return.
  460  */
  461 //--------------------------------------------------------------------------------------------------
  462 le_result_t le_mcc_Start
  463 (
  464     le_mcc_CallRef_t callRef
  465         ///< [IN] Reference to the call object.
  466 );
  467 
  468 //--------------------------------------------------------------------------------------------------
  469 /**
  470  * Allow the caller to know if the given call is actually connected or not.
  471  *
  472  * @return TRUE if the call is connected, FALSE otherwise.
  473  *
  474  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  475  *       function will not return.
  476  */
  477 //--------------------------------------------------------------------------------------------------
  478 bool le_mcc_IsConnected
  479 (
  480     le_mcc_CallRef_t callRef
  481         ///< [IN] The call reference to read.
  482 );
  483 
  484 //--------------------------------------------------------------------------------------------------
  485 /**
  486  * Read out the remote party telephone number associated with the call.
  487  *
  488  * Output parameter is updated with the telephone number. If the Telephone number string length exceeds
  489  * the value of 'len' parameter, the LE_OVERFLOW error code is returned and 'telPtr' is used until
  490  * 'len-1' characters and a null-character is implicitly appended at the end of 'telPtr'.
  491  * Note that 'len' sould be at least equal to LE_MDMDEFS_PHONE_NUM_MAX_BYTES, otherwise LE_OVERFLOW
  492  * error code will be common.
  493  *
  494  * @return LE_OVERFLOW      The Telephone number length exceed the maximum length.
  495  * @return LE_OK            The function succeeded.
  496  *
  497  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  498  *       function will not return.
  499  */
  500 //--------------------------------------------------------------------------------------------------
  501 le_result_t le_mcc_GetRemoteTel
  502 (
  503     le_mcc_CallRef_t callRef,
  504         ///< [IN]  The call reference to read from.
  505     char* telPtr,
  506         ///< [OUT] The telephone number string.
  507     size_t telPtrSize
  508         ///< [IN]
  509 );
  510 
  511 //--------------------------------------------------------------------------------------------------
  512 /**
  513  * Called to get the termination reason.
  514  *
  515  * @return The termination reason.
  516  *
  517  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  518  *       function will not return.
  519  */
  520 //--------------------------------------------------------------------------------------------------
  521 le_mcc_TerminationReason_t le_mcc_GetTerminationReason
  522 (
  523     le_mcc_CallRef_t callRef
  524         ///< [IN] The call reference to read from.
  525 );
  526 
  527 //--------------------------------------------------------------------------------------------------
  528 /**
  529  * Called to get the platform specific termination code.
  530  *
  531  * @return The platform specific termination code.
  532  *
  533  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  534  *       function will not return.
  535  */
  536 //--------------------------------------------------------------------------------------------------
  537 int32_t le_mcc_GetPlatformSpecificTerminationCode
  538 (
  539     le_mcc_CallRef_t callRef
  540         ///< [IN] The call reference to read from.
  541 );
  542 
  543 //--------------------------------------------------------------------------------------------------
  544 /**
  545  *  Answers incoming call.
  546  *
  547  * @return LE_TIMEOUT       No response was received from the Modem.
  548  * @return LE_OK            The function succeeded.
  549  *
  550  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  551  *       function will not return.
  552  * @note A call waiting call must be answered using SetCallActive() API. This API doesn't manage
  553  * call waiting supplementary service.
  554  */
  555 //--------------------------------------------------------------------------------------------------
  556 le_result_t le_mcc_Answer
  557 (
  558     le_mcc_CallRef_t callRef
  559         ///< [IN] The call reference.
  560 );
  561 
  562 //--------------------------------------------------------------------------------------------------
  563 /**
  564  * Disconnect, or hang up, the specifed call. Any active call handlers
  565  * will be notified.
  566  *
  567  * @return LE_FAULT         The function failed.
  568  * @return LE_TIMEOUT       No response was received from the Modem.
  569  * @return LE_OK            Function succeeded.
  570  *
  571  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  572  *       function will not return.
  573  * @note this API can also be used to disconnect a waiting or on hold call.
  574  */
  575 //--------------------------------------------------------------------------------------------------
  576 le_result_t le_mcc_HangUp
  577 (
  578     le_mcc_CallRef_t callRef
  579         ///< [IN] The call to end.
  580 );
  581 
  582 //--------------------------------------------------------------------------------------------------
  583 /**
  584  * This function will disconnect, or hang up all the ongoing calls. Any active call handlers will
  585  * be notified.
  586  *
  587  * @return LE_FAULT         The function failed.
  588  * @return LE_TIMEOUT       No response was received from the Modem.
  589  * @return LE_OK            The function succeeded.
  590  */
  591 //--------------------------------------------------------------------------------------------------
  592 le_result_t le_mcc_HangUpAll
  593 (
  594     void
  595 );
  596 
  597 //--------------------------------------------------------------------------------------------------
  598 /**
  599  * This function return the Calling Line Identification Restriction (CLIR) status on the specific
  600  *  call.
  601  *
  602  * The output parameter is updated with the CLIR status.
  603  *    - LE_ON  Disable presentation of own phone number to remote.
  604  *    - LE_OFF Enable presentation of own phone number to remote.
  605  *
  606  * @return
  607  *    - LE_OK        The function succeed.
  608  *    - LE_NOT_FOUND The call reference was not found.
  609  */
  610 //--------------------------------------------------------------------------------------------------
  611 le_result_t le_mcc_GetCallerIdRestrict
  612 (
  613     le_mcc_CallRef_t callRef,
  614         ///< [IN] The call reference.
  615     le_onoff_t* clirStatusPtrPtr
  616         ///< [OUT] the Calling Line Identification Restriction (CLIR) status
  617 );
  618 
  619 //--------------------------------------------------------------------------------------------------
  620 /**
  621  * This function set the Calling Line Identification Restriction (CLIR) status on the specific call.
  622  * Default value is LE_OFF (Enable presentation of own phone number to remote).
  623  *
  624  * @return
  625  *     - LE_OK        The function succeed.
  626  *     - LE_NOT_FOUND The call reference was not found.
  627  *
  628  */
  629 //--------------------------------------------------------------------------------------------------
  630 le_result_t le_mcc_SetCallerIdRestrict
  631 (
  632     le_mcc_CallRef_t callRef,
  633         ///< [IN] The call reference.
  634     le_onoff_t clirStatus
  635         ///< [IN] The Calling Line Identification Restriction (CLIR) status.
  636 );
  637 
  638 //--------------------------------------------------------------------------------------------------
  639 /**
  640  * Add handler function for EVENT 'le_mcc_CallEvent'
  641  *
  642  * Register an event handler that will be notified when an call's event occurs.
  643  *
  644  * @return A reference to the new event handler object.
  645  *
  646  * @note It is a fatal error if this function does succeed.  If this function fails, it will not
  647  *       return.
  648  *
  649  */
  650 //--------------------------------------------------------------------------------------------------
  651 le_mcc_CallEventHandlerRef_t le_mcc_AddCallEventHandler
  652 (
  653     le_mcc_CallEventHandlerFunc_t handlerPtr,
  654         ///< [IN]
  655     void* contextPtr
  656         ///< [IN]
  657 );
  658 
  659 //--------------------------------------------------------------------------------------------------
  660 /**
  661  * Remove handler function for EVENT 'le_mcc_CallEvent'
  662  */
  663 //--------------------------------------------------------------------------------------------------
  664 void le_mcc_RemoveCallEventHandler
  665 (
  666     le_mcc_CallEventHandlerRef_t handlerRef
  667         ///< [IN]
  668 );
  669 
  670 //--------------------------------------------------------------------------------------------------
  671 /**
  672  * This function activates or deactivates the call waiting service.
  673  *
  674  * @return
  675  *     - LE_OK        The function succeed.
  676  *     - LE_FAULT     The function failed.
  677  *
  678  */
  679 //--------------------------------------------------------------------------------------------------
  680 le_result_t le_mcc_SetCallWaitingService
  681 (
  682     bool active
  683         ///< [IN] The call waiting activation.
  684 );
  685 
  686 //--------------------------------------------------------------------------------------------------
  687 /**
  688  * This function gets the call waiting service status.
  689  *
  690  * @return
  691  *     - LE_OK        The function succeed.
  692  *     - LE_FAULT     The function failed.
  693  *
  694  */
  695 //--------------------------------------------------------------------------------------------------
  696 le_result_t le_mcc_GetCallWaitingService
  697 (
  698     bool* activePtr
  699         ///< [OUT] The call waiting activation.
  700 );
  701 
  702 //--------------------------------------------------------------------------------------------------
  703 /**
  704  * This function activates the specified call. Other calls are placed on hold.
  705  *
  706  * @return
  707  *     - LE_OK        The function succeed.
  708  *     - LE_FAULT     The function failed.
  709  *
  710  */
  711 //--------------------------------------------------------------------------------------------------
  712 le_result_t le_mcc_ActivateCall
  713 (
  714     le_mcc_CallRef_t callRef
  715         ///< [IN] The call reference.
  716 );
  717 
  718 #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 *LE_NONNULL 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