EraGlonassUveos/Src/EraGlonassUveos_EmergencyMode.c

//
// Created by xemon on 30.11.22.
//

#include "EraGlonassUveos_Private.h"
//#include "UserInput.h"
#include "AsciiStringParsingUtils.h"
#include "egtsWorker.h"
#include "Rtc.h"

#define LOGGER env->logger
#define LOG_SIGN "УВЭОС,ЭВ"
#define DEVTST_PLAY_SAMPLE(SAMPLE)  AudioPlayer_PlayStatic(env->audioPlayer, SAMPLE, 5000);

eEraGlonassUveos_EcallProcessingResult smsTransmitFl = ERA_GLONASS_UVEOS_SEND_FAIL;

static void EraGlonassUveos_UpdateMsd(tEraGlonassUveos *env, eEcallTimeSourse timeSourse) {
    EraGlonassUveosNavData nav;
    uint32_t time;

    if (timeSourse == GNSS_TIME_SOURSE) {
        NavDataProvider_GetTime(env->navDataProvider, &time);
    }
    if (timeSourse == RTC_TIME_SOURSE) {
        RtcGet(env->timings.rtcIo, (time_t *) &time);
    }
    if (timeSourse == NOT_CHANGE_TIME) {
        time = env->currentMsd->msd.MSD_Data.timestamp;
    }

    NavDataProvider_GetNavData(env->navDataProvider, &nav, true);
    EraGlonassMsdSetTimeStamp(&env->currentMsd->msd, time);

    if (nav.valid != 0) {
        EraGlonassMsdSetPositionValue(&env->currentMsd->msd, nav.longitude, nav.latitude, nav.direction, nav.valid);
    } else {
        EraGlonassMsdNoGnssSetDefaults(&env->currentMsd->msd);
    }

}

static void EraGlonassUveos_SignMsd(tEraGlonassUveos *env, eEcallActivationType type, bool test) {
    EraGlonassMsdSetDataEmergencySituationFlags(
            &env->currentMsd->msd,
            env->currentMsd->msd.MSD_Data.msgId,
            type,
            test ? TEST_CALL : EMERGENCY_CALL
    );
}

void EraGlonassUveos_CompileMsd(tEraGlonassUveos *env, tEraGlonassMsd *msd, tMsdEncoded *msdEncoded) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Собираем бинарный пакет МНД")

    msdEncoded->len = EraGlonassMsdEncode(msd, MSD_V_2, msdEncoded->data);

    char asciiMsd[msdEncoded->len * 2];
    size_t asciiMsdLen = 0;
    vAsciiStringAddBytesAsHex(asciiMsd, &asciiMsdLen, msdEncoded->data, msdEncoded->len);

    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Бинарный пакет МНД сформирован: ")
    LoggerInfo(LOGGER, LOG_SIGN, asciiMsd, asciiMsdLen)
}


eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_ProcessingSms(
        tEraGlonassUveos *env,
        tMsdEncoded *msdEncoded
) {

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отправка смс...")
    if (EraGlonassUveos_EmergencySendMsdSmsTry(env, msdEncoded)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправленно по средствам СМС")
        env->currentMsd->attemptsLeft = 0;
        SystemDelayMs(100);
        EraGlonassUveosDumper_ForceDump(env->dumper);
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_SMS_TRANSMIT);
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
        return ERA_GLONASS_UVEOS_SMS_SENT;
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось отпаравить МНД по средствам СМС")
        return ERA_GLONASS_UVEOS_SEND_FAIL;
    }
}

void reSetMsdToPull(tEraGlonassUveos *env, const bool *wasNewSetMsd, const bool *wasResent, tMsdEncoded *msdEncoded) {
    if (
            (*wasNewSetMsd == true) &&
            (*wasResent == false) &&
            (env->currentMsd->msd.MSD_Data.msgId > 1)
            ) {
        env->currentMsd->msd.MSD_Data.msgId--;

        EraGlonassUveos_UpdateMsd(env, RTC_TIME_SOURSE);
        EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
        EraGlonassEcallProvider_SettingNewMsd(env->ecallProvider, msdEncoded->data, msdEncoded->len);
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Переотправка МНД по PULL запросу от оператора НЕ была выполнена, не получен URC об отправке")
    }
}

