Merge changes I494af5b7,Ib32f140d (2f8af3ce) · Commits · e / os / android_packages_modules_Bluetooth

android/app/AndroidManifest.xml

+8 −0

Original line number	Diff line number	Diff line
		@@ -382,6 +382,14 @@
		<action android:name="android.bluetooth.IBluetoothPbapClient" />
		</intent-filter>
		</service>
		<service
		android:process="@string/process"
		android:name = ".hearingaid.HearingAidService"
		android:enabled="@bool/profile_supported_hearing_aid">
		<intent-filter>
		<action android:name="android.bluetooth.IBluetoothHearingAid" />
		</intent-filter>
		</service>
		<!-- Authenticator for PBAP account. -->
		<service
		android:process="@string/process"

android/app/res/values/config.xml

+1 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@
		<bool name="profile_supported_pbapclient">false</bool>
		<bool name="profile_supported_mapmce">false</bool>
		<bool name="profile_supported_hid_device">true</bool>
		<bool name="profile_supported_hearing_aid">true</bool>

		<!-- If true, we will require location to be enabled on the device to
		fire Bluetooth LE scan result callbacks in addition to having one

android/app/src/com/android/bluetooth/btservice/Config.java

+4 −1

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@ import com.android.bluetooth.a2dpsink.A2dpSinkService;
		import com.android.bluetooth.avrcpcontroller.AvrcpControllerService;
		import com.android.bluetooth.gatt.GattService;
		import com.android.bluetooth.hdp.HealthService;
		import com.android.bluetooth.hearingaid.HearingAidService;
		import com.android.bluetooth.hfp.HeadsetService;
		import com.android.bluetooth.hfpclient.HeadsetClientService;
		import com.android.bluetooth.hid.HidDeviceService;
		@@ -94,7 +95,9 @@ public class Config {
		new ProfileConfig(BluetoothOppService.class, R.bool.profile_supported_opp,
		(1 << BluetoothProfile.OPP)),
		new ProfileConfig(BluetoothPbapService.class, R.bool.profile_supported_pbap,
		(1 << BluetoothProfile.PBAP))
		(1 << BluetoothProfile.PBAP)),
		new ProfileConfig(HearingAidService.class, R.bool.profile_supported_hearing_aid,
		(1 << BluetoothProfile.HEARING_AID))
		};

		private static Class[] sSupportedProfiles = new Class[0];

android/app/src/com/android/bluetooth/hearingaid/HearingAidService.java

0 → 100644

+668 −0

File added.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/hearingaid/HearingAidStateMachine.java

0 → 100644

