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

Commit 0b29fb52 authored by Chienyuan Huang's avatar Chienyuan Huang Committed by Automerger Merge Worker
Browse files

Merge "Add VTS for Channel Sounding" into main am: e608eb8d am: b97107ae 

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



Change-Id: I70293b2756df641c2f719dffa7795f11f23421da
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents eb6c88c9 b97107ae

bluetooth/ranging/OWNERS

0 → 100644
+5 −0
Original line number Diff line number Diff line 
# Bug component: 27441



include platform/packages/modules/Bluetooth:/OWNERS



chienyuanhuang@google.com

bluetooth/ranging/aidl/vts/Android.bp

0 → 100644
+27 −0
Original line number Diff line number Diff line 
package {

    default_applicable_licenses: ["hardware_interfaces_license"],

}



cc_test {

    name: "VtsHalBluetoothRangingTargetTest",

    defaults: [

        "use_libaidlvintf_gtest_helper_static",

    ],

    srcs: ["VtsHalBluetoothRangingTargetTest.cpp"],

    shared_libs: [

        "libbase",

        "libbinder_ndk",

        "libcutils",

        "liblog",

        "libutils",

    ],

    static_libs: [

        "android.hardware.bluetooth.ranging-V1-ndk",

        "libbluetooth-types",

    ],

    test_config: "VtsHalBluetoothRangingTargetTest.xml",

    test_suites: [

        "general-tests",

        "vts",

    ],

}

bluetooth/ranging/aidl/vts/VtsHalBluetoothRangingTargetTest.cpp

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

 * Copyright (C) 2023 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 <aidl/Gtest.h>

#include <aidl/Vintf.h>

#include <aidl/android/hardware/bluetooth/ranging/BnBluetoothChannelSoundingSessionCallback.h>

#include <aidl/android/hardware/bluetooth/ranging/IBluetoothChannelSounding.h>

#include <aidl/android/hardware/bluetooth/ranging/IBluetoothChannelSoundingSessionCallback.h>

#include <android-base/logging.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>

#include <binder/IServiceManager.h>

#include <utils/Log.h>



using aidl::android::hardware::bluetooth::ranging::

    BluetoothChannelSoundingParameters;

using aidl::android::hardware::bluetooth::ranging::

    BnBluetoothChannelSoundingSessionCallback;

using aidl::android::hardware::bluetooth::ranging::ChannelSoudingRawData;

using aidl::android::hardware::bluetooth::ranging::CsSecurityLevel;

using aidl::android::hardware::bluetooth::ranging::IBluetoothChannelSounding;

using aidl::android::hardware::bluetooth::ranging::

    IBluetoothChannelSoundingSession;

using aidl::android::hardware::bluetooth::ranging::

    IBluetoothChannelSoundingSessionCallback;

using aidl::android::hardware::bluetooth::ranging::RangingResult;

using aidl::android::hardware::bluetooth::ranging::Reason;

using aidl::android::hardware::bluetooth::ranging::ResultType;

using aidl::android::hardware::bluetooth::ranging::SessionType;

using aidl::android::hardware::bluetooth::ranging::VendorSpecificData;

using ndk::ScopedAStatus;



class BluetoothChannelSoundingSessionCallback

    : public BnBluetoothChannelSoundingSessionCallback {

 public:

  ScopedAStatus onOpened(Reason reason) override;

  ScopedAStatus onOpenFailed(Reason reason) override;

  ScopedAStatus onResult(const RangingResult& in_result) override;

  ScopedAStatus onClose(Reason reason) override;

  ScopedAStatus onCloseFailed(Reason reason) override;

};



