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

Commit 56c98e4c authored by Kathan Shukla's avatar Kathan Shukla
Browse files

Mock hal for Occupant Awareness interface. 

Mock hal has limited capability - driver and front passenger presence
detection and driver monitoring detection.

Bug: 142383127
Test: VTS tests
Change-Id: I72e4b443a0d8063288e14333bd9ebbb1f2c19720
parent 66135e54

automotive/occupant_awareness/aidl/mock/Android.bp

0 → 100644
+32 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



cc_binary {

    name: "android.hardware.automotive.occupant_awareness@1.0-service_mock",

    relative_install_path: "hw",

    vendor: true,

    srcs: [

        "service.cpp",

        "OccupantAwareness.cpp",

        "DetectionGenerator.cpp",

    ],

    shared_libs: [

        "libbase",

        "libbinder_ndk",

        "libutils",

        "android.hardware.automotive.occupant_awareness-ndk_platform",

    ],

}

automotive/occupant_awareness/aidl/mock/DetectionGenerator.cpp

0 → 100644
+71 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <utils/SystemClock.h>



#include "DetectionGenerator.h"



namespace android {

namespace hardware {

namespace automotive {

namespace occupant_awareness {

namespace V1_0 {

namespace implementation {



using ::aidl::android::hardware::automotive::occupant_awareness::ConfidenceLevel;

using ::aidl::android::hardware::automotive::occupant_awareness::DriverMonitoringDetection;

using ::aidl::android::hardware::automotive::occupant_awareness::OccupantDetection;

using ::aidl::android::hardware::automotive::occupant_awareness::PresenceDetection;



static int64_t kNanoSecondsPerMilliSecond = 1000 * 1000;



OccupantDetections DetectionGenerator::GetNextDetections() {

    OccupantDetections detections;

    detections.timeStampMillis = android::elapsedRealtimeNano() / kNanoSecondsPerMilliSecond;

    int remainingRoles = getSupportedRoles();

    while (remainingRoles) {

        int currentRole = remainingRoles & (~(remainingRoles - 1));

        remainingRoles = remainingRoles & (remainingRoles - 1);



        OccupantDetection occupantDetection;

        occupantDetection.role = static_cast<Role>(currentRole);



        // Add presence detection object for this occupant.

        PresenceDetection presenceDetection;

        presenceDetection.isOccupantDetected = true;

        presenceDetection.detectionDurationMillis = detections.timeStampMillis;

        occupantDetection.presenceData.emplace_back(presenceDetection);



        if (occupantDetection.role == Role::DRIVER) {

            // Add driver monitoring detection object for this occupant.

            DriverMonitoringDetection driverMonitoringDetection;

            driverMonitoringDetection.confidenceScore = ConfidenceLevel::HIGH;

            driverMonitoringDetection.isLookingOnRoad = 0;

            driverMonitoringDetection.gazeDurationMillis = detections.timeStampMillis;

            occupantDetection.attentionData.emplace_back(driverMonitoringDetection);

        }



        detections.detections.emplace_back(occupantDetection);

    }

    return detections;

}



}  // namespace implementation

}  // namespace V1_0

}  // namespace occupant_awareness

}  // namespace automotive

}  // namespace hardware

}  // namespace android

automotive/occupant_awareness/aidl/mock/DetectionGenerator.h

0 → 100644
+50 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <aidl/android/hardware/automotive/occupant_awareness/BnOccupantAwareness.h>



namespace android {

namespace hardware {

namespace automotive {

namespace occupant_awareness {

namespace V1_0 {

namespace implementation {



using ::aidl::android::hardware::automotive::occupant_awareness::BnOccupantAwareness;

using ::aidl::android::hardware::automotive::occupant_awareness::OccupantDetections;

using ::aidl::android::hardware::automotive::occupant_awareness::Role;



class DetectionGenerator {

  public:

    static int getSupportedRoles() {

        return static_cast<int>(Role::DRIVER) | static_cast<int>(Role::FRONT_PASSENGER);

    }

    static int getSupportedCapabilities() {

        return static_cast<int>(BnOccupantAwareness::CAP_PRESENCE_DETECTION) |

               static_cast<int>(BnOccupantAwareness::CAP_DRIVER_MONITORING_DETECTION);

    }



