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