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

Commit 233994a3 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 8386572 from f898641c to tm-d1-release

Change-Id: Ifdbecc5e7aee213845a4c0ee5c2e62703d4723aa
parents efaf5679 f898641c
Loading
Loading
Loading
Loading
+34 −32
Original line number Original line Diff line number Diff line
@@ -430,8 +430,8 @@ TEST_P(EvsAidlTest, CameraStreamPerformance) {
        mActiveCameras.push_back(pCam);
        mActiveCameras.push_back(pCam);


        // Set up a frame receiver object which will fire up its own thread
        // Set up a frame receiver object which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, nullptr, FrameHandler::eAutoReturn);
                pCam, cam, nullptr, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start the camera's video stream
        // Start the camera's video stream
@@ -529,8 +529,8 @@ TEST_P(EvsAidlTest, CameraStreamBuffering) {
        ASSERT_TRUE(pCam->setMaxFramesInFlight(kBuffersToHold).isOk());
        ASSERT_TRUE(pCam->setMaxFramesInFlight(kBuffersToHold).isOk());


        // Set up a frame receiver object which will fire up its own thread.
        // Set up a frame receiver object which will fire up its own thread.
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, nullptr, FrameHandler::eNoAutoReturn);
                pCam, cam, nullptr, FrameHandler::eNoAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start the camera's video stream
        // Start the camera's video stream
@@ -619,8 +619,8 @@ TEST_P(EvsAidlTest, CameraToDisplayRoundTrip) {
        mActiveCameras.push_back(pCam);
        mActiveCameras.push_back(pCam);


        // Set up a frame receiver object which will fire up its own thread.
        // Set up a frame receiver object which will fire up its own thread.
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, pDisplay, FrameHandler::eAutoReturn);
                pCam, cam, pDisplay, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Activate the display
        // Activate the display
@@ -697,10 +697,10 @@ TEST_P(EvsAidlTest, MultiCameraStream) {
        mActiveCameras.push_back(pCam1);
        mActiveCameras.push_back(pCam1);


        // Set up per-client frame receiver objects which will fire up its own thread
        // Set up per-client frame receiver objects which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandler0 =
        std::shared_ptr<FrameHandler> frameHandler0 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam0, cam, nullptr, FrameHandler::eAutoReturn);
                pCam0, cam, nullptr, FrameHandler::eAutoReturn);
        std::shared_ptr<FrameHandler> frameHandler1 =
        std::shared_ptr<FrameHandler> frameHandler1 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam1, cam, nullptr, FrameHandler::eAutoReturn);
                pCam1, cam, nullptr, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler1, nullptr);
        EXPECT_NE(frameHandler1, nullptr);


@@ -803,8 +803,8 @@ TEST_P(EvsAidlTest, CameraParameter) {
        }
        }


        // Set up per-client frame receiver objects which will fire up its own thread
        // Set up per-client frame receiver objects which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, nullptr, FrameHandler::eAutoReturn);
                pCam, cam, nullptr, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start the camera's video stream
        // Start the camera's video stream
@@ -903,10 +903,11 @@ TEST_P(EvsAidlTest, CameraPrimaryClientRelease) {
        mActiveCameras.push_back(pSecondaryCam);
        mActiveCameras.push_back(pSecondaryCam);


        // Set up per-client frame receiver objects which will fire up its own thread
        // Set up per-client frame receiver objects which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandlerPrimary = std::make_shared<FrameHandler>(
        std::shared_ptr<FrameHandler> frameHandlerPrimary = ndk::SharedRefBase::make<FrameHandler>(
                pPrimaryCam, cam, nullptr, FrameHandler::eAutoReturn);
                pPrimaryCam, cam, nullptr, FrameHandler::eAutoReturn);
        std::shared_ptr<FrameHandler> frameHandlerSecondary = std::make_shared<FrameHandler>(
        std::shared_ptr<FrameHandler> frameHandlerSecondary =
                pSecondaryCam, cam, nullptr, FrameHandler::eAutoReturn);
                ndk::SharedRefBase::make<FrameHandler>(pSecondaryCam, cam, nullptr,
                                                       FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandlerPrimary, nullptr);
        EXPECT_NE(frameHandlerPrimary, nullptr);
        EXPECT_NE(frameHandlerSecondary, nullptr);
        EXPECT_NE(frameHandlerSecondary, nullptr);