+377 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2018 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.
		*/

		/**
		* Bluetooth HearingAid StateMachine. There is one instance per remote device.
		* - "Disconnected" and "Connected" are steady states.
		* - "Connecting" and "Disconnecting" are transient states until the
		* connection / disconnection is completed.
		*
		*
		* (Disconnected)
		* \| ^
		* CONNECT \| \| DISCONNECTED
		* V \|
		* (Connecting)<--->(Disconnecting)
		* \| ^
		* CONNECTED \| \| DISCONNECT
		* V \|
		* (Connected)
		* NOTES:
		* - If state machine is in "Connecting" state and the remote device sends
		* DISCONNECT request, the state machine transitions to "Disconnecting" state.
		* - Similarly, if the state machine is in "Disconnecting" state and the remote device
		* sends CONNECT request, the state machine transitions to "Connecting" state.
		*
		* DISCONNECT
		* (Connecting) ---------------> (Disconnecting)
		* <---------------
		* CONNECT
		*
		*/

		package com.android.bluetooth.hearingaid;

		import android.bluetooth.BluetoothDevice;
		import android.bluetooth.BluetoothHearingAid;
		import android.bluetooth.BluetoothProfile;
		import android.content.Intent;
		import android.os.Looper;
		import android.os.Message;
		import android.support.annotation.VisibleForTesting;
		import android.util.Log;

		import com.android.bluetooth.btservice.ProfileService;
		import com.android.internal.util.State;
		import com.android.internal.util.StateMachine;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.io.StringWriter;
		import java.util.Scanner;

		final class HearingAidStateMachine extends StateMachine {
		private static final boolean DBG = false;
		private static final String TAG = "HearingAidStateMachine";

		static final int CONNECT = 1;
		static final int DISCONNECT = 2;
		@VisibleForTesting
		static final int STACK_EVENT = 101;
		private static final int CONNECT_TIMEOUT = 201;

		// NOTE: the value is not "final" - it is modified in the unit tests
		@VisibleForTesting
		static int sConnectTimeoutMs = 30000; // 30s

		private Disconnected mDisconnected;
		private Connecting mConnecting;
		private Disconnecting mDisconnecting;
		private Connected mConnected;
		private int mConnectionState = BluetoothProfile.STATE_DISCONNECTED;
		private int mLastConnectionState = -1;

		private HearingAidService mService;

		private final BluetoothDevice mDevice;

		HearingAidStateMachine(BluetoothDevice device, HearingAidService svc, Looper looper) {
		super(TAG, looper);
		mDevice = device;
		mService = svc;

		mDisconnected = new Disconnected();
		mConnecting = new Connecting();
		mDisconnecting = new Disconnecting();
		mConnected = new Connected();

		addState(mDisconnected);
		addState(mConnecting);
		addState(mDisconnecting);
		addState(mConnected);

		setInitialState(mDisconnected);
		}

		static HearingAidStateMachine make(BluetoothDevice device, HearingAidService svc,
		Looper looper) {
		Log.i(TAG, "make for device " + device);
		HearingAidStateMachine HearingAidSm = new HearingAidStateMachine(device, svc, looper);
		HearingAidSm.start();
		return HearingAidSm;
		}

		public void doQuit() {
		log("doQuit for device " + mDevice);
		quitNow();
		}

		public void cleanup() {
		log("cleanup for device " + mDevice);
		}

		@VisibleForTesting
		class Disconnected extends State {
		@Override
		public void enter() {
		Log.i(TAG, "Enter Disconnected(" + mDevice + "): " + messageWhatToString(
		getCurrentMessage().what));
		mConnectionState = BluetoothProfile.STATE_DISCONNECTED;

		removeDeferredMessages(DISCONNECT);
		// Remove Timeout messages when moved to stable state
		removeMessages(CONNECT_TIMEOUT);

		if (mLastConnectionState != -1) {
		// Don't broadcast during startup
		broadcastConnectionState(mConnectionState, mLastConnectionState);
		}
		}

		@Override
		public void exit() {
		log("Exit Disconnected(" + mDevice + "): " + messageWhatToString(
		getCurrentMessage().what));
		mLastConnectionState = BluetoothProfile.STATE_DISCONNECTED;
		}

		@Override
		public boolean processMessage(Message message) {
		log("Disconnected process message(" + mDevice + "): " + messageWhatToString(
		message.what));

		switch (message.what) {
		case CONNECT:
		log("Connecting to " + mDevice);
		if (mService.okToConnect(mDevice)) {
		transitionTo(mConnecting);
		} else {
		// Reject the request and stay in Disconnected state
		Log.w(TAG, "Outgoing HearingAid Connecting request rejected: " + mDevice);
		}
		break;
		case DISCONNECT:
		Log.w(TAG, "Disconnected: DISCONNECT ignored: " + mDevice);
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}
		}

		@VisibleForTesting
		class Connecting extends State {
		@Override
		public void enter() {
		Log.i(TAG, "Enter Connecting(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		sendMessageDelayed(CONNECT_TIMEOUT, sConnectTimeoutMs);
		mConnectionState = BluetoothProfile.STATE_CONNECTING;
		broadcastConnectionState(mConnectionState, mLastConnectionState);
		}

		@Override
		public void exit() {
		log("Exit Connecting(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		mLastConnectionState = BluetoothProfile.STATE_CONNECTING;
		removeMessages(CONNECT_TIMEOUT);
		}

		@Override
		public boolean processMessage(Message message) {
		log("Connecting process message(" + mDevice + "): "
		+ messageWhatToString(message.what));

		switch (message.what) {
		case CONNECT:
		deferMessage(message);
		break;
		case DISCONNECT:
		// Cancel connection
		log("Connecting: connection canceled to " + mDevice);
		transitionTo(mDisconnected);
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}
		}

		@VisibleForTesting
		class Disconnecting extends State {
		@Override
		public void enter() {
		Log.i(TAG, "Enter Disconnecting(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		sendMessageDelayed(CONNECT_TIMEOUT, sConnectTimeoutMs);
		mConnectionState = BluetoothProfile.STATE_DISCONNECTING;
		broadcastConnectionState(mConnectionState, mLastConnectionState);
		}

		@Override
		public void exit() {
		log("Exit Disconnecting(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		mLastConnectionState = BluetoothProfile.STATE_DISCONNECTING;
		removeMessages(CONNECT_TIMEOUT);
		}

		@Override
		public boolean processMessage(Message message) {
		log("Disconnecting process message(" + mDevice + "): "
		+ messageWhatToString(message.what));

		switch (message.what) {
		case CONNECT:
		deferMessage(message);
		break;
		case DISCONNECT:
		deferMessage(message);
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}
		}

		@VisibleForTesting
		class Connected extends State {
		@Override
		public void enter() {
		Log.i(TAG, "Enter Connected(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		mConnectionState = BluetoothProfile.STATE_CONNECTED;
		removeDeferredMessages(CONNECT);
		broadcastConnectionState(mConnectionState, mLastConnectionState);
		}

		@Override
		public void exit() {
		log("Exit Connected(" + mDevice + "): "
		+ messageWhatToString(getCurrentMessage().what));
		mLastConnectionState = BluetoothProfile.STATE_CONNECTED;
		}

		@Override
		public boolean processMessage(Message message) {
		log("Connected process message(" + mDevice + "): "
		+ messageWhatToString(message.what));

		switch (message.what) {
		case CONNECT:
		Log.w(TAG, "Connected: CONNECT ignored: " + mDevice);
		break;
		case DISCONNECT: {
		log("Disconnecting from " + mDevice);
		transitionTo(mDisconnecting);
		}
		break;
		case CONNECT_TIMEOUT:
		break;
		default:
		return NOT_HANDLED;
		}
		return HANDLED;
		}
		}

		int getConnectionState() {
		return mConnectionState;
		}

		BluetoothDevice getDevice() {
		return mDevice;
		}

		synchronized boolean isConnected() {
		return (getCurrentState() == mConnected);
		}

		// This method does not check for error condition (newState == prevState)
		private void broadcastConnectionState(int newState, int prevState) {
		log("Connection state " + mDevice + ": " + profileStateToString(prevState)
		+ "->" + profileStateToString(newState));

		Intent intent = new Intent(BluetoothHearingAid.ACTION_CONNECTION_STATE_CHANGED);
		intent.putExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, prevState);
		intent.putExtra(BluetoothProfile.EXTRA_STATE, newState);
		intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mDevice);
		intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT
		\| Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
		mService.sendBroadcast(intent, ProfileService.BLUETOOTH_PERM);
		}

		private static String messageWhatToString(int what) {
		switch (what) {
		case CONNECT:
		return "CONNECT";
		case DISCONNECT:
		return "DISCONNECT";
		case STACK_EVENT:
		return "STACK_EVENT";
		case CONNECT_TIMEOUT:
		return "CONNECT_TIMEOUT";
		default:
		break;
		}
		return Integer.toString(what);
		}

		private static String profileStateToString(int state) {
		switch (state) {
		case BluetoothProfile.STATE_DISCONNECTED:
		return "DISCONNECTED";
		case BluetoothProfile.STATE_CONNECTING:
		return "CONNECTING";
		case BluetoothProfile.STATE_CONNECTED:
		return "CONNECTED";
		case BluetoothProfile.STATE_DISCONNECTING:
		return "DISCONNECTING";
		default:
		break;
		}
		return Integer.toString(state);
		}

		public void dump(StringBuilder sb) {
		ProfileService.println(sb, "mDevice: " + mDevice);
		ProfileService.println(sb, " StateMachine: " + this);
		// Dump the state machine logs
		StringWriter stringWriter = new StringWriter();
		PrintWriter printWriter = new PrintWriter(stringWriter);
		super.dump(new FileDescriptor(), printWriter, new String[]{});
		printWriter.flush();
		stringWriter.flush();
		ProfileService.println(sb, " StateMachineLog:");
		Scanner scanner = new Scanner(stringWriter.toString());
		while (scanner.hasNextLine()) {
		String line = scanner.nextLine();
		ProfileService.println(sb, " " + line);
		}
		scanner.close();
		}

		@Override
		protected void log(String msg) {
		if (DBG) {
		super.log(msg);
		}
		}
		}