void setMsdToPull(tEraGlonassUveos *env, const bool *mndSendFlag, bool *wasNewSetMsd, bool *wasResent,
                  tMsdEncoded *msdEncoded) {
    if (
            (*mndSendFlag == true) &&
            (*wasNewSetMsd == false)
            ) {

        env->currentMsd->msd.MSD_Data.msgId++;

        EraGlonassUveos_UpdateMsd(env, RTC_TIME_SOURSE);
        EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
        EraGlonassEcallProvider_SettingNewMsd(env->ecallProvider, msdEncoded->data, msdEncoded->len);
        *wasNewSetMsd = true;
    } else if (EraGlonassEcallProvider_IsMsdReSent(env->ecallProvider)) {
        *wasNewSetMsd = false;
        *wasResent = true;
        LoggerInfoStatic(LOGGER, LOG_SIGN,
                         "Была выполнена переотправка МНД по PULL запросу от оператора, будет установлен новый МНД")
    }
}

static eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_EmergencyCallTry(
        tEraGlonassUveos *env,
        tMsdEncoded *msdEncoded,
        eEcallActivationType activationType,
        eEcallTestMode testMode,
        uint32_t dialTimeoutEnd,
        bool *mndSendFlag,
        bool blocReg
) {

    eEraGlonassUveos_EcallProcessingResult callResult = ERA_GLONASS_UVEOS_CALL_FAIL;

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Пробуем совершить экстренный вызов")
    if(testMode != TEST_CALL) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_INITIATE);
    }

    SystemDelayMs(500);
    EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
    SystemDelayMs(500);

    if (!EraGlonassEcallProvider_Ecall(
            env->ecallProvider,
            msdEncoded->data,
            msdEncoded->len,
            env->settings->ECALL_TEST_NUMBER.data,
            env->settings->ECALL_TEST_NUMBER.length,
            activationType,
            testMode,
            blocReg
    )) {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось инициировать экстренный вызов")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
        }
        env->currentMsd->attemptsLeft--;
        return ERA_GLONASS_UVEOS_CALL_FAIL;
    }

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренный вызов успешно инициирован")
    tUserInputButtonEvent buttonEvent;
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Дозвон")

    while (EraGlonassEcallProvider_IsDialing(env->ecallProvider)) {
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        if (env->settings->ECALL_MANUAL_CAN_CANCEL) {
            while (UserButtons_GetNext(env->buttons, &buttonEvent, 0)) {
                if (UserInputButtonEventIsBetween(buttonEvent, env->buttonsIds.additional, RAISE, 500, 4000)) {
                    EraGlonassEcallProvider_Hangup(env->ecallProvider);
                    LoggerInfoStatic(LOGGER, LOG_SIGN, ".")
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок прерван пользователем")
                    return ERA_GLONASS_UVEOS_CALL_USER_BREAK;
                }
            }
        }
        SystemDelayMs(500);
        if (SystemGetMs() > dialTimeoutEnd) {
            EraGlonassEcallProvider_Hangup(env->ecallProvider);
            LoggerInfoStatic(LOGGER, LOG_SIGN, ".")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок прерван, превышена общая продолжительность дозвона")
            if(testMode != TEST_CALL) {
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
            }
            return ERA_GLONASS_UVEOS_CALL_FAIL;
        }
    }
    LoggerInfoStatic(LOGGER, LOG_SIGN, ".")
    if(testMode != TEST_CALL) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
    }
    uint32_t msdSendTimeout = SystemGetMs() + (env->settings->MSD_MAX_TRANSMISSION_TIME * 1000);

    if (EraGlonassEcallProvider_IsActive(env->ecallProvider)) {
        DEVTST_PLAY_SAMPLE("audio_on")
    }

    while (!EraGlonassEcallProvider_IsMsdSent(env->ecallProvider) &&
           EraGlonassEcallProvider_IsActive(env->ecallProvider) &&
           (msdSendTimeout > SystemGetMs())) {

        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        SystemDelayMs(500);
    }
    LoggerInfoStatic(LOGGER, LOG_SIGN, ".")

    if (EraGlonassEcallProvider_IsMsdSent(env->ecallProvider)) {
        env->currentMsd->attemptsLeft = 0;
        *mndSendFlag = true;
        callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Отправка МНД...")
        DEVTST_PLAY_SAMPLE("msd_on")
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД передан по средствам тонального модема")
        EraGlonassUveosDumper_ForceDump(env->dumper);
    } else {
        if (!EraGlonassEcallProvider_IsActive(env->ecallProvider)) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов звершен принимающей стороной")
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Превышено время передачи МНД тональным модемом")
            callResult = ERA_GLONASS_UVEOS_SEND_FAIL;
        }
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
        }
    }

    if(blocReg == false) {
        if ((callResult == ERA_GLONASS_UVEOS_CALL_FAIL) && (*mndSendFlag == false)) {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Не удалось отправить МНД (цикл вызовов) ошибка установки соединения")
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Производиться проверка сети")
            if (EraGlonassEcallProvider_CheckNetState(env->ecallProvider, 10000) == true) {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует, попытка отправки МНД по средствам СМС")
                EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
                if (EraGlonassUveos_ProcessingSms(env, msdEncoded) == ERA_GLONASS_UVEOS_SMS_SENT) {
                    *mndSendFlag = true;
                    callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлен по средствам СМС")
                } else {
                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось выполнить отправку СМС")
                    *mndSendFlag = false;
                    callResult = ERA_GLONASS_UVEOS_CALL_FAIL;
                }
                EraGlonassUveosDumper_ForceDump(env->dumper);
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть отсутствует_3")
            }
        }

        if ((callResult == ERA_GLONASS_UVEOS_SEND_FAIL) && (*mndSendFlag == false)) {
            LoggerErrorStatic(LOGGER, LOG_SIGN,
                              "Не удалось отправить МНД (цикл вызовов) ошибка передачи МНД по средствам тональной связи")
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует, попытка отправки МНД по средсвам СМС")

            EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, msdEncoded);
            if (EraGlonassUveos_ProcessingSms(env, msdEncoded) == ERA_GLONASS_UVEOS_SMS_SENT) {
                *mndSendFlag = true;
                callResult = ERA_GLONASS_UVEOS_CALL_SUCCESS;
                LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлен по средствам СМС")
            } else {
                LoggerInfoStatic(LOGGER, LOG_SIGN, "Не удалось выполнить отправку СМС")
                *mndSendFlag = false;
                callResult = ERA_GLONASS_UVEOS_SEND_FAIL;
            }
        }
    } else {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети запрещена текущей конфигурацией вызова")
    }

    bool wasNewSetMsd = false;
    bool wasResent = false;
    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Звонок")
    uint64_t times = SystemGetMs();

    if(testMode != TEST_CALL) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_ACTIVE);
    }

    while (EraGlonassEcallProvider_IsActive(env->ecallProvider)) {
        EraGlonassEcallProvider_CheckSms(env->ecallProvider);
        EraGlonassEcallProvider_CheckShutdownIsBattary(env->ecallProvider);
        LoggerCnInfoStatic(LOGGER, LOG_SIGN, ".")
        if (times < SystemGetMs() && (wasNewSetMsd == true)) {
            SystemDelayMs(1000);
            times = SystemGetMs() + 5000;
        }
    }

    EraGlonassEcallProvider_CheckShutdownIsBattary(env->ecallProvider);
