# Ecall operation

This sample app demonstrates how to prepare for an eCall operation and indicate eCall completion.

1. Get platform factory instance

auto &platformFactory = PlatformFactory::getInstance();
    Copy to clipboard

2. Prepare a callback that is invoked when the filesystem sub-system initialization is complete

std::promise<telux::common::ServiceStatus> p;
    auto initCb = [&p](telux::common::ServiceStatus status) {
       std::cout << "Received service status: " << static_cast<int>(status) << std::endl;
       p.set_value(status);
    };
    Copy to clipboard

3. Get the filesystem manager

std::shared_ptr<telux::platform::IFsManager> fsManager = platformFactory.getFsManager(initCb);
    if (fsManager == nullptr) {
       std::cout << "filesystem manager is nullptr" << std::endl;
       exit(1);
    }
    std::cout << "Obtained filesystem manager" << std::endl;
    Copy to clipboard

4. Wait until initialization is complete

p.get_future().get();
    if (fsManager->getServiceStatus() != telux::common::ServiceStatus::SERVICE_AVAILABLE) {
       std::cout << "Filesystem service not available" << std::endl;
       exit(1);
    }
    std::cout << "Filesystem service is now available" << std::endl;
    Copy to clipboard

5. Create the listener object and register as a listener

std::shared_ptr<EcallOperationListener> ecallOperationListener
        = std::make_shared<EcallOperationListener>();
    fsManager->registerListener(ecallOperationListener);
    Copy to clipboard

6. Receive service status notifications

virtual void onServiceStatusChange(telux::common::ServiceStatus serviceStatus) override {
       PRINT_NOTIFICATION << "Ecall operation service status: ";
       std::string status;
       switch (serviceStatus) {
          case ServiceStatus::SERVICE_AVAILABLE: {
             status = "Available";
             break;
          }
          case ServiceStatus::SERVICE_UNAVAILABLE: {
             status = "Unavailable";
             break;
          }
          case ServiceStatus::SERVICE_FAILED: {
             status = "Failed";
             break;
          }
          default: {
             status = "Unknown";
             break;
          }
       }
       std::cout << status << std::endl;
    }
    Copy to clipboard

7. Before starting an eCall, prepare the filesystem manager for an eCall

> 
> 
> Note: It is recommended to start an eCall even if the request to prepare for an eCall fails.this API can re-invoke while an eCall is ongoing.
> 
> 
> telux::common::Status ecallStartStatus = telux::common::Status::FAILED;
>     std::cout << "Request to prepare for eCall start invoked " << std::endl;
>     
>     ecallStartStatus = fsManager->prepareForEcall();
>     
>     if (ecallStartStatus == telux::common::Status::SUCCESS) {
>        std::cout << "Request to prepare for eCall start successful";
>     } else {
>        std::cout << "Request to prepare for eCall start failed : ";
>        Utils::printStatus(ecallStartStatus);
>     }
>     Copy to clipboard

8. Initiate an eCall
9. Receive notification when filesystem operation is about to resumes in seconds - timeLetftToStart

> 
> 
> Note: *On this notification, the client can still suspand the filesystem operation and continue the eCall by invoking prepareForEcall API (Step[7])*
> 
> 
> virtual void OnFsOperationImminentEvent(uint32_t timeLeftToStart) override {
>          PRINT_NOTIFICATION << "Filesystem operation resumes in seconds: ";
>          std::cout << timeLeftToStart << std::endl;
>     }
>     Copy to clipboard

10. Once an eCall is completed, indicate to the filesystem manager

telux::common::Status ecallEndStatus = telux::common::Status::FAILED;
    std::cout << "eCall completion request being invoked " << std::endl;
    
    ecallEndStatus = fsManager->eCallCompleted();
    
    if (ecallEndStatus == telux::common::Status::SUCCESS) {
       std::cout << "eCall completion request successful";
    } else {
       std::cout << "eCall completion request failed : ";
       Utils::printStatus(ecallEndStatus);
    }
    Copy to clipboard

11. Clean-up when we do not need to listen anything

fsManager->deregisterListener(ecallOperationListener);
    ecallOperationListener = nullptr;
    fsManager = nullptr;
    Copy to clipboard

Last Published: Jun 24, 2026

[Previous Topic
OTA operation](https://docs.qualcomm.com/bundle/publicresource/80-PF458-1/topics/ota_operation.md) [Next Topic
Crypto](https://docs.qualcomm.com/bundle/publicresource/80-PF458-1/topics/crypto.md)