Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9f982fb8 authored by Yu Shan's avatar Yu Shan
Browse files

Support Enter Garage Mode in remote access HAL. 

Handles task type in reference remote access HAL and passes to
remote access server through GRPC.

Update host-side TestWakeupClientService to handle vehicleInUse
and ApPowerBootupReason VHAL properties.

Update reference VHAL to get the property values rom a remote grpc
server.

Test: atest --host TestWakeupClientServiceImplUnitTest
Manual run TestWakeupClientServerHost verifies that reference
VHAL can get power properties.
Bug: 316233421

Change-Id: I188aa9eed2dedb3b81b4eb6f5685ca33b646b2f5
parent 25ef5691

automotive/remoteaccess/hal/default/proto/wakeup_client.proto

+28 −0
Original line number Diff line number Diff line
@@ -124,6 +124,11 @@ message ScheduleTaskResponse { 
    ErrorCode errorCode = 1;

}



enum ScheduleTaskType {

    CUSTOM = 0;

    ENTER_GARAGE_MODE = 1;

}



message GrpcScheduleInfo {

    string clientId = 1;

    string scheduleId = 2;
@@ -131,6 +136,7 @@ message GrpcScheduleInfo { 
    int32 count = 4;

    int64 startTimeInEpochSeconds = 5;

    int64 periodicInSeconds = 6;

    ScheduleTaskType taskType = 7;

}



message UnscheduleTaskRequest {
@@ -162,3 +168,25 @@ message GetAllPendingScheduledTasksRequest { 
message GetAllPendingScheduledTasksResponse {

    repeated GrpcScheduleInfo allScheduledTasks = 1;

}



/**

 * Service provided by a power controller unit.

 */

service PowerController {

    rpc IsVehicleInUse(IsVehicleInUseRequest) returns (IsVehicleInUseResponse) {}



    rpc GetApPowerBootupReason(GetApPowerBootupReasonRequest)

            returns (GetApPowerBootupReasonResponse) {}

}



message IsVehicleInUseRequest {}



message IsVehicleInUseResponse {

    bool isVehicleInUse = 1;

}



message GetApPowerBootupReasonRequest {}



message GetApPowerBootupReasonResponse {

    int32 bootupReason = 1;

}

automotive/remoteaccess/hal/default/src/RemoteAccessService.cpp

+4 −1
Original line number Diff line number Diff line
@@ -346,8 +346,8 @@ ndk::ScopedAStatus RemoteAccessService::getSupportedTaskTypesForScheduling( 
        return ScopedAStatus::ok();

    }



    // TODO(b/316233421): support ENTER_GARAGE_MODE type.

    out->push_back(TaskType::CUSTOM);

    out->push_back(TaskType::ENTER_GARAGE_MODE);

    return ScopedAStatus::ok();

}
@@ -380,6 +380,8 @@ ScopedAStatus RemoteAccessService::scheduleTask(const ScheduleInfo& scheduleInfo 
    }



    request.mutable_scheduleinfo()->set_clientid(scheduleInfo.clientId);

    request.mutable_scheduleinfo()->set_tasktype(

            static_cast<ScheduleTaskType>(scheduleInfo.taskType));

    request.mutable_scheduleinfo()->set_scheduleid(scheduleInfo.scheduleId);

    request.mutable_scheduleinfo()->set_data(scheduleInfo.taskData.data(),

                                             scheduleInfo.taskData.size());
@@ -485,6 +487,7 @@ ScopedAStatus RemoteAccessService::getAllPendingScheduledTasks(const std::string 
        const GrpcScheduleInfo& rpcScheduleInfo = response.allscheduledtasks(i);

        ScheduleInfo scheduleInfo = {

                .clientId = rpcScheduleInfo.clientid(),

                .taskType = static_cast<TaskType>(rpcScheduleInfo.tasktype()),

                .scheduleId = rpcScheduleInfo.scheduleid(),

                .taskData = stringToBytes(rpcScheduleInfo.data()),

                .count = rpcScheduleInfo.count(),

automotive/remoteaccess/test_grpc_server/impl/include/TestWakeupClientServiceImpl.h

+106 −16
Original line number Diff line number Diff line
@@ -30,6 +30,11 @@ namespace hardware { 
namespace automotive {

namespace remoteaccess {



// The following are the same as VehicleApPowerBootupReason defined in VHAL.

constexpr int32_t BOOTUP_REASON_USER_POWER_ON = 0;

constexpr int32_t BOOTUP_REASON_SYSTEM_REMOTE_ACCESS = 2;

constexpr int32_t BOOTUP_REASON_SYSTEM_ENTER_GARAGE_MODE = 3;



// A class to generate fake task for testing. Not required for real implementation. In real

// implementation, the task should come from remote task server. This class is thread-safe.

class FakeTaskGenerator final {
@@ -98,50 +103,57 @@ class TaskQueue final { 
};



// forward-declaration

class TestWakeupClientServiceImpl;

class ServiceImpl;



class TaskScheduleMsgHandler final : public android::MessageHandler {

  public:

    TaskScheduleMsgHandler(TestWakeupClientServiceImpl* mImpl);

    TaskScheduleMsgHandler(ServiceImpl* impl);

    void handleMessage(const android::Message& message) override;



  private:

    TestWakeupClientServiceImpl* mImpl;

    ServiceImpl* mImpl;

};



class TestWakeupClientServiceImpl : public WakeupClient::Service {

class ServiceImpl {

  public:

    TestWakeupClientServiceImpl();

    ServiceImpl();



    ~TestWakeupClientServiceImpl();

    virtual ~ServiceImpl() = 0;



    // Stop the handling for all income requests. Prepare for shutdown.

    void stopServer();



    grpc::Status GetRemoteTasks(grpc::ServerContext* context, const GetRemoteTasksRequest* request,

                                grpc::ServerWriter<GetRemoteTasksResponse>* writer) override;

                                grpc::ServerWriter<GetRemoteTasksResponse>* writer);



    grpc::Status NotifyWakeupRequired(grpc::ServerContext* context,

                                      const NotifyWakeupRequiredRequest* request,

                                      NotifyWakeupRequiredResponse* response) override;

                                      NotifyWakeupRequiredResponse* response);



    grpc::Status ScheduleTask(grpc::ServerContext* context, const ScheduleTaskRequest* request,

                              ScheduleTaskResponse* response) override;

                              ScheduleTaskResponse* response);



    grpc::Status UnscheduleTask(grpc::ServerContext* context, const UnscheduleTaskRequest* request,

                                UnscheduleTaskResponse* response) override;

                                UnscheduleTaskResponse* response);



    grpc::Status UnscheduleAllTasks(grpc::ServerContext* context,

                                    const UnscheduleAllTasksRequest* request,

                                    UnscheduleAllTasksResponse* response) override;

                                    UnscheduleAllTasksResponse* response);



    grpc::Status IsTaskScheduled(grpc::ServerContext* context,

                                 const IsTaskScheduledRequest* request,

                                 IsTaskScheduledResponse* response) override;

                                 IsTaskScheduledResponse* response);



    grpc::Status GetAllPendingScheduledTasks(

            grpc::ServerContext* context, const GetAllPendingScheduledTasksRequest* request,

            GetAllPendingScheduledTasksResponse* response) override;

    grpc::Status GetAllPendingScheduledTasks(grpc::ServerContext* context,

                                             const GetAllPendingScheduledTasksRequest* request,

                                             GetAllPendingScheduledTasksResponse* response);



    grpc::Status IsVehicleInUse(grpc::ServerContext* context, const IsVehicleInUseRequest* request,

                                IsVehicleInUseResponse* response);



    grpc::Status GetApPowerBootupReason(grpc::ServerContext* context,

                                        const GetApPowerBootupReasonRequest* request,

                                        GetApPowerBootupReasonResponse* response);



    /**

     * Starts generating fake tasks for the specific client repeatedly.
@@ -177,7 +189,7 @@ class TestWakeupClientServiceImpl : public WakeupClient::Service { 
     * This must be implemented by child class and contains device specific logic. E.g. this might

     * be sending QEMU commands for the emulator device.

     */

    virtual void wakeupApplicationProcessor() = 0;

    virtual void wakeupApplicationProcessor(int32_t bootupReason) = 0;



    /**

     * Cleans up a scheduled task info.
@@ -185,6 +197,16 @@ class TestWakeupClientServiceImpl : public WakeupClient::Service { 
    void cleanupScheduledTaskLocked(const std::string& clientId, const std::string& scheduleId)

            REQUIRES(mLock);



    /**

     * Sets whether vehicle is in use.

     */

    void setVehicleInUse(bool vehicleInUse);



    /**

     * Sets the bootup reason.

     */

    void setBootupReason(int32_t bootupReason);



  private:

    friend class TaskScheduleMsgHandler;
@@ -218,6 +240,8 @@ class TestWakeupClientServiceImpl : public WakeupClient::Service { 
    std::atomic<bool> mServerStopped = false;

    std::unordered_map<std::string, std::unordered_map<std::string, ScheduleInfo>>

            mInfoByScheduleIdByClientId GUARDED_BY(mLock);

    std::atomic<bool> mVehicleInUse = false;

    std::atomic<int32_t> mBootupReason = BOOTUP_REASON_USER_POWER_ON;



    // Thread-safe. For test impl only.

    FakeTaskGenerator mFakeTaskGenerator;
@@ -232,6 +256,72 @@ class TestWakeupClientServiceImpl : public WakeupClient::Service { 
    void loop();

};



class WakeupClientServiceImpl : public WakeupClient::Service {

  public:

    WakeupClientServiceImpl(ServiceImpl* impl) { mImpl = impl; }



    grpc::Status GetRemoteTasks(grpc::ServerContext* context, const GetRemoteTasksRequest* request,

                                grpc::ServerWriter<GetRemoteTasksResponse>* writer) override {

        return mImpl->GetRemoteTasks(context, request, writer);

    }



    grpc::Status NotifyWakeupRequired(grpc::ServerContext* context,

                                      const NotifyWakeupRequiredRequest* request,

                                      NotifyWakeupRequiredResponse* response) override {

        return mImpl->NotifyWakeupRequired(context, request, response);

    }



    grpc::Status ScheduleTask(grpc::ServerContext* context, const ScheduleTaskRequest* request,

                              ScheduleTaskResponse* response) override {

        return mImpl->ScheduleTask(context, request, response);

    }



    grpc::Status UnscheduleTask(grpc::ServerContext* context, const UnscheduleTaskRequest* request,

                                UnscheduleTaskResponse* response) override {

        return mImpl->UnscheduleTask(context, request, response);

    }



    grpc::Status UnscheduleAllTasks(grpc::ServerContext* context,

                                    const UnscheduleAllTasksRequest* request,

                                    UnscheduleAllTasksResponse* response) override {

        return mImpl->UnscheduleAllTasks(context, request, response);

    }



    grpc::Status IsTaskScheduled(grpc::ServerContext* context,

                                 const IsTaskScheduledRequest* request,

                                 IsTaskScheduledResponse* response) override {

        return mImpl->IsTaskScheduled(context, request, response);

    }



    grpc::Status GetAllPendingScheduledTasks(

            grpc::ServerContext* context, const GetAllPendingScheduledTasksRequest* request,

            GetAllPendingScheduledTasksResponse* response) override {

        return mImpl->GetAllPendingScheduledTasks(context, request, response);

    }



  private:

    ServiceImpl* mImpl;

};



class PowerControllerServiceImpl : public PowerController::Service {

  public:

    PowerControllerServiceImpl(ServiceImpl* impl) { mImpl = impl; }



    grpc::Status IsVehicleInUse(grpc::ServerContext* context, const IsVehicleInUseRequest* request,

                                IsVehicleInUseResponse* response) override {

        return mImpl->IsVehicleInUse(context, request, response);

    }



    grpc::Status GetApPowerBootupReason(grpc::ServerContext* context,

                                        const GetApPowerBootupReasonRequest* request,

                                        GetApPowerBootupReasonResponse* response) override {

        return mImpl->GetApPowerBootupReason(context, request, response);

    }



  private:

    ServiceImpl* mImpl;

};



}  // namespace remoteaccess

}  // namespace automotive

}  // namespace hardware

automotive/remoteaccess/test_grpc_server/impl/src/TestWakeupClientServiceImpl.cpp

+77 −50
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ using ::grpc::ServerWriter; 
using ::grpc::Status;



constexpr int64_t kTaskIntervalInMs = 5'000;

constexpr int64_t kTaskTimeoutInMs = 20'000;

constexpr int64_t kTaskTimeoutInMs = 60'000;



int64_t msToNs(int64_t ms) {

    return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds(ms))
@@ -140,21 +140,21 @@ void TaskQueue::handleTaskTimeout() { 
    }

}



TestWakeupClientServiceImpl::TestWakeupClientServiceImpl() {

ServiceImpl::ServiceImpl() {

    mTaskScheduleMsgHandler = android::sp<TaskScheduleMsgHandler>::make(this);

    mLooper = android::sp<Looper>::make(/*opts=*/0);

    mLooperThread = std::thread([this] { loop(); });

    mTaskQueue = std::make_unique<TaskQueue>(mLooper);

}



TestWakeupClientServiceImpl::~TestWakeupClientServiceImpl() {

ServiceImpl::~ServiceImpl() {

    if (mServerStopped) {

        return;

    }

    stopServer();

}



void TestWakeupClientServiceImpl::stopServer() {

void ServiceImpl::stopServer() {

    mTaskQueue->stopWait();

    stopGeneratingFakeTask();

    // Set the flag so that the loop thread will exit.
@@ -165,7 +165,7 @@ void TestWakeupClientServiceImpl::stopServer() { 
    }

}



void TestWakeupClientServiceImpl::loop() {

void ServiceImpl::loop() {

    Looper::setForThread(mLooper);



    while (true) {
@@ -176,23 +176,22 @@ void TestWakeupClientServiceImpl::loop() { 
    }

}



void TestWakeupClientServiceImpl::injectTask(const std::string& taskData,

                                             const std::string& clientId) {

void ServiceImpl::injectTask(const std::string& taskData, const std::string& clientId) {

    GetRemoteTasksResponse response;

    response.set_data(taskData);

    response.set_clientid(clientId);

    injectTaskResponse(response);

}



void TestWakeupClientServiceImpl::injectTaskResponse(const GetRemoteTasksResponse& response) {

void ServiceImpl::injectTaskResponse(const GetRemoteTasksResponse& response) {

    printf("Receive a new task\n");

    mTaskQueue->add(response);

    if (mWakeupRequired) {

        wakeupApplicationProcessor();

        wakeupApplicationProcessor(BOOTUP_REASON_SYSTEM_REMOTE_ACCESS);

    }

}



void TestWakeupClientServiceImpl::startGeneratingFakeTask(const std::string& clientId) {

void ServiceImpl::startGeneratingFakeTask(const std::string& clientId) {

    std::lock_guard<std::mutex> lockGuard(mLock);

    if (mGeneratingFakeTask) {

        printf("Fake task is already being generated\n");
@@ -203,7 +202,7 @@ void TestWakeupClientServiceImpl::startGeneratingFakeTask(const std::string& cli 
    printf("Started generating fake tasks\n");

}



void TestWakeupClientServiceImpl::stopGeneratingFakeTask() {

void ServiceImpl::stopGeneratingFakeTask() {

    {

        std::lock_guard<std::mutex> lockGuard(mLock);

        if (!mGeneratingFakeTask) {
@@ -219,7 +218,7 @@ void TestWakeupClientServiceImpl::stopGeneratingFakeTask() { 
    printf("Stopped generating fake tasks\n");

}



void TestWakeupClientServiceImpl::fakeTaskGenerateLoop(const std::string& clientId) {

void ServiceImpl::fakeTaskGenerateLoop(const std::string& clientId) {

    // In actual implementation, this should communicate with the remote server and receives tasks

    // from it. Here we simulate receiving one remote task every {kTaskIntervalInMs}ms.

    while (true) {
@@ -237,8 +236,7 @@ void TestWakeupClientServiceImpl::fakeTaskGenerateLoop(const std::string& client 
    }

}



Status TestWakeupClientServiceImpl::GetRemoteTasks(ServerContext* context,

                                                   const GetRemoteTasksRequest* request,

Status ServiceImpl::GetRemoteTasks(ServerContext* context, const GetRemoteTasksRequest* request,

                                   ServerWriter<GetRemoteTasksResponse>* writer) {

    printf("GetRemoteTasks called\n");

    mRemoteTaskConnectionAlive = true;
@@ -277,7 +275,7 @@ Status TestWakeupClientServiceImpl::GetRemoteTasks(ServerContext* context, 
    return Status::CANCELLED;

}



Status TestWakeupClientServiceImpl::NotifyWakeupRequired(ServerContext* context,

Status ServiceImpl::NotifyWakeupRequired(ServerContext* context,

                                         const NotifyWakeupRequiredRequest* request,

                                         NotifyWakeupRequiredResponse* response) {

    printf("NotifyWakeupRequired called\n");
@@ -285,7 +283,7 @@ Status TestWakeupClientServiceImpl::NotifyWakeupRequired(ServerContext* context, 
        // If wakeup is now required and previously not required, this means we have finished

        // shutting down the device. If there are still pending tasks, try waking up AP again

        // to finish executing those tasks.

        wakeupApplicationProcessor();

        wakeupApplicationProcessor(BOOTUP_REASON_SYSTEM_REMOTE_ACCESS);

    }

    mWakeupRequired = request->iswakeuprequired();

    if (mWakeupRequired) {
@@ -296,7 +294,7 @@ Status TestWakeupClientServiceImpl::NotifyWakeupRequired(ServerContext* context, 
    return Status::OK;

}



void TestWakeupClientServiceImpl::cleanupScheduledTaskLocked(const std::string& clientId,

void ServiceImpl::cleanupScheduledTaskLocked(const std::string& clientId,

                                             const std::string& scheduleId) {

    mInfoByScheduleIdByClientId[clientId].erase(scheduleId);

    if (mInfoByScheduleIdByClientId[clientId].size() == 0) {
@@ -304,14 +302,13 @@ void TestWakeupClientServiceImpl::cleanupScheduledTaskLocked(const std::string& 
    }

}



TaskScheduleMsgHandler::TaskScheduleMsgHandler(TestWakeupClientServiceImpl* impl) : mImpl(impl) {}

TaskScheduleMsgHandler::TaskScheduleMsgHandler(ServiceImpl* impl) : mImpl(impl) {}



void TaskScheduleMsgHandler::handleMessage(const android::Message& message) {

    mImpl->handleAddTask(message.what);

}



Status TestWakeupClientServiceImpl::ScheduleTask(ServerContext* context,

                                                 const ScheduleTaskRequest* request,

Status ServiceImpl::ScheduleTask(ServerContext* context, const ScheduleTaskRequest* request,

                                 ScheduleTaskResponse* response) {

    std::lock_guard<std::mutex> lockGuard(mLock);
@@ -359,8 +356,7 @@ Status TestWakeupClientServiceImpl::ScheduleTask(ServerContext* context, 
    return Status::OK;

}



bool TestWakeupClientServiceImpl::getScheduleInfoLocked(int scheduleMsgId,

                                                        ScheduleInfo** outScheduleInfoPtr) {

bool ServiceImpl::getScheduleInfoLocked(int scheduleMsgId, ScheduleInfo** outScheduleInfoPtr) {

    for (auto& [_, infoByScheduleId] : mInfoByScheduleIdByClientId) {

        for (auto& [_, scheduleInfo] : infoByScheduleId) {

            if (scheduleInfo.scheduleMsgId == scheduleMsgId) {
@@ -372,7 +368,7 @@ bool TestWakeupClientServiceImpl::getScheduleInfoLocked(int scheduleMsgId, 
    return false;

}



void TestWakeupClientServiceImpl::handleAddTask(int scheduleMsgId) {

void ServiceImpl::handleAddTask(int scheduleMsgId) {

    std::lock_guard<std::mutex> lockGuard(mLock);



    ScheduleInfo* scheduleInfoPtr;
@@ -385,15 +381,27 @@ void TestWakeupClientServiceImpl::handleAddTask(int scheduleMsgId) { 
    const GrpcScheduleInfo& grpcScheduleInfo = *scheduleInfoPtr->grpcScheduleInfo;

    const std::string scheduleId = grpcScheduleInfo.scheduleid();

    const std::string clientId = grpcScheduleInfo.clientid();

    scheduleInfoPtr->currentCount++;

    ScheduleTaskType taskType = grpcScheduleInfo.tasktype();

    printf("Sending scheduled tasks for scheduleId: %s, clientId: %s, taskCount: %d, "

           "taskType: %d\n",

           scheduleId.c_str(), clientId.c_str(), scheduleInfoPtr->currentCount,

           static_cast<int>(taskType));



    if (taskType == ScheduleTaskType::ENTER_GARAGE_MODE) {

        if (mWakeupRequired) {

            wakeupApplicationProcessor(BOOTUP_REASON_SYSTEM_ENTER_GARAGE_MODE);

        } else {

            printf("Ignore ENTER_GARAGE_MODE task type because the head unit is already running");

        }

    } else if (grpcScheduleInfo.tasktype() == ScheduleTaskType::CUSTOM) {

        GetRemoteTasksResponse injectResponse;

        injectResponse.set_data(grpcScheduleInfo.data().data(), grpcScheduleInfo.data().size());

        injectResponse.set_clientid(clientId);

        injectTaskResponse(injectResponse);

    scheduleInfoPtr->currentCount++;



    printf("Sending scheduled tasks for scheduleId: %s, clientId: %s, taskCount: %d\n",

           scheduleId.c_str(), clientId.c_str(), scheduleInfoPtr->currentCount);

    } else {

        printf("Unknown task type: %d\n", static_cast<int>(taskType));

    }



    if (scheduleInfoPtr->totalCount != 0 &&

        scheduleInfoPtr->currentCount == scheduleInfoPtr->totalCount) {
@@ -407,8 +415,7 @@ void TestWakeupClientServiceImpl::handleAddTask(int scheduleMsgId) { 
                                android::Message(scheduleMsgId));

}



Status TestWakeupClientServiceImpl::UnscheduleTask(ServerContext* context,

                                                   const UnscheduleTaskRequest* request,

Status ServiceImpl::UnscheduleTask(ServerContext* context, const UnscheduleTaskRequest* request,

                                   UnscheduleTaskResponse* response) {

    std::lock_guard<std::mutex> lockGuard(mLock);
@@ -431,7 +438,7 @@ Status TestWakeupClientServiceImpl::UnscheduleTask(ServerContext* context, 
    return Status::OK;

}



Status TestWakeupClientServiceImpl::UnscheduleAllTasks(ServerContext* context,

Status ServiceImpl::UnscheduleAllTasks(ServerContext* context,

                                       const UnscheduleAllTasksRequest* request,

                                       UnscheduleAllTasksResponse* response) {

    std::lock_guard<std::mutex> lockGuard(mLock);
@@ -452,8 +459,7 @@ Status TestWakeupClientServiceImpl::UnscheduleAllTasks(ServerContext* context, 
    return Status::OK;

}



Status TestWakeupClientServiceImpl::IsTaskScheduled(ServerContext* context,

                                                    const IsTaskScheduledRequest* request,

Status ServiceImpl::IsTaskScheduled(ServerContext* context, const IsTaskScheduledRequest* request,

                                    IsTaskScheduledResponse* response) {

    std::lock_guard<std::mutex> lockGuard(mLock);
@@ -475,8 +481,8 @@ Status TestWakeupClientServiceImpl::IsTaskScheduled(ServerContext* context, 
    return Status::OK;

}



Status TestWakeupClientServiceImpl::GetAllPendingScheduledTasks(

        ServerContext* context, const GetAllPendingScheduledTasksRequest* request,

Status ServiceImpl::GetAllPendingScheduledTasks(ServerContext* context,

                                                const GetAllPendingScheduledTasksRequest* request,

                                                GetAllPendingScheduledTasksResponse* response) {

    const std::string& clientId = request->clientid();

    printf("GetAllPendingScheduledTasks called with client Id: %s\n", clientId.c_str());
@@ -493,14 +499,35 @@ Status TestWakeupClientServiceImpl::GetAllPendingScheduledTasks( 
    return Status::OK;

}



bool TestWakeupClientServiceImpl::isWakeupRequired() {

Status ServiceImpl::IsVehicleInUse(ServerContext* context, const IsVehicleInUseRequest* request,

                                   IsVehicleInUseResponse* response) {

    response->set_isvehicleinuse(mVehicleInUse);

    return Status::OK;

}



Status ServiceImpl::GetApPowerBootupReason(ServerContext* context,

                                           const GetApPowerBootupReasonRequest* request,

                                           GetApPowerBootupReasonResponse* response) {

    response->set_bootupreason(mBootupReason);

    return Status::OK;

}



bool ServiceImpl::isWakeupRequired() {

    return mWakeupRequired;

}



bool TestWakeupClientServiceImpl::isRemoteTaskConnectionAlive() {

bool ServiceImpl::isRemoteTaskConnectionAlive() {

    return mRemoteTaskConnectionAlive;

}



void ServiceImpl::setVehicleInUse(bool vehicleInUse) {

    mVehicleInUse = vehicleInUse;

}



void ServiceImpl::setBootupReason(int32_t bootupReason) {

    mBootupReason = bootupReason;

}



}  // namespace remoteaccess

}  // namespace automotive

}  // namespace hardware

automotive/remoteaccess/test_grpc_server/impl/src/main.cpp

+24 −34

File changed.

Preview size limit exceeded, changes collapsed.