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