//    reSetMsdToPull(env, &wasNewSetMsd, &wasResent, msdEncoded);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Звонок завершен")
    EraGlonassUveosDumper_ForceDump(env->dumper);
    return callResult;
}

static void EraGlonassUveos_ClearEgtsBuffers(tEraGlonassUveos *env, tEgtsEncoded *egtsEncoded) {
    LoggerErrorStatic(LOGGER, LOG_SIGN, "Очистка памяти под ЕГТС пакет...")
    memset(egtsEncoded, '\0', sizeof(tEgtsEncoded));    // Clear
}

static void EraGlonassUveos_PrepareEgtsData(tEraGlonassUveos *env, tMsdEncoded *msdEncoded, tEgtsEncoded *egtsEncoded) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Формируем ЕГТС пакет... ")
    uint32_t timeNow;
    NavDataProvider_GetTime(env->navDataProvider, &timeNow);
    egtsEncoded->len = vEgtsPackMsdTransport(
            0x01,
            egtsEncoded->data,
            msdEncoded->data,
            msdEncoded->len,
            timeNow
    );

    char egtsHexStr[egtsEncoded->len * 2];
    size_t egtsHexStrLen = 0;
    vAsciiStringAddBytesAsHex(egtsHexStr, &egtsHexStrLen, egtsEncoded->data, egtsEncoded->len);

    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Бинарный пакет ЕГТС сформирован: ")
    LoggerInfo(LOGGER, LOG_SIGN, egtsHexStr, egtsHexStrLen)
}

