am 139a4d2e: test_vendor_lib: Add test channel command transport and handler (89bf5c60) · Commits · e / os / android_packages_modules_Bluetooth

system/vendor_libs/test_vendor_lib/Android.mk

+2 −0

Original line number	Diff line number	Diff line
		@@ -13,6 +13,8 @@ LOCAL_SRC_FILES := \
		src/hci_transport.cc \
		src/packet.cc \
		src/packet_stream.cc \
		src/test_channel_handler.cc \
		src/test_channel_transport.cc \
		src/vendor_manager.cc \

		LOCAL_C_INCLUDES := \

system/vendor_libs/test_vendor_lib/include/dual_mode_controller.h

+24 −0

Original line number	Diff line number	Diff line
		@@ -17,10 +17,12 @@
		#pragma once

		#include <cstdint>
		#include <string>
		#include <vector>
		#include <unordered_map>

		#include "vendor_libs/test_vendor_lib/include/hci_handler.h"
		#include "vendor_libs/test_vendor_lib/include/test_channel_handler.h"

		namespace test_vendor_lib {

		@@ -48,6 +50,11 @@ class DualModeController {
		// in which commands are made available by which controller.
		void RegisterCommandsWithHandler(HciHandler& handler);

		// Registers test channel command callbacks with the TestChannelHandler
		// instance so that they are fired when the corresponding command name is
		// received from the test channel.
		void RegisterCommandsWithTestChannelHandler(TestChannelHandler& handler);

		// Sets the callback to be used for sending events back to the HCI.
		void RegisterEventChannel(
		std::function<void(std::unique_ptr<EventPacket>)> send_event);
		@@ -317,7 +324,17 @@ class DualModeController {
		// is halted.
		void HciInquiry(const std::vector<std::uint8_t>& args);

		void UciTimeoutAll(const std::vector<std::uint8_t>& args);

		private:
		enum State {
		kStandby, // Not receiving/transmitting any packets from/to other devices.
		kAdvertising, // Transmitting advertising packets.
		kScanning, // Listening for advertising packets.
		kInitiating, // Listening for advertising packets from a specific device.
		kConnection, // In a connection.
		};

		// Creates a command complete event and sends it back to the HCI.
		void SendCommandComplete(uint16_t command_opcode,
		const std::vector<uint8_t>& return_parameters) const;
		@@ -348,6 +365,10 @@ class DualModeController {
		std::function<void(const std::vector<std::uint8_t>&)>>
		active_commands_;

		std::unordered_map<std::string,
		std::function<void(const std::vector<std::uint8_t>&)>>
		test_channel_active_commands_;

		// Specifies the format of Inquiry Result events to be returned during the
		// Inquiry command.
		// 0x00: Standard Inquiry Result event format (default).
		@@ -356,6 +377,9 @@ class DualModeController {
		// 0x03-0xFF: Reserved.
		std::uint8_t inquiry_mode_;

		// Current link layer state of the controller.
		State state_;

		DISALLOW_COPY_AND_ASSIGN(DualModeController);
		};

system/vendor_libs/test_vendor_lib/include/hci_handler.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -58,7 +58,7 @@ class HciHandler {

		private:
		// Controller callbacks to be executed in handlers and registered in
		// RegisterControllerCallback().
		// RegisterControllerCommand().
		std::unordered_map<std::uint16_t,
		std::function<void(const std::vector<std::uint8_t> args)> >
		commands_;

system/vendor_libs/test_vendor_lib/include/test_channel_handler.h

0 → 100644

+61 −0

Original line number	Diff line number	Diff line
		//
		// Copyright 2015 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 <cstdint>
		#include <memory>
		#include <string>
		#include <unordered_map>
		#include <vector>

		#include "vendor_libs/test_vendor_lib/include/test_channel_transport.h"

		namespace test_vendor_lib {

		// Manages mappings from test channel commands to test channel callbacks
		// provided by the controller. Parallels the functionality of the HciHandler for
		// the test channel.
		class TestChannelHandler {
		public:
		TestChannelHandler() = default;

		~TestChannelHandler() = default;

		// Callback to be fired when a command is received from the test channel.
		void HandleTestCommand(std::string command_name,
		std::vector<std::uint8_t> args);

		// Creates the mapping from the \|command_name\| to the method \|callback\|,
		// which is provided by the controller and will be fired when its command is
		// received from the test channel.
		void RegisterControllerCommand(
		std::string command_name,
		std::function<void(const std::vector<std::uint8_t> args)> callback);

		void RegisterHandlersWithTransport(TestChannelTransport& transport);

		private:
		// Controller callbacks to be executed in handlers and registered in
		// RegisterControllerCommand().
		std::unordered_map<std::string,
		std::function<void(const std::vector<std::uint8_t> args)> >
		commands_;

		DISALLOW_COPY_AND_ASSIGN(TestChannelHandler);
		};

		} // namespace test_vendor_lib

system/vendor_libs/test_vendor_lib/include/test_channel_transport.h

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		//
		// Copyright 2015 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 <string>
		#include <memory>

		#include "base/files/scoped_file.h"
		#include "base/message_loop/message_loop.h"

		namespace test_vendor_lib {

		// Manages communications between test channel and the controller. Mirrors the
		// HciTransport for the test channel.
		class TestChannelTransport : public base::MessageLoopForIO::Watcher {
		public:
		TestChannelTransport(bool enabled, int port);

		~TestChannelTransport() = default;

		// Waits for a connection request from the test channel program and
		// allocates the file descriptor to watch for run-time parameters at. This
		// file descriptor gets stored in \|fd_\|.
		bool SetUp();

		int GetFd();

		// Because it imposes a different flow of work, the test channel must be
		// actively enabled to be used. \|enabled_\| is set by the vendor manager.
		bool IsEnabled();

		// Turns the test channel off for use in circumstances where an error occurs
		// and leaving the channel on would crash Bluetooth (e.g. if the test channel
		// is unable to bind to its socket, Bluetooth should still start without the
		// channel enabled).
		void Disable();

		// Sets the callback that fires when data is read in
		// \|OnFileCanReadWithoutBlocking\|.
		void RegisterCommandHandler(
		std::function<void(std::string, std::vector<std::uint8_t>)> callback);

		private:
		// base::MessageLoopForIO::Watcher overrides:
		void OnFileCanReadWithoutBlocking(int fd) override;

		void OnFileCanWriteWithoutBlocking(int fd) override;

		std::function<void(std::string, std::vector<std::uint8_t>)>
		command_handler_;

		// File descriptor to watch for test hook data.
		std::unique_ptr<base::ScopedFD> fd_;

		// TODO(dennischeng): Get port and enabled flag from a config file.
		int port_;
		bool enabled_;

		DISALLOW_COPY_AND_ASSIGN(TestChannelTransport);
		};

		} // namespace test_vendor_lib