# Set TCU activity state

This sample application demonstrates how to change the TCU activity state of all the application processors (machines) in the system

1. Implement a command response callback method

// This is invoked with error code indicating whether the request
    // was SUCCESS or FAILURE
    void commandResponse(ErrorCode error) {
        if (error == ErrorCode::SUCCESS) {
            std::cout << " Command executed successfully" << std::endl;
        } else {
            std::cout << " Command failed, errorCode: " << static_cast<int>(error) << std::endl;
        }
    }
    Copy to clipboard

2. Implement ITcuActivityListener and IServiceStatusListener interface

class MyTcuActivityStateListener : public ITcuActivityListener,
                                       public IServiceStatusListener {
    public:
       void onMachineUpdate(const std::string machineName, const MachineEvent machineEvent);
       void onSlaveAckStatusUpdate(const telux::common::Status status,
          const std::string machineName, const std::vector<ClientInfo> unresponsiveClients,
          const std::vector<ClientInfo> nackResponseClients) override;
       void onServiceStatusChange(ServiceStatus status) override;
    };
    Copy to clipboard

3. Get an instance of PowerFactory, and then obtain a TCU-activity manager instance with ClientType as MASTER

auto &powerFactory = PowerFactory::getInstance();
    std::promise<telux::common::ServiceStatus> prom = std::promise<telux::common::ServiceStatus>();
    ClientInstanceConfig config;
    config.clientType = ClientType::MASTER;
    config.clientName = "client_name_" + std::to_string(getpid());
    config.machineName =  ALL_MACHINES;
    auto tcuActivityManager = powerFactory.getTcuActivityManager(config,
                                  [&](telux::common::ServiceStatus status) {
                                     std::cout << " Init Callback called " << std::endl;
                                     prom.set_value(status);
                                  });
    Copy to clipboard

4. Wait for the TCU-activity management services to be initialized and ready

if (tcuActivityStateMgr_ == nullptr) {
       std::cout << " ERROR - Failed to get manager instance" << std::endl;
    }
    std::cout << "  Waiting for TCU Activity Manager to be ready" << std::endl;
    telux::common::ServiceStatus serviceStatus = prom.get_future().get();
    Copy to clipboard

5. Exit the application, if SDK is unable to initialize TCU-activity management service

if (serviceStatus == telux::common::ServiceStatus::SERVICE_AVAILABLE) {
       std::cout << " *** TCU-activity management service is Ready *** " << std::endl;
    } else {
       std::cout << " *** ERROR - Unable to initialize TCU-activity management service" << std::endl;
       return 1;
    }
    Copy to clipboard

6. Instantiate MyTcuActivityStateListener and register for updates on the triggered TCU-activity state and its management service status

auto myTcuStateListener = std::make_shared<MyTcuActivityStateListener>();
    tcuActivityManager->registerListener(myTcuStateListener);
    tcuActivityManager->registerServiceStateListener(myTcuStateListener);
    Copy to clipboard

7. Set the TCU activity state (SUSPEND here) of all the machines in the system

telux::common::Status status = tcuActivityManager->setActivityState(TcuActivityState::SUSPEND, ALL_MACHINES, &commandResponse);
    
    if (status == telux::common::Status::SUCCESS) {
       // successfully passed trigger, wait for the command response callback (commandResponse) to know if trigger is accepted and getting processed
    } else {
       std::cout << " *** ERROR - Failed to trigger TCU activity state change " << std::endl;
       // failed to pass trigger check status for more information
    }
    Copy to clipboard

8. The below listener API is invoked to notify the consolidated acknowledgement status of all the SLAVE clients, corresponding to the machine that is undergoing the transition

void void MyTcuActivityStateListener::onSlaveAckStatusUpdate(const telux::common::Status status,
       const std::string machineName, const std::vector<ClientInfo> unresponsiveClients,
       const std::vector<ClientInfo> nackResponseClients) {
       std::cout << "********* TCU-activity state update status and consolidate slave acknowledgement information *********" << std::endl;
       // Avoid long blocking calls when handling notifications
    
       if (status != telux::common::Status::SUCCESS) {
          std::cout << " Analyze which clients have not responded or responded with nack " << std::endl;
          if(unresponsiveClients.size() > 0) {
             std::cout << " Number of unresponsive clients : "<< unresponsiveClients.size() << std::endl;
             for (size_t i = 0; i < unresponsiveClients.size(); i++) {
                std::cout << " client name : "<< unresponsiveClients[i].first
                            << " , machine name : "<< unresponsiveClients[i].second << std::endl;
             }
          }
    
          if(nackResponseClients.size() > 0) {
             std::cout << " Number of clients responded with nack : "<< nackResponseClients.size()
                   << std::endl;
             for (size_t i = 0; i < nackResponseClients.size(); i++) {
                   std::cout << " client name : "<< nackResponseClients[i].first
                            << " , machine name : "<< nackResponseClients[i].second << std::endl;
             }
          }
    
          // If master expects to stop state transition considering the above information, then call
          // setActivityState and revert state, or else state transition will proceed after the configured
          // timeout
          tcuActivityManager->setActivityState(TcuActivityState::RESUME, desiredVMName, &commandResponse);
       }
    }
    Copy to clipboard

9. Implement onServiceStatusChange callback to know when TCU-activity management service goes down

// When the TCU-activity management service goes down, this API is invoked
    // with status UNAVAILABLE. All TCU-activity state notifications will be
    // stopped until the status becomes AVAILABLE again.
    void MyTcuActivityStateListener::onServiceStatusChange(ServiceStatus status) {
         std::cout << std::endl << "****** TCU-activity management service status update ******" << std::endl;
         // Avoid long blocking calls when handling notifications
    }
    Copy to clipboard

Last Published: Mar 31, 2026

[Previous Topic
Get TCU power state updates](https://docs.qualcomm.com/bundle/publicresource/80-PF458-9/topics/get_tcu_activity_state_notifications.md) [Next Topic
Thermal](https://docs.qualcomm.com/bundle/publicresource/80-PF458-9/topics/thermal.md)