tests/AccessoryDisplay/sink/src/com/android/accessorydisplay/sink/SinkActivity.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2013 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 com.android.accessorydisplay.sink;

 import com.android.accessorydisplay.common.Logger;

 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.hardware.usb.UsbConstants;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbDeviceConnection;
 import android.hardware.usb.UsbEndpoint;
 import android.hardware.usb.UsbInterface;
 import android.hardware.usb.UsbManager;
 import android.media.MediaCodec;
 import android.media.MediaCodec.BufferInfo;
 import android.media.MediaFormat;
 import android.os.Bundle;
 import android.text.method.ScrollingMovementMethod;
 import android.util.Log;
 import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.widget.TextView;

 import java.nio.ByteBuffer;
 import java.util.LinkedList;
 import java.util.Map;

 public class SinkActivity extends Activity {
     private static final String TAG = "SinkActivity";

     private static final String ACTION_USB_DEVICE_PERMISSION =
             "com.android.accessorydisplay.sink.ACTION_USB_DEVICE_PERMISSION";

     private static final String MANUFACTURER = "Android";
     private static final String MODEL = "Accessory Display";
     private static final String DESCRIPTION = "Accessory Display Sink Test Application";
     private static final String VERSION = "1.0";
     private static final String URI = "http://www.android.com/";
     private static final String SERIAL = "0000000012345678";

     private static final int MULTITOUCH_DEVICE_ID = 0;
     private static final int MULTITOUCH_REPORT_ID = 1;
     private static final int MULTITOUCH_MAX_CONTACTS = 1;

     private UsbManager mUsbManager;
     private DeviceReceiver mReceiver;
     private TextView mLogTextView;
     private TextView mFpsTextView;
     private SurfaceView mSurfaceView;
     private Logger mLogger;

     private boolean mConnected;
     private int mProtocolVersion;
     private UsbDevice mDevice;
     private UsbInterface mAccessoryInterface;
     private UsbDeviceConnection mAccessoryConnection;
     private UsbEndpoint mControlEndpoint;
     private UsbAccessoryBulkTransport mTransport;

     private boolean mAttached;
     private DisplaySinkService mDisplaySinkService;

     private final ByteBuffer mHidBuffer = ByteBuffer.allocate(4096);
     private UsbHid.Multitouch mMultitouch;
     private boolean mMultitouchEnabled;
     private UsbHid.Multitouch.Contact[] mMultitouchContacts;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         mUsbManager = (UsbManager)getSystemService(Context.USB_SERVICE);

         setContentView(R.layout.sink_activity);

         mLogTextView = (TextView) findViewById(R.id.logTextView);
         mLogTextView.setMovementMethod(ScrollingMovementMethod.getInstance());
         mLogger = new TextLogger();

         mFpsTextView = (TextView) findViewById(R.id.fpsTextView);

         mSurfaceView = (SurfaceView) findViewById(R.id.surfaceView);
         mSurfaceView.setOnTouchListener(new View.OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
                 sendHidTouch(event);
                 return true;
             }
         });

         mLogger.log("Waiting for accessory display source to be attached to USB...");

         IntentFilter filter = new IntentFilter();
         filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
         filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
         filter.addAction(ACTION_USB_DEVICE_PERMISSION);
         mReceiver = new DeviceReceiver();
         registerReceiver(mReceiver, filter);

         Intent intent = getIntent();
         if (intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
             UsbDevice device = intent.<UsbDevice>getParcelableExtra(UsbManager.EXTRA_DEVICE);
             if (device != null) {
                 onDeviceAttached(device);
             }
         } else {
             Map<String, UsbDevice> devices = mUsbManager.getDeviceList();
             if (devices != null) {
                 for (UsbDevice device : devices.values()) {
                     onDeviceAttached(device);
                 }
             }
         }
     }

     @Override
     protected void onDestroy() {
         super.onDestroy();

         unregisterReceiver(mReceiver);
     }

     private void onDeviceAttached(UsbDevice device) {
         mLogger.log("USB device attached: " + device);
         if (!mConnected) {
             connect(device);
         }
     }

     private void onDeviceDetached(UsbDevice device) {
         mLogger.log("USB device detached: " + device);
         if (mConnected && device.equals(mDevice)) {
             disconnect();
         }
     }

     private void connect(UsbDevice device) {
         if (mConnected) {
             disconnect();
         }

         // Check whether we have permission to access the device.
         if (!mUsbManager.hasPermission(device)) {
             mLogger.log("Prompting the user for access to the device.");
             Intent intent = new Intent(ACTION_USB_DEVICE_PERMISSION);
             intent.setPackage(getPackageName());
             PendingIntent pendingIntent = PendingIntent.getBroadcast(
                     this, 0, intent, PendingIntent.FLAG_ONE_SHOT);
             mUsbManager.requestPermission(device, pendingIntent);
             return;
         }

         // Claim the device.
         UsbDeviceConnection conn = mUsbManager.openDevice(device);
         if (conn == null) {
             mLogger.logError("Could not obtain device connection.");
             return;
         }
         UsbInterface iface = device.getInterface(0);
         UsbEndpoint controlEndpoint = iface.getEndpoint(0);
         if (!conn.claimInterface(iface, true)) {
             mLogger.logError("Could not claim interface.");
             return;
         }
         try {
             // If already in accessory mode, then connect to the device.
             if (isAccessory(device)) {
                 mLogger.log("Connecting to accessory...");

                 int protocolVersion = getProtocol(conn);
                 if (protocolVersion < 1) {
                     mLogger.logError("Device does not support accessory protocol.");
                     return;
                 }
                 mLogger.log("Protocol version: " + protocolVersion);

                 // Setup bulk endpoints.
                 UsbEndpoint bulkIn = null;
                 UsbEndpoint bulkOut = null;
                 for (int i = 0; i < iface.getEndpointCount(); i++) {
                     UsbEndpoint ep = iface.getEndpoint(i);
                     if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
                         if (bulkIn == null) {
                             mLogger.log(String.format("Bulk IN endpoint: %d", i));
                             bulkIn = ep;
                         }
                     } else {
                         if (bulkOut == null) {
                             mLogger.log(String.format("Bulk OUT endpoint: %d", i));
                             bulkOut = ep;
                         }
                     }
                 }
                 if (bulkIn == null || bulkOut == null) {
                     mLogger.logError("Unable to find bulk endpoints");
                     return;
                 }

                 mLogger.log("Connected");
                 mConnected = true;
                 mDevice = device;
                 mProtocolVersion = protocolVersion;
                 mAccessoryInterface = iface;
                 mAccessoryConnection = conn;
                 mControlEndpoint = controlEndpoint;
                 mTransport = new UsbAccessoryBulkTransport(mLogger, conn, bulkIn, bulkOut);
                 if (mProtocolVersion >= 2) {
                     registerHid();
                 }
                 startServices();
                 mTransport.startReading();
                 return;
             }

             // Do accessory negotiation.
             mLogger.log("Attempting to switch device to accessory mode...");

             // Send get protocol.
             int protocolVersion = getProtocol(conn);
             if (protocolVersion < 1) {
                 mLogger.logError("Device does not support accessory protocol.");
                 return;
             }
             mLogger.log("Protocol version: " + protocolVersion);

             // Send identifying strings.
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MANUFACTURER, MANUFACTURER);
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MODEL, MODEL);
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_DESCRIPTION, DESCRIPTION);
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_VERSION, VERSION);
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_URI, URI);
             sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_SERIAL, SERIAL);

             // Send start.
             // The device should re-enumerate as an accessory.
             mLogger.log("Sending accessory start request.");
             int len = conn.controlTransfer(UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR,
                     UsbAccessoryConstants.ACCESSORY_START, 0, 0, null, 0, 10000);
             if (len != 0) {
                 mLogger.logError("Device refused to switch to accessory mode.");
             } else {
                 mLogger.log("Waiting for device to re-enumerate...");
             }
         } finally {
             if (!mConnected) {
                 conn.releaseInterface(iface);
             }
         }
     }

     private void disconnect() {
         mLogger.log("Disconnecting from device: " + mDevice);
         stopServices();
         unregisterHid();

         mLogger.log("Disconnected.");
         mConnected = false;
         mDevice = null;
         mAccessoryConnection = null;
         mAccessoryInterface = null;
         mControlEndpoint = null;
         if (mTransport != null) {
             mTransport.close();
             mTransport = null;
         }
     }

     private void registerHid() {
         mLogger.log("Registering HID multitouch device.");

         mMultitouch = new UsbHid.Multitouch(MULTITOUCH_REPORT_ID, MULTITOUCH_MAX_CONTACTS,
                 mSurfaceView.getWidth(), mSurfaceView.getHeight());

         mHidBuffer.clear();
         mMultitouch.generateDescriptor(mHidBuffer);
         mHidBuffer.flip();

         mLogger.log("HID descriptor size: " + mHidBuffer.limit());
         mLogger.log("HID report size: " + mMultitouch.getReportSize());

         final int maxPacketSize = mControlEndpoint.getMaxPacketSize();
         mLogger.log("Control endpoint max packet size: " + maxPacketSize);
         if (mMultitouch.getReportSize() > maxPacketSize) {
             mLogger.logError("HID report is too big for this accessory.");
             return;
         }

         int len = mAccessoryConnection.controlTransfer(
                 UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR,
                 UsbAccessoryConstants.ACCESSORY_REGISTER_HID,
                 MULTITOUCH_DEVICE_ID, mHidBuffer.limit(), null, 0, 10000);
         if (len != 0) {
             mLogger.logError("Device rejected ACCESSORY_REGISTER_HID request.");
             return;
         }

         while (mHidBuffer.hasRemaining()) {
             int position = mHidBuffer.position();
             int count = Math.min(mHidBuffer.remaining(), maxPacketSize);
             len = mAccessoryConnection.controlTransfer(
                     UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR,
                     UsbAccessoryConstants.ACCESSORY_SET_HID_REPORT_DESC,
                     MULTITOUCH_DEVICE_ID, 0,
                     mHidBuffer.array(), position, count, 10000);
             if (len != count) {
                 mLogger.logError("Device rejected ACCESSORY_SET_HID_REPORT_DESC request.");
                 return;
             }
             mHidBuffer.position(position + count);
         }

         mLogger.log("HID device registered.");

         mMultitouchEnabled = true;
         if (mMultitouchContacts == null) {
             mMultitouchContacts = new UsbHid.Multitouch.Contact[MULTITOUCH_MAX_CONTACTS];
             for (int i = 0; i < MULTITOUCH_MAX_CONTACTS; i++) {
                 mMultitouchContacts[i] = new UsbHid.Multitouch.Contact();
             }
         }
     }

     private void unregisterHid() {
         mMultitouch = null;
         mMultitouchContacts = null;
         mMultitouchEnabled = false;
     }

     private void sendHidTouch(MotionEvent event) {
         if (mMultitouchEnabled) {
             mLogger.log("Sending touch event: " + event);

             switch (event.getActionMasked()) {
                 case MotionEvent.ACTION_DOWN:
                 case MotionEvent.ACTION_MOVE: {
                     final int pointerCount =
                             Math.min(MULTITOUCH_MAX_CONTACTS, event.getPointerCount());
                     final int historySize = event.getHistorySize();
                     for (int p = 0; p < pointerCount; p++) {
                         mMultitouchContacts[p].id = event.getPointerId(p);
                     }
                     for (int h = 0; h < historySize; h++) {
                         for (int p = 0; p < pointerCount; p++) {
                             mMultitouchContacts[p].x = (int)event.getHistoricalX(p, h);
                             mMultitouchContacts[p].y = (int)event.getHistoricalY(p, h);
                         }
                         sendHidTouchReport(pointerCount);
                     }
                     for (int p = 0; p < pointerCount; p++) {
                         mMultitouchContacts[p].x = (int)event.getX(p);
                         mMultitouchContacts[p].y = (int)event.getY(p);
                     }
                     sendHidTouchReport(pointerCount);
                     break;
                 }

                 case MotionEvent.ACTION_CANCEL:
                 case MotionEvent.ACTION_UP:
                     sendHidTouchReport(0);
                     break;
             }
         }
     }

     private void sendHidTouchReport(int contactCount) {
         mHidBuffer.clear();
         mMultitouch.generateReport(mHidBuffer, mMultitouchContacts, contactCount);
         mHidBuffer.flip();

         int count = mHidBuffer.limit();
         int len = mAccessoryConnection.controlTransfer(
                 UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR,
                 UsbAccessoryConstants.ACCESSORY_SEND_HID_EVENT,
                 MULTITOUCH_DEVICE_ID, 0,
                 mHidBuffer.array(), 0, count, 10000);
         if (len != count) {
             mLogger.logError("Device rejected ACCESSORY_SEND_HID_EVENT request.");
             return;
         }
     }

     private void startServices() {
         mDisplaySinkService = new DisplaySinkService(this, mTransport,
                 getResources().getConfiguration().densityDpi);
         mDisplaySinkService.start();

         if (mAttached) {
             mDisplaySinkService.setSurfaceView(mSurfaceView);
         }
     }

     private void stopServices() {
         if (mDisplaySinkService != null) {
             mDisplaySinkService.stop();
             mDisplaySinkService = null;
         }
     }

     @Override
     public void onAttachedToWindow() {
         super.onAttachedToWindow();

         mAttached = true;
         if (mDisplaySinkService != null) {
             mDisplaySinkService.setSurfaceView(mSurfaceView);
         }
     }

     @Override
     public void onDetachedFromWindow() {
         super.onDetachedFromWindow();

         mAttached = false;
         if (mDisplaySinkService != null) {
             mDisplaySinkService.setSurfaceView(null);
         }
     }

     private int getProtocol(UsbDeviceConnection conn) {
         byte buffer[] = new byte[2];
         int len = conn.controlTransfer(
                 UsbConstants.USB_DIR_IN | UsbConstants.USB_TYPE_VENDOR,
                 UsbAccessoryConstants.ACCESSORY_GET_PROTOCOL, 0, 0, buffer, 2, 10000);
         if (len != 2) {
             return -1;
         }
         return (buffer[1] << 8) | buffer[0];
     }

     private void sendString(UsbDeviceConnection conn, int index, String string) {
         byte[] buffer = (string + "\0").getBytes();
         int len = conn.controlTransfer(UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR,
                 UsbAccessoryConstants.ACCESSORY_SEND_STRING, 0, index,
                 buffer, buffer.length, 10000);
         if (len != buffer.length) {
             mLogger.logError("Failed to send string " + index + ": \"" + string + "\"");
         } else {
             mLogger.log("Sent string " + index + ": \"" + string + "\"");
         }
     }

     private static boolean isAccessory(UsbDevice device) {
         final int vid = device.getVendorId();
         final int pid = device.getProductId();
         return vid == UsbAccessoryConstants.USB_ACCESSORY_VENDOR_ID
                 && (pid == UsbAccessoryConstants.USB_ACCESSORY_PRODUCT_ID
                         || pid == UsbAccessoryConstants.USB_ACCESSORY_ADB_PRODUCT_ID);
     }

     class TextLogger extends Logger {
         @Override
         public void log(final String message) {
             Log.d(TAG, message);

             mLogTextView.post(new Runnable() {
                 @Override
                 public void run() {
                     mLogTextView.append(message);
                     mLogTextView.append("\n");
                 }
             });
         }
     }

     class DeviceReceiver extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             UsbDevice device = intent.<UsbDevice>getParcelableExtra(UsbManager.EXTRA_DEVICE);
             if (device != null) {
                 String action = intent.getAction();
                 if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
                     onDeviceAttached(device);
                 } else if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED)) {
                     onDeviceDetached(device);
                 } else if (action.equals(ACTION_USB_DEVICE_PERMISSION)) {
                     if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                         mLogger.log("Device permission granted: " + device);
                         onDeviceAttached(device);
                     } else {
                         mLogger.logError("Device permission denied: " + device);
                     }
                 }
             }
         }
     }
 }
	/*
	* Copyright (C) 2013 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 com.android.accessorydisplay.sink;

	import com.android.accessorydisplay.common.Logger;

	import android.app.Activity;
	import android.app.PendingIntent;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.hardware.usb.UsbConstants;
	import android.hardware.usb.UsbDevice;
	import android.hardware.usb.UsbDeviceConnection;
	import android.hardware.usb.UsbEndpoint;
	import android.hardware.usb.UsbInterface;
	import android.hardware.usb.UsbManager;
	import android.media.MediaCodec;
	import android.media.MediaCodec.BufferInfo;
	import android.media.MediaFormat;
	import android.os.Bundle;
	import android.text.method.ScrollingMovementMethod;
	import android.util.Log;
	import android.view.MotionEvent;
	import android.view.Surface;
	import android.view.SurfaceHolder;
	import android.view.SurfaceView;
	import android.view.View;
	import android.widget.TextView;

	import java.nio.ByteBuffer;
	import java.util.LinkedList;
	import java.util.Map;

	public class SinkActivity extends Activity {
	private static final String TAG = "SinkActivity";

	private static final String ACTION_USB_DEVICE_PERMISSION =
	"com.android.accessorydisplay.sink.ACTION_USB_DEVICE_PERMISSION";

	private static final String MANUFACTURER = "Android";
	private static final String MODEL = "Accessory Display";
	private static final String DESCRIPTION = "Accessory Display Sink Test Application";
	private static final String VERSION = "1.0";
	private static final String URI = "http://www.android.com/";
	private static final String SERIAL = "0000000012345678";

	private static final int MULTITOUCH_DEVICE_ID = 0;
	private static final int MULTITOUCH_REPORT_ID = 1;
	private static final int MULTITOUCH_MAX_CONTACTS = 1;

	private UsbManager mUsbManager;
	private DeviceReceiver mReceiver;
	private TextView mLogTextView;
	private TextView mFpsTextView;
	private SurfaceView mSurfaceView;
	private Logger mLogger;

	private boolean mConnected;
	private int mProtocolVersion;
	private UsbDevice mDevice;
	private UsbInterface mAccessoryInterface;
	private UsbDeviceConnection mAccessoryConnection;
	private UsbEndpoint mControlEndpoint;
	private UsbAccessoryBulkTransport mTransport;

	private boolean mAttached;
	private DisplaySinkService mDisplaySinkService;

	private final ByteBuffer mHidBuffer = ByteBuffer.allocate(4096);
	private UsbHid.Multitouch mMultitouch;
	private boolean mMultitouchEnabled;
	private UsbHid.Multitouch.Contact[] mMultitouchContacts;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	mUsbManager = (UsbManager)getSystemService(Context.USB_SERVICE);

	setContentView(R.layout.sink_activity);

	mLogTextView = (TextView) findViewById(R.id.logTextView);
	mLogTextView.setMovementMethod(ScrollingMovementMethod.getInstance());
	mLogger = new TextLogger();

	mFpsTextView = (TextView) findViewById(R.id.fpsTextView);

	mSurfaceView = (SurfaceView) findViewById(R.id.surfaceView);
	mSurfaceView.setOnTouchListener(new View.OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
	sendHidTouch(event);
	return true;
	}
	});

	mLogger.log("Waiting for accessory display source to be attached to USB...");

	IntentFilter filter = new IntentFilter();
	filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
	filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
	filter.addAction(ACTION_USB_DEVICE_PERMISSION);
	mReceiver = new DeviceReceiver();
	registerReceiver(mReceiver, filter);

	Intent intent = getIntent();
	if (intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
	UsbDevice device = intent.<UsbDevice>getParcelableExtra(UsbManager.EXTRA_DEVICE);
	if (device != null) {
	onDeviceAttached(device);
	}
	} else {
	Map<String, UsbDevice> devices = mUsbManager.getDeviceList();
	if (devices != null) {
	for (UsbDevice device : devices.values()) {
	onDeviceAttached(device);
	}
	}
	}
	}

	@Override
	protected void onDestroy() {
	super.onDestroy();

	unregisterReceiver(mReceiver);
	}

	private void onDeviceAttached(UsbDevice device) {
	mLogger.log("USB device attached: " + device);
	if (!mConnected) {
	connect(device);
	}
	}

	private void onDeviceDetached(UsbDevice device) {
	mLogger.log("USB device detached: " + device);
	if (mConnected && device.equals(mDevice)) {
	disconnect();
	}
	}

	private void connect(UsbDevice device) {
	if (mConnected) {
	disconnect();
	}

	// Check whether we have permission to access the device.
	if (!mUsbManager.hasPermission(device)) {
	mLogger.log("Prompting the user for access to the device.");
	Intent intent = new Intent(ACTION_USB_DEVICE_PERMISSION);
	intent.setPackage(getPackageName());
	PendingIntent pendingIntent = PendingIntent.getBroadcast(
	this, 0, intent, PendingIntent.FLAG_ONE_SHOT);
	mUsbManager.requestPermission(device, pendingIntent);
	return;
	}

	// Claim the device.
	UsbDeviceConnection conn = mUsbManager.openDevice(device);
	if (conn == null) {
	mLogger.logError("Could not obtain device connection.");
	return;
	}
	UsbInterface iface = device.getInterface(0);
	UsbEndpoint controlEndpoint = iface.getEndpoint(0);
	if (!conn.claimInterface(iface, true)) {
	mLogger.logError("Could not claim interface.");
	return;
	}
	try {
	// If already in accessory mode, then connect to the device.
	if (isAccessory(device)) {
	mLogger.log("Connecting to accessory...");

	int protocolVersion = getProtocol(conn);
	if (protocolVersion < 1) {
	mLogger.logError("Device does not support accessory protocol.");
	return;
	}
	mLogger.log("Protocol version: " + protocolVersion);

	// Setup bulk endpoints.
	UsbEndpoint bulkIn = null;
	UsbEndpoint bulkOut = null;
	for (int i = 0; i < iface.getEndpointCount(); i++) {
	UsbEndpoint ep = iface.getEndpoint(i);
	if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
	if (bulkIn == null) {
	mLogger.log(String.format("Bulk IN endpoint: %d", i));
	bulkIn = ep;
	}
	} else {
	if (bulkOut == null) {
	mLogger.log(String.format("Bulk OUT endpoint: %d", i));
	bulkOut = ep;
	}
	}
	}
	if (bulkIn == null \|\| bulkOut == null) {
	mLogger.logError("Unable to find bulk endpoints");
	return;
	}

	mLogger.log("Connected");
	mConnected = true;
	mDevice = device;
	mProtocolVersion = protocolVersion;
	mAccessoryInterface = iface;
	mAccessoryConnection = conn;
	mControlEndpoint = controlEndpoint;
	mTransport = new UsbAccessoryBulkTransport(mLogger, conn, bulkIn, bulkOut);
	if (mProtocolVersion >= 2) {
	registerHid();
	}
	startServices();
	mTransport.startReading();
	return;
	}

	// Do accessory negotiation.
	mLogger.log("Attempting to switch device to accessory mode...");

	// Send get protocol.
	int protocolVersion = getProtocol(conn);
	if (protocolVersion < 1) {
	mLogger.logError("Device does not support accessory protocol.");
	return;
	}
	mLogger.log("Protocol version: " + protocolVersion);

	// Send identifying strings.
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MANUFACTURER, MANUFACTURER);
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_MODEL, MODEL);
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_DESCRIPTION, DESCRIPTION);
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_VERSION, VERSION);
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_URI, URI);
	sendString(conn, UsbAccessoryConstants.ACCESSORY_STRING_SERIAL, SERIAL);

	// Send start.
	// The device should re-enumerate as an accessory.
	mLogger.log("Sending accessory start request.");
	int len = conn.controlTransfer(UsbConstants.USB_DIR_OUT \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_START, 0, 0, null, 0, 10000);
	if (len != 0) {
	mLogger.logError("Device refused to switch to accessory mode.");
	} else {
	mLogger.log("Waiting for device to re-enumerate...");
	}
	} finally {
	if (!mConnected) {
	conn.releaseInterface(iface);
	}
	}
	}

	private void disconnect() {
	mLogger.log("Disconnecting from device: " + mDevice);
	stopServices();
	unregisterHid();

	mLogger.log("Disconnected.");
	mConnected = false;
	mDevice = null;
	mAccessoryConnection = null;
	mAccessoryInterface = null;
	mControlEndpoint = null;
	if (mTransport != null) {
	mTransport.close();
	mTransport = null;
	}
	}

	private void registerHid() {
	mLogger.log("Registering HID multitouch device.");

	mMultitouch = new UsbHid.Multitouch(MULTITOUCH_REPORT_ID, MULTITOUCH_MAX_CONTACTS,
	mSurfaceView.getWidth(), mSurfaceView.getHeight());

	mHidBuffer.clear();
	mMultitouch.generateDescriptor(mHidBuffer);
	mHidBuffer.flip();

	mLogger.log("HID descriptor size: " + mHidBuffer.limit());
	mLogger.log("HID report size: " + mMultitouch.getReportSize());

	final int maxPacketSize = mControlEndpoint.getMaxPacketSize();
	mLogger.log("Control endpoint max packet size: " + maxPacketSize);
	if (mMultitouch.getReportSize() > maxPacketSize) {
	mLogger.logError("HID report is too big for this accessory.");
	return;
	}

	int len = mAccessoryConnection.controlTransfer(
	UsbConstants.USB_DIR_OUT \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_REGISTER_HID,
	MULTITOUCH_DEVICE_ID, mHidBuffer.limit(), null, 0, 10000);
	if (len != 0) {
	mLogger.logError("Device rejected ACCESSORY_REGISTER_HID request.");
	return;
	}

	while (mHidBuffer.hasRemaining()) {
	int position = mHidBuffer.position();
	int count = Math.min(mHidBuffer.remaining(), maxPacketSize);
	len = mAccessoryConnection.controlTransfer(
	UsbConstants.USB_DIR_OUT \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_SET_HID_REPORT_DESC,
	MULTITOUCH_DEVICE_ID, 0,
	mHidBuffer.array(), position, count, 10000);
	if (len != count) {
	mLogger.logError("Device rejected ACCESSORY_SET_HID_REPORT_DESC request.");
	return;
	}
	mHidBuffer.position(position + count);
	}

	mLogger.log("HID device registered.");

	mMultitouchEnabled = true;
	if (mMultitouchContacts == null) {
	mMultitouchContacts = new UsbHid.Multitouch.Contact[MULTITOUCH_MAX_CONTACTS];
	for (int i = 0; i < MULTITOUCH_MAX_CONTACTS; i++) {
	mMultitouchContacts[i] = new UsbHid.Multitouch.Contact();
	}
	}
	}

	private void unregisterHid() {
	mMultitouch = null;
	mMultitouchContacts = null;
	mMultitouchEnabled = false;
	}

	private void sendHidTouch(MotionEvent event) {
	if (mMultitouchEnabled) {
	mLogger.log("Sending touch event: " + event);

	switch (event.getActionMasked()) {
	case MotionEvent.ACTION_DOWN:
	case MotionEvent.ACTION_MOVE: {
	final int pointerCount =
	Math.min(MULTITOUCH_MAX_CONTACTS, event.getPointerCount());
	final int historySize = event.getHistorySize();
	for (int p = 0; p < pointerCount; p++) {
	mMultitouchContacts[p].id = event.getPointerId(p);
	}
	for (int h = 0; h < historySize; h++) {
	for (int p = 0; p < pointerCount; p++) {
	mMultitouchContacts[p].x = (int)event.getHistoricalX(p, h);
	mMultitouchContacts[p].y = (int)event.getHistoricalY(p, h);
	}
	sendHidTouchReport(pointerCount);
	}
	for (int p = 0; p < pointerCount; p++) {
	mMultitouchContacts[p].x = (int)event.getX(p);
	mMultitouchContacts[p].y = (int)event.getY(p);
	}
	sendHidTouchReport(pointerCount);
	break;
	}

	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	sendHidTouchReport(0);
	break;
	}
	}
	}

	private void sendHidTouchReport(int contactCount) {
	mHidBuffer.clear();
	mMultitouch.generateReport(mHidBuffer, mMultitouchContacts, contactCount);
	mHidBuffer.flip();

	int count = mHidBuffer.limit();
	int len = mAccessoryConnection.controlTransfer(
	UsbConstants.USB_DIR_OUT \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_SEND_HID_EVENT,
	MULTITOUCH_DEVICE_ID, 0,
	mHidBuffer.array(), 0, count, 10000);
	if (len != count) {
	mLogger.logError("Device rejected ACCESSORY_SEND_HID_EVENT request.");
	return;
	}
	}

	private void startServices() {
	mDisplaySinkService = new DisplaySinkService(this, mTransport,
	getResources().getConfiguration().densityDpi);
	mDisplaySinkService.start();

	if (mAttached) {
	mDisplaySinkService.setSurfaceView(mSurfaceView);
	}
	}

	private void stopServices() {
	if (mDisplaySinkService != null) {
	mDisplaySinkService.stop();
	mDisplaySinkService = null;
	}
	}

	@Override
	public void onAttachedToWindow() {
	super.onAttachedToWindow();

	mAttached = true;
	if (mDisplaySinkService != null) {
	mDisplaySinkService.setSurfaceView(mSurfaceView);
	}
	}

	@Override
	public void onDetachedFromWindow() {
	super.onDetachedFromWindow();

	mAttached = false;
	if (mDisplaySinkService != null) {
	mDisplaySinkService.setSurfaceView(null);
	}
	}

	private int getProtocol(UsbDeviceConnection conn) {
	byte buffer[] = new byte[2];
	int len = conn.controlTransfer(
	UsbConstants.USB_DIR_IN \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_GET_PROTOCOL, 0, 0, buffer, 2, 10000);
	if (len != 2) {
	return -1;
	}
	return (buffer[1] << 8) \| buffer[0];
	}

	private void sendString(UsbDeviceConnection conn, int index, String string) {
	byte[] buffer = (string + "\0").getBytes();
	int len = conn.controlTransfer(UsbConstants.USB_DIR_OUT \| UsbConstants.USB_TYPE_VENDOR,
	UsbAccessoryConstants.ACCESSORY_SEND_STRING, 0, index,
	buffer, buffer.length, 10000);
	if (len != buffer.length) {
	mLogger.logError("Failed to send string " + index + ": \"" + string + "\"");
	} else {
	mLogger.log("Sent string " + index + ": \"" + string + "\"");
	}
	}

	private static boolean isAccessory(UsbDevice device) {
	final int vid = device.getVendorId();
	final int pid = device.getProductId();
	return vid == UsbAccessoryConstants.USB_ACCESSORY_VENDOR_ID
	&& (pid == UsbAccessoryConstants.USB_ACCESSORY_PRODUCT_ID
	\|\| pid == UsbAccessoryConstants.USB_ACCESSORY_ADB_PRODUCT_ID);
	}

	class TextLogger extends Logger {
	@Override
	public void log(final String message) {
	Log.d(TAG, message);

	mLogTextView.post(new Runnable() {
	@Override
	public void run() {
	mLogTextView.append(message);
	mLogTextView.append("\n");
	}
	});
	}
	}

	class DeviceReceiver extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
	UsbDevice device = intent.<UsbDevice>getParcelableExtra(UsbManager.EXTRA_DEVICE);
	if (device != null) {
	String action = intent.getAction();
	if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
	onDeviceAttached(device);
	} else if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED)) {
	onDeviceDetached(device);
	} else if (action.equals(ACTION_USB_DEVICE_PERMISSION)) {
	if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
	mLogger.log("Device permission granted: " + device);
	onDeviceAttached(device);
	} else {
	mLogger.logError("Device permission denied: " + device);
	}
	}
	}
	}
	}
	}