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

Commit 0ee6d518 authored by Arun Voddu's avatar Arun Voddu Committed by Automerger Merge Worker
Browse files

Merge "VTS to verify set/get AllowedCarriers for HAL 2.2" into android15-tests-dev am: 0a93bdbd 

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/3298014



Change-Id: I77cbab5239101000e7f61ca7cf2f7db0fd76a9ff
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fc1f3184 0a93bdbd

radio/aidl/compat/libradiocompat/sim/structs.cpp

+40 −6
Original line number Diff line number Diff line
@@ -70,26 +70,60 @@ V1_0::Carrier toHidl(const aidl::Carrier& carrier) { 
    };

}



static aidl::CarrierInfo toCarrierInfo(const aidl::Carrier& carrier) {

    return {

            .mcc = carrier.mcc,

            .mnc = carrier.mnc,

    };

}



static std::vector<aidl::CarrierInfo> toCarrierInfos(const std::vector<aidl::Carrier>& carriers) {

    std::vector<aidl::CarrierInfo> infos(carriers.size());

    for (size_t i = 0; i < carriers.size(); i++) {

        infos[i] = toCarrierInfo(carriers[i]);

    }

    return infos;

}



V1_0::Carrier toHidl(const aidl::CarrierInfo& carrierInfo) {

    return {

            .mcc = carrierInfo.mcc,

            .mnc = carrierInfo.mnc,

    };

}



aidl::CarrierRestrictions toAidl(const V1_0::CarrierRestrictions& cr) {

    auto allowedCarriers = toAidl(cr.allowedCarriers);

    auto excludedCarriers = toAidl(cr.excludedCarriers);

    return {

            .allowedCarriers = toAidl(cr.allowedCarriers),

            .excludedCarriers = toAidl(cr.excludedCarriers),

            .allowedCarriers = allowedCarriers,

            .excludedCarriers = excludedCarriers,

            .allowedCarriersPrioritized = true,

            .allowedCarrierInfoList = toCarrierInfos(allowedCarriers),

            .excludedCarrierInfoList = toCarrierInfos(excludedCarriers),

    };

}



aidl::CarrierRestrictions toAidl(const V1_4::CarrierRestrictionsWithPriority& cr) {

    auto allowedCarriers = toAidl(cr.allowedCarriers);

    auto excludedCarriers = toAidl(cr.excludedCarriers);

    return {

            .allowedCarriers = toAidl(cr.allowedCarriers),

            .excludedCarriers = toAidl(cr.excludedCarriers),

            .allowedCarriers = allowedCarriers,

            .excludedCarriers = excludedCarriers,

            .allowedCarriersPrioritized = cr.allowedCarriersPrioritized,

            .allowedCarrierInfoList = toCarrierInfos(allowedCarriers),

            .excludedCarrierInfoList = toCarrierInfos(excludedCarriers),

    };

}



V1_4::CarrierRestrictionsWithPriority toHidl(const aidl::CarrierRestrictions& cr) {

    return {

            .allowedCarriers = toHidl(cr.allowedCarriers),

            .excludedCarriers = toHidl(cr.excludedCarriers),

            .allowedCarriers = (cr.allowedCarriers.size() > cr.allowedCarrierInfoList.size())

                                       ? toHidl(cr.allowedCarriers)

                                       : toHidl(cr.allowedCarrierInfoList),

            .excludedCarriers = (cr.excludedCarriers.size() > cr.excludedCarrierInfoList.size())

                                        ? toHidl(cr.excludedCarriers)

                                        : toHidl(cr.excludedCarrierInfoList),

            .allowedCarriersPrioritized = cr.allowedCarriersPrioritized,

    };

}

radio/aidl/compat/libradiocompat/sim/structs.h

+1 −0
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ V1_0::SimApdu toHidl(const ::aidl::android::hardware::radio::sim::SimApdu& apdu) 


::aidl::android::hardware::radio::sim::Carrier toAidl(const V1_0::Carrier& carrier);

V1_0::Carrier toHidl(const ::aidl::android::hardware::radio::sim::Carrier& carrier);

V1_0::Carrier toHidl(const ::aidl::android::hardware::radio::sim::CarrierInfo& carrierInfo);



::aidl::android::hardware::radio::sim::CarrierRestrictions  //

toAidl(const V1_0::CarrierRestrictions& cr);

radio/aidl/vts/radio_sim_test.cpp