static void
EraGlonassUveos_PrepareEgtsResponse(tEraGlonassUveos *env, uint16_t recNum, uint16_t crn, uint16_t cid,
                                    tEgtsEncoded *egtsEncoded) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Формируем подтверждающий ЕГТС пакет... ")
    uint32_t timeNow;
    NavDataProvider_GetTime(env->navDataProvider, &timeNow);

    egtsEncoded->len = vEgtsPackEgtsResponse(
            0b0001,
            egtsEncoded->data,
            0b0000,
            recNum,
            cid,
            timeNow
    );

    char egtsHexStr[egtsEncoded->len * 2];
    size_t egtsHexStrLen = 0;
    vAsciiStringAddBytesAsHex(egtsHexStr, &egtsHexStrLen, egtsEncoded->data, egtsEncoded->len);

    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Бинарный подтверждающий пакет ЕГТС сформирован: ")
    LoggerInfo(LOGGER, LOG_SIGN, egtsHexStr, egtsHexStrLen)
}

static void EraGlonassUveos_PrepareEgtsCmdConfirmation(
        tEraGlonassUveos *env,
        uint16_t cmdType,
        uint16_t cmdConfirType,
        uint16_t cid,
        uint16_t sid,
        uint16_t acfe,
        uint16_t chsfe,
        uint16_t adr,
        uint8_t sz,
        uint8_t act,
        uint16_t ccd,
        uint32_t dt,
        tEgtsEncoded *egtsEncoded
) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Формируем подтверждающий ЕГТС пакет... ")
    uint32_t timeNow;
    NavDataProvider_GetTime(env->navDataProvider, &timeNow);

    egtsEncoded->len = vEgtsPackSrCmdConfirmation(
            egtsEncoded->data,
            0,
            cmdType,
            cmdConfirType,
            cid,
            sid,
            acfe,
            chsfe,
            adr,
            sz,
            act,
            ccd,
            dt
    );


    char egtsHexStr[egtsEncoded->len * 2];
    size_t egtsHexStrLen = 0;
    vAsciiStringAddBytesAsHex(egtsHexStr, &egtsHexStrLen, egtsEncoded->data, egtsEncoded->len);

    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Подтверждающий пакет ЕГТС сформирован: ")
    LoggerInfo(LOGGER, LOG_SIGN, egtsHexStr, egtsHexStrLen)
}

static bool EraGlonassUveos_SendEgtsSms(tEraGlonassUveos *env, tEgtsEncoded *egtsEncoded) {
    EraGlonassUveos_Indicate(env, UVEOS_STATUS_SMS_TRANSMIT);
    return EraGlonassSmsProvider_SendDataPdu(
            env->smsProvider,
            env->settings->ECALL_SMS_FALLBACK_NUMBER,
            egtsEncoded->data,
            egtsEncoded->len
    );
}

static bool EraGlonassUveos_SendEgtsResponse(tEraGlonassUveos *env, uint16_t recNum, uint16_t crn, uint16_t cid) {
    tEgtsEncoded egtsEncoded;
    EraGlonassUveos_ClearEgtsBuffers(env, &egtsEncoded);
    EraGlonassUveos_PrepareEgtsResponse(env, recNum, crn, cid, &egtsEncoded);
    return EraGlonassUveos_SendEgtsSms(env, &egtsEncoded);
}

static bool EraGlonassUveos_SendEgtsSmsConfirmation(
        tEraGlonassUveos *env,
        uint16_t cmdType,
        uint16_t cmdConfirType,
        uint16_t cid,
        uint16_t sid,
        uint16_t acfe,
        uint16_t chsfe,
        uint16_t adr,
        uint8_t sz,
        uint8_t act,
        uint16_t ccd,
        uint32_t dt
) {
    tEgtsEncoded egtsEncoded;
    EraGlonassUveos_ClearEgtsBuffers(env, &egtsEncoded);
    EraGlonassUveos_PrepareEgtsCmdConfirmation(env, cmdType, cmdConfirType, cid, sid, acfe, chsfe, adr, sz, act, ccd,
                                               dt, &egtsEncoded);

    return EraGlonassUveos_SendEgtsSms(env, &egtsEncoded);
}

static bool EraGlonassUveos_EmergencySendMsdSmsTry(tEraGlonassUveos *env, tMsdEncoded *msdEncoded) {
    tEgtsEncoded egtsEncoded;
    EraGlonassUveos_ClearEgtsBuffers(env, &egtsEncoded);
    EraGlonassUveos_PrepareEgtsData(env, msdEncoded, &egtsEncoded);
    return EraGlonassUveos_SendEgtsSms(env, &egtsEncoded);
}