    OccupantDetections GetNextDetections();

};



}  // namespace implementation

}  // namespace V1_0

}  // namespace occupant_awareness

}  // namespace automotive

}  // namespace hardware

}  // namespace android

automotive/occupant_awareness/aidl/mock/OccupantAwareness.cpp

0 → 100644
+176 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <utils/SystemClock.h>



#include "OccupantAwareness.h"



namespace android {

namespace hardware {

namespace automotive {

namespace occupant_awareness {

namespace V1_0 {

namespace implementation {



using ndk::ScopedAStatus;



static const int32_t kAllCapabilities = OccupantAwareness::CAP_PRESENCE_DETECTION |

                                        OccupantAwareness::CAP_GAZE_DETECTION |

                                        OccupantAwareness::CAP_DRIVER_MONITORING_DETECTION;



constexpr int64_t kNanoSecondsPerMilliSecond = 1000 * 1000;



ScopedAStatus OccupantAwareness::startDetection(OccupantAwarenessStatus* status) {

    std::lock_guard<std::mutex> lock(mMutex);

    if (mStatus != OccupantAwarenessStatus::NOT_INITIALIZED) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    mStatus = OccupantAwarenessStatus::READY;

    mWorkerThread = std::thread(startWorkerThread, this);

    if (mCallback) {

        mCallback->onSystemStatusChanged(kAllCapabilities, mStatus);

    }



    *status = mStatus;

    return ScopedAStatus::ok();

}



ScopedAStatus OccupantAwareness::stopDetection(OccupantAwarenessStatus* status) {

    std::lock_guard<std::mutex> lock(mMutex);

    if (mStatus != OccupantAwarenessStatus::READY) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    mStatus = OccupantAwarenessStatus::NOT_INITIALIZED;

    mWorkerThread.join();

    if (mCallback) {

        mCallback->onSystemStatusChanged(kAllCapabilities, mStatus);

    }



    *status = mStatus;

    return ScopedAStatus::ok();

}



ScopedAStatus OccupantAwareness::getCapabilityForRole(Role occupantRole, int32_t* capabilities) {

    if (!isValidRole(occupantRole)) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    int intVal = static_cast<int>(occupantRole);

    if ((intVal & DetectionGenerator::getSupportedRoles()) == intVal) {

        int capabilities_ = DetectionGenerator::getSupportedCapabilities();

        if (occupantRole != Role::DRIVER) {

            capabilities_ &= ~CAP_DRIVER_MONITORING_DETECTION;

        }

        *capabilities = capabilities_;

    } else {

        *capabilities = 0;

    }



    return ScopedAStatus::ok();

}



ScopedAStatus OccupantAwareness::getState(Role occupantRole, int detectionCapability,

                                          OccupantAwarenessStatus* status) {

    if (!isValidRole(occupantRole)) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    if (!isValidDetectionCapabilities(detectionCapability) ||

        !isSingularCapability(detectionCapability)) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    int roleVal = static_cast<int>(occupantRole);



    if (((roleVal & DetectionGenerator::getSupportedRoles()) != roleVal) ||

        ((detectionCapability & DetectionGenerator::getSupportedCapabilities()) !=

         detectionCapability)) {

        *status = OccupantAwarenessStatus::NOT_SUPPORTED;

        return ScopedAStatus::ok();

    }



    std::lock_guard<std::mutex> lock(mMutex);

    *status = mStatus;

    return ScopedAStatus::ok();

}



ScopedAStatus OccupantAwareness::setCallback(

        const std::shared_ptr<IOccupantAwarenessClientCallback>& callback) {

    if (callback == nullptr) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    std::lock_guard<std::mutex> lock(mMutex);

    mCallback = callback;

    return ScopedAStatus::ok();

}



ScopedAStatus OccupantAwareness::getLatestDetection(OccupantDetections* detections) {

    std::lock_guard<std::mutex> lock(mMutex);



    if (mStatus != OccupantAwarenessStatus::READY) {

        return ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);

    }



    *detections = mLatestDetections;