ScopedAStatus BluetoothChannelSoundingSessionCallback::onOpened(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onOpenFailed(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onResult(

    const RangingResult& /*in_result*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onClose(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}

ScopedAStatus BluetoothChannelSoundingSessionCallback::onCloseFailed(

    Reason /*reason*/) {

  return ::ndk::ScopedAStatus::ok();

}



class BluetoothRangingTest : public ::testing::TestWithParam<std::string> {

 public:

  virtual void SetUp() override {

    ALOGI("SetUp Ranging Test");

    bluetooth_channel_sounding_ = IBluetoothChannelSounding::fromBinder(

        ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));

    ASSERT_NE(bluetooth_channel_sounding_, nullptr);

  }



  virtual void TearDown() override {

    ALOGI("TearDown Ranging Test");

    bluetooth_channel_sounding_ = nullptr;

    ASSERT_EQ(bluetooth_channel_sounding_, nullptr);

  }



  ScopedAStatus getVendorSpecificData(

      std::optional<std::vector<std::optional<VendorSpecificData>>>*

          _aidl_return);

  ScopedAStatus getSupportedSessionTypes(

      std::optional<std::vector<SessionType>>* _aidl_return);

  ScopedAStatus getMaxSupportedCsSecurityLevel(CsSecurityLevel* _aidl_return);

  ScopedAStatus openSession(

      const BluetoothChannelSoundingParameters& in_params,

      const std::shared_ptr<IBluetoothChannelSoundingSessionCallback>&

          in_callback,

      std::shared_ptr<IBluetoothChannelSoundingSession>* _aidl_return);



  ScopedAStatus initBluetoothChannelSoundingSession(

      std::shared_ptr<IBluetoothChannelSoundingSession>* session) {

    BluetoothChannelSoundingParameters params;

    std::shared_ptr<BluetoothChannelSoundingSessionCallback> callback = nullptr;

    callback =

        ndk::SharedRefBase::make<BluetoothChannelSoundingSessionCallback>();

    ScopedAStatus status = openSession(params, callback, session);

    return status;

  }



 private:

  std::shared_ptr<IBluetoothChannelSounding> bluetooth_channel_sounding_;

};



ScopedAStatus BluetoothRangingTest::getVendorSpecificData(

    std::optional<std::vector<std::optional<VendorSpecificData>>>*

        _aidl_return) {

  return bluetooth_channel_sounding_->getVendorSpecificData(_aidl_return);

}

ScopedAStatus BluetoothRangingTest::getSupportedSessionTypes(

    std::optional<std::vector<SessionType>>* _aidl_return) {

  return bluetooth_channel_sounding_->getSupportedSessionTypes(_aidl_return);

}



ScopedAStatus BluetoothRangingTest::getMaxSupportedCsSecurityLevel(

    CsSecurityLevel* _aidl_return) {

  return bluetooth_channel_sounding_->getMaxSupportedCsSecurityLevel(

      _aidl_return);

}

ScopedAStatus BluetoothRangingTest::openSession(

    const BluetoothChannelSoundingParameters& in_params,

    const std::shared_ptr<IBluetoothChannelSoundingSessionCallback>&

        in_callback,

    std::shared_ptr<IBluetoothChannelSoundingSession>* _aidl_return) {

  return bluetooth_channel_sounding_->openSession(in_params, in_callback,

                                                  _aidl_return);

}



TEST_P(BluetoothRangingTest, SetupAndTearDown) {}



TEST_P(BluetoothRangingTest, GetVendorSpecificData) {

  std::optional<std::vector<std::optional<VendorSpecificData>>>

      vendor_specific_data;

  ScopedAStatus status = getVendorSpecificData(&vendor_specific_data);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetSupportedSessionTypes) {

  std::optional<std::vector<SessionType>> supported_session_types;

  ScopedAStatus status = getSupportedSessionTypes(&supported_session_types);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetMaxSupportedCsSecurityLevel) {

  CsSecurityLevel security_level;

  ScopedAStatus status = getMaxSupportedCsSecurityLevel(&security_level);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, OpenSession) {

  BluetoothChannelSoundingParameters params;

  std::shared_ptr<BluetoothChannelSoundingSessionCallback> callback = nullptr;

  callback =

      ndk::SharedRefBase::make<BluetoothChannelSoundingSessionCallback>();

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  ScopedAStatus status = openSession(params, callback, &session);

  ASSERT_TRUE(status.isOk());

}



TEST_P(BluetoothRangingTest, GetVendorSpecificReplies) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    std::optional<std::vector<std::optional<VendorSpecificData>>>

        vendor_specific_data;

    status = session->getVendorSpecificReplies(&vendor_specific_data);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, GetSupportedResultTypes) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    std::vector<ResultType> supported_result_types;

    status = session->getSupportedResultTypes(&supported_result_types);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, IsAbortedProcedureRequired) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    bool is_abort_procedure_required = true;

    status = session->isAbortedProcedureRequired(&is_abort_procedure_required);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, WriteRawData) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    ChannelSoudingRawData raw_data;

    status = session->writeRawData(raw_data);

    ASSERT_TRUE(status.isOk());

  }

}



TEST_P(BluetoothRangingTest, CloseSession) {

  std::shared_ptr<IBluetoothChannelSoundingSession> session;

  auto status = initBluetoothChannelSoundingSession(&session);

  ASSERT_TRUE(status.isOk());

  if (session != nullptr) {

    status = session->close(Reason::LOCAL_STACK_REQUEST);

    ASSERT_TRUE(status.isOk());

  }

}



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BluetoothRangingTest);

INSTANTIATE_TEST_SUITE_P(PerInstance, BluetoothRangingTest,

                         testing::ValuesIn(android::getAidlHalInstanceNames(

                             IBluetoothChannelSounding::descriptor)),

                         android::PrintInstanceNameToString);



int main(int argc, char** argv) {

  ::testing::InitGoogleTest(&argc, argv);

  ABinderProcess_startThreadPool();

  int status = RUN_ALL_TESTS();

  ALOGI("Test result = %d", status);

  return status;

}
 
 No newline at end of file

bluetooth/ranging/aidl/vts/VtsHalBluetoothRangingTargetTest.xml

0 → 100644
+33 −0
Original line number Diff line number Diff line 
<!--

  Copyright (C) 2023 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.

-->



<configuration description="Runs VtsHalBluetoothRangingTargetTest.">

    <option name="test-suite-tag" value="apct" />

    <option name="test-suite-tag" value="apct-native" />



    <target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer">

    </target_preparer>



    <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer">

        <option name="cleanup" value="true" />

        <option name="push" value="VtsHalBluetoothRangingTargetTest->/data/local/tmp/VtsHalBluetoothRangingTargetTest" />

    </target_preparer>



    <test class="com.android.tradefed.testtype.GTest" >

        <option name="native-test-device-path" value="/data/local/tmp" />

        <option name="module-name" value="VtsHalBluetoothRangingTargetTest" />

    </test>

</configuration>