le_mcc_interface.h

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