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

Commit b88e07e3 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes from topic "floss_suspend_resume_api" am: 2d952ade am:... 

Merge changes from topic "floss_suspend_resume_api" am: 2d952ade am: 53c1dfba am: 3339334a am: 1abccdb3 am: dd6512a1

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2078538



Change-Id: Ie7b9568be7f050414558b92b78ab1c4c703a4502
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 14834d58 dd6512a1

android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

+6 −1
Original line number Diff line number Diff line
@@ -626,6 +626,10 @@ static void switch_codec_callback(bool is_low_latency_buffer_size) { 
                               (jboolean)is_low_latency_buffer_size);

}



static void le_rand_callback(uint64_t random) {

  // Android doesn't support the LeRand API.

}



static void callback_thread_event(bt_cb_thread_evt event) {

  if (event == ASSOCIATE_JVM) {

    JavaVMAttachArgs args;
@@ -704,7 +708,8 @@ static bt_callbacks_t sBluetoothCallbacks = {sizeof(sBluetoothCallbacks), 
                                             link_quality_report_callback,

                                             generate_local_oob_data_callback,

                                             switch_buffer_size_callback,

                                             switch_codec_callback};

                                             switch_codec_callback,

                                             le_rand_callback};



// The callback to call when the wake alarm fires.

static alarm_cb sAlarmCallback;

system/blueberry/facade/topshim/facade.proto

+8 −0
Original line number Diff line number Diff line
@@ -9,11 +9,19 @@ service AdapterService { 
  rpc ToggleStack(ToggleStackRequest) returns (ToggleStackResponse) {}

  rpc SetDiscoveryMode(SetDiscoveryModeRequest) returns (SetDiscoveryModeResponse) {}

  rpc ClearEventFilter(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc ClearEventMask(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc ClearFilterAcceptList(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc DisconnectAllAcls(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc LeRand(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc RestoreFilterAcceptList(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc SetDefaultEventMask(google.protobuf.Empty) returns (google.protobuf.Empty) {}

  rpc SetEventFilterInquiryResultAllDevices(google.protobuf.Empty) returns (google.protobuf.Empty) {}

}



enum EventType {

  ADAPTER_STATE = 0;

  SSP_REQUEST = 1;

  LE_RAND = 2;

}

message FetchEventsRequest {}

system/blueberry/tests/gd/rust/topshim/facade/suspend_test.py

deleted100644 → 0
+0 −42
Original line number Diff line number Diff line 
#!/usr/bin/env python3

#

#   Copyright 2021 - 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.



import asyncio

from mobly import test_runner

from blueberry.tests.gd.rust.topshim.facade import topshim_base_test

from blueberry.tests.gd.rust.topshim.facade.automation_helper import AdapterAutomationHelper

import time





class SuspendTest(topshim_base_test.TopshimBaseTest):



    async def _test_verify_event_filter_cleared(self):

        self.dut_adapter = AdapterAutomationHelper(port=self.dut_port)

        event_loop = asyncio.get_running_loop()

        self.dut_adapter.fetch_events(event_loop)

        self.dut_adapter.pending_future = event_loop.create_future()

        await self.dut_adapter.clear_event_filter()

        #TODO(optedoblivion): Replace sleep with a call to LeGetRandom and synchronize on

        # the callback

        time.sleep(1)

        self.dut_adapter.event_handler.cancel()



    def test_verify_event_filter_cleared(self):

        asyncio.run(self._test_verify_event_filter_cleared())





if __name__ == "__main__":

    test_runner.main()

system/blueberry/tests/gd/rust/topshim/facade/adapter_test.py→system/blueberry/tests/topshim/adapter/adapter_test.py

+33 −0
Original line number Diff line number Diff line 
#!/usr/bin/env python3

#

#   Copyright 2021 - The Android Open Source Project

#   Copyright 2022 - 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.
@@ -15,24 +15,18 @@ 
#   limitations under the License.



import asyncio

from mobly import test_runner

from blueberry.tests.gd.rust.topshim.facade import topshim_base_test

from blueberry.tests.gd.rust.topshim.facade.automation_helper import AdapterAutomationHelper



from blueberry.tests.gd.cert.truth import assertThat

from blueberry.tests.topshim.lib.topshim_base_test import TopshimBaseTest

from blueberry.tests.topshim.lib.adapter_client import AdapterClient



from mobly import test_runner



class AdapterTest(topshim_base_test.TopshimBaseTest):



    async def _test_verify_adapter_started(self):

        self.dut_adapter = AdapterAutomationHelper(port=self.dut_port)

        event_loop = asyncio.get_running_loop()

        self.dut_adapter.fetch_events(event_loop)

        self.dut_adapter.pending_future = event_loop.create_future()

        await self.dut_adapter.toggle_stack()

        await self.dut_adapter.verify_adapter_started()

        self.dut_adapter.event_handler.cancel()

class AdapterTest(TopshimBaseTest):



    def test_verify_adapter_started(self):

        asyncio.run(self._test_verify_adapter_started())

        print("Adapter is verified when test starts")





if __name__ == "__main__":

system/blueberry/tests/gd/rust/topshim/facade/automation_helper.py→system/blueberry/tests/topshim/lib/adapter_client.py

+130 −0
Original line number Diff line number Diff line
@@ -23,55 +23,96 @@ from blueberry.facade.topshim import facade_pb2_grpc 
from google.protobuf import empty_pb2 as empty_proto





class AdapterAutomationHelper():

class AdapterClient():

    """

    Wrapper gRPC interface to the Topshim/BTIF layer

    """

    # Timeout for async wait

    DEFAULT_TIMEOUT = 6

    """Invoke gRPC on topshim for Adapter testing"""

    DEFAULT_TIMEOUT = 2

    __task_list = []

    __channel = None

    __adapter_stub = None

    __adapter_event_stream = None



    def __init__(self, port=8999):

        self.channel = grpc.aio.insecure_channel("localhost:%d" % port)

        self.adapter_stub = facade_pb2_grpc.AdapterServiceStub(self.channel)



        self.pending_future = None

        self.__channel = grpc.aio.insecure_channel("localhost:%d" % port)

        self.__adapter_stub = facade_pb2_grpc.AdapterServiceStub(self.__channel)

        self.__adapter_event_stream = self.__adapter_stub.FetchEvents(facade_pb2.FetchEventsRequest())



    async def terminate(self):

        for task in self.__task_list:

            task.cancel()

            task = None

        self.__task_list.clear()

        await self.__channel.close()



    async def __get_next_event(self, event, future):

        """Get the future of next event from the stream"""

        while True:

            e = await self.__adapter_event_stream.read()



            # Match event by some condition.

            if e.event_type == event:

                future.set_result(e.data)

                break

            else:

                print("Got '%s'; expecting '%s'" % (e.event_type, event))

                print(e)



    async def _listen_for_event(self, event):

        """Start fetching events"""

        future = asyncio.get_running_loop().create_future()

        self.__task_list.append(asyncio.get_running_loop().create_task(self.__get_next_event(event, future)))

        await asyncio.wait_for(future, AdapterClient.DEFAULT_TIMEOUT)

        return future



    def fetch_events(self, async_event_loop):

        self.adapter_event_stream = self.adapter_stub.FetchEvents(facade_pb2.FetchEventsRequest())

        self.event_handler = async_event_loop.create_task(self.get_next_event())



    """Enable/disable the stack"""

    async def _verify_adapter_started(self):

        future = await self._listen_for_event(facade_pb2.EventType.ADAPTER_STATE)

        return future.result() == "ON"



    async def toggle_stack(self, is_start=True):

        await self.adapter_stub.ToggleStack(facade_pb2.ToggleStackRequest(start_stack=is_start))

        """Enable/disable the stack"""

        await self.__adapter_stub.ToggleStack(facade_pb2.ToggleStackRequest(start_stack=is_start))

        return await self._verify_adapter_started()



    async def set_enable_page_scan(self):

        """Enable page scan (might be used for A2dp sink to be discoverable)"""

        await self.__adapter_stub.SetDiscoveryMode(facade_pb2.SetDiscoveryModeRequest(enable_page_scan=True))



    async def set_enable_page_scan(self):

        await self.adapter_stub.SetDiscoveryMode(facade_pb2.SetDiscoveryModeRequest(enable_page_scan=True))

    async def clear_event_filter(self):

        await self.__adapter_stub.ClearEventFilter(empty_proto.Empty())



    """Get the future of next event from the stream"""

    async def clear_event_mask(self):

        await self.__adapter_stub.ClearEventMask(empty_proto.Empty())



    async def get_next_event(self):

        while True:

            e = await self.adapter_event_stream.read()

            # Match event by some condition.

            if e.event_type == facade_pb2.EventType.ADAPTER_STATE and e.data == "ON" and self.pending_future is not None:

                self.pending_future.set_result(True)

    async def clear_filter_accept_list(self):

        await self.__adapter_stub.ClearFilterAcceptList(empty_proto.Empty())



    async def verify_adapter_started(self):

        await asyncio.wait_for(self.pending_future, AdapterAutomationHelper.DEFAULT_TIMEOUT)

    async def disconnect_all_acls(self):

        await self.__adapter_stub.DisconnectAllAcls(empty_proto.Empty())



    async def clear_event_filter(self):

        await self.adapter_stub.ClearEventFilter(empty_proto.Empty())

    async def le_rand(self):

        await self.__adapter_stub.LeRand(empty_proto.Empty())

        future = await self._listen_for_event(facade_pb2.EventType.LE_RAND)

        #        await asyncio.wait_for(future, AdapterClient.DEFAULT_TIMEOUT)

        return future.result()



    async def restore_filter_accept_list(self):

        await self.__adapter_stub.RestoreFilterAcceptList(empty_proto.Empty())



    async def set_default_event_mask(self):

        await self.__adapter_stub.SetDefaultEventMask(empty_proto.Empty())



    async def set_event_filter_inquiry_result_all_devices(self):

        await self.__adapter_stub.SetEventFilterInquiryResultAllDevices(empty_proto.Empty())





class A2dpAutomationHelper():

    """Invoke gRPC on topshim for A2DP testing"""



    def __init__(self, port=8999):

        self.channel = grpc.insecure_channel("localhost:%d" % port)

        self.media_stub = facade_pb2_grpc.MediaServiceStub(self.channel)

        self.__channel = grpc.insecure_channel("localhost:%d" % port)

        self.media_stub = facade_pb2_grpc.MediaServiceStub(self.__channel)



    """Start A2dp source profile service"""