+78 −22
Original line number Diff line number Diff line
@@ -460,6 +460,20 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
    serial = GetRandomSerialNumber();

    CarrierRestrictions carrierRestrictions;

    memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));

    int32_t aidl_version;

    ndk::ScopedAStatus aidl_status = radio_sim->getInterfaceVersion(&aidl_version);

    ASSERT_OK(aidl_status);



    // Changes start



    SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;

    ALOGI("VTSAllowedCarriers Current AIDL version is %d ", aidl_version);

    if (aidl_version <= 2) {

        ALOGI("VTSAllowedCarriers If aidl_version is below 3 then , it will consider old AIDLs");

        carrierRestrictions.allowedCarrierInfoList.resize(1);

        if ((carrierRestrictions.allowedCarrierInfoList.size() > 0)) {

            ALOGI("VTSAllowedCarriers If size of allowedCarrierInfoList is greater than 0");

        }

        carrierRestrictions.allowedCarriers.resize(1);

        carrierRestrictions.excludedCarriers.resize(0);

        carrierRestrictions.allowedCarriers[0].mcc = std::string("123");
@@ -467,7 +481,22 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
        carrierRestrictions.allowedCarriers[0].matchType = Carrier::MATCH_TYPE_ALL;

        carrierRestrictions.allowedCarriers[0].matchData = std::string();

        carrierRestrictions.allowedCarriersPrioritized = true;

    SimLockMultiSimPolicy multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;

        multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;

    } else {

        carrierRestrictions.allowedCarrierInfoList.resize(1);

        carrierRestrictions.excludedCarrierInfoList.resize(0);

        // TODO(b/365568518): change mcc/mnc to something else once CF fully supports

        // setAllowedCarriers

        carrierRestrictions.allowedCarrierInfoList[0].mcc = std::string("123");

        carrierRestrictions.allowedCarrierInfoList[0].mnc = std::string("456");

        carrierRestrictions.allowedCarrierInfoList[0].spn = std::string("TestNetwork");

        carrierRestrictions.allowedCarrierInfoList[0].gid1 = std::string("BAE000000000000");

        carrierRestrictions.allowedCarrierInfoList[0].gid2 = std::string("AE0000000000000");

        carrierRestrictions.allowedCarrierInfoList[0].imsiPrefix = std::string("9987");

        carrierRestrictions.allowedCarriersPrioritized = true;

        carrierRestrictions.status = CarrierRestrictions::CarrierRestrictionStatus::RESTRICTED;

        multisimPolicy = SimLockMultiSimPolicy::NO_MULTISIM_POLICY;

    }



    radio_sim->setAllowedCarriers(serial, carrierRestrictions, multisimPolicy);

    EXPECT_EQ(std::cv_status::no_timeout, wait());
@@ -490,7 +519,7 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
                sleep(2);

                updateSimCardStatus();

            }

            // TODO: uncomment once CF fully supports setAllowedCarriers

            // TODO(b/365568518): uncomment once CF fully supports setAllowedCarriers

            // EXPECT_EQ(CardStatus::STATE_RESTRICTED, cardStatus.cardState);

        }
@@ -503,8 +532,10 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
        EXPECT_EQ(serial, radioRsp_sim->rspInfo.serial);

        EXPECT_EQ(RadioError::NONE, radioRsp_sim->rspInfo.error);



        if (aidl_version <= 2) {

            EXPECT_EQ(1, radioRsp_sim->carrierRestrictionsResp.allowedCarriers.size());

            EXPECT_EQ(0, radioRsp_sim->carrierRestrictionsResp.excludedCarriers.size());



            ASSERT_TRUE(std::string("123") ==

                        radioRsp_sim->carrierRestrictionsResp.allowedCarriers[0].mcc);

            ASSERT_TRUE(std::string("456") ==
@@ -513,7 +544,26 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
                      radioRsp_sim->carrierRestrictionsResp.allowedCarriers[0].matchType);

            ASSERT_TRUE(radioRsp_sim->carrierRestrictionsResp.allowedCarriersPrioritized);

            EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_sim->multiSimPolicyResp);



        } else {

            EXPECT_EQ(1, radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList.size());

            EXPECT_EQ(0, radioRsp_sim->carrierRestrictionsResp.excludedCarrierInfoList.size());

            ASSERT_EQ(std::string("123"),

                      radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].mcc);

            ASSERT_EQ(std::string("456"),

                      radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].mnc);

#if 0  // TODO(b/365568518): enable once CF fully supports setAllowedCarriers

            ASSERT_EQ(std::string("BAE000000000000"),

                        radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].gid1);

            ASSERT_EQ(std::string("AE0000000000000"),

                        radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].gid2);

            ASSERT_EQ(std::string("9987"),

                        radioRsp_sim->carrierRestrictionsResp.allowedCarrierInfoList[0].imsiPrefix);

            EXPECT_EQ(CarrierRestrictions::CarrierRestrictionStatus::RESTRICTED,

                      radioRsp_sim->carrierRestrictionsResp.status);

#endif

            ASSERT_TRUE(radioRsp_sim->carrierRestrictionsResp.allowedCarriersPrioritized);

            EXPECT_EQ(SimLockMultiSimPolicy::NO_MULTISIM_POLICY, radioRsp_sim->multiSimPolicyResp);

        }

        sleep(10);



        /**
@@ -522,9 +572,15 @@ TEST_P(RadioSimTest, setAllowedCarriers) { 
         * status for cardStatus.

         */

        memset(&carrierRestrictions, 0, sizeof(carrierRestrictions));

        if (aidl_version <= 2) {

            carrierRestrictions.allowedCarriers.resize(0);

            carrierRestrictions.excludedCarriers.resize(0);

            carrierRestrictions.allowedCarriersPrioritized = false;

        } else {

            carrierRestrictions.allowedCarrierInfoList.resize(0);

            carrierRestrictions.excludedCarrierInfoList.resize(0);

            carrierRestrictions.allowedCarriersPrioritized = false;

        }



        serial = GetRandomSerialNumber();

        radio_sim->setAllowedCarriers(serial, carrierRestrictions, multisimPolicy);