le_mcc_interface.h

Go to the documentation of this file.
1 
2 
3 /*
4  * ====================== WARNING ======================
5  *
6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
7  * DO NOT MODIFY IN ANY WAY.
8  *
9  * ====================== WARNING ======================
10  */
11 
12 /**
13  * @page c_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 //--------------------------------------------------------------------------------------------------
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 //--------------------------------------------------------------------------------------------------
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 //--------------------------------------------------------------------------------------------------
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 //--------------------------------------------------------------------------------------------------
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 {
225  ///< Call is being set up.
227  ///< Incoming call attempt (new call).
229  ///< Outgoing call attempt.
231  ///< Far end is now alerting its user (outgoing call).
233  ///< Call has been established, and is media is active.
235  ///< Call has terminated.
237  ///< Call is waiting
239  ///< Remote party has put the call on hold.
241  ///< Enumerate max value.
242 }
244 
245 
246 //--------------------------------------------------------------------------------------------------
247 /**
248  * Enumeration of the possible reasons for call termination.
249  */
250 //--------------------------------------------------------------------------------------------------
251 typedef enum
252 {
254  ///< Local party ended the call (Normal Call Clearing).
256  ///< Remote party ended the call (Normal Call Clearing).
258  ///< Network could not complete the call.
260  ///< cf. 3GPP 24.008 Annex H
262  ///< cf. 3GPP 24.008 Annex H
264  ///< cf. 3GPP 24.008 Annex H
266  ///< cf. 3GPP 24.008 Annex H
268  ///< cf. 3GPP 24.008 Annex H
270  ///< cf. 3GPP 24.008 Annex H
272  ///< cf. 3GPP 24.008 Annex H
274  ///< cf. 3GPP 24.008 Annex H
276  ///< cf. 3GPP 24.008 Annex H
278  ///< cf. 3GPP 24.008 Annex H
280  ///< cf. 3GPP 24.008 Annex H
282  ///< cf. 3GPP 24.008 Annex H
284  ///< cf. 3GPP 24.008 Annex H
286  ///< cf. 3GPP 24.008 Annex H
288  ///< cf. 3GPP 24.008 Annex H
290  ///< cf. 3GPP 24.008 Annex H
292  ///< cf. 3GPP 24.008 Annex H
294  ///< cf. 3GPP 24.008 Annex H
296  ///< cf. 3GPP 24.008 Annex H
298  ///< cf. 3GPP 24.008 Annex H
300  ///< cf. 3GPP 24.008 Annex H
302  ///< cf. 3GPP 24.008 Annex H
304  ///< cf. 3GPP 24.008 Annex H
306  ///< cf. 3GPP 24.008 Annex H
308  ///< cf. 3GPP 24.008 Annex H
310  ///< cf. 3GPP 24.008 Annex H
312  ///< cf. 3GPP 24.008 Annex H
314  ///< cf. 3GPP 24.008 Annex H
316  ///< cf. 3GPP 24.008 Annex H
318  ///< cf. 3GPP 24.008 Annex H
320  ///< cf. 3GPP 24.008 Annex H
322  ///< cf. 3GPP 24.008 Annex H
324  ///< cf. 3GPP 24.008 Annex H
326  ///< cf. 3GPP 24.008 Annex H
328  ///< cf. 3GPP 24.008 Annex H
330  ///< cf. 3GPP 24.008 Annex H
332  ///< cf. 3GPP 24.008 Annex H
334  ///< cf. 3GPP 24.008 Annex H
336  ///< cf. 3GPP 24.008 Annex H
338  ///< cf. 3GPP 24.008 Annex H
340  ///< cf. 3GPP 24.008 Annex H
342  ///< cf. 3GPP 24.008 Annex H
344  ///< cf. 3GPP 24.008 Annex H
346  ///< cf. 3GPP 24.008 Annex H
348  ///< cf. 3GPP 24.008 Annex H
350  ///< cf. 3GPP 24.008 Annex H
352  ///< cf. 3GPP 24.008 Annex H
354  ///< cf. 3GPP 24.008 10.5.3.6
356  ///< Call operations not allowed
357  ///< (i.e. Radio off).
359  ///< FDN is active and number is not
360  ///< in the FDN.
362  ///< No service or bad signal quality
364  ///< Platform specific code.
366  ///< Undefined reason.
367 }
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 //--------------------------------------------------------------------------------------------------
419 (
420  const char* phoneNumPtr
421  ///< [IN] The target number we are going to
422  ///< call.
423 )
424 __attribute__(( nonnull(1) ));
425 
426 //--------------------------------------------------------------------------------------------------
427 /**
428  * Call to free up a call reference.
429  *
430  * @return
431  * - LE_OK The function succeed.
432  * - LE_NOT_FOUND The call reference was not found.
433  * - LE_FAULT The function failed.
434  *
435  *
436  */
437 //--------------------------------------------------------------------------------------------------
439 (
440  le_mcc_CallRef_t callRef
441  ///< [IN] The call object to free.
442 );
443 
444 //--------------------------------------------------------------------------------------------------
445 /**
446  * Start a call attempt.
447  *
448  * Asynchronous due to possible time to connect.
449  *
450  * As the call attempt proceeds, the profile's registered call event handler receives events.
451  *
452  * @return
453  * - LE_OK Function succeed.
454  * - LE_BUSY The call is already in progress
455  *
456  * * @note As this is an asynchronous call, a successful only confirms a call has been
457  * started. Don't assume a call has been successful yet.
458  *
459  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
460  * function will not return.
461  */
462 //--------------------------------------------------------------------------------------------------
464 (
465  le_mcc_CallRef_t callRef
466  ///< [IN] Reference to the call object.
467 );
468 
469 //--------------------------------------------------------------------------------------------------
470 /**
471  * Allow the caller to know if the given call is actually connected or not.
472  *
473  * @return TRUE if the call is connected, FALSE otherwise.
474  *
475  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
476  * function will not return.
477  */
478 //--------------------------------------------------------------------------------------------------
480 (
481  le_mcc_CallRef_t callRef
482  ///< [IN] The call reference to read.
483 );
484 
485 //--------------------------------------------------------------------------------------------------
486 /**
487  * Read out the remote party telephone number associated with the call.
488  *
489  * Output parameter is updated with the telephone number. If the Telephone number string length exceeds
490  * the value of 'len' parameter, the LE_OVERFLOW error code is returned and 'telPtr' is used until
491  * 'len-1' characters and a null-character is implicitly appended at the end of 'telPtr'.
492  * Note that 'len' sould be at least equal to LE_MDMDEFS_PHONE_NUM_MAX_BYTES, otherwise LE_OVERFLOW
493  * error code will be common.
494  *
495  * @return LE_OVERFLOW The Telephone number length exceed the maximum length.
496  * @return LE_OK The function succeeded.
497  *
498  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
499  * function will not return.
500  */
501 //--------------------------------------------------------------------------------------------------
503 (
504  le_mcc_CallRef_t callRef,
505  ///< [IN] The call reference to read from.
506  char* telPtr,
507  ///< [OUT] The telephone number string.
508  size_t telPtrSize
509  ///< [IN]
510 );
511 
512 //--------------------------------------------------------------------------------------------------
513 /**
514  * Called to get the termination reason.
515  *
516  * @return The termination reason.
517  *
518  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
519  * function will not return.
520  */
521 //--------------------------------------------------------------------------------------------------
523 (
524  le_mcc_CallRef_t callRef
525  ///< [IN] The call reference to read from.
526 );
527 
528 //--------------------------------------------------------------------------------------------------
529 /**
530  * Called to get the platform specific termination code.
531  *
532  * @return The platform specific termination code.
533  *
534  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
535  * function will not return.
536  */
537 //--------------------------------------------------------------------------------------------------
539 (
540  le_mcc_CallRef_t callRef
541  ///< [IN] The call reference to read from.
542 );
543 
544 //--------------------------------------------------------------------------------------------------
545 /**
546  * Answers incoming call.
547  *
548  * @return LE_TIMEOUT No response was received from the Modem.
549  * @return LE_OK The function succeeded.
550  *
551  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
552  * function will not return.
553  * @note A call waiting call must be answered using SetCallActive() API. This API doesn't manage
554  * call waiting supplementary service.
555  */
556 //--------------------------------------------------------------------------------------------------
558 (
559  le_mcc_CallRef_t callRef
560  ///< [IN] The call reference.
561 );
562 
563 //--------------------------------------------------------------------------------------------------
564 /**
565  * Disconnect, or hang up, the specifed call. Any active call handlers
566  * will be notified.
567  *
568  * @return LE_FAULT The function failed.
569  * @return LE_TIMEOUT No response was received from the Modem.
570  * @return LE_OK Function succeeded.
571  *
572  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
573  * function will not return.
574  * @note this API can also be used to disconnect a waiting or on hold call.
575  */
576 //--------------------------------------------------------------------------------------------------
578 (
579  le_mcc_CallRef_t callRef
580  ///< [IN] The call to end.
581 );
582 
583 //--------------------------------------------------------------------------------------------------
584 /**
585  * This function will disconnect, or hang up all the ongoing calls. Any active call handlers will
586  * be notified.
587  *
588  * @return LE_FAULT The function failed.
589  * @return LE_TIMEOUT No response was received from the Modem.
590  * @return LE_OK The function succeeded.
591  */
592 //--------------------------------------------------------------------------------------------------
594 (
595  void
596 );
597 
598 //--------------------------------------------------------------------------------------------------
599 /**
600  * This function return the Calling Line Identification Restriction (CLIR) status on the specific
601  * call.
602  *
603  * The output parameter is updated with the CLIR status.
604  * - LE_ON Disable presentation of own phone number to remote.
605  * - LE_OFF Enable presentation of own phone number to remote.
606  *
607  * @return
608  * - LE_OK The function succeed.
609  * - LE_NOT_FOUND The call reference was not found.
610  */
611 //--------------------------------------------------------------------------------------------------
613 (
614  le_mcc_CallRef_t callRef,
615  ///< [IN] The call reference.
616  le_onoff_t* clirStatusPtrPtr
617  ///< [OUT] the Calling Line Identification Restriction (CLIR) status
618 );
619 
620 //--------------------------------------------------------------------------------------------------
621 /**
622  * This function set the Calling Line Identification Restriction (CLIR) status on the specific call.
623  * Default value is LE_OFF (Enable presentation of own phone number to remote).
624  *
625  * @return
626  * - LE_OK The function succeed.
627  * - LE_NOT_FOUND The call reference was not found.
628  *
629  */
630 //--------------------------------------------------------------------------------------------------
632 (
633  le_mcc_CallRef_t callRef,
634  ///< [IN] The call reference.
635  le_onoff_t clirStatus
636  ///< [IN] The Calling Line Identification Restriction (CLIR) status.
637 );
638 
639 //--------------------------------------------------------------------------------------------------
640 /**
641  * Add handler function for EVENT 'le_mcc_CallEvent'
642  *
643  * Register an event handler that will be notified when an call's event occurs.
644  *
645  * @return A reference to the new event handler object.
646  *
647  * @note It is a fatal error if this function does succeed. If this function fails, it will not
648  * return.
649  *
650  */
651 //--------------------------------------------------------------------------------------------------
653 (
655  ///< [IN]
656  void* contextPtr
657  ///< [IN]
658 );
659 
660 //--------------------------------------------------------------------------------------------------
661 /**
662  * Remove handler function for EVENT 'le_mcc_CallEvent'
663  */
664 //--------------------------------------------------------------------------------------------------
666 (
668  ///< [IN]
669 );
670 
671 //--------------------------------------------------------------------------------------------------
672 /**
673  * This function activates or deactivates the call waiting service.
674  *
675  * @return
676  * - LE_OK The function succeed.
677  * - LE_FAULT The function failed.
678  *
679  */
680 //--------------------------------------------------------------------------------------------------
682 (
683  bool active
684  ///< [IN] The call waiting activation.
685 );
686 
687 //--------------------------------------------------------------------------------------------------
688 /**
689  * This function gets the call waiting service status.
690  *
691  * @return
692  * - LE_OK The function succeed.
693  * - LE_FAULT The function failed.
694  *
695  */
696 //--------------------------------------------------------------------------------------------------
698 (
699  bool* activePtr
700  ///< [OUT] The call waiting activation.
701 );
702 
703 //--------------------------------------------------------------------------------------------------
704 /**
705  * This function activates the specified call. Other calls are placed on hold.
706  *
707  * @return
708  * - LE_OK The function succeed.
709  * - LE_FAULT The function failed.
710  *
711  */
712 //--------------------------------------------------------------------------------------------------
714 (
715  le_mcc_CallRef_t callRef
716  ///< [IN] The call reference.
717 );
718 
719 #endif // LE_MCC_INTERFACE_H_INCLUDE_GUARD
Outgoing call attempt.
Definition: le_mcc_interface.h:228
void le_mcc_ConnectService(void)
le_result_t le_mcc_GetCallerIdRestrict(le_mcc_CallRef_t callRef, le_onoff_t *clirStatusPtrPtr)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:349
le_result_t le_mcc_ActivateCall(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:279
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:327
Remote party has put the call on hold.
Definition: le_mcc_interface.h:238
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:261
Undefined reason.
Definition: le_mcc_interface.h:365
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:267
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:273
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:305
le_result_t
Definition: le_basics.h:35
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:259
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:331
Call has terminated.
Definition: le_mcc_interface.h:234
le_mcc_CallEventHandlerRef_t le_mcc_AddCallEventHandler(le_mcc_CallEventHandlerFunc_t handlerPtr, void *contextPtr)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:347
le_mcc_TerminationReason_t
Definition: le_mcc_interface.h:251
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:311
struct le_mcc_Call * le_mcc_CallRef_t
Definition: le_mcc_interface.h:376
Remote party ended the call (Normal Call Clearing).
Definition: le_mcc_interface.h:255
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:287
Platform specific code.
Definition: le_mcc_interface.h:363
le_result_t le_mcc_GetCallWaitingService(bool *activePtr)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:275
Far end is now alerting its user (outgoing call).
Definition: le_mcc_interface.h:230
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:325
Enumerate max value.
Definition: le_mcc_interface.h:240
le_result_t le_mcc_TryConnectService(void)
le_mcc_CallRef_t le_mcc_Create(const char *phoneNumPtr)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:291
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:329
le_result_t le_mcc_Delete(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:321
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:335
Incoming call attempt (new call).
Definition: le_mcc_interface.h:226
le_result_t le_mcc_SetCallWaitingService(bool active)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:265
void le_mcc_DisconnectService(void)
Local party ended the call (Normal Call Clearing).
Definition: le_mcc_interface.h:253
le_result_t le_mcc_HangUpAll(void)
int32_t le_mcc_GetPlatformSpecificTerminationCode(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:315
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:277
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:341
le_result_t le_mcc_Start(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:339
Network could not complete the call.
Definition: le_mcc_interface.h:257
No service or bad signal quality.
Definition: le_mcc_interface.h:361
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:281
Definition: le_mcc_interface.h:358
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:269
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:343
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:337
bool le_mcc_IsConnected(le_mcc_CallRef_t callRef)
struct le_mcc_CallEventHandler * le_mcc_CallEventHandlerRef_t
Definition: le_mcc_interface.h:384
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:283
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:351
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:285
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:345
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:297
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:299
Call is waiting.
Definition: le_mcc_interface.h:236
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:333
void le_mcc_RemoveCallEventHandler(le_mcc_CallEventHandlerRef_t handlerRef)
le_mcc_Event_t
Definition: le_mcc_interface.h:222
void(* le_mcc_CallEventHandlerFunc_t)(le_mcc_CallRef_t callRef, le_mcc_Event_t event, void *contextPtr)
Definition: le_mcc_interface.h:398
Call has been established, and is media is active.
Definition: le_mcc_interface.h:232
le_result_t le_mcc_HangUp(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:323
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:317
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:295
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:271
le_mcc_TerminationReason_t le_mcc_GetTerminationReason(le_mcc_CallRef_t callRef)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:319
Call is being set up.
Definition: le_mcc_interface.h:224
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:293
le_result_t le_mcc_Answer(le_mcc_CallRef_t callRef)
Definition: le_mcc_interface.h:355
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:303
le_result_t le_mcc_GetRemoteTel(le_mcc_CallRef_t callRef, char *telPtr, size_t telPtrSize)
cf. 3GPP 24.008 10.5.3.6
Definition: le_mcc_interface.h:353
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:307
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:309
void le_mcc_SetServerDisconnectHandler(le_mcc_DisconnectHandler_t disconnectHandler, void *contextPtr)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:313
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:301
le_result_t le_mcc_SetCallerIdRestrict(le_mcc_CallRef_t callRef, le_onoff_t clirStatus)
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:263
cf. 3GPP 24.008 Annex H
Definition: le_mcc_interface.h:289
void(* le_mcc_DisconnectHandler_t)(void *)
Definition: le_mcc_interface.h:140
le_onoff_t
Definition: le_basics.h:70