bool EraGlonassUveos_EgtsSmsConfirmation(
        tEraGlonassUveos *env,
        uint8_t cmdType,
        uint8_t cmdConfirmationType,
        uint32_t cmdId,
        uint32_t srcId,
        uint16_t address,
        uint8_t size,
        uint8_t act,
        uint16_t reqType
) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сборка ответа")

    if (EraGlonassUveos_SendEgtsSmsConfirmation(
            env,
            CT_COMCONF,
            CC_OK,
            cmdId,
            srcId,
            0,
            0,
            address,
            size,
            act,
            reqType,
            0)
            ) {

        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ответ отправлен по средствам СМС")
        return true;

    } else {
        if (EraGlonassUveos_SendEgtsSmsConfirmation(
                env,
                CT_COMCONF,
                CC_OK,
                cmdId,
                srcId,
                0,
                0,
                address,
                size,
                act,
                reqType,
                0)
                ) {

            LoggerInfoStatic(LOGGER, LOG_SIGN, "Ответ отправлен по средствам СМС")
            return true;
        } else {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось отпаравить ответ по средствам СМС")
            return false;
        }
    }
}


bool EraGlonassUveos_EgtsResponse(tEraGlonassUveos *env, uint16_t recNum, uint16_t crn, uint16_t cid) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сборка ответа response")

    if (EraGlonassUveos_SendEgtsResponse(env, recNum, crn, cid)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ответ отправлен по средствам СМС")
        EraGlonassUveosDumper_ForceDump(env->dumper);
        return true;
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось отпаравить response по средствам СМС")
        return false;
    }
}

bool EraGlonassUveos_ResentMsdTry(tEraGlonassUveos *env, tEraGlonassMsdTableItem *msdItem) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переотправка МНД...")
    tMsdEncoded msdEncoded;

    EraGlonassUveos_CompileMsd(env, &msdItem->msd, &msdEncoded);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Отправка смс...")

    if (EraGlonassUveos_EmergencySendMsdSmsTry(env, &msdEncoded)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправленно по средствам СМС")
        msdItem->attemptsLeft = 0;
        EraGlonassUveosDumper_ForceDump(env->dumper);
        return true;
    } else {
        msdItem->attemptsLeft--;
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Неудалось отпаравить МНД по средствам СМС")
        EraGlonassUveosDumper_ForceDump(env->dumper);
        return false;
    }
}

void EraGlonassUveos_UpdateCurrentSettingsMsd(tEraGlonassUveos *env, eEcallTimeSourse timeSourse) {

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнавляем настройки...")
    EraGlonassUveos_InvalidateSettings(env);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем МНД...")
    EraGlonassUveos_UpdateMsd(env, timeSourse);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сохраняем изменения в ПЗУ")
    EraGlonassUveosDumper_ForceDump(env->dumper);
}

void EraGlonassUveos_GenCurrentMsd(tEraGlonassUveos *env, eEcallActivationType activationType, eEcallTestMode testMode,
                                   eEcallTimeSourse timeSourse) {

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнавляем настройки...")
    EraGlonassUveos_InvalidateSettings(env);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем МНД...")
    EraGlonassUveos_UpdateMsd(env, timeSourse);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Выделяем МНД ID в таблице")
    EraGlonassUveos_SignMsd(env, activationType, testMode);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сохраняем изменения в ПЗУ")
    EraGlonassUveosDumper_ForceDump(env->dumper);
}