@@ -1075,10 +1076,11 @@ TEST_P(EvsAidlTest, MultiCameraParameter) {
        }
        }


        // Set up per-client frame receiver objects which will fire up its own thread
        // Set up per-client frame receiver objects which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandlerPrimary = std::make_shared<FrameHandler>(
        std::shared_ptr<FrameHandler> frameHandlerPrimary = ndk::SharedRefBase::make<FrameHandler>(
                pPrimaryCam, cam, nullptr, FrameHandler::eAutoReturn);
                pPrimaryCam, cam, nullptr, FrameHandler::eAutoReturn);
        std::shared_ptr<FrameHandler> frameHandlerSecondary = std::make_shared<FrameHandler>(
        std::shared_ptr<FrameHandler> frameHandlerSecondary =
                pSecondaryCam, cam, nullptr, FrameHandler::eAutoReturn);
                ndk::SharedRefBase::make<FrameHandler>(pSecondaryCam, cam, nullptr,
                                                       FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandlerPrimary, nullptr);
        EXPECT_NE(frameHandlerPrimary, nullptr);
        EXPECT_NE(frameHandlerSecondary, nullptr);
        EXPECT_NE(frameHandlerSecondary, nullptr);


@@ -1418,10 +1420,10 @@ TEST_P(EvsAidlTest, HighPriorityCameraClient) {
        }
        }


        // Set up a frame receiver object which will fire up its own thread.
        // Set up a frame receiver object which will fire up its own thread.
        std::shared_ptr<FrameHandler> frameHandler0 =
        std::shared_ptr<FrameHandler> frameHandler0 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam0, cam, nullptr, FrameHandler::eAutoReturn);
                pCam0, cam, nullptr, FrameHandler::eAutoReturn);
        std::shared_ptr<FrameHandler> frameHandler1 =
        std::shared_ptr<FrameHandler> frameHandler1 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam1, cam, nullptr, FrameHandler::eAutoReturn);
                pCam1, cam, nullptr, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler1, nullptr);
        EXPECT_NE(frameHandler1, nullptr);


@@ -1733,8 +1735,8 @@ TEST_P(EvsAidlTest, CameraUseStreamConfigToDisplay) {
        mActiveCameras.push_back(pCam);
        mActiveCameras.push_back(pCam);


        // Set up a frame receiver object which will fire up its own thread.
        // Set up a frame receiver object which will fire up its own thread.
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, pDisplay, FrameHandler::eAutoReturn);
                pCam, cam, pDisplay, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Activate the display
        // Activate the display
@@ -1843,10 +1845,10 @@ TEST_P(EvsAidlTest, MultiCameraStreamUseConfig) {
        EXPECT_NE(pCam1, nullptr);
        EXPECT_NE(pCam1, nullptr);


        // Set up per-client frame receiver objects which will fire up its own thread
        // Set up per-client frame receiver objects which will fire up its own thread
        std::shared_ptr<FrameHandler> frameHandler0 =
        std::shared_ptr<FrameHandler> frameHandler0 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam0, cam, nullptr, FrameHandler::eAutoReturn);
                pCam0, cam, nullptr, FrameHandler::eAutoReturn);
        std::shared_ptr<FrameHandler> frameHandler1 =
        std::shared_ptr<FrameHandler> frameHandler1 = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam1, cam, nullptr, FrameHandler::eAutoReturn);
                pCam1, cam, nullptr, FrameHandler::eAutoReturn);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler0, nullptr);
        EXPECT_NE(frameHandler1, nullptr);
        EXPECT_NE(frameHandler1, nullptr);