    return ScopedAStatus::ok();

}



bool OccupantAwareness::isValidRole(Role occupantRole) {

    int intVal = static_cast<int>(occupantRole);

    int allOccupants = static_cast<int>(Role::ALL_OCCUPANTS);

    return (occupantRole != Role::INVALID) && ((intVal & (~allOccupants)) == 0);

}



bool OccupantAwareness::isValidDetectionCapabilities(int detectionCapabilities) {

    return (detectionCapabilities != OccupantAwareness::CAP_NONE) &&

           ((detectionCapabilities & (~kAllCapabilities)) == 0);

}



bool OccupantAwareness::isSingularCapability(int detectionCapability) {

    // Check whether the value is 0, or the value has only one bit set.

    return (detectionCapability & (detectionCapability - 1)) == 0;

}



void OccupantAwareness::startWorkerThread(OccupantAwareness* occupantAwareness) {

    occupantAwareness->workerThreadFunction();

}



void OccupantAwareness::workerThreadFunction() {

    bool isFirstDetection = true;

    int64_t prevDetectionTimeMs;

    while (mStatus == OccupantAwarenessStatus::READY) {

        int64_t currentTimeMs = android::elapsedRealtimeNano() / kNanoSecondsPerMilliSecond;

        if ((isFirstDetection) || (currentTimeMs - prevDetectionTimeMs > mDetectionDurationMs)) {

            std::lock_guard<std::mutex> lock(mMutex);

            mLatestDetections = mGenerator.GetNextDetections();

            if (mCallback != nullptr) {

                mCallback->onDetectionEvent(mLatestDetections);

            }

            isFirstDetection = false;

            prevDetectionTimeMs = currentTimeMs;

        }

    }

}



}  // namespace implementation

}  // namespace V1_0

}  // namespace occupant_awareness

}  // namespace automotive

}  // namespace hardware

}  // namespace android

automotive/occupant_awareness/aidl/mock/OccupantAwareness.h

0 → 100644
+83 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <thread>



#include <aidl/android/hardware/automotive/occupant_awareness/BnOccupantAwareness.h>

#include <aidl/android/hardware/automotive/occupant_awareness/BnOccupantAwarenessClientCallback.h>

#include <utils/StrongPointer.h>



#include "DetectionGenerator.h"



namespace android {

namespace hardware {

namespace automotive {

namespace occupant_awareness {

namespace V1_0 {

namespace implementation {



using ::aidl::android::hardware::automotive::occupant_awareness::BnOccupantAwareness;

using ::aidl::android::hardware::automotive::occupant_awareness::IOccupantAwarenessClientCallback;

using ::aidl::android::hardware::automotive::occupant_awareness::OccupantAwarenessStatus;

using ::aidl::android::hardware::automotive::occupant_awareness::OccupantDetections;

using ::aidl::android::hardware::automotive::occupant_awareness::Role;



/**

 * The mock HAL can detect presence of Driver and front passenger, and driver awareness detection

 * for driver.

 **/

class OccupantAwareness : public BnOccupantAwareness {

  public:

    // Methods from ::android::hardware::automotive::occupant_awareness::IOccupantAwareness

    // follow.

    ndk::ScopedAStatus startDetection(OccupantAwarenessStatus* status) override;

    ndk::ScopedAStatus stopDetection(OccupantAwarenessStatus* status) override;

    ndk::ScopedAStatus getCapabilityForRole(Role occupantRole, int32_t* capabilities) override;

    ndk::ScopedAStatus getState(Role occupantRole, int detectionCapability,

                                OccupantAwarenessStatus* status) override;

    ndk::ScopedAStatus setCallback(

            const std::shared_ptr<IOccupantAwarenessClientCallback>& callback) override;

    ndk::ScopedAStatus getLatestDetection(OccupantDetections* detections) override;



  private:

    bool isValidRole(Role occupantRole);

    bool isValidDetectionCapabilities(int detectionCapabilities);

    bool isSingularCapability(int detectionCapability);



    void workerThreadFunction();

    static void startWorkerThread(OccupantAwareness* occupantAwareness);



    std::mutex mMutex;

    std::shared_ptr<IOccupantAwarenessClientCallback> mCallback = nullptr;

    OccupantAwarenessStatus mStatus = OccupantAwarenessStatus::NOT_INITIALIZED;



    OccupantDetections mLatestDetections;

    std::thread mWorkerThread;



    DetectionGenerator mGenerator;



    // Generate a new detection every 1ms.

    const int64_t mDetectionDurationMs = 1;

};



}  // namespace implementation

}  // namespace V1_0

}  // namespace occupant_awareness

}  // namespace automotive

}  // namespace hardware

}  // namespace android