le_ecall_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_ecall eCall
   14  *
   15  * @ref le_ecall_interface.h "API Reference" <br>
   16  * @ref legatoServicesModemECall <br>
   17  * @ref sampleApps_eCall sample app <br>
   18  * @ref le_ecall_samples <br>
   19  *
   20  * eCall is a technology initiative intended to bring rapid assistance to auto
   21  * accidents anywhere in the European Union. When a serious vehicle accident occurs,
   22  * sensors automatically trigger an eCall. When activated, the in-vehicle system (IVS)
   23  * establishes a 112-voice connection.
   24  *
   25  * The Mobile Network Operator handles the eCall like any other 112 call and routes the call to the
   26  * most appropriate emergency response centre - Public Safety Answering Point (PSAP).
   27  *
   28  * At the same time, a digital "minimum set of data" (MSD) message is sent over the voice call using
   29  * in-band modem signals. The MSD includes accident information like time, location, driving
   30  * direction, and vehicle description.
   31  *
   32  * The eCall can also be activated manually. The mobile network operator identifies that the 112
   33  * call is an eCall from the “eCall flag” inserted by the vehicle’s communication module.
   34  *
   35  * This API applies for both PAN-EUROPEAN and ERA-GLONASS standards.
   36  *
   37  * @note eCall service is only available on automotive products.
   38  *
   39  * @section le_ecall_binding IPC interfaces binding
   40  *
   41  * All the functions of this API are provided by the @b modemService service.
   42  *
   43  * Here's a code sample binding to modem services:
   44  * @verbatim
   45    bindings:
   46    {
   47       clientExe.clientComponent.le_ecall -> modemService.le_ecall
   48    }
   49    @endverbatim
   50  *
   51  * @section le_ecall_operation Operation modes
   52  *
   53  * The modem can be configured to operate in three different operation modes:
   54  * - le_ecall_ForceOnlyMode(): this function configures the eCall operation mode to eCall only, only
   55  *   emergency number can be used to start an eCall session. The modem doesn't try to register on
   56  *   the Cellular network. This function forces the modem to behave as eCall only mode whatever
   57  *   U/SIM operation mode. The change doesn't persist over power cycles.
   58  *   This function can be called before making an eCall.
   59  *
   60  * - le_ecall_ForcePersistentOnlyMode(): Same as le_ecall_ForceOnlyMode(), but the change persists
   61  *   over power cycles.
   62  *
   63  * - le_ecall_ExitOnlyMode(): this function exits from eCall Only mode. It configures the eCall
   64  *   operation mode to Normal mode, the modem uses the default operation mode at power up (or after
   65  *   U/SIM hotswap). The modem behaves following the U/SIM eCall operation mode; for example the
   66  *   U/SIM can be configured only for eCall, or a combination of eCall and commercial service
   67  *   provision.
   68  *
   69  * - le_ecall_GetConfiguredOperationMode(): this function allows the user to retrieve the configured
   70  *   Operation mode.
   71  *   The configured operation mode can be:
   72  *   - @c LE_ECALL_NORMAL_MODE : normal mode. The modem behaves following the U/SIM eCall operation
   73  *                               mode.
   74  *   - @c LE_ECALL_ONLY_MODE : eCall only mode according to U/SIM operation mode or forced by
   75  *                             application through the le_ecall_ForceOnlyMode() function.
   76  *   - @c LE_ECALL_FORCED_PERSISTENT_ONLY_MODE : persistent eCall only mode.
   77  *
   78  * @section le_ecall_session eCall Session
   79  *
   80  * le_ecall_Create() creates a new eCall object and returns a reference to the eCall session.
   81  * The eCall is not yet initiated at this point, the session must be started using one of the
   82  * following functions:
   83  * - le_ecall_StartManual(): initiate a manual eCall session (triggered by a passenger)
   84  * - le_ecall_StartAutomatic(): initiate an automatic eCall session (automatically triggered by
   85  *   the IVS in case of accident)
   86  * - le_ecall_StartTest(): initiate a test eCall session (to test the communication between the
   87  *   IVS and the PSAP)
   88  *
   89  * The session can be stopped by calling le_ecall_End(). Note that in some cases, the ongoing eCall
   90  * session cannot be ended until a specific eCall state is reached. These cases are listed below:
   91  * - During an automatic eCall session, it is not possible to end the ongoing session until
   92  *   LE_ECALL_STATE_STOPPED event is notified.
   93  * - For manual session, it is possible to end the ongoing session if the eCall is not connected
   94  *   (LE_ECALL_STATE_CONNECTED not yet received) and after LE_ECALL_STATE_STOPPED event is notified.
   95  *
   96  * @warning An application must wait for the end of the ongoing eCall before triggering another
   97  * one with the @c le_ecall_StartXxx() functions. An eCall is ended when:
   98  * - the application successfully ended it with le_ecall_End() returning @c LE_OK
   99  * - or the event @ref LE_ECALL_STATE_STOPPED is received
  100  * - or the event @ref LE_ECALL_STATE_ALACK_RECEIVED_CLEAR_DOWN is received
  101  * - or the event @ref LE_ECALL_STATE_DISCONNECTED is received and no redial is launched (see
  102  * @ref le_ecall_redial section for more information about the redial process).
  103  *
  104  * When the eCall object is no longer needed, call le_ecall_Delete() to free all allocated
  105  * resources associated with the object.
  106  *
  107  * The current state of an eCall session can be queried using le_ecall_GetState().
  108  * Alternatively, an application can register a handler be notified when the session state
  109  * changes. The handler can be managed using le_ecall_AddStateChangeHandler() and
  110  * le_ecall_RemoveStateChangeHandler().
  111  *
  112  * An application can also call le_ecall_GetTerminationReason() to retrieve the reason of the call
  113  * termination when call state is @ref LE_ECALL_STATE_DISCONNECTED, and also
  114  * le_ecall_GetPlatformSpecificTerminationCode() to get platform specific termination code (refer
  115  * to your platform documentation for further details).
  116  *
  117  * @section le_ecall_concurrency Concurrency
  118  *
  119  * If another application tries to use the eCall service while a session is already in progress, the
  120  * le_ecall_StartManual(), le_ecall_StartAutomatic(), le_ecall_StartTest() functions will return a
  121  * @c LE_BUSY error. The eCall session in progress won't be interrupted or disturbed. The
  122  * application can follow the session progress with 'state' functions like le_ecall_GetState() and
  123  * le_ecall_AddStateChangeHandler().
  124  * A manual eCall can't interrupt an automatic eCall, and an automatic eCall can't interrupt a
  125  * manual eCall.
  126  *
  127  * @section le_ecall_msd Minimum Set of Data (MSD)
  128  *
  129  * The dynamic values of the MSD can be set with:
  130  * - le_ecall_SetMsdPosition() sets the position of the vehicle.
  131  * - le_ecall_SetMsdPositionN1() sets the first delta position of the vehicle.
  132  * - le_ecall_SetMsdPositionN2() sets the second delta position of the vehicle.
  133  * - le_ecall_SetMsdPassengersCount() sets the number of passengers.
  134  *
  135  * The MSD is automatically encoded with the values previously set.
  136  *
  137  * @warning Those functions return a LE_DUPLICATE error when the MSD has been already imported with
  138  * le_ecall_ImportMsd() function.
  139  *
  140  * The MSD transmission mode can be set or get with:
  141  *  - le_ecall_SetMsdTxMode()
  142  *  - le_ecall_GetMsdTxMode()
  143  *
  144  * The transmission mode can be:
  145  * - @c LE_ECALL_TX_MODE_PUSH : the MSD is pushed by the IVS
  146  * - @c LE_ECALL_TX_MODE_PULL : the MSD is sent when requested by the PSAP
  147  *
  148  * It's possible to import a prepared MSD using the le_ecall_ImportMsd() function.
  149  * The prepared MSD must answer the requirements described in the "EN 15722:2013" publication (this
  150  * publication has been prepared by Technical Committee CEN/TC 278 “Intelligent Transport Systems").
  151  *
  152  * @warning The imported MSD doesn't take into account the values provided by the
  153  * le_ecall_SetMsdXxx() functions. It overwrites any previous imported MSD or encoded MSD.
  154  *
  155  * @warning The imported MSD overwrites the control flags (automaticActivation and testCall) set by
  156  * le_ecall_StartXxx() functions (Manual, Automatic, Test). The User App is in charge of their
  157  * correct settings.
  158  *
  159  * The encoded MSD can be retrieved with le_ecall_ExportMsd() function.
  160  *
  161  * @note The User app must perform the MSD transmission by calling le_ecall_SendMsd() when the
  162  * LE_ECALL_STATE_PSAP_START_IND_RECEIVED event is received.
  163  * The MSD can be updated before calling le_ecall_SendMsd(), using the e_ecall_ImportMsd() function
  164  * or the le_ecall_SetMsdXxx() functions.
  165  *
  166  * The date/time on MSD information is internally set by fetching the time from linux system time
  167  * (epoch time since 1970-01-01 00:00:00 +0000 (UTC)).
  168  *
  169  * This time is automatically updated if NITS is supported by the cellular network. Otherwise, it is
  170  * up to the user to update the system date/time by calling le_clk_SetAbsoluteTime() function. The
  171  * time provided to le_clk_SetAbsoluteTime() function can be retrieved by:
  172  * - le_data_GetTime()/le_data_GetDate(): the time from the network NTP.
  173  * - le_gnss_GetEpochTime() the GPS epoch time.
  174  *
  175  * @note Only unsandboxed application can set the date/time by le_clk_SetAbsoluteTime(). In case of
  176  * sandboxed application, please contact Sierra Wireless support to update the system date/time in
  177  * different ways.
  178  *
  179  * @section le_ecall_eraglonass ERA-GLONASS compliancy
  180  *
  181  * To perform an emergency call following the ERA-GLONASS requirements, the 'systemStandard' entry
  182  * of the configuration database must be set to 'ERA-GLONASS'.
  183  *
  184  * Moreover, the User can set some specific configuration settings in accordance with the PSAP
  185  * configuration:
  186  *
  187  * - le_ecall_SetEraGlonassManualDialAttempts(): set the ECALL_MANUAL_DIAL_ATTEMPTS value. If a dial
  188  *   attempt under manual emergency call initiation failed, it should be repeated maximally
  189  *   ECALL_MANUAL_DIAL_ATTEMPTS-1 times within the maximal time limit of ECALL_DIAL_DURATION.
  190  *   The default value is 10.
  191  *   Redial attempts stop once the call has been cleared down correctly, or if counter / timer
  192  *   reached their limits.
  193  *
  194  *   Available for both manual and test modes:
  195  * - le_ecall_SetEraGlonassAutoDialAttempts(): set the ECALL_AUTO_DIAL_ATTEMPTS value. If a dial
  196  *   attempt under automatic emergency call initiation failed, it should be repeated maximally
  197  *   ECALL_AUTO_DIAL_ATTEMPTS-1 times within the maximal time limit of ECALL_DIAL_DURATION.
  198  *   The default value is 10.
  199  *   Redial attempts stop once the call has been cleared down correctly, or if counter / timer
  200  *   reached their limits.
  201  * - le_ecall_SetEraGlonassDialDuration(): set the ECALL_DIAL_DURATION time. It is the maximum time
  202  *   the IVS have to connect the emergency call to the PSAP, including all redial attempts.
  203  *   If the call is not connected within this time (or ManualDialAttempts/AutoDialAttempts dial
  204  *   attempts), it will stop.
  205  * - le_ecall_SetEraGlonassFallbackTime(): set the ECALL_CCFT time. When the specified timer
  206  *   duration is reached and IVS NAD didn't receive a call clear-down indication then the call
  207  *   is automatically terminated.
  208  * - le_ecall_SetEraGlonassAutoAnswerTime(): sets the ECALL_AUTO_ANSWER_TIME time, the
  209  *   maximum time interval wherein IVDS responds to incoming calls automatically after emergency
  210  *   call completion.
  211  * - le_ecall_SetEraGlonassMSDMaxTransmissionTime(): sets the ECALL_MSD_MAX_TRANSMISSION_TIME time,
  212  *   the maximum time for MSD transmission.
  213  *
  214  *   Available for test mode only:
  215  * - le_ecall_SetEraGlonassPostTestRegistrationTime(): sets the ECALL_POST_TEST_REGISTRATION_TIME,
  216  *   the time interval wherein IVS remains registered in the network after the completion of
  217  *   transmission of test results to System Operator. The ECALL_POST_TEST_REGISTRATION_TIME default
  218  *   time value is 120 seconds.
  219  *
  220  * The corresponding getter functions let you retrieve the configuration settings values:
  221  *
  222  * - le_ecall_GetEraGlonassManualDialAttempts(): get the ECALL_MANUAL_DIAL_ATTEMPTS value.
  223  * - le_ecall_GetEraGlonassAutoDialAttempts(): get the ECALL_AUTO_DIAL_ATTEMPTS value.
  224  * - le_ecall_GetEraGlonassDialDuration(): get the ECALL_DIAL_DURATION time.
  225  * - le_ecall_GetEraGlonassFallbackTime(): get the ECALL_CCFT time.
  226  * - le_ecall_GetEraGlonassAutoAnswerTime(): get the ECALL_AUTO_ANSWER_TIME time.
  227  * - le_ecall_GetEraGlonassMSDMaxTransmissionTime(): get the ECALL_MSD_MAX_TRANSMISSION_TIME time.
  228  * - le_ecall_GetEraGlonassPostTestRegistrationTime(): get the ECALL_POST_TEST_REGISTRATION_TIME
  229  *   time.
  230  *
  231  * @section le_ecall_eraGlonassData ERA-GLONASS MSD additional data
  232  *
  233  * ERA-GLONASS additional data are optional and provided in the MSD message if any.
  234  * They are located in MSD data block number 12 as optional additional data.
  235  *
  236  * ERA-GLONASS MSD additional data for MSD version 1 describes:
  237  * - The crash severity (Accident Severity Index - ASI15)
  238  * - The diagnostic result
  239  * - The crash information
  240  *
  241  * ERA-GLONASS MSD additional data for MSD version 2 describes:
  242  * - The crash severity (Accident Severity Index - ASI15)
  243  * - The diagnostic result
  244  * - The crash information
  245  * - The coordinate system type
  246  *
  247  * ERA-GLONASS MSD additional data can be specified through the following functions:
  248  * - le_ecall_SetMsdEraGlonassCrashSeverity().
  249  * - le_ecall_ResetMsdEraGlonassCrashSeverity().
  250  * - le_ecall_SetMsdEraGlonassDiagnosticResult().
  251  * - le_ecall_ResetMsdEraGlonassDiagnosticResult().
  252  * - le_ecall_SetMsdEraGlonassCrashInfo().
  253  * - le_ecall_ResetMsdEraGlonassCrashInfo().
  254  * - le_ecall_SetMsdEraGlonassCoordinateSystemType().
  255  * - le_ecall_ResetMsdEraGlonassCoordinateSystemType().
  256  *
  257  * ERA-GLONASS additional data is encoded using the OID version "1.4.1" for
  258  * MSD version 1 and the OID version "1.4.2" for MSD version 2.
  259  * This was assigned to ERA-GLONASS optional additional data by CEN.
  260  *
  261  * Content of data block in the AdditionalData for MSD version 1 should be:
  262  *
  263  * @code
  264  *
  265  * ERAOADASN1Module
  266  * DEFINITIONS
  267  * AUTOMATIC TAGS ::=
  268  * BEGIN
  269  * ERADataFormatId::= INTEGER (1)
  270  *
  271  * ERAAdditionalData ::= SEQUENCE {
  272  *    crashSeverity INTEGER(0..2047) OPTIONAL,
  273  *    diagnosticResult DiagnosticResult OPTIONAL,
  274  *    crashInfo CrashInfo OPTIONAL,
  275  *    ...
  276  * }
  277  *
  278  * DiagnosticResult ::= SEQUENCE {
  279  *    micConnectionFailure BOOLEAN OPTIONAL,
  280  *    micFailure BOOLEAN OPTIONAL,
  281  *    rightSpeakerFailure BOOLEAN OPTIONAL,
  282  *    leftSpeakerFailure BOOLEAN OPTIONAL,
  283  *    speakersFailure BOOLEAN OPTIONAL,
  284  *    ignitionLineFailure BOOLEAN OPTIONAL,
  285  *    uimFailure BOOLEAN OPTIONAL,
  286  *    statusIndicatorFailure BOOLEAN OPTIONAL,
  287  *    batteryFailure BOOLEAN OPTIONAL,
  288  *    batteryVoltageLow BOOLEAN OPTIONAL,
  289  *    crashSensorFailure BOOLEAN OPTIONAL,
  290  *    firmwareImageCorruption BOOLEAN OPTIONAL,
  291  *    commModuleInterfaceFailure BOOLEAN OPTIONAL,
  292  *    gnssReceiverFailure BOOLEAN OPTIONAL,
  293  *    raimProblem BOOLEAN OPTIONAL,
  294  *    gnssAntennaFailure BOOLEAN OPTIONAL,
  295  *    commModuleFailure BOOLEAN OPTIONAL,
  296  *    eventsMemoryOverflow BOOLEAN OPTIONAL,
  297  *    crashProfileMemoryOverflow BOOLEAN OPTIONAL,
  298  *    otherCriticalFailires BOOLEAN OPTIONAL,
  299  *    otherNotCriticalFailures BOOLEAN OPTIONAL
  300  * }
  301  *
  302  * CrashInfo ::= SEQUENCE {
  303  *    crashFront BOOLEAN OPTIONAL,
  304  *    crashLeft BOOLEAN OPTIONAL,
  305  *    crashRight BOOLEAN OPTIONAL,
  306  *    crashRear BOOLEAN OPTIONAL,
  307  *    crashRollover BOOLEAN OPTIONAL,
  308  *    crashSide BOOLEAN OPTIONAL,
  309  *    crashFrontOrSide BOOLEAN OPTIONAL,
  310  *    crashAnotherType BOOLEAN OPTIONAL
  311  * }
  312  * END
  313  * @endcode
  314  *
  315  * Content of data block in the AdditionalData for MSD version 2 should be:
  316  *
  317  * @code
  318  *
  319  * ERAOADASN1Module
  320  * DEFINITIONS
  321  * AUTOMATIC TAGS ::=
  322  * BEGIN
  323  * ERADataFormatId::= INTEGER (1)
  324  *
  325  * ERAAdditionalData ::= SEQUENCE {
  326  *    crashSeverity INTEGER(0..2047) OPTIONAL,
  327  *    diagnosticResult DiagnosticResult OPTIONAL,
  328  *    crashInfo CrashInfo OPTIONAL,
  329  *    coordinateSystemType CoordinateSystemType DEFAULT wgs84,
  330  *    ...
  331  * }
  332  *
  333  * DiagnosticResult ::= SEQUENCE {
  334  *    micConnectionFailure BOOLEAN OPTIONAL,
  335  *    micFailure BOOLEAN OPTIONAL,
  336  *    rightSpeakerFailure BOOLEAN OPTIONAL,
  337  *    leftSpeakerFailure BOOLEAN OPTIONAL,
  338  *    speakersFailure BOOLEAN OPTIONAL,
  339  *    ignitionLineFailure BOOLEAN OPTIONAL,
  340  *    uimFailure BOOLEAN OPTIONAL,
  341  *    statusIndicatorFailure BOOLEAN OPTIONAL,
  342  *    batteryFailure BOOLEAN OPTIONAL,
  343  *    batteryVoltageLow BOOLEAN OPTIONAL,
  344  *    crashSensorFailure BOOLEAN OPTIONAL,
  345  *    firmwareImageCorruption BOOLEAN OPTIONAL,
  346  *    commModuleInterfaceFailure BOOLEAN OPTIONAL,
  347  *    gnssReceiverFailure BOOLEAN OPTIONAL,
  348  *    raimProblem BOOLEAN OPTIONAL,
  349  *    gnssAntennaFailure BOOLEAN OPTIONAL,
  350  *    commModuleFailure BOOLEAN OPTIONAL,
  351  *    eventsMemoryOverflow BOOLEAN OPTIONAL,
  352  *    crashProfileMemoryOverflow BOOLEAN OPTIONAL,
  353  *    otherCriticalFailires BOOLEAN OPTIONAL,
  354  *    otherNotCriticalFailures BOOLEAN OPTIONAL
  355  * }
  356  *
  357  * CrashInfo ::= SEQUENCE {
  358  *    crashFront BOOLEAN OPTIONAL,
  359  *    crashLeft BOOLEAN OPTIONAL,
  360  *    crashRight BOOLEAN OPTIONAL,
  361  *    crashRear BOOLEAN OPTIONAL,
  362  *    crashRollover BOOLEAN OPTIONAL,
  363  *    crashSide BOOLEAN OPTIONAL,
  364  *    crashFrontOrSide BOOLEAN OPTIONAL,
  365  *    crashAnotherType BOOLEAN OPTIONAL
  366  * }
  367  *
  368  * CoordinateSystemType ::= ENUMERATED {
  369  *    wgs64 (1),
  370  *    ps90 (2)
  371  * }
  372  * END
  373  *
  374  * @endcode
  375  *
  376  * @section le_ecall_redial Redial management
  377  *
  378  * In the case of PAN-EUROPEAN, the redial can be performed as many times as desired but should be
  379  * performed within 2 minutes. (EN 16062:2014 -7.14.3).
  380  *
  381  * In the case of ERA-GLONASS, the redial can be performed ECALL_MANUAL_DIAL_ATTEMPTS times within
  382  * the maximal time limit of ECALL_DIAL_DURATION (GOST 54620 2013 -- Appendix A).
  383  *
  384  * The \b LE_ECALL_STATE_END_OF_REDIAL_PERIOD state event notifies the User of the redial period
  385  * end.
  386  *
  387  * @section le_ecall_configuration eCall configuration
  388  *
  389  * Some parameters used by the eCall service can be configured through APIs. This includes the
  390  * number to dial, the deregistration time, the redial interval, and some MSD information.
  391  *
  392  * @note It is not possible to change the current configuration if an eCall session is already
  393  * started. The ongoing session needs to be stopped first by calling le_ecall_End() before
  394  * calling the eCall configuration setting functions.
  395  * There is one exception to the previous statement: if the NAD deregistration mechanism is enabled
  396  * an T9/T10 timers have not expired yet, it is not possible to change the eCall settings even after
  397  * calling le_ecall_End(). It is recommended to wait for T9/T10 expiry notification first, then
  398  * call le_ecall_End() to apply new eCall settings for the next session.
  399  *
  400  * @subsection le_ecall_configuration_callNumber eCall number
  401  *
  402  * By default, the number to dial is read from the FDN/SDN (Fixed Dialling Numbers/Service
  403  * Dialling Numbers) of the U/SIM, depending upon the eCall operating mode.
  404  *
  405  * However, the PSAP phone number can be queried and set with:
  406  *  - le_ecall_GetPsapNumber()
  407  *  - le_ecall_SetPsapNumber()
  408  *
  409  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" PsapNumber
  410  *
  411  * @note That PSAP number is not applied to a manual or an automatically initiated eCall. For these
  412  *       modes, an emergency call is launched.
  413  *
  414  * @warning These two functions don't modify or read the U/SIM content.
  415  *
  416  * When modem is in @ref LE_ECALL_FORCED_PERSISTENT_ONLY_MODE or @ref LE_ECALL_ONLY_MODE,
  417  * le_ecall_UseUSimNumbers() API can be called to request the modem to read the number to
  418  * dial from the FDN/SDN of the U/SIM.
  419  *
  420  * @note If FDN directory is updated with new dial numbers, be sure that the SIM card is refreshed.
  421  *
  422  * @subsection le_ecall_configuration_nad NAD deregistration time
  423  *
  424  * The NAD (Network Access Device, i.e. the Modem) deregistration allows the device to remain
  425  * registered to the network for an amount of time after the eCall is exited whether remotely or
  426  * user-initiated using le_ecall_End().
  427  * The time value can be set with the le_ecall_SetNadDeregistrationTime() API and retrieved with the
  428  * le_ecall_GetNadDeregistrationTime() API.
  429  *
  430  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" NadTime
  431  *
  432  * 1. PAN-EUROPEAN standard (<em>EN 16062</em>) defines the T9 and T10 timers. After an eCall
  433  *    clear-down, an <b>eCall only</b> IVS shall:
  434  *    - Remain registered on the network for at least the duration of T9, which is set to
  435  *      one hour by default.
  436  *    - Deregister from the network after the expiration of T10, which duration is set to
  437  *      twelve hours by default.
  438  * 2. ERA-GLONASS standard (<em>ENG_GOST_R_54620</em>) defines the NAD_DEREGISTRATION_TIME
  439  *    with a minimal value of 2 hours and a maximum value of 12 hours. After an eCall clear-down,
  440  *    the IVS shall remain registered on the network and deregister from the network after the
  441  *    expiration of the NAD_DEREGISTRATION_TIME.
  442  *
  443  * The le_ecall_SetNadDeregistrationTime() API is used to set the duration of a
  444  * <em>deregistration timer</em>: after an eCall clear-down, the IVS remains registered on the
  445  * network for the duration of this timer and then automatically deregisters from the network upon
  446  * its expiration.
  447  *
  448  * Moreover, when IVS NAD is in <b>eCall only</b> mode, and the eCall has been normally ended by
  449  * PSAP or by le_ecall_End(), then the user can terminate registration state before T9/T10 or
  450  * NAD_DEREGISTRATION_TIME expired by le_ecall_TerminateRegistration().
  451  *
  452  * @subsubsection le_ecall_configuration_nad_panEU PAN-EUROPEAN standard
  453  * As the T9 timer duration is fixed to one hour, the notified events depend on the
  454  * <em>deregistration timer</em> duration:
  455  *  - If its duration is set to one hour, the @ref LE_ECALL_STATE_TIMEOUT_T9 event will be reported.
  456  *    In this case deregistration is automatically performed when the T9 timeout indication is
  457  *    received.
  458  *  - If its duration is set to more than one hour and less than twelve hours then the
  459  *    @ref LE_ECALL_STATE_TIMEOUT_T10 event will be reported when the <em>deregistration timer</em>
  460  *    expires. The T9 timeout (@ref LE_ECALL_STATE_TIMEOUT_T9 event) will not be notified.
  461  *    In this case deregistration is automatically performed when the <em>deregistration timer</em>
  462  *    expires, provided that the application didn't already deregister from the network before.
  463  *
  464  * @subsubsection le_ecall_configuration_nad_eraGlonass ERA-GLONASS standard
  465  *  - The @ref LE_ECALL_STATE_TIMEOUT_T9 event is not reported as it is not defined in the
  466  *    ERA-GLONASS standard.
  467  *  - The NAD_DEREGISTRATION_TIME default value is eight hours, as defined by
  468  *    <em>GOST_R 54620 Table A.1</em>. It can be changed with le_ecall_SetNadDeregistrationTime()
  469  *    and the value must be set between 2 and 12 hours.
  470  *  - The @ref LE_ECALL_STATE_TIMEOUT_T10 event will be reported when the NAD_DEREGISTRATION_TIME
  471  *    expires. In this case deregistration is automatically performed when the timer expires.
  472  *
  473  * @subsubsection le_ecall_configuration_nad_timerValue Timer value
  474  *
  475  * Although the time is set in minutes the value is taken in hours, for example:
  476  * - from 1 to 60 minutes -> 1 hour
  477  * - from 61 to 120 minutes -> 2 hours, etc.
  478  *
  479  * Example: if @c deregTime parameter unit is minutes, the effective time is:
  480  * @code ECallConfiguration.nad_deregistration_time = (deregTime+59)/60; @endcode
  481  *
  482  * After termination of an emergency call the in-vehicle system remains registered on the network
  483  * for the period of time, defined by the installation parameter NAD_DEREGISTRATION_TIME.
  484  *
  485  * @warning Be sure to check the possible values of NAD_DEREGISTRATION_TIME for your specific
  486  * platform.
  487  *
  488  * @subsection le_ecall_configuration_postTestRegistrationTime Post test registration time
  489  *
  490  * The ECALL_POST_TEST_REGISTRATION_TIME time value can be set with the
  491  * le_ecall_SetEraGlonassPostTestRegistrationTime() function and retrieved by the
  492  * le_ecall_GetEraGlonassPostTestRegistrationTime() function.
  493  *
  494  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" PostTest
  495  *
  496  * @subsection le_ecall_configuration_redialInterval Redial interval
  497  *
  498  * The minimum interval value between dial attempts can be set or get with:
  499  *  - le_ecall_SetIntervalBetweenDialAttempts()
  500  *  - le_ecall_GetIntervalBetweenDialAttempts()
  501  *
  502  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" DialTimer
  503  *
  504  * The default value is set to 30 seconds.
  505  *
  506  * The time is counted from the start of the first dial attempt.
  507  *
  508  * If more time has expired during the dial attempt, it will wait for 1 second to allow hangup
  509  * before redialing.
  510  *
  511  * If less time has expired during the dial attempt, it will wait for
  512  * (interval - 'dial attempt duration') seconds to allow hangup before redialing.
  513  *
  514  * In the case the call was connected, the redial will be immediate.
  515  *
  516  * le_ecall_SetIntervalBetweenDialAttempts() is available for both manual and test modes.
  517  *
  518  * @subsection le_ecall_configuration_misc Miscellaneous
  519  *
  520  * The preferred system standard defaults to PAN-EUROPEAN
  521  * It can be set an gotten with the following functions:
  522  * - le_ecall_SetSystemStandard()
  523  * - le_ecall_GetSystemStandard()
  524  *
  525  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Standard
  526  *
  527  * The MSD version can be set and and gotten with the following functions:
  528  * - le_ecall_SetMsdVersion()
  529  * - le_ecall_GetMsdVersion()
  530  *
  531  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" MsdVersion
  532  *
  533  * The vehicle type can be set and gotten with the following functions:
  534  * - le_ecall_SetVehicleType()
  535  * - le_ecall_GetVehicleType()
  536  *
  537  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Vehicle
  538  *
  539  * The vehicle identifier can be set and gotten with the following functions:
  540  * - le_ecall_SetVIN()
  541  * - le_ecall_GetVIN()
  542  *
  543  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" VIN
  544  *
  545  * The propulsion type can be set and gotten with the following functions:
  546  * - le_ecall_SetPropulsionType()
  547  * - le_ecall_GetPropulsionType()
  548  *
  549  * @snippet "apps/test/modemServices/ecall/ecallIntegrationTest/eCallTest/le_ecallTest.c" Propulsion
  550  *
  551  * @section le_ecall_samples Code samples
  552  *
  553  * A sample code that implements an eCall test session with a local voice prompt can be found in
  554  * \b eCallWPrompt.c file (please refer to @ref c_ecallWPromptSample page).
  555  *
  556  * A sample code that implements an eCall test session with a voice call connection can be found in
  557  * \b eCallWVoice.c file (please refer to @ref c_ecallWVoiceSample page).
  558  *
  559  * If you want to have a look at a more in-depth usage of these APIs, please refer to the
  560  * @ref le_ecall_interface.h.
  561  *
  562  * <HR>
  563  *
  564  * Copyright (C) Sierra Wireless Inc.
  565  */
  566 /**
  567  * @file le_ecall_interface.h
  568  *
  569  * Legato @ref c_ecall include file.
  570  *
  571  * Copyright (C) Sierra Wireless Inc.
  572  */
  573 /**
  574  * @page c_ecallWPromptSample Sample code of an eCall test session with a local voice prompt
  575  *
  576  * @include "apps/test/modemServices/ecall/ecallWPrompt/eCallWPrompt/eCallWPrompt.c"
  577  */
  578 /**
  579  * @page c_ecallWVoiceSample Sample code an eCall test session with a voice call connection
  580  *
  581  * @include "apps/test/modemServices/ecall/ecallWVoice/eCallWVoice/eCallWVoice.c"
  582  */
  583 
  584 #ifndef LE_ECALL_INTERFACE_H_INCLUDE_GUARD
  585 #define LE_ECALL_INTERFACE_H_INCLUDE_GUARD
  586 
  587 
  588 #include "legato.h"
  589 
  590 // Interface specific includes
  591 #include "le_mdmDefs_interface.h"
  592 #include "le_mcc_interface.h"
  593 
  594 // Internal includes for this interface
  595 #include "le_ecall_common.h"
  596 /** @addtogroup le_ecall le_ecall API Reference
  597  * @{
  598  * @file le_ecall_common.h
  599  * @file le_ecall_interface.h **/
  600 //--------------------------------------------------------------------------------------------------
  601 /**
  602  * Type for handler called when a server disconnects.
  603  */
  604 //--------------------------------------------------------------------------------------------------
  605 typedef void (*le_ecall_DisconnectHandler_t)(void *);
  606 
  607 //--------------------------------------------------------------------------------------------------
  608 /**
  609  *
  610  * Connect the current client thread to the service providing this API. Block until the service is
  611  * available.
  612  *
  613  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  614  * called before any other functions in this API.  Normally, ConnectService is automatically called
  615  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  616  *
  617  * This function is created automatically.
  618  */
  619 //--------------------------------------------------------------------------------------------------
  620 void le_ecall_ConnectService
  621 (
  622     void
  623 );
  624 
  625 //--------------------------------------------------------------------------------------------------
  626 /**
  627  *
  628  * Try to connect the current client thread to the service providing this API. Return with an error
  629  * if the service is not available.
  630  *
  631  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  632  * called before any other functions in this API.  Normally, ConnectService is automatically called
  633  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  634  *
  635  * This function is created automatically.
  636  *
  637  * @return
  638  *  - LE_OK if the client connected successfully to the service.
  639  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  640  *    bound.
  641  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  642  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  643  */
  644 //--------------------------------------------------------------------------------------------------
  645 le_result_t le_ecall_TryConnectService
  646 (
  647     void
  648 );
  649 
  650 //--------------------------------------------------------------------------------------------------
  651 /**
  652  * Set handler called when server disconnection is detected.
  653  *
  654  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  655  * to continue without exiting, it should call longjmp() from inside the handler.
  656  */
  657 //--------------------------------------------------------------------------------------------------
  658 LE_FULL_API void le_ecall_SetServerDisconnectHandler
  659 (
  660     le_ecall_DisconnectHandler_t disconnectHandler,
  661     void *contextPtr
  662 );
  663 
  664 //--------------------------------------------------------------------------------------------------
  665 /**
  666  *
  667  * Disconnect the current client thread from the service providing this API.
  668  *
  669  * Normally, this function doesn't need to be called. After this function is called, there's no
  670  * longer a connection to the service, and the functions in this API can't be used. For details, see
  671  * @ref apiFilesC_client.
  672  *
  673  * This function is created automatically.
  674  */
  675 //--------------------------------------------------------------------------------------------------
  676 void le_ecall_DisconnectService
  677 (
  678     void
  679 );
  680 
  681 
  682 //--------------------------------------------------------------------------------------------------
  683 /**
  684  * Reference returned by Create function and used by other functions
  685  */
  686 //--------------------------------------------------------------------------------------------------
  687 
  688 
  689 //--------------------------------------------------------------------------------------------------
  690 /**
  691  *  Configured operation modes.
  692  */
  693 //--------------------------------------------------------------------------------------------------
  694 
  695 
  696 //--------------------------------------------------------------------------------------------------
  697 /**
  698  *  Configure which standard to follow for the eCall, either PAN European eCall or ERA GLONASS.
  699  */
  700 //--------------------------------------------------------------------------------------------------
  701 
  702 
  703 //--------------------------------------------------------------------------------------------------
  704 /**
  705  *  eCall session states.
  706  */
  707 //--------------------------------------------------------------------------------------------------
  708 
  709 
  710 //--------------------------------------------------------------------------------------------------
  711 /**
  712  *  eCall MSD transmission mode.
  713  */
  714 //--------------------------------------------------------------------------------------------------
  715 
  716 
  717 //--------------------------------------------------------------------------------------------------
  718 /**
  719  *  eCall MSD vehicle type
  720  */
  721 //--------------------------------------------------------------------------------------------------
  722 
  723 
  724 //--------------------------------------------------------------------------------------------------
  725 /**
  726  * Propulsion type Bit Mask
  727  */
  728 //--------------------------------------------------------------------------------------------------
  729 
  730 
  731 //--------------------------------------------------------------------------------------------------
  732 /**
  733  * Diagnostic result Bit Mask (64 bits)
  734  *
  735  */
  736 //--------------------------------------------------------------------------------------------------
  737 
  738 
  739 //--------------------------------------------------------------------------------------------------
  740 /**
  741  * Crash information Bit Mask (16 bits) indicating the type of road accident.
  742  *
  743  */
  744 //--------------------------------------------------------------------------------------------------
  745 
  746 
  747 //--------------------------------------------------------------------------------------------------
  748 /**
  749  *  eCall MSD coordinate system type
  750  */
  751 //--------------------------------------------------------------------------------------------------
  752 
  753 
  754 //--------------------------------------------------------------------------------------------------
  755 /**
  756  * Handler for eCall state changes.
  757  *
  758  */
  759 //--------------------------------------------------------------------------------------------------
  760 
  761 
  762 //--------------------------------------------------------------------------------------------------
  763 /**
  764  * Reference type used by Add/Remove functions for EVENT 'le_ecall_StateChange'
  765  */
  766 //--------------------------------------------------------------------------------------------------
  767 
  768 
  769 //--------------------------------------------------------------------------------------------------
  770 /**
  771  * This function configures the eCall operation mode to eCall only, only emergency number can be
  772  * used to start an eCall session. The modem doesn't try to register on the Cellular network.
  773  * This function forces the modem to behave as eCall only mode whatever U/SIM operation mode.
  774  * The change doesn't persist over power cycles.
  775  * This function can be called before making an eCall.
  776  *
  777  * @return
  778  *      - LE_OK on success
  779  *      - LE_FAULT for other failures
  780  *      - LE_UNSUPPORTED Not supported on this platform
  781  */
  782 //--------------------------------------------------------------------------------------------------
  783 le_result_t le_ecall_ForceOnlyMode
  784 (
  785     void
  786 );
  787 
  788 //--------------------------------------------------------------------------------------------------
  789 /**
  790  * Same as le_ecall_ForceOnlyMode(), but the change persists over power cycles.
  791  *
  792  * @return
  793  *      - LE_OK on success
  794  *      - LE_FAULT for other failures
  795  *      - LE_UNSUPPORTED Not supported on this platform
  796  */
  797 //--------------------------------------------------------------------------------------------------
  798 le_result_t le_ecall_ForcePersistentOnlyMode
  799 (
  800     void
  801 );
  802 
  803 //--------------------------------------------------------------------------------------------------
  804 /**
  805  * This function exits from eCall Only mode. It configures the eCall operation mode to Normal mode,
  806  * the modem uses the default operation mode at power up (or after U/SIM hotswap). The modem behaves
  807  * following the U/SIM eCall operation mode; for example the U/SIM can be configured only for eCall,
  808  * or a combination of eCall and commercial service provision.
  809  *
  810  * @return
  811  *      - LE_OK on success
  812  *      - LE_FAULT for other failures
  813  *      - LE_UNSUPPORTED Not supported on this platform
  814  */
  815 //--------------------------------------------------------------------------------------------------
  816 le_result_t le_ecall_ExitOnlyMode
  817 (
  818     void
  819 );
  820 
  821 //--------------------------------------------------------------------------------------------------
  822 /**
  823  * Get the configured Operation mode.
  824  *
  825  * @return
  826  *      - LE_OK     on success
  827  *      - LE_FAULT  for other failures
  828  *      - LE_UNSUPPORTED Not supported on this platform
  829  *
  830  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  831  *       function will not return.
  832  */
  833 //--------------------------------------------------------------------------------------------------
  834 le_result_t le_ecall_GetConfiguredOperationMode
  835 (
  836     le_ecall_OpMode_t* opModePtr
  837         ///< [OUT] Operation mode
  838 );
  839 
  840 //--------------------------------------------------------------------------------------------------
  841 /**
  842  * Add handler function for EVENT 'le_ecall_StateChange'
  843  *
  844  * This event provides information on eCall state changes.
  845  *
  846  */
  847 //--------------------------------------------------------------------------------------------------
  848 le_ecall_StateChangeHandlerRef_t le_ecall_AddStateChangeHandler
  849 (
  850     le_ecall_StateChangeHandlerFunc_t handlerPtr,
  851         ///< [IN]
  852     void* contextPtr
  853         ///< [IN]
  854 );
  855 
  856 //--------------------------------------------------------------------------------------------------
  857 /**
  858  * Remove handler function for EVENT 'le_ecall_StateChange'
  859  */
  860 //--------------------------------------------------------------------------------------------------
  861 void le_ecall_RemoveStateChangeHandler
  862 (
  863     le_ecall_StateChangeHandlerRef_t handlerRef
  864         ///< [IN]
  865 );
  866 
  867 //--------------------------------------------------------------------------------------------------
  868 /**
  869  * Create a new eCall object
  870  *
  871  * The eCall is not actually established at this point. It's still up to the caller to call
  872  * le_ecall_Start() when ready.
  873  *
  874  * @return
  875  *      - A reference to the new Call object.
  876  *
  877  * @note On failure, the process exits; you don't have to worry about checking the returned
  878  *       reference for validity.
  879  */
  880 //--------------------------------------------------------------------------------------------------
  881 le_ecall_CallRef_t le_ecall_Create
  882 (
  883     void
  884 );
  885 
  886 //--------------------------------------------------------------------------------------------------
  887 /**
  888  * Call to free up a call reference.
  889  *
  890  * @note This will free the reference, but not necessarily stop an active eCall. If there are
  891  *       other holders of this reference the eCall will remain active.
  892  */
  893 //--------------------------------------------------------------------------------------------------
  894 void le_ecall_Delete
  895 (
  896     le_ecall_CallRef_t ecallRef
  897         ///< [IN] eCall reference
  898 );
  899 
  900 //--------------------------------------------------------------------------------------------------
  901 /**
  902  * Set the system standard.
  903  * Default is PAN EUROPEAN
  904  *
  905  * @return
  906  *  - LE_OK on success
  907  *  - LE_FAULT for other failures
  908  */
  909 //--------------------------------------------------------------------------------------------------
  910 le_result_t le_ecall_SetSystemStandard
  911 (
  912     le_ecall_SystemStandard_t systemStandard
  913         ///< [IN] System standard
  914 );
  915 
  916 //--------------------------------------------------------------------------------------------------
  917 /**
  918  * Get the system standard.
  919  *
  920  * @return
  921  *  - LE_OK on success
  922  *  - LE_FAULT for other failures
  923  *  - LE_BAD_PARAMETER parameter is NULL
  924  */
  925 //--------------------------------------------------------------------------------------------------
  926 le_result_t le_ecall_GetSystemStandard
  927 (
  928     le_ecall_SystemStandard_t* systemStandardPtr
  929         ///< [OUT] System Standard
  930 );
  931 
  932 //--------------------------------------------------------------------------------------------------
  933 /**
  934  * Set the MSDs version.
  935  * Default value is 1
  936  *
  937  * @return
  938  *  - LE_OK on success
  939  *  - LE_FAULT for other failures
  940  */
  941 //--------------------------------------------------------------------------------------------------
  942 le_result_t le_ecall_SetMsdVersion
  943 (
  944     uint32_t msdVersion
  945         ///< [IN] Msd version
  946 );
  947 
  948 //--------------------------------------------------------------------------------------------------
  949 /**
  950  * Get the MSD version.
  951  *
  952  * @return
  953  *  - LE_OK on success
  954  *  - LE_FAULT for other failures
  955  *  - LE_BAD_PARAMETER parameter is NULL
  956  */
  957 //--------------------------------------------------------------------------------------------------
  958 le_result_t le_ecall_GetMsdVersion
  959 (
  960     uint32_t* msdVersionPtr
  961         ///< [OUT] Msd version
  962 );
  963 
  964 //--------------------------------------------------------------------------------------------------
  965 /**
  966  * Set the Vehicled Type
  967  * Default value is 0
  968  *
  969  * @return
  970  *  - LE_OK on success
  971  *  - LE_FAULT for other failures
  972  */
  973 //--------------------------------------------------------------------------------------------------
  974 le_result_t le_ecall_SetVehicleType
  975 (
  976     le_ecall_MsdVehicleType_t vehicleType
  977         ///< [IN] Vehicle type
  978 );
  979 
  980 //--------------------------------------------------------------------------------------------------
  981 /**
  982  * Get the Vehicled Type.
  983  *
  984  * @return
  985  *  - LE_OK on success
  986  *  - LE_BAD_PARAMETER parameter is NULL
  987  *  - LE_FAULT for other failures
  988  */
  989 //--------------------------------------------------------------------------------------------------
  990 le_result_t le_ecall_GetVehicleType
  991 (
  992     le_ecall_MsdVehicleType_t* vehicleTypePtr
  993         ///< [OUT] Vehicle type
  994 );
  995 
  996 //--------------------------------------------------------------------------------------------------
  997 /**
  998  * Set the VIN (Vehicle Identification Number).
  999  *
 1000  * @return
 1001  *  - LE_OK on success
 1002  *  - LE_BAD_PARAMETER parameter is NULL.
 1003  *  - LE_FAULT for other failures
 1004  */
 1005 //--------------------------------------------------------------------------------------------------
 1006 le_result_t le_ecall_SetVIN
 1007 (
 1008     const char* LE_NONNULL vin
 1009         ///< [IN] VIN (Vehicle Identification Number)
 1010 );
 1011 
 1012 //--------------------------------------------------------------------------------------------------
 1013 /**
 1014  * Get the VIN (Vehicle Identification Number).
 1015  *
 1016  * @return
 1017  *  - LE_OK on success
 1018  *  - LE_NOT_FOUND if the value is not set.
 1019  *  - LE_BAD_PARAMETER parameter is NULL or to small
 1020  *  - LE_FAULT for other failures
 1021  */
 1022 //--------------------------------------------------------------------------------------------------
 1023 le_result_t le_ecall_GetVIN
 1024 (
 1025     char* vin,
 1026         ///< [OUT] VIN is gotten with a null termination.
 1027     size_t vinSize
 1028         ///< [IN]
 1029 );
 1030 
 1031 //--------------------------------------------------------------------------------------------------
 1032 /**
 1033  * Set the propulsion type.
 1034  * Note that a vehicle may have more than one propulsion type.
 1035  *
 1036  * @return
 1037  *  - LE_OK on success
 1038  *  - LE_FAULT for other failures
 1039  */
 1040 //--------------------------------------------------------------------------------------------------
 1041 le_result_t le_ecall_SetPropulsionType
 1042 (
 1043     le_ecall_PropulsionTypeBitMask_t propulsionType
 1044         ///< [IN] bitmask
 1045 );
 1046 
 1047 //--------------------------------------------------------------------------------------------------
 1048 /**
 1049  * Get the propulsion stored.
 1050  * Note that a vehicle may have more than one propulsion type.
 1051  *
 1052  * @return
 1053  *  - LE_OK on success
 1054  *  - LE_NOT_FOUND if the value is not set.
 1055  *  - LE_FAULT for other failures
 1056  *  - LE_BAD_PARAMETER parameter is NULL
 1057  */
 1058 //--------------------------------------------------------------------------------------------------
 1059 le_result_t le_ecall_GetPropulsionType
 1060 (
 1061     le_ecall_PropulsionTypeBitMask_t* propulsionTypePtr
 1062         ///< [OUT] bitmask
 1063 );
 1064 
 1065 //--------------------------------------------------------------------------------------------------
 1066 /**
 1067  * Set the push/pull transmission mode.
 1068  *
 1069  * @return
 1070  *  - LE_OK on success
 1071  *  - LE_FAULT for other failures
 1072  *  - LE_UNSUPPORTED Not supported on this platform
 1073  */
 1074 //--------------------------------------------------------------------------------------------------
 1075 le_result_t le_ecall_SetMsdTxMode
 1076 (
 1077     le_ecall_MsdTxMode_t mode
 1078         ///< [IN] Transmission mode
 1079 );
 1080 
 1081 //--------------------------------------------------------------------------------------------------
 1082 /**
 1083  * Get the push/pull transmission mode.
 1084  *
 1085  * @return
 1086  *      - LE_OK     on success
 1087  *      - LE_FAULT  for other failures
 1088  *      - LE_UNSUPPORTED Not supported on this platform
 1089  *
 1090  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1091  *       function will not return.
 1092  */
 1093 //--------------------------------------------------------------------------------------------------
 1094 le_result_t le_ecall_GetMsdTxMode
 1095 (
 1096     le_ecall_MsdTxMode_t* modePtr
 1097         ///< [OUT] Transmission mode
 1098 );
 1099 
 1100 //--------------------------------------------------------------------------------------------------
 1101 /**
 1102  * Set the position transmitted by the MSD.
 1103  *
 1104  * @return
 1105  *      - LE_OK on success
 1106  *      - LE_DUPLICATE an MSD has been already imported
 1107  *      - LE_BAD_PARAMETER bad input parameter
 1108  *      - LE_FAULT on other failures
 1109  *
 1110  * @note The process exits, if an invalid eCall reference is given
 1111  */
 1112 //--------------------------------------------------------------------------------------------------
 1113 le_result_t le_ecall_SetMsdPosition
 1114 (
 1115     le_ecall_CallRef_t ecallRef,
 1116         ///< [IN] eCall reference
 1117     bool isTrusted,
 1118         ///< [IN] true if the position is accurate, false otherwise
 1119     int32_t latitude,
 1120         ///< [IN] latitude in degrees with 6 decimal places, positive North.
 1121         ///< Maximum value is +90 degrees (+90000000), minimum value is -90
 1122         ///< degrees (-90000000).
 1123     int32_t longitude,
 1124         ///< [IN] longitude in degrees with 6 decimal places, positive East.
 1125         ///< Maximum value is +180 degrees (+180000000), minimum value is
 1126         ///< -180 degrees (-180000000).
 1127     int32_t direction
 1128         ///< [IN] direction of the vehicle from magnetic north (0 to 358, clockwise)
 1129         ///< in 2-degrees unit. Valid range is 0 to 179. If direction of
 1130         ///< travel is invalid or unknown, the value 0xFF shall be used.
 1131 );
 1132 
 1133 //--------------------------------------------------------------------------------------------------
 1134 /**
 1135  * Set the position Delta N-1 from position set in le_ecall_SetMsdPosition() transmitted by the MSD.
 1136  *
 1137  * @return
 1138  *      - LE_OK on success
 1139  *      - LE_DUPLICATE an MSD has been already imported
 1140  *      - LE_BAD_PARAMETER bad input parameter
 1141  *      - LE_FAULT on other failures
 1142  *
 1143  * @note The process exits, if an invalid eCall reference is given
 1144  */
 1145 //--------------------------------------------------------------------------------------------------
 1146 le_result_t le_ecall_SetMsdPositionN1
 1147 (
 1148     le_ecall_CallRef_t ecallRef,
 1149         ///< [IN] eCall reference
 1150     int32_t latitudeDeltaN1,
 1151         ///< [IN] longitude delta from position set in SetMsdPosition
 1152         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1153         ///< maximum value: 511 = 0 0'51.100'' (+- 1580m)
 1154         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m)
 1155     int32_t longitudeDeltaN1
 1156         ///< [IN] longitude delta from position set in SetMsdPosition
 1157         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1158         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1159         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m) )
 1160 );
 1161 
 1162 //--------------------------------------------------------------------------------------------------
 1163 /**
 1164  * Set the position Delta N-2 from position set in le_ecall_SetMsdPositionN1() transmitted by the MSD.
 1165  *
 1166  * @return
 1167  *      - LE_OK on success
 1168  *      - LE_DUPLICATE an MSD has been already imported
 1169  *      - LE_BAD_PARAMETER bad input parameter
 1170  *      - LE_FAULT on other failures
 1171  *
 1172  * @note The process exits, if an invalid eCall reference is given
 1173  */
 1174 //--------------------------------------------------------------------------------------------------
 1175 le_result_t le_ecall_SetMsdPositionN2
 1176 (
 1177     le_ecall_CallRef_t ecallRef,
 1178         ///< [IN] eCall reference
 1179     int32_t latitudeDeltaN2,
 1180         ///< [IN] longitude delta from position set in SetMsdPositionN1
 1181         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1182         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1183         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m)
 1184     int32_t longitudeDeltaN2
 1185         ///< [IN] longitude delta from position set in SetMsdPositionN1
 1186         ///< 1 Unit = 100 miliarcseconds, which is approximately 3m
 1187         ///< maximum value: 511 = 0 0'51.100'' (+-1580m)
 1188         ///< minimum value: -512 = -0 0'51.200'' (+- -1583m) )
 1189 );
 1190 
 1191 //--------------------------------------------------------------------------------------------------
 1192 /**
 1193  * Set the number of passengers transmitted by the MSD.
 1194  *
 1195  * @return
 1196  *      - LE_OK on success
 1197  *      - LE_DUPLICATE an MSD has been already imported
 1198  *      - LE_BAD_PARAMETER bad eCall reference
 1199  *
 1200  * @note The process exits, if an invalid eCall reference is given
 1201  */
 1202 //--------------------------------------------------------------------------------------------------
 1203 le_result_t le_ecall_SetMsdPassengersCount
 1204 (
 1205     le_ecall_CallRef_t ecallRef,
 1206         ///< [IN] eCall reference
 1207     uint32_t paxCount
 1208         ///< [IN] number of passengers
 1209 );
 1210 
 1211 //--------------------------------------------------------------------------------------------------
 1212 /**
 1213  * Set the ECALL_DIAL_DURATION time. It's the maximum time the IVS have to connect the emergency
 1214  * call to the PSAP, including all redial attempts.
 1215  * If the call is not connected within this time (or ManualDialAttempts/AutoDialAttempts dial
 1216  * attempts), it will stop.
 1217  *
 1218  * @return
 1219  *  - LE_OK on success
 1220  *  - LE_FAULT on failure
 1221  *
 1222  * @note This ECALL_DIAL_DURATION time is only applicable to initial call (call never established
 1223  *       with PSAP). After first call establishment, in case of dropped call, redial duration is
 1224  *       fixed by PAN-European eCall standard to 2 minutes.
 1225  */
 1226 //--------------------------------------------------------------------------------------------------
 1227 le_result_t le_ecall_SetPanInitialDialDuration
 1228 (
 1229     uint16_t duration
 1230         ///< [IN] the ECALL_DIAL_DURATION time value (in seconds)
 1231 );
 1232 
 1233 //--------------------------------------------------------------------------------------------------
 1234 /**
 1235  * Get the ECALL_DIAL_DURATION time.
 1236  *
 1237  * @return
 1238  *  - LE_OK on success
 1239  *  - LE_FAULT on failure
 1240  */
 1241 //--------------------------------------------------------------------------------------------------
 1242 le_result_t le_ecall_GetPanInitialDialDuration
 1243 (
 1244     uint16_t* durationPtr
 1245         ///< [OUT] the ECALL_DIAL_DURATION time value (in seconds)
 1246 );
 1247 
 1248 //--------------------------------------------------------------------------------------------------
 1249 /**
 1250  * Import an already prepared MSD.
 1251  *
 1252  * MSD is transmitted only after an emergency call has been established.
 1253  *
 1254  * @return
 1255  *      - LE_OK on success
 1256  *      - LE_OVERFLOW The imported MSD length exceeds the MSD_MAX_LEN maximum length.
 1257  *      - LE_BAD_PARAMETER bad eCall reference
 1258  *      - LE_FAULT for other failures
 1259  *
 1260  * @note On failure, the process exits; you don't have to worry about checking the returned
 1261  *       reference for validity.
 1262  */
 1263 //--------------------------------------------------------------------------------------------------
 1264 le_result_t le_ecall_ImportMsd
 1265 (
 1266     le_ecall_CallRef_t ecallRef,
 1267         ///< [IN] eCall reference
 1268     const uint8_t* msdPtr,
 1269         ///< [IN] the prepared MSD
 1270     size_t msdSize
 1271         ///< [IN]
 1272 );
 1273 
 1274 //--------------------------------------------------------------------------------------------------
 1275 /**
 1276  * Export the encoded MSD.
 1277  *
 1278  * @return
 1279  *  - LE_OK on success
 1280  *  - LE_OVERFLOW  The encoded MSD length exceeds the user's buffer length.
 1281  *  - LE_NOT_FOUND  No encoded MSD is available.
 1282  *  - LE_BAD_PARAMETER bad eCall reference.
 1283  *  - LE_FAULT for other failures.
 1284  *
 1285  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1286  *       function will not return.
 1287  */
 1288 //--------------------------------------------------------------------------------------------------
 1289 le_result_t le_ecall_ExportMsd
 1290 (
 1291     le_ecall_CallRef_t ecallRef,
 1292         ///< [IN] eCall reference
 1293     uint8_t* msdPtr,
 1294         ///< [OUT] the encoded MSD
 1295     size_t* msdSizePtr
 1296         ///< [INOUT]
 1297 );
 1298 
 1299 //--------------------------------------------------------------------------------------------------
 1300 /**
 1301  * Send the MSD.
 1302  *
 1303  * @return
 1304  *      - LE_OK on success
 1305  *      - LE_BAD_PARAMETER bad eCall reference
 1306  *      - LE_FAULT for other failures
 1307  *      - LE_UNSUPPORTED Not supported on this platform
 1308  *
 1309  * @note On failure, the process exits, so you don't have to worry about checking the returned
 1310  *       reference for validity.
 1311  */
 1312 //--------------------------------------------------------------------------------------------------
 1313 le_result_t le_ecall_SendMsd
 1314 (
 1315     le_ecall_CallRef_t ecallRef
 1316         ///< [IN] eCall reference
 1317 );
 1318 
 1319 //--------------------------------------------------------------------------------------------------
 1320 /**
 1321  * Start an automatic eCall session
 1322  *
 1323  * @return
 1324  *      - LE_OK on success
 1325  *      - LE_BUSY an eCall session is already in progress
 1326  *      - LE_BAD_PARAMETER bad eCall reference
 1327  *      - LE_FAULT for other failures
 1328  *      - LE_UNSUPPORTED Not supported on this platform
 1329  *
 1330  * @note The process exits, if an invalid eCall reference is given
 1331  */
 1332 //--------------------------------------------------------------------------------------------------
 1333 le_result_t le_ecall_StartAutomatic
 1334 (
 1335     le_ecall_CallRef_t ecallRef
 1336         ///< [IN] eCall reference
 1337 );
 1338 
 1339 //--------------------------------------------------------------------------------------------------
 1340 /**
 1341  * Start a manual eCall session
 1342  *
 1343  * @return
 1344  *      - LE_OK on success
 1345  *      - LE_BUSY an eCall session is already in progress
 1346  *      - LE_BAD_PARAMETER bad eCall reference
 1347  *      - LE_FAULT for other failures
 1348  *      - LE_UNSUPPORTED Not supported on this platform
 1349  *
 1350  * @note The process exits, if an invalid eCall reference is given
 1351  */
 1352 //--------------------------------------------------------------------------------------------------
 1353 le_result_t le_ecall_StartManual
 1354 (
 1355     le_ecall_CallRef_t ecallRef
 1356         ///< [IN] eCall reference
 1357 );
 1358 
 1359 //--------------------------------------------------------------------------------------------------
 1360 /**
 1361  * Start a test eCall  session
 1362  *
 1363  * @return
 1364  *      - LE_OK on success
 1365  *      - LE_BUSY an eCall session is already in progress
 1366  *      - LE_BAD_PARAMETER bad eCall reference
 1367  *      - LE_FAULT for other failures
 1368  *      - LE_UNSUPPORTED Not supported on this platform
 1369  *
 1370  * @note The process exits, if an invalid eCall reference is given
 1371  */
 1372 //--------------------------------------------------------------------------------------------------
 1373 le_result_t le_ecall_StartTest
 1374 (
 1375     le_ecall_CallRef_t ecallRef
 1376         ///< [IN] eCall reference
 1377 );
 1378 
 1379 //--------------------------------------------------------------------------------------------------
 1380 /**
 1381  * End the current eCall session
 1382  *
 1383  * @note
 1384  * - During an automatic eCall session, it is not possible to end the ongoing session until
 1385  *   LE_ECALL_STATE_STOPPED event is notified.
 1386  * - For manual session, it is possible to end the ongoing session if the eCall is not connected
 1387  *   (LE_ECALL_STATE_CONNECTED not yet received) and after LE_ECALL_STATE_STOPPED event is notified.
 1388  * - Using this API doesn't affect the NAD deregistration mechanism. However, it disables the call
 1389  *   auto answer function if already running.
 1390  *
 1391  * @return
 1392  *      - LE_OK on success
 1393  *      - LE_BAD_PARAMETER bad eCall reference
 1394  *      - LE_FAULT for other failures
 1395  *      - LE_UNSUPPORTED Not supported on this platform
 1396  */
 1397 //--------------------------------------------------------------------------------------------------
 1398 le_result_t le_ecall_End
 1399 (
 1400     le_ecall_CallRef_t ecallRef
 1401         ///< [IN] eCall reference
 1402 );
 1403 
 1404 //--------------------------------------------------------------------------------------------------
 1405 /**
 1406  * Get the current state for the given eCall
 1407  *
 1408  * @return
 1409  *      - The current state for the given eCall
 1410  *
 1411  * @note The process exits, if an invalid eCall reference is given
 1412  */
 1413 //--------------------------------------------------------------------------------------------------
 1414 le_ecall_State_t le_ecall_GetState
 1415 (
 1416     le_ecall_CallRef_t ecallRef
 1417         ///< [IN] eCall reference
 1418 );
 1419 
 1420 //--------------------------------------------------------------------------------------------------
 1421 /**
 1422  * Set the Public Safely Answering Point telephone number.
 1423  *
 1424  * @note That PSAP number is not applied to Manually or Automatically initiated eCall. For those
 1425  *       modes, an emergency call is launched.
 1426  *
 1427  * @warning This function doesn't modify the U/SIM content.
 1428  *
 1429  * @return
 1430  *  - LE_OK           On success
 1431  *  - LE_FAULT        For other failures
 1432  *  - LE_UNSUPPORTED  Not supported on this platform
 1433  *
 1434  * @note If PSAP number is empty or too long (max LE_MDMDEFS_PHONE_NUM_MAX_LEN digits), it is a
 1435  *       fatal error, the function will not return.
 1436  */
 1437 //--------------------------------------------------------------------------------------------------
 1438 le_result_t le_ecall_SetPsapNumber
 1439 (
 1440     const char* LE_NONNULL psap
 1441         ///< [IN] Public Safely Answering Point number
 1442 );
 1443 
 1444 //--------------------------------------------------------------------------------------------------
 1445 /**
 1446  * Get the Public Safely Answering Point telephone number set with le_ecall_SetPsapNumber()
 1447  * function.
 1448  *
 1449  * @note That PSAP number is not applied to Manually or Automatically initiated eCall. For those
 1450  *       modes, an emergency call is launched.
 1451  *
 1452  * @warning This function doesn't read the U/SIM content.
 1453  *
 1454  * @return
 1455  *  - LE_OK           On success
 1456  *  - LE_FAULT        On failures or if le_ecall_SetPsapNumber() has never been called before
 1457  *  * - LE_OVERFLOW     Retrieved PSAP number is too long for the out parameter
 1458  *  - LE_UNSUPPORTED  Not supported on this platform
 1459  *
 1460  * @note If the passed PSAP pointer is NULL, a fatal error is raised and the function will not
 1461  *       return.
 1462  */
 1463 //--------------------------------------------------------------------------------------------------
 1464 le_result_t le_ecall_GetPsapNumber
 1465 (
 1466     char* psap,
 1467         ///< [OUT] Public Safely Answering Point telephone
 1468         ///< number
 1469     size_t psapSize
 1470         ///< [IN]
 1471 );
 1472 
 1473 //--------------------------------------------------------------------------------------------------
 1474 /**
 1475  * When modem is in ECALL_FORCED_PERSISTENT_ONLY_MODE or ECALL_ONLY_MODE, this function
 1476  * can be called to request the modem to read the number to dial from the FDN/SDN of the U/SIM.
 1477  *
 1478  * @note If FDN directory is updated with new dial numbers, be sure that the SIM card is refreshed.
 1479  *
 1480  * @return
 1481  *  - LE_OK on success
 1482  *  - LE_FAULT for other failures
 1483  */
 1484 //--------------------------------------------------------------------------------------------------
 1485 le_result_t le_ecall_UseUSimNumbers
 1486 (
 1487     void
 1488 );
 1489 
 1490 //--------------------------------------------------------------------------------------------------
 1491 /**
 1492  * Set the NAD (network access device) deregistration time value. After termination of an emergency
 1493  * call the in-vehicle system remains registered on the network for the period of time, defined by
 1494  * the installation parameter NAD (network access device) deregistration time.
 1495  *
 1496  * @return
 1497  *  - LE_OK on success
 1498  *  - LE_FAULT on failure
 1499  *
 1500  * @note The formula to calculate NAD deregistration time for PAN_EUROPEAN is as below:
 1501  *       ECallConfiguration.nad_deregistration_time = (deregTime+59)/60;
 1502  */
 1503 //--------------------------------------------------------------------------------------------------
 1504 le_result_t le_ecall_SetNadDeregistrationTime
 1505 (
 1506     uint16_t deregTime
 1507         ///< [IN] the NAD (network access device) deregistration time value (in minutes).
 1508 );
 1509 
 1510 //--------------------------------------------------------------------------------------------------
 1511 /**
 1512  * Get the NAD (network access device) deregistration time value.
 1513  *
 1514  * @return
 1515  *  - LE_OK on success
 1516  *  - LE_FAULT on failure
 1517  */
 1518 //--------------------------------------------------------------------------------------------------
 1519 le_result_t le_ecall_GetNadDeregistrationTime
 1520 (
 1521     uint16_t* deregTimePtr
 1522         ///< [OUT] the NAD (network access device) deregistration time value
 1523 );
 1524 
 1525 //--------------------------------------------------------------------------------------------------
 1526 /**
 1527  * Set the minimum interval value between dial attempts.
 1528  *
 1529  * @return
 1530  *  - LE_OK on success
 1531  *  - LE_FAULT for other failures
 1532  */
 1533 //--------------------------------------------------------------------------------------------------
 1534 le_result_t le_ecall_SetIntervalBetweenDialAttempts
 1535 (
 1536     uint16_t pause
 1537         ///< [IN] the minimum interval value in seconds
 1538 );
 1539 
 1540 //--------------------------------------------------------------------------------------------------
 1541 /**
 1542  * Get the minimum interval value between dial attempts.
 1543  *
 1544  * @return
 1545  *  - LE_OK on success
 1546  *  - LE_FAULT for other failures
 1547  */
 1548 //--------------------------------------------------------------------------------------------------
 1549 le_result_t le_ecall_GetIntervalBetweenDialAttempts
 1550 (
 1551     uint16_t* pausePtr
 1552         ///< [OUT] the minimum interval value in seconds
 1553 );
 1554 
 1555 //--------------------------------------------------------------------------------------------------
 1556 /**
 1557  * Set the ECALL_MANUAL_DIAL_ATTEMPTS value. If a dial attempt under manual emergency call
 1558  * initiation failed, it should be repeated maximally ECALL_MANUAL_DIAL_ATTEMPTS-1 times within
 1559  * the maximal time limit of ECALL_DIAL_DURATION. The default value is 10.
 1560  * Redial attempts stop once the call has been cleared down correctly, or if counter/timer reached
 1561  * their limits.
 1562  *
 1563  * @return
 1564  *  - LE_OK on success
 1565  *  - LE_FAULT on failure
 1566  */
 1567 //--------------------------------------------------------------------------------------------------
 1568 le_result_t le_ecall_SetEraGlonassManualDialAttempts
 1569 (
 1570     uint16_t attempts
 1571         ///< [IN] the ECALL_MANUAL_DIAL_ATTEMPTS value
 1572 );
 1573 
 1574 //--------------------------------------------------------------------------------------------------
 1575 /**
 1576  * Set the ECALL_AUTO_DIAL_ATTEMPTS value. If a dial attempt under automatic emergency call
 1577  * initiation failed, it should be repeated maximally ECALL_AUTO_DIAL_ATTEMPTS-1 times within
 1578  * the maximal time limit of ECALL_DIAL_DURATION. The default value is 10.
 1579  * Redial attempts stop once the call has been cleared down correctly, or if counter/timer reached
 1580  * their limits.
 1581  *
 1582  * @return
 1583  *  - LE_OK on success
 1584  *  - LE_FAULT on failure
 1585  */
 1586 //--------------------------------------------------------------------------------------------------
 1587 le_result_t le_ecall_SetEraGlonassAutoDialAttempts
 1588 (
 1589     uint16_t attempts
 1590         ///< [IN] the ECALL_AUTO_DIAL_ATTEMPTS value
 1591 );
 1592 
 1593 //--------------------------------------------------------------------------------------------------
 1594 /**
 1595  * Set the ECALL_DIAL_DURATION time. It's the maximum time the IVS have to connect the emergency
 1596  * call to the PSAP, including all redial attempts.
 1597  * If the call is not connected within this time (or ManualDialAttempts/AutoDialAttempts dial
 1598  * attempts), it will stop.
 1599  *
 1600  * @return
 1601  *  - LE_OK on success
 1602  *  - LE_FAULT on failure
 1603  *  - LE_UNSUPPORTED if the function is not supported by the target
 1604  */
 1605 //--------------------------------------------------------------------------------------------------
 1606 le_result_t le_ecall_SetEraGlonassDialDuration
 1607 (
 1608     uint16_t duration
 1609         ///< [IN] the ECALL_DIAL_DURATION time value (in seconds)
 1610 );
 1611 
 1612 //--------------------------------------------------------------------------------------------------
 1613 /**
 1614  * Set the ECALL_CCFT time. It's the maximum delay before initiating an an automatic call
 1615  * termination.
 1616  * When the delay is reached and IVS NAD didn't receive a call clear-down indication then the call
 1617  * is immediatly terminated.
 1618  *
 1619  * @note Allowed range of values is 1 to 720 minutes.
 1620  *
 1621  * @return
 1622  *  - LE_OK on success
 1623  *  - LE_FAULT on failure
 1624  *  - LE_UNSUPPORTED if the function is not supported by the target
 1625  */
 1626 //--------------------------------------------------------------------------------------------------
 1627 le_result_t le_ecall_SetEraGlonassFallbackTime
 1628 (
 1629     uint16_t duration
 1630         ///< [IN] the ECALL_CCFT time value (in minutes)
 1631 );
 1632 
 1633 //--------------------------------------------------------------------------------------------------
 1634 /**
 1635  * Set the ECALL_AUTO_ANSWER_TIME time, the time interval wherein IVDS responds to incoming calls
 1636  * automatically after emergency call completion.
 1637  *
 1638  * @note Default value of auto answer time is 20 minutes. Maximum value is 720 minutes.
 1639  *
 1640  * @return
 1641  *  - LE_OK on success
 1642  *  - LE_FAULT on failure
 1643  *  - LE_UNSUPPORTED if the function is not supported by the target
 1644  */
 1645 //--------------------------------------------------------------------------------------------------
 1646 le_result_t le_ecall_SetEraGlonassAutoAnswerTime
 1647 (
 1648     uint16_t autoAnswerTime
 1649         ///< [IN] The ECALL_AUTO_ANSWER_TIME time value (in minutes)
 1650 );
 1651 
 1652 //--------------------------------------------------------------------------------------------------
 1653 /**
 1654  * Set the ECALL_MSD_MAX_TRANSMISSION_TIME time, the time period for MSD transmission.
 1655  *
 1656  * @note Default value of MSD transmission time is 20 seconds.
 1657  *
 1658  * @return
 1659  *  - LE_OK on success
 1660  *  - LE_FAULT on failure
 1661  *  - LE_UNSUPPORTED if the function is not supported by the target
 1662  */
 1663 //--------------------------------------------------------------------------------------------------
 1664 le_result_t le_ecall_SetEraGlonassMSDMaxTransmissionTime
 1665 (
 1666     uint16_t msdMaxTransTime
 1667         ///< [IN] The ECALL_MSD_MAX_TRANSMISSION_TIME time value (in seconds)
 1668 );
 1669 
 1670 //--------------------------------------------------------------------------------------------------
 1671 /**
 1672  * Set the ERA-GLONASS ECALL_POST_TEST_REGISTRATION_TIME time.
 1673  *
 1674  * After completion of transmission of test diagnostics results in an eCall test session, the
 1675  * in-vehicle system remains registered on the network for the period of time defined by the
 1676  * ECALL_POST_TEST_REGISTRATION_TIME value.
 1677  *
 1678  * @note The ECALL_POST_TEST_REGISTRATION_TIME setting takes effect immediately and is persistent to
 1679  * reset.
 1680  *
 1681  * @note An ECALL_POST_TEST_REGISTRATION_TIME value of zero means the IVS doesn't remain registered
 1682  * after completion of transmission of test (diagnostics) results.
 1683  *
 1684  * @return
 1685  *  - LE_OK on success
 1686  *  - LE_FAULT on failure
 1687  *  - LE_UNSUPPORTED if the function is not supported by the target
 1688  */
 1689 //--------------------------------------------------------------------------------------------------
 1690 le_result_t le_ecall_SetEraGlonassPostTestRegistrationTime
 1691 (
 1692     uint16_t postTestRegTime
 1693         ///< [IN] The ECALL_POST_TEST_REGISTRATION_TIME time value (in seconds)
 1694 );
 1695 
 1696 //--------------------------------------------------------------------------------------------------
 1697 /**
 1698  * Get the ECALL_MANUAL_DIAL_ATTEMPTS value.
 1699  *
 1700  * @return
 1701  *  - LE_OK on success
 1702  *  - LE_FAULT on failure
 1703  */
 1704 //--------------------------------------------------------------------------------------------------
 1705 le_result_t le_ecall_GetEraGlonassManualDialAttempts
 1706 (
 1707     uint16_t* attemptsPtr
 1708         ///< [OUT] the ECALL_MANUAL_DIAL_ATTEMPTS value
 1709 );
 1710 
 1711 //--------------------------------------------------------------------------------------------------
 1712 /**
 1713  * Get the ECALL_AUTO_DIAL_ATTEMPTS value.
 1714  *
 1715  * @return
 1716  *  - LE_OK on success
 1717  *  - LE_FAULT on failure
 1718  */
 1719 //--------------------------------------------------------------------------------------------------
 1720 le_result_t le_ecall_GetEraGlonassAutoDialAttempts
 1721 (
 1722     uint16_t* attemptsPtr
 1723         ///< [OUT] the ECALL_AUTO_DIAL_ATTEMPTS value
 1724 );
 1725 
 1726 //--------------------------------------------------------------------------------------------------
 1727 /**
 1728  * Get the ECALL_DIAL_DURATION time.
 1729  *
 1730  * @return
 1731  *  - LE_OK on success
 1732  *  - LE_FAULT on failure
 1733  */
 1734 //--------------------------------------------------------------------------------------------------
 1735 le_result_t le_ecall_GetEraGlonassDialDuration
 1736 (
 1737     uint16_t* durationPtr
 1738         ///< [OUT] the ECALL_DIAL_DURATION time value (in seconds)
 1739 );
 1740 
 1741 //--------------------------------------------------------------------------------------------------
 1742 /**
 1743  * Get the ECALL_CCFT time.
 1744  *
 1745  * @return
 1746  *  - LE_OK on success
 1747  *  - LE_FAULT on failure
 1748  */
 1749 //--------------------------------------------------------------------------------------------------
 1750 le_result_t le_ecall_GetEraGlonassFallbackTime
 1751 (
 1752     uint16_t* durationPtr
 1753         ///< [OUT] the ECALL_CCFT time value (in minutes)
 1754 );
 1755 
 1756 //--------------------------------------------------------------------------------------------------
 1757 /**
 1758  * Get the ECALL_AUTO_ANSWER_TIME time.
 1759  *
 1760  * @return
 1761  *  - LE_OK on success
 1762  *  - LE_FAULT on execution failure
 1763  */
 1764 //--------------------------------------------------------------------------------------------------
 1765 le_result_t le_ecall_GetEraGlonassAutoAnswerTime
 1766 (
 1767     uint16_t* autoAnswerTimePtr
 1768         ///< [OUT] The ECALL_AUTO_ANSWER_TIME time value (in minutes)
 1769 );
 1770 
 1771 //--------------------------------------------------------------------------------------------------
 1772 /**
 1773  * Get the ECALL_MSD_MAX_TRANSMISSION_TIME time.
 1774  *
 1775  * @return
 1776  *  - LE_OK on success
 1777  *  - LE_FAULT on failure
 1778  *  - LE_UNSUPPORTED if the function is not supported by the target
 1779  */
 1780 //--------------------------------------------------------------------------------------------------
 1781 le_result_t le_ecall_GetEraGlonassMSDMaxTransmissionTime
 1782 (
 1783     uint16_t* msdMaxTransTimePtr
 1784         ///< [OUT] The ECALL_MSD_MAX_TRANSMISSION_TIME time value (in seconds)
 1785 );
 1786 
 1787 //--------------------------------------------------------------------------------------------------
 1788 /**
 1789  * Get the ERA-GLONASS ECALL_POST_TEST_REGISTRATION_TIME time.
 1790  *
 1791  * @return
 1792  *  - LE_OK on success
 1793  *  - LE_FAULT on failure
 1794  *  - LE_UNSUPPORTED if the function is not supported by the target
 1795  */
 1796 //--------------------------------------------------------------------------------------------------
 1797 le_result_t le_ecall_GetEraGlonassPostTestRegistrationTime
 1798 (
 1799     uint16_t* postTestRegTimePtr
 1800         ///< [OUT] The ECALL_POST_TEST_REGISTRATION_TIME time value (in
 1801         ///< seconds).
 1802 );
 1803 
 1804 //--------------------------------------------------------------------------------------------------
 1805 /**
 1806  * Set the ERA-GLONASS crash severity parameter.
 1807  *
 1808  * @return
 1809  *  - LE_OK on success
 1810  *  - LE_DUPLICATE an MSD has been already imported
 1811  *  - LE_BAD_PARAMETER bad eCall reference
 1812  *  - LE_FAULT on other failures
 1813  */
 1814 //--------------------------------------------------------------------------------------------------
 1815 le_result_t le_ecall_SetMsdEraGlonassCrashSeverity
 1816 (
 1817     le_ecall_CallRef_t ecallRef,
 1818         ///< [IN] eCall reference
 1819     uint32_t crashSeverity
 1820         ///< [IN] the ERA-GLONASS crash severity parameter
 1821 );
 1822 
 1823 //--------------------------------------------------------------------------------------------------
 1824 /**
 1825  * Reset the ERA-GLONASS crash severity parameter. Therefore that optional parameter is not included
 1826  * in the MSD message.
 1827  *
 1828  * @return
 1829  *  - LE_OK on success
 1830  *  - LE_DUPLICATE an MSD has been already imported
 1831  *  - LE_BAD_PARAMETER bad eCall reference
 1832  *  - LE_FAULT on other failures
 1833  */
 1834 //--------------------------------------------------------------------------------------------------
 1835 le_result_t le_ecall_ResetMsdEraGlonassCrashSeverity
 1836 (
 1837     le_ecall_CallRef_t ecallRef
 1838         ///< [IN] eCall reference
 1839 );
 1840 
 1841 //--------------------------------------------------------------------------------------------------
 1842 /**
 1843  * Set the ERA-GLONASS diagnostic result using a bit mask.
 1844  *
 1845  * @return
 1846  *  - LE_OK on success
 1847  *  - LE_DUPLICATE an MSD has been already imported
 1848  *  - LE_BAD_PARAMETER bad eCall reference
 1849  *  - LE_FAULT on other failures
 1850  */
 1851 //--------------------------------------------------------------------------------------------------
 1852 le_result_t le_ecall_SetMsdEraGlonassDiagnosticResult
 1853 (
 1854     le_ecall_CallRef_t ecallRef,
 1855         ///< [IN] eCall reference
 1856     le_ecall_DiagnosticResultBitMask_t diagnosticResultMask
 1857         ///< [IN] ERA-GLONASS diagnostic result bit mask.
 1858 );
 1859 
 1860 //--------------------------------------------------------------------------------------------------
 1861 /**
 1862  * Reset the ERA-GLONASS diagnostic result bit mask. Optional parameter is not
 1863  * included in the MSD message.
 1864  *
 1865  * @return
 1866  *  - LE_OK on success
 1867  *  - LE_DUPLICATE an MSD has been already imported
 1868  *  - LE_BAD_PARAMETER bad eCall reference
 1869  *  - LE_FAULT on other failures
 1870  */
 1871 //--------------------------------------------------------------------------------------------------
 1872 le_result_t le_ecall_ResetMsdEraGlonassDiagnosticResult
 1873 (
 1874     le_ecall_CallRef_t ecallRef
 1875         ///< [IN] eCall reference
 1876 );
 1877 
 1878 //--------------------------------------------------------------------------------------------------
 1879 /**
 1880  * Set the ERA-GLONASS crash type bit mask
 1881  *
 1882  * @return
 1883  *  - LE_OK on success
 1884  *  - LE_DUPLICATE an MSD has been already imported
 1885  *  - LE_BAD_PARAMETER bad eCall reference
 1886  *  - LE_FAULT on other failures
 1887  */
 1888 //--------------------------------------------------------------------------------------------------
 1889 le_result_t le_ecall_SetMsdEraGlonassCrashInfo
 1890 (
 1891     le_ecall_CallRef_t ecallRef,
 1892         ///< [IN] eCall reference
 1893     le_ecall_CrashInfoBitMask_t crashInfoMask
 1894         ///< [IN] ERA-GLONASS crash type bit mask.
 1895 );
 1896 
 1897 //--------------------------------------------------------------------------------------------------
 1898 /**
 1899  * Reset the ERA-GLONASS crash type bit mask. Optional parameter is not included
 1900  * in the MSD message.
 1901  *
 1902  * @return
 1903  *  - LE_OK on success
 1904  *  - LE_DUPLICATE an MSD has been already imported
 1905  *  - LE_BAD_PARAMETER bad eCall reference
 1906  *  - LE_FAULT on other failures
 1907  */
 1908 //--------------------------------------------------------------------------------------------------
 1909 le_result_t le_ecall_ResetMsdEraGlonassCrashInfo
 1910 (
 1911     le_ecall_CallRef_t ecallRef
 1912         ///< [IN] eCall reference
 1913 );
 1914 
 1915 //--------------------------------------------------------------------------------------------------
 1916 /**
 1917  * Set the ERA-GLONASS coordinate system type.
 1918  *
 1919  * @return
 1920  *  - LE_OK on success
 1921  *  - LE_DUPLICATE an MSD has been already imported
 1922  *  - LE_BAD_PARAMETER bad eCall reference
 1923  *  - LE_FAULT on other failures
 1924  */
 1925 //--------------------------------------------------------------------------------------------------
 1926 le_result_t le_ecall_SetMsdEraGlonassCoordinateSystemType
 1927 (
 1928     le_ecall_CallRef_t ecallRef,
 1929         ///< [IN] eCall reference
 1930     le_ecall_MsdCoordinateType_t coordinateSystemType
 1931         ///< [IN] the ERA-GLONASS coordinate system type
 1932 );
 1933 
 1934 //--------------------------------------------------------------------------------------------------
 1935 /**
 1936  * Reset the ERA-GLONASS coordinate system type. Therefore that optional parameter is not included
 1937  * in the MSD message.
 1938  *
 1939  * @return
 1940  *  - LE_OK on success
 1941  *  - LE_DUPLICATE an MSD has been already imported
 1942  *  - LE_BAD_PARAMETER bad eCall reference
 1943  *  - LE_FAULT on other failures
 1944  */
 1945 //--------------------------------------------------------------------------------------------------
 1946 le_result_t le_ecall_ResetMsdEraGlonassCoordinateSystemType
 1947 (
 1948     le_ecall_CallRef_t ecallRef
 1949         ///< [IN] eCall reference
 1950 );
 1951 
 1952 //--------------------------------------------------------------------------------------------------
 1953 /**
 1954  * Called to get the termination reason.
 1955  *
 1956  * @return The termination reason.
 1957  *
 1958  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1959  *       function will not return.
 1960  */
 1961 //--------------------------------------------------------------------------------------------------
 1962 le_mcc_TerminationReason_t le_ecall_GetTerminationReason
 1963 (
 1964     le_ecall_CallRef_t ecallRef
 1965         ///< [IN] eCall reference.
 1966 );
 1967 
 1968 //--------------------------------------------------------------------------------------------------
 1969 /**
 1970  * Called to get the platform specific termination code.
 1971  *
 1972  * @return The platform specific termination code.
 1973  *
 1974  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1975  *       function will not return.
 1976  */
 1977 //--------------------------------------------------------------------------------------------------
 1978 int32_t le_ecall_GetPlatformSpecificTerminationCode
 1979 (
 1980     le_ecall_CallRef_t ecallRef
 1981         ///< [IN] eCall reference.
 1982 );
 1983 
 1984 //--------------------------------------------------------------------------------------------------
 1985 /**
 1986  * Terminate NAD registered on the network. After termination of an emergency call the in-vehicle
 1987  * system remains registered on the network for a period of time, this API will deregister device
 1988  * from network in this period.
 1989  *
 1990  * @return
 1991  *  - LE_OK on success
 1992  *  - LE_FAULT on failure
 1993  *  - LE_UNSUPPORTED if the function is not supported by the target
 1994  */
 1995 //--------------------------------------------------------------------------------------------------
 1996 le_result_t le_ecall_TerminateRegistration
 1997 (
 1998     void
 1999 );
 2000 
 2001 /** @} **/
 2002 
 2003 #endif // LE_ECALL_INTERFACE_H_INCLUDE_GUARD