@@ -2008,8 +2010,8 @@ TEST_P(EvsAidlTest, CameraStreamExternalBuffering) {
        EXPECT_GE(delta, kBuffersToHold);
        EXPECT_GE(delta, kBuffersToHold);


        // Set up a frame receiver object which will fire up its own thread.
        // Set up a frame receiver object which will fire up its own thread.
        std::shared_ptr<FrameHandler> frameHandler =
        std::shared_ptr<FrameHandler> frameHandler = ndk::SharedRefBase::make<FrameHandler>(
                std::make_shared<FrameHandler>(pCam, cam, nullptr, FrameHandler::eNoAutoReturn);
                pCam, cam, nullptr, FrameHandler::eNoAutoReturn);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start the camera's video stream
        // Start the camera's video stream
@@ -2101,7 +2103,7 @@ TEST_P(EvsAidlTest, UltrasonicsVerifyStreamData) {
        EXPECT_NE(pUltrasonicsArray, nullptr);
        EXPECT_NE(pUltrasonicsArray, nullptr);


        std::shared_ptr<FrameHandlerUltrasonics> frameHandler =
        std::shared_ptr<FrameHandlerUltrasonics> frameHandler =
                std::make_shared<FrameHandlerUltrasonics>(pUltrasonicsArray);
                ndk::SharedRefBase::make<FrameHandlerUltrasonics>(pUltrasonicsArray);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start stream.
        // Start stream.
@@ -2141,7 +2143,7 @@ TEST_P(EvsAidlTest, UltrasonicsSetFramesInFlight) {
        ASSERT_TRUE(pUltrasonicsArray->setMaxFramesInFlight(10).isOk());
        ASSERT_TRUE(pUltrasonicsArray->setMaxFramesInFlight(10).isOk());


        std::shared_ptr<FrameHandlerUltrasonics> frameHandler =
        std::shared_ptr<FrameHandlerUltrasonics> frameHandler =
                std::make_shared<FrameHandlerUltrasonics>(pUltrasonicsArray);
                ndk::SharedRefBase::make<FrameHandlerUltrasonics>(pUltrasonicsArray);
        EXPECT_NE(frameHandler, nullptr);
        EXPECT_NE(frameHandler, nullptr);


        // Start stream.
        // Start stream.
+105 −0
Original line number Original line Diff line number Diff line
@@ -287,6 +287,71 @@ const std::vector<ConfigDeclaration> kVehicleProperties = {
                 },
                 },
         .initialValue = {.floatValues = {0.0f}}},
         .initialValue = {.floatValues = {0.0f}}},


        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_CHARGE_CURRENT_DRAW_LIMIT),
                         .access = VehiclePropertyAccess::READ_WRITE,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.floatValues = {(float)VehicleUnit::AMPERE}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_CHARGE_PERCENT_LIMIT),
                         .access = VehiclePropertyAccess::READ_WRITE,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                         .configArray = {20, 40, 60, 80, 100},
                 },
         .initialValue = {.floatValues = {40}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_CHARGE_STATE),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {2}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_CHARGE_SWITCH),
                         .access = VehiclePropertyAccess::READ_WRITE,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {0 /* false */}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_CHARGE_TIME_REMAINING),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::CONTINUOUS,
                 },
         .initialValue = {.int32Values = {20}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::EV_REGENERATIVE_BRAKING_STATE),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {2}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::TRAILER_PRESENT),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {2}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::VEHICLE_CURB_WEIGHT),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::STATIC,
                 },
         .initialValue = {.int32Values = {30}}},

        {.config =
        {.config =
                 {
                 {
                         .prop = toInt(VehicleProperty::RANGE_REMAINING),
                         .prop = toInt(VehicleProperty::RANGE_REMAINING),
@@ -818,6 +883,22 @@ const std::vector<ConfigDeclaration> kVehicleProperties = {
                 },
                 },
         .initialValue = {.int32Values = {LIGHT_STATE_ON}}},
         .initialValue = {.int32Values = {LIGHT_STATE_ON}}},


        {.config =
                 {
                         .prop = toInt(VehicleProperty::FRONT_FOG_LIGHTS_STATE),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {LIGHT_STATE_ON}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::REAR_FOG_LIGHTS_STATE),
                         .access = VehiclePropertyAccess::READ,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {LIGHT_STATE_ON}}},

        {.config =
        {.config =
                 {
                 {
                         .prop = toInt(VehicleProperty::HAZARD_LIGHTS_STATE),
                         .prop = toInt(VehicleProperty::HAZARD_LIGHTS_STATE),
@@ -850,6 +931,22 @@ const std::vector<ConfigDeclaration> kVehicleProperties = {
                 },
                 },
         .initialValue = {.int32Values = {LIGHT_SWITCH_AUTO}}},
         .initialValue = {.int32Values = {LIGHT_SWITCH_AUTO}}},


        {.config =
                 {
                         .prop = toInt(VehicleProperty::FRONT_FOG_LIGHTS_SWITCH),
                         .access = VehiclePropertyAccess::READ_WRITE,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {LIGHT_SWITCH_AUTO}}},

        {.config =
                 {
                         .prop = toInt(VehicleProperty::REAR_FOG_LIGHTS_SWITCH),
                         .access = VehiclePropertyAccess::READ_WRITE,
                         .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                 },
         .initialValue = {.int32Values = {LIGHT_SWITCH_AUTO}}},

        {.config =
        {.config =
                 {
                 {
                         .prop = toInt(VehicleProperty::HAZARD_LIGHTS_SWITCH),
                         .prop = toInt(VehicleProperty::HAZARD_LIGHTS_SWITCH),
@@ -1124,6 +1221,14 @@ const std::vector<ConfigDeclaration> kVehicleProperties = {
                        },
                        },
                .initialValue = {.stringValue = {"Test"}},
                .initialValue = {.stringValue = {"Test"}},
        },
        },
        {
                .config =
                        {
                                .prop = ECHO_REVERSE_BYTES,
                                .access = VehiclePropertyAccess::READ_WRITE,
                                .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
                        },
        },
#ifdef ENABLE_VENDOR_CLUSTER_PROPERTY_FOR_TESTING
#ifdef ENABLE_VENDOR_CLUSTER_PROPERTY_FOR_TESTING
        // Vendor propetry for E2E ClusterHomeService testing.
        // Vendor propetry for E2E ClusterHomeService testing.
        {
        {
+2 −0
Original line number Original line Diff line number Diff line
@@ -131,6 +131,8 @@ class FakeVehicleHardware : public IVehicleHardware {
            const aidl::android::hardware::automotive::vehicle::VehiclePropValue& value);
            const aidl::android::hardware::automotive::vehicle::VehiclePropValue& value);
    ValueResultType getUserHalProp(
    ValueResultType getUserHalProp(
            const aidl::android::hardware::automotive::vehicle::VehiclePropValue& value) const;
            const aidl::android::hardware::automotive::vehicle::VehiclePropValue& value) const;
    ValueResultType getEchoReverseBytes(
            const aidl::android::hardware::automotive::vehicle::VehiclePropValue& value) const;
    bool isHvacPropAndHvacNotAvailable(int32_t propId);
    bool isHvacPropAndHvacNotAvailable(int32_t propId);


    std::string dumpAllProperties();
    std::string dumpAllProperties();
+20 −0
Original line number Original line Diff line number Diff line
@@ -23,6 +23,7 @@
#include <FakeObd2Frame.h>
#include <FakeObd2Frame.h>
#include <JsonFakeValueGenerator.h>
#include <JsonFakeValueGenerator.h>
#include <PropertyUtils.h>
#include <PropertyUtils.h>
#include <TestPropertyUtils.h>
#include <VehicleHalTypes.h>
#include <VehicleHalTypes.h>
#include <VehicleUtils.h>
#include <VehicleUtils.h>
#include <android-base/parsedouble.h>
#include <android-base/parsedouble.h>
@@ -335,6 +336,9 @@ FakeVehicleHardware::ValueResultType FakeVehicleHardware::maybeGetSpecialValue(
                result.value()->timestamp = elapsedRealtimeNano();
                result.value()->timestamp = elapsedRealtimeNano();
            }
            }
            return result;
            return result;
        case ECHO_REVERSE_BYTES:
            *isSpecialValue = true;
            return getEchoReverseBytes(value);
        default:
        default:
            // Do nothing.
            // Do nothing.
            break;
            break;
@@ -343,6 +347,22 @@ FakeVehicleHardware::ValueResultType FakeVehicleHardware::maybeGetSpecialValue(
    return nullptr;
    return nullptr;
}
}


FakeVehicleHardware::ValueResultType FakeVehicleHardware::getEchoReverseBytes(
        const VehiclePropValue& value) const {
    auto readResult = mServerSidePropStore->readValue(value);
    if (!readResult.ok()) {
        return readResult;
    }
    auto& gotValue = readResult.value();
    gotValue->timestamp = elapsedRealtimeNano();
    std::vector<uint8_t> byteValues = gotValue->value.byteValues;
    size_t byteSize = byteValues.size();
    for (size_t i = 0; i < byteSize; i++) {
        gotValue->value.byteValues[i] = byteValues[byteSize - 1 - i];
    }
    return std::move(gotValue);
}

VhalResult<void> FakeVehicleHardware::maybeSetSpecialValue(const VehiclePropValue& value,
VhalResult<void> FakeVehicleHardware::maybeSetSpecialValue(const VehiclePropValue& value,
                                                           bool* isSpecialValue) {
                                                           bool* isSpecialValue) {
    *isSpecialValue = false;
    *isSpecialValue = false;
+23 −0
Original line number Original line Diff line number Diff line
@@ -276,6 +276,11 @@ TEST_F(FakeVehicleHardwareTest, testGetDefaultValues) {
            continue;
            continue;
        }
        }


        if (config.config.prop == ECHO_REVERSE_BYTES) {
            // Ignore ECHO_REVERSE_BYTES, it has special logic.
            continue;
        }

        int propId = config.config.prop;
        int propId = config.config.prop;
        if (isGlobalProp(propId)) {
        if (isGlobalProp(propId)) {
            if (config.initialValue == RawPropValues{}) {
            if (config.initialValue == RawPropValues{}) {
@@ -1487,6 +1492,24 @@ TEST_F(FakeVehicleHardwareTest, SetComplexPropTest) {
    ASSERT_EQ(3.402823466E+38f, value.value.floatValues[2]);
    ASSERT_EQ(3.402823466E+38f, value.value.floatValues[2]);
}
}


TEST_F(FakeVehicleHardwareTest, testGetEchoReverseBytes) {
    ASSERT_EQ(setValue(VehiclePropValue{
                      .prop = ECHO_REVERSE_BYTES,
                      .value =
                              {
                                      .byteValues = {0x01, 0x02, 0x03, 0x04},
                              },
              }),
              StatusCode::OK);

    auto result = getValue(VehiclePropValue{
            .prop = ECHO_REVERSE_BYTES,
    });

    ASSERT_TRUE(result.ok()) << "failed to get ECHO_REVERSE_BYTES value: " << getStatus(result);
    ASSERT_EQ(result.value().value.byteValues, std::vector<uint8_t>({0x04, 0x03, 0x02, 0x01}));
}

}  // namespace fake
}  // namespace fake
}  // namespace vehicle
}  // namespace vehicle
}  // namespace automotive
}  // namespace automotive
Loading