eEraGlonassUveos_EcallProcessingResult EraGlonassUveos_ProcessingEmergency(
        tEraGlonassUveos *env,
        eEcallActivationType activationType,
        eEcallTestMode testMode,
        bool blocReg
) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обработка экстренной ситуации...")

    env->currentMsd->msd.MSD_Data.msgId = 1;
    tMsdEncoded msdEncoded;

    EraGlonassUveos_GenCurrentMsd(env, activationType, testMode, RTC_TIME_SOURSE);

    uint16_t attemptsLeft = activationType == AUTOMATIC_ACTIVATION ?
                            env->settings->ECALL_AUTO_DIAL_ATTEMPTS :
                            env->settings->ECALL_MANUAL_DIAL_ATTEMPTS;

    uint32_t dialTimeout = SystemGetMs() + (env->settings->ECALL_DIAL_DURATION * 60 * 1000);
    if(testMode != TEST_CALL) {
        EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_INITIATE);
    }
    eEraGlonassUveos_EcallProcessingResult resultSendEmergy = ERA_GLONASS_UVEOS_CALL_FAIL;

    bool pr_mndSendFlag = false;

    while (((SystemGetMs() < dialTimeout)) && (attemptsLeft)) {

        if ((pr_mndSendFlag) && (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_SUCCESS)) {
            --attemptsLeft;
            break;
        }
        --attemptsLeft;

        DEVTST_PLAY_SAMPLE("do_sos")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_DIALING);
        }

        resultSendEmergy = EraGlonassUveos_EmergencyCallTry(
                env,
                &msdEncoded,
                activationType,
                testMode,
                dialTimeout,
                &pr_mndSendFlag,
                blocReg
        );

        if (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_USER_BREAK) {
            return resultSendEmergy;
        }

        env->currentMsd->attemptsLeft--;
    }
    if(blocReg == true){
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Включён запрет на регистрацию внутри цикла вызовов")
    }
    if((blocReg == true) && (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_SUCCESS)){
        env->currentMsd->attemptsLeft = 0;
        EraGlonassUveosDumper_ForceDump(env->dumper);
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Обработка экстренной ситуации завершена код 1")
        env->currentMsd = EraGlonassMsdTable_GetNextFree(env->msdTable);
        return ERA_GLONASS_UVEOS_CALL_SUCCESS;
    }

    if((blocReg == true) && (resultSendEmergy != ERA_GLONASS_UVEOS_CALL_SUCCESS)){
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка вызова код 4")
        if(resultSendEmergy == ERA_GLONASS_UVEOS_CALL_FAIL){
            LoggerInfoStatic(LOGGER, LOG_SIGN, "ERA_GLONASS_UVEOS_CALL_FAIL")
        }
        if(resultSendEmergy == ERA_GLONASS_UVEOS_SMS_SENT){
            LoggerInfoStatic(LOGGER, LOG_SIGN, "ERA_GLONASS_UVEOS_SMS_SENT")
        }
        if(resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL){
            LoggerInfoStatic(LOGGER, LOG_SIGN, "ERA_GLONASS_UVEOS_SEND_FAIL")
        }
        if(resultSendEmergy == ERA_GLONASS_UVEOS_TEST_CALL_NOT_ALLOWED){
            LoggerInfoStatic(LOGGER, LOG_SIGN, "ERA_GLONASS_UVEOS_TEST_CALL_NOT_ALLOWED")
        }
    }

    if (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_SUCCESS) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Произведен успешный экстренный вызов")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
        }
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные о вызове очищены из внутренней памяти")

    } else if ((resultSendEmergy == ERA_GLONASS_UVEOS_CALL_FAIL) || (resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL)) {
        LoggerErrorStatic(LOGGER, LOG_SIGN,
                          "Не удалось совершить отправку МНД, производиться проверка сети и попытка отправки МНД по средсвам СМС")
        if (EraGlonassEcallProvider_CheckNetState(env->ecallProvider, 5000) == true) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
            DEVTST_PLAY_SAMPLE("msd_on")
            if(testMode != TEST_CALL) {
                EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
            }
            EraGlonassUveos_CompileMsd(env, &env->currentMsd->msd, &msdEncoded);
            resultSendEmergy = EraGlonassUveos_ProcessingSms(env, &msdEncoded);
        } else {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть отсутствует")
        }

    }

    if ((pr_mndSendFlag) || ((int) resultSendEmergy == ERA_GLONASS_UVEOS_SMS_SENT)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "МНД отправлено по средствам СМС")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_SMS_TRANSMIT);
            SystemDelayMs(1000);
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_MSD_TRANSMIT);
        }
    }

    if ((!pr_mndSendFlag) || ((int) resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL)) {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Не удалось отправить МНД по средствам СМС")
        if(testMode != TEST_CALL) {
            EraGlonassUveos_Indicate(env, UVEOS_STATUS_CALL_FAILURE);
        }
    }

    if ((resultSendEmergy == ERA_GLONASS_UVEOS_SEND_FAIL) || (resultSendEmergy == ERA_GLONASS_UVEOS_CALL_FAIL)) {
        env->currentMsd->attemptsLeft = env->settings->INT_MEM_TRANSMIT_ATTEMPTS;
    } else {
        env->currentMsd->attemptsLeft = 0;
    }

    EraGlonassUveosDumper_ForceDump(env->dumper);

    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обработка экстренной ситуации завершена")
    env->currentMsd = EraGlonassMsdTable_GetNextFree(env->msdTable);

    return resultSendEmergy;
}