car-usb-handler/src/android/car/usb/handler/AoapServiceManager.java - platform/packages/services/Car - Git at Google

 /*
  * Copyright (C) 2019 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.
  */

 package android.car.usb.handler;

 import static android.car.AoapService.KEY_DEVICE;
 import static android.car.AoapService.KEY_RESULT;
 import static android.car.AoapService.MSG_CAN_SWITCH_TO_AOAP;
 import static android.car.AoapService.MSG_CAN_SWITCH_TO_AOAP_RESPONSE;
 import static android.car.AoapService.MSG_NEW_DEVICE_ATTACHED;
 import static android.car.AoapService.MSG_NEW_DEVICE_ATTACHED_RESPONSE;

 import android.annotation.Nullable;
 import android.annotation.WorkerThread;
 import android.car.AoapService;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.hardware.usb.UsbDevice;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.util.Log;
 import android.util.SparseArray;

 import java.lang.ref.WeakReference;
 import java.util.HashMap;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;

 /** Manages connections to {@link android.car.AoapService} (AOAP handler apps). */
 public class AoapServiceManager {
     private static final String TAG = AoapServiceManager.class.getSimpleName();

     private static final int MSG_DISCONNECT = 1;
     private static final int DISCONNECT_DELAY_MS = 30000;
     private static final int INVOCATION_TIMEOUT_MS = 20000;

     private final HashMap<ComponentName, AoapServiceConnection> mConnections = new HashMap<>();
     private Context mContext;
     private final Object mLock = new Object();
     private final HandlerThread mHandlerThread;
     private final Handler mHandler;

     public AoapServiceManager(Context context) {
         mContext = context;

         mHandlerThread = new HandlerThread(TAG);
         mHandlerThread.start();

         mHandler = new Handler(mHandlerThread.getLooper()) {
             @Override
             public void handleMessage(Message msg) {
                 if (msg.what == MSG_DISCONNECT) {
                     removeConnection((AoapServiceConnection) msg.obj);
                 } else {
                     Log.e(TAG, "Unexpected message " + msg.what);
                 }
             }
         };
     }

     /**
      * Calls synchronously with timeout {@link #INVOCATION_TIMEOUT_MS} to the given service to check
      * if it supports the device.
      */
     @WorkerThread
     public boolean isDeviceSupported(UsbDevice device, ComponentName serviceName) {
         final AoapServiceConnection connection = getConnectionOrNull(serviceName);
         if (connection == null) {
             return false;
         }

         try {
             return connection.isDeviceSupported(device)
                     .get(INVOCATION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
         } catch (ExecutionException | InterruptedException | TimeoutException e) {
             Log.w(TAG, "Failed to get response isDeviceSupported from " + serviceName, e);
             return false;
         }
     }

     /**
      * Calls synchronously with timeout {@link #INVOCATION_TIMEOUT_MS} to the given service to check
      * if the device can be switched to AOAP mode now.
      */
     @WorkerThread
     public boolean canSwitchDeviceToAoap(UsbDevice device, ComponentName serviceName) {
         final AoapServiceConnection connection = getConnectionOrNull(serviceName);
         if (connection == null) {
             return false;
         }

         try {
             return connection.canSwitchDeviceToAoap(device)
                     .get(INVOCATION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
         } catch (ExecutionException | InterruptedException | TimeoutException e) {
             Log.w(TAG, "Failed to get response of canSwitchDeviceToAoap from " + serviceName, e);
             return false;
         }
     }

     @Nullable
     private AoapServiceConnection getConnectionOrNull(ComponentName name) {
         AoapServiceConnection connection;
         synchronized (mLock) {
             connection = mConnections.get(name);
             if (connection != null) {
                 postponeServiceDisconnection(connection);
                 return connection;
             }

             connection = new AoapServiceConnection(name, this, mHandlerThread.getLooper());
             boolean bound = mContext.bindService(
                     createIntent(name), connection, Context.BIND_AUTO_CREATE);
             if (bound) {
                 mConnections.put(name, connection);
                 postponeServiceDisconnection(connection);
             } else {
                 Log.w(TAG, "Failed to bind to service " + name);
                 return null;
             }
         }
         return connection;
     }

     private void postponeServiceDisconnection(AoapServiceConnection connection) {
         mHandler.removeMessages(MSG_DISCONNECT, connection);
         mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_DISCONNECT, connection),
                 DISCONNECT_DELAY_MS);
     }

     private static Intent createIntent(ComponentName name) {
         Intent intent = new Intent();
         intent.setComponent(name);
         return intent;
     }

     private void removeConnection(AoapServiceConnection connection) {
         Log.i(TAG, "Removing connection to " + connection);
         synchronized (mLock) {
             mConnections.remove(connection.mComponentName);
             if (connection.mBound) {
                 mContext.unbindService(connection);
                 connection.mBound = false;
             }
         }
     }

     private static class AoapServiceConnection implements ServiceConnection {
         private Messenger mOutgoingMessenger;
         private boolean mBound;
         private final CompletableFuture<Void> mConnected = new CompletableFuture<>();
         private final SparseArray<CompletableFuture<Bundle>> mExpectedResponses =
                 new SparseArray<>();
         private final ComponentName mComponentName;
         private final WeakReference<AoapServiceManager> mManagerRef;
         private final Messenger mIncomingMessenger;
         private final Object mLock = new Object();

         private AoapServiceConnection(ComponentName name, AoapServiceManager manager,
                 Looper looper) {
             mComponentName = name;
             mManagerRef = new WeakReference<>(manager);
             mIncomingMessenger = new Messenger(new Handler(looper) {
                 @Override
                 public void handleMessage(Message msg) {
                     onResponse(msg);
                 }
             });
         }

         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             if (service == null) {
                 Log.e(TAG, "Binder object was not provided on service connection to " + name);
                 return;
             }

             synchronized (mLock) {
                 mBound = true;
                 mOutgoingMessenger = new Messenger(service);
             }
             mConnected.complete(null);
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {
             synchronized (mLock) {
                 mOutgoingMessenger = null;
                 mBound = false;
             }

             final AoapServiceManager mgr = mManagerRef.get();
             if (mgr != null) {
                 mgr.removeConnection(this);
             }
         }

         private void onResponse(Message message) {
             final CompletableFuture<Bundle> response;
             synchronized (mLock) {
                 response = mExpectedResponses.removeReturnOld(message.what);
             }
             if (response == null) {
                 Log.e(TAG, "Received unexpected response " + message.what + ", expected: "
                         + mExpectedResponses);
                 return;
             }

             if (message.getData() == null) {
                 throw new IllegalArgumentException("Received response msg " + message.what
                         + " without data");
             }
             Log.i(TAG, "onResponse msg: " + message.what + ", data: " + message.getData());
             boolean res = response.complete(message.getData());
             if (!res) {
                 Log.w(TAG, "Failed to complete future " + response);
             }
         }

         CompletableFuture<Boolean> isDeviceSupported(UsbDevice device) {
             return sendMessageForResult(
                     MSG_NEW_DEVICE_ATTACHED,
                     MSG_NEW_DEVICE_ATTACHED_RESPONSE,
                     createUsbDeviceData(device))
                     .thenApply(this::isResultOk);

         }

         CompletableFuture<Boolean> canSwitchDeviceToAoap(UsbDevice device) {
             return sendMessageForResult(
                     MSG_CAN_SWITCH_TO_AOAP,
                     MSG_CAN_SWITCH_TO_AOAP_RESPONSE,
                     createUsbDeviceData(device))
                     .thenApply(this::isResultOk);
         }

         private boolean isResultOk(Bundle data) {
             int result = data.getInt(KEY_RESULT);
             Log.i(TAG, "Got result: " + data);
             return AoapService.RESULT_OK == result;
         }

         private static Bundle createUsbDeviceData(UsbDevice device) {
             Bundle data = new Bundle(1);
             data.putParcelable(KEY_DEVICE, device);
             return data;
         }

         private CompletableFuture<Bundle> sendMessageForResult(
                 int msgRequest, int msgResponse, Bundle data) {
             return mConnected.thenCompose(x -> {
                 CompletableFuture<Bundle> responseFuture = new CompletableFuture<>();
                 Messenger messenger;
                 synchronized (mLock) {
                     mExpectedResponses.put(msgResponse, responseFuture);
                     messenger = mOutgoingMessenger;
                 }
                 send(messenger, msgRequest, data);

                 return responseFuture;
             });
         }

         private void send(Messenger messenger, int req, Bundle data) {
             Message msg = Message.obtain(null, req, null);
             msg.replyTo = mIncomingMessenger;
             msg.setData(data);
             try {
                 messenger.send(msg);
             } catch (RemoteException e) {
                 throw new RuntimeException("Connection broken with " + mComponentName, e);
             }
         }

         @Override
         public String toString() {
             return "AoapServiceConnection{"
                     + "mBound=" + mBound
                     + ", mConnected=" + mConnected
                     + ", mExpectedResponses=" + mExpectedResponses
                     + ", mComponentName=" + mComponentName
                     + '}';
         }
     }
 }
	/*
	* Copyright (C) 2019 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.
	*/

	package android.car.usb.handler;

	import static android.car.AoapService.KEY_DEVICE;
	import static android.car.AoapService.KEY_RESULT;
	import static android.car.AoapService.MSG_CAN_SWITCH_TO_AOAP;
	import static android.car.AoapService.MSG_CAN_SWITCH_TO_AOAP_RESPONSE;
	import static android.car.AoapService.MSG_NEW_DEVICE_ATTACHED;
	import static android.car.AoapService.MSG_NEW_DEVICE_ATTACHED_RESPONSE;

	import android.annotation.Nullable;
	import android.annotation.WorkerThread;
	import android.car.AoapService;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.hardware.usb.UsbDevice;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.IBinder;
	import android.os.Looper;
	import android.os.Message;
	import android.os.Messenger;
	import android.os.RemoteException;
	import android.util.Log;
	import android.util.SparseArray;

	import java.lang.ref.WeakReference;
	import java.util.HashMap;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;

	/** Manages connections to {@link android.car.AoapService} (AOAP handler apps). */
	public class AoapServiceManager {
	private static final String TAG = AoapServiceManager.class.getSimpleName();

	private static final int MSG_DISCONNECT = 1;
	private static final int DISCONNECT_DELAY_MS = 30000;
	private static final int INVOCATION_TIMEOUT_MS = 20000;

	private final HashMap<ComponentName, AoapServiceConnection> mConnections = new HashMap<>();
	private Context mContext;
	private final Object mLock = new Object();
	private final HandlerThread mHandlerThread;
	private final Handler mHandler;

	public AoapServiceManager(Context context) {
	mContext = context;

	mHandlerThread = new HandlerThread(TAG);
	mHandlerThread.start();

	mHandler = new Handler(mHandlerThread.getLooper()) {
	@Override
	public void handleMessage(Message msg) {
	if (msg.what == MSG_DISCONNECT) {
	removeConnection((AoapServiceConnection) msg.obj);
	} else {
	Log.e(TAG, "Unexpected message " + msg.what);
	}
	}
	};
	}

	/**
	* Calls synchronously with timeout {@link #INVOCATION_TIMEOUT_MS} to the given service to check
	* if it supports the device.
	*/
	@WorkerThread
	public boolean isDeviceSupported(UsbDevice device, ComponentName serviceName) {
	final AoapServiceConnection connection = getConnectionOrNull(serviceName);
	if (connection == null) {
	return false;
	}

	try {
	return connection.isDeviceSupported(device)
	.get(INVOCATION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
	} catch (ExecutionException \| InterruptedException \| TimeoutException e) {
	Log.w(TAG, "Failed to get response isDeviceSupported from " + serviceName, e);
	return false;
	}
	}

	/**
	* Calls synchronously with timeout {@link #INVOCATION_TIMEOUT_MS} to the given service to check
	* if the device can be switched to AOAP mode now.
	*/
	@WorkerThread
	public boolean canSwitchDeviceToAoap(UsbDevice device, ComponentName serviceName) {
	final AoapServiceConnection connection = getConnectionOrNull(serviceName);
	if (connection == null) {
	return false;
	}

	try {
	return connection.canSwitchDeviceToAoap(device)
	.get(INVOCATION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
	} catch (ExecutionException \| InterruptedException \| TimeoutException e) {
	Log.w(TAG, "Failed to get response of canSwitchDeviceToAoap from " + serviceName, e);
	return false;
	}
	}

	@Nullable
	private AoapServiceConnection getConnectionOrNull(ComponentName name) {
	AoapServiceConnection connection;
	synchronized (mLock) {
	connection = mConnections.get(name);
	if (connection != null) {
	postponeServiceDisconnection(connection);
	return connection;
	}

	connection = new AoapServiceConnection(name, this, mHandlerThread.getLooper());
	boolean bound = mContext.bindService(
	createIntent(name), connection, Context.BIND_AUTO_CREATE);
	if (bound) {
	mConnections.put(name, connection);
	postponeServiceDisconnection(connection);
	} else {
	Log.w(TAG, "Failed to bind to service " + name);
	return null;
	}
	}
	return connection;
	}

	private void postponeServiceDisconnection(AoapServiceConnection connection) {
	mHandler.removeMessages(MSG_DISCONNECT, connection);
	mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_DISCONNECT, connection),
	DISCONNECT_DELAY_MS);
	}

	private static Intent createIntent(ComponentName name) {
	Intent intent = new Intent();
	intent.setComponent(name);
	return intent;
	}

	private void removeConnection(AoapServiceConnection connection) {
	Log.i(TAG, "Removing connection to " + connection);
	synchronized (mLock) {
	mConnections.remove(connection.mComponentName);
	if (connection.mBound) {
	mContext.unbindService(connection);
	connection.mBound = false;
	}
	}
	}

	private static class AoapServiceConnection implements ServiceConnection {
	private Messenger mOutgoingMessenger;
	private boolean mBound;
	private final CompletableFuture<Void> mConnected = new CompletableFuture<>();
	private final SparseArray<CompletableFuture<Bundle>> mExpectedResponses =
	new SparseArray<>();
	private final ComponentName mComponentName;
	private final WeakReference<AoapServiceManager> mManagerRef;
	private final Messenger mIncomingMessenger;
	private final Object mLock = new Object();

	private AoapServiceConnection(ComponentName name, AoapServiceManager manager,
	Looper looper) {
	mComponentName = name;
	mManagerRef = new WeakReference<>(manager);
	mIncomingMessenger = new Messenger(new Handler(looper) {
	@Override
	public void handleMessage(Message msg) {
	onResponse(msg);
	}
	});
	}

	@Override
	public void onServiceConnected(ComponentName name, IBinder service) {
	if (service == null) {
	Log.e(TAG, "Binder object was not provided on service connection to " + name);
	return;
	}

	synchronized (mLock) {
	mBound = true;
	mOutgoingMessenger = new Messenger(service);
	}
	mConnected.complete(null);
	}

	@Override
	public void onServiceDisconnected(ComponentName name) {
	synchronized (mLock) {
	mOutgoingMessenger = null;
	mBound = false;
	}

	final AoapServiceManager mgr = mManagerRef.get();
	if (mgr != null) {
	mgr.removeConnection(this);
	}
	}

	private void onResponse(Message message) {
	final CompletableFuture<Bundle> response;
	synchronized (mLock) {
	response = mExpectedResponses.removeReturnOld(message.what);
	}
	if (response == null) {
	Log.e(TAG, "Received unexpected response " + message.what + ", expected: "
	+ mExpectedResponses);
	return;
	}

	if (message.getData() == null) {
	throw new IllegalArgumentException("Received response msg " + message.what
	+ " without data");
	}
	Log.i(TAG, "onResponse msg: " + message.what + ", data: " + message.getData());
	boolean res = response.complete(message.getData());
	if (!res) {
	Log.w(TAG, "Failed to complete future " + response);
	}
	}

	CompletableFuture<Boolean> isDeviceSupported(UsbDevice device) {
	return sendMessageForResult(
	MSG_NEW_DEVICE_ATTACHED,
	MSG_NEW_DEVICE_ATTACHED_RESPONSE,
	createUsbDeviceData(device))
	.thenApply(this::isResultOk);

	}

	CompletableFuture<Boolean> canSwitchDeviceToAoap(UsbDevice device) {
	return sendMessageForResult(
	MSG_CAN_SWITCH_TO_AOAP,
	MSG_CAN_SWITCH_TO_AOAP_RESPONSE,
	createUsbDeviceData(device))
	.thenApply(this::isResultOk);
	}

	private boolean isResultOk(Bundle data) {
	int result = data.getInt(KEY_RESULT);
	Log.i(TAG, "Got result: " + data);
	return AoapService.RESULT_OK == result;
	}

	private static Bundle createUsbDeviceData(UsbDevice device) {
	Bundle data = new Bundle(1);
	data.putParcelable(KEY_DEVICE, device);
	return data;
	}

	private CompletableFuture<Bundle> sendMessageForResult(
	int msgRequest, int msgResponse, Bundle data) {
	return mConnected.thenCompose(x -> {
	CompletableFuture<Bundle> responseFuture = new CompletableFuture<>();
	Messenger messenger;
	synchronized (mLock) {
	mExpectedResponses.put(msgResponse, responseFuture);
	messenger = mOutgoingMessenger;
	}
	send(messenger, msgRequest, data);

	return responseFuture;
	});
	}

	private void send(Messenger messenger, int req, Bundle data) {
	Message msg = Message.obtain(null, req, null);
	msg.replyTo = mIncomingMessenger;
	msg.setData(data);
	try {
	messenger.send(msg);
	} catch (RemoteException e) {
	throw new RuntimeException("Connection broken with " + mComponentName, e);
	}
	}

	@Override
	public String toString() {
	return "AoapServiceConnection{"
	+ "mBound=" + mBound
	+ ", mConnected=" + mConnected
	+ ", mExpectedResponses=" + mExpectedResponses
	+ ", mComponentName=" + mComponentName
	+ '}';
	}
	}
	}