le_ecall_State_t
le_ecall_State_t
Definition: le_ecall_common.h:100
le_ecall_TerminateRegistration
le_result_t le_ecall_TerminateRegistration(void)
le_ecall_SetMsdPositionN2
le_result_t le_ecall_SetMsdPositionN2(le_ecall_CallRef_t ecallRef, int32_t latitudeDeltaN2, int32_t longitudeDeltaN2)
le_mdmDefs_interface.h
le_ecall_ExportMsd
le_result_t le_ecall_ExportMsd(le_ecall_CallRef_t ecallRef, uint8_t *msdPtr, size_t *msdSizePtr)
le_ecall_GetPlatformSpecificTerminationCode
int32_t le_ecall_GetPlatformSpecificTerminationCode(le_ecall_CallRef_t ecallRef)
le_ecall_SetMsdVersion
le_result_t le_ecall_SetMsdVersion(uint32_t msdVersion)
le_ecall_GetTerminationReason
le_mcc_TerminationReason_t le_ecall_GetTerminationReason(le_ecall_CallRef_t ecallRef)
le_ecall_ImportMsd
le_result_t le_ecall_ImportMsd(le_ecall_CallRef_t ecallRef, const uint8_t *msdPtr, size_t msdSize)
le_ecall_SetVehicleType
le_result_t le_ecall_SetVehicleType(le_ecall_MsdVehicleType_t vehicleType)
le_ecall_GetNadDeregistrationTime
le_result_t le_ecall_GetNadDeregistrationTime(uint16_t *deregTimePtr)
le_ecall_SetPropulsionType
le_result_t le_ecall_SetPropulsionType(le_ecall_PropulsionTypeBitMask_t propulsionType)
le_ecall_GetEraGlonassManualDialAttempts
le_result_t le_ecall_GetEraGlonassManualDialAttempts(uint16_t *attemptsPtr)
le_ecall_SetEraGlonassMSDMaxTransmissionTime
le_result_t le_ecall_SetEraGlonassMSDMaxTransmissionTime(uint16_t msdMaxTransTime)
le_ecall_GetMsdVersion
le_result_t le_ecall_GetMsdVersion(uint32_t *msdVersionPtr)
le_result_t
le_result_t
Definition: le_basics.h:46
le_ecall_SetEraGlonassDialDuration
le_result_t le_ecall_SetEraGlonassDialDuration(uint16_t duration)
le_ecall_SetEraGlonassManualDialAttempts
le_result_t le_ecall_SetEraGlonassManualDialAttempts(uint16_t attempts)
le_ecall_CallRef_t
struct le_ecall_Call * le_ecall_CallRef_t
Definition: le_ecall_common.h:59
le_ecall_GetEraGlonassMSDMaxTransmissionTime
le_result_t le_ecall_GetEraGlonassMSDMaxTransmissionTime(uint16_t *msdMaxTransTimePtr)
le_ecall_SetMsdPositionN1
le_result_t le_ecall_SetMsdPositionN1(le_ecall_CallRef_t ecallRef, int32_t latitudeDeltaN1, int32_t longitudeDeltaN1)
le_ecall_SetMsdPosition
le_result_t le_ecall_SetMsdPosition(le_ecall_CallRef_t ecallRef, bool isTrusted, int32_t latitude, int32_t longitude, int32_t direction)
le_ecall_SetEraGlonassFallbackTime
le_result_t le_ecall_SetEraGlonassFallbackTime(uint16_t duration)
le_ecall_GetEraGlonassFallbackTime
le_result_t le_ecall_GetEraGlonassFallbackTime(uint16_t *durationPtr)
le_ecall_MsdCoordinateType_t
le_ecall_MsdCoordinateType_t
Definition: le_ecall_common.h:307
le_ecall_Create
le_ecall_CallRef_t le_ecall_Create(void)
le_ecall_SetMsdTxMode
le_result_t le_ecall_SetMsdTxMode(le_ecall_MsdTxMode_t mode)
le_ecall_SetEraGlonassPostTestRegistrationTime
le_result_t le_ecall_SetEraGlonassPostTestRegistrationTime(uint16_t postTestRegTime)
le_ecall_DisconnectService
void le_ecall_DisconnectService(void)
le_ecall_SetMsdEraGlonassCrashInfo
le_result_t le_ecall_SetMsdEraGlonassCrashInfo(le_ecall_CallRef_t ecallRef, le_ecall_CrashInfoBitMask_t crashInfoMask)
le_ecall_SetEraGlonassAutoDialAttempts
le_result_t le_ecall_SetEraGlonassAutoDialAttempts(uint16_t attempts)
le_ecall_GetPropulsionType
le_result_t le_ecall_GetPropulsionType(le_ecall_PropulsionTypeBitMask_t *propulsionTypePtr)
le_ecall_ResetMsdEraGlonassCrashInfo
le_result_t le_ecall_ResetMsdEraGlonassCrashInfo(le_ecall_CallRef_t ecallRef)
le_ecall_TryConnectService
le_result_t le_ecall_TryConnectService(void)
le_ecall_MsdVehicleType_t
le_ecall_MsdVehicleType_t
Definition: le_ecall_common.h:179
le_ecall_ExitOnlyMode
le_result_t le_ecall_ExitOnlyMode(void)
le_mcc_interface.h
le_ecall_ForcePersistentOnlyMode
le_result_t le_ecall_ForcePersistentOnlyMode(void)
le_ecall_ResetMsdEraGlonassDiagnosticResult
le_result_t le_ecall_ResetMsdEraGlonassDiagnosticResult(le_ecall_CallRef_t ecallRef)
le_ecall_ResetMsdEraGlonassCrashSeverity
le_result_t le_ecall_ResetMsdEraGlonassCrashSeverity(le_ecall_CallRef_t ecallRef)
le_ecall_StartManual
le_result_t le_ecall_StartManual(le_ecall_CallRef_t ecallRef)
le_ecall_SetMsdEraGlonassCrashSeverity
le_result_t le_ecall_SetMsdEraGlonassCrashSeverity(le_ecall_CallRef_t ecallRef, uint32_t crashSeverity)
le_ecall_GetEraGlonassPostTestRegistrationTime
le_result_t le_ecall_GetEraGlonassPostTestRegistrationTime(uint16_t *postTestRegTimePtr)
le_ecall_MsdTxMode_t
le_ecall_MsdTxMode_t
Definition: le_ecall_common.h:164
le_ecall_RemoveStateChangeHandler
void le_ecall_RemoveStateChangeHandler(le_ecall_StateChangeHandlerRef_t handlerRef)
le_ecall_End
le_result_t le_ecall_End(le_ecall_CallRef_t ecallRef)
le_ecall_UseUSimNumbers
le_result_t le_ecall_UseUSimNumbers(void)
le_ecall_SetServerDisconnectHandler
LE_FULL_API void le_ecall_SetServerDisconnectHandler(le_ecall_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_ecall_Delete
void le_ecall_Delete(le_ecall_CallRef_t ecallRef)
le_ecall_SetSystemStandard
le_result_t le_ecall_SetSystemStandard(le_ecall_SystemStandard_t systemStandard)
le_ecall_SetNadDeregistrationTime
le_result_t le_ecall_SetNadDeregistrationTime(uint16_t deregTime)
le_ecall_SystemStandard_t
le_ecall_SystemStandard_t
Definition: le_ecall_common.h:85
le_ecall_GetVIN
le_result_t le_ecall_GetVIN(char *vin, size_t vinSize)
le_ecall_SetMsdPassengersCount
le_result_t le_ecall_SetMsdPassengersCount(le_ecall_CallRef_t ecallRef, uint32_t paxCount)
le_ecall_GetConfiguredOperationMode
le_result_t le_ecall_GetConfiguredOperationMode(le_ecall_OpMode_t *opModePtr)
LE_FULL_API
#define LE_FULL_API
Definition: le_apiFeatures.h:40
le_ecall_GetIntervalBetweenDialAttempts
le_result_t le_ecall_GetIntervalBetweenDialAttempts(uint16_t *pausePtr)
le_ecall_SetPsapNumber
le_result_t le_ecall_SetPsapNumber(const char *LE_NONNULL psap)
le_mcc_TerminationReason_t
le_mcc_TerminationReason_t
Definition: le_mcc_common.h:65
legato.h
le_ecall_SetPanInitialDialDuration
le_result_t le_ecall_SetPanInitialDialDuration(uint16_t duration)
le_ecall_GetEraGlonassAutoAnswerTime
le_result_t le_ecall_GetEraGlonassAutoAnswerTime(uint16_t *autoAnswerTimePtr)
le_ecall_SetEraGlonassAutoAnswerTime
le_result_t le_ecall_SetEraGlonassAutoAnswerTime(uint16_t autoAnswerTime)
le_ecall_StateChangeHandlerRef_t
struct le_ecall_StateChangeHandler * le_ecall_StateChangeHandlerRef_t
Definition: le_ecall_common.h:324
le_ecall_OpMode_t
le_ecall_OpMode_t
Definition: le_ecall_common.h:67
le_ecall_SetMsdEraGlonassDiagnosticResult
le_result_t le_ecall_SetMsdEraGlonassDiagnosticResult(le_ecall_CallRef_t ecallRef, le_ecall_DiagnosticResultBitMask_t diagnosticResultMask)
le_ecall_GetState
le_ecall_State_t le_ecall_GetState(le_ecall_CallRef_t ecallRef)
le_ecall_AddStateChangeHandler
le_ecall_StateChangeHandlerRef_t le_ecall_AddStateChangeHandler(le_ecall_StateChangeHandlerFunc_t handlerPtr, void *contextPtr)
le_ecall_GetVehicleType
le_result_t le_ecall_GetVehicleType(le_ecall_MsdVehicleType_t *vehicleTypePtr)
le_ecall_SetVIN
le_result_t le_ecall_SetVIN(const char *LE_NONNULL vin)
le_ecall_StateChangeHandlerFunc_t
void(* le_ecall_StateChangeHandlerFunc_t)(le_ecall_CallRef_t ecallRef, le_ecall_State_t state, void *contextPtr)
Definition: le_ecall_common.h:334
le_ecall_StartAutomatic
le_result_t le_ecall_StartAutomatic(le_ecall_CallRef_t ecallRef)
le_ecall_SendMsd
le_result_t le_ecall_SendMsd(le_ecall_CallRef_t ecallRef)
le_ecall_GetEraGlonassAutoDialAttempts
le_result_t le_ecall_GetEraGlonassAutoDialAttempts(uint16_t *attemptsPtr)
le_ecall_GetSystemStandard
le_result_t le_ecall_GetSystemStandard(le_ecall_SystemStandard_t *systemStandardPtr)
le_ecall_common.h
le_ecall_ForceOnlyMode
le_result_t le_ecall_ForceOnlyMode(void)
le_ecall_StartTest
le_result_t le_ecall_StartTest(le_ecall_CallRef_t ecallRef)
le_ecall_ConnectService
void le_ecall_ConnectService(void)
le_ecall_GetPsapNumber
le_result_t le_ecall_GetPsapNumber(char *psap, size_t psapSize)
le_ecall_GetEraGlonassDialDuration
le_result_t le_ecall_GetEraGlonassDialDuration(uint16_t *durationPtr)
le_ecall_DisconnectHandler_t
void(* le_ecall_DisconnectHandler_t)(void *)
Definition: le_ecall_interface.h:605
le_ecall_GetMsdTxMode
le_result_t le_ecall_GetMsdTxMode(le_ecall_MsdTxMode_t *modePtr)
le_ecall_ResetMsdEraGlonassCoordinateSystemType
le_result_t le_ecall_ResetMsdEraGlonassCoordinateSystemType(le_ecall_CallRef_t ecallRef)
le_ecall_SetMsdEraGlonassCoordinateSystemType
le_result_t le_ecall_SetMsdEraGlonassCoordinateSystemType(le_ecall_CallRef_t ecallRef, le_ecall_MsdCoordinateType_t coordinateSystemType)
le_ecall_GetPanInitialDialDuration
le_result_t le_ecall_GetPanInitialDialDuration(uint16_t *durationPtr)
le_ecall_SetIntervalBetweenDialAttempts
le_result_t le_ecall_SetIntervalBetweenDialAttempts(uint16_t pause)