1 files changed, 386 insertions, 0 deletions
diff --git a/app/src/com/google/android/DemoKit/DemoKitActivity.java b/app/src/com/google/android/DemoKit/DemoKitActivity.java
new file mode 100644
index 0000000..de16c1a
--- /dev/null
+++ b/app/src/com/google/android/DemoKit/DemoKitActivity.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2011 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.google.android.DemoKit;
+
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+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.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+import android.widget.SeekBar;
+
+import com.android.future.usb.UsbAccessory;
+import com.android.future.usb.UsbManager;
+
+public class DemoKitActivity extends Activity implements Runnable {
+	private static final String TAG = "DemoKit";
+
+	private static final String ACTION_USB_PERMISSION = "com.google.android.DemoKit.action.USB_PERMISSION";
+
+	private UsbManager mUsbManager;
+	private PendingIntent mPermissionIntent;
+	private boolean mPermissionRequestPending;
+
+	UsbAccessory mAccessory;
+	ParcelFileDescriptor mFileDescriptor;
+	FileInputStream mInputStream;
+	FileOutputStream mOutputStream;
+
+	private static final int MESSAGE_SWITCH = 1;
+	private static final int MESSAGE_TEMPERATURE = 2;
+	private static final int MESSAGE_LIGHT = 3;
+	private static final int MESSAGE_JOY = 4;
+
+	public static final byte LED_SERVO_COMMAND = 2;
+	public static final byte RELAY_COMMAND = 3;
+
+	protected class SwitchMsg {
+		private byte sw;
+		private byte state;
+
+		public SwitchMsg(byte sw, byte state) {
+			this.sw = sw;
+			this.state = state;
+		}
+
+		public byte getSw() {
+			return sw;
+		}
+
+		public byte getState() {
+			return state;
+		}
+	}
+
+	protected class TemperatureMsg {
+		private int temperature;
+
+		public TemperatureMsg(int temperature) {
+			this.temperature = temperature;
+		}
+
+		public int getTemperature() {
+			return temperature;
+		}
+	}
+
+	protected class LightMsg {
+		private int light;
+
+		public LightMsg(int light) {
+			this.light = light;
+		}
+
+		public int getLight() {
+			return light;
+		}
+	}
+
+	protected class JoyMsg {
+		private int x;
+		private int y;
+
+		public JoyMsg(int x, int y) {
+			this.x = x;
+			this.y = y;
+		}
+
+		public int getX() {
+			return x;
+		}
+
+		public int getY() {
+			return y;
+		}
+	}
+
+	private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
+		@Override
+		public void onReceive(Context context, Intent intent) {
+			String action = intent.getAction();
+			if (ACTION_USB_PERMISSION.equals(action)) {
+				synchronized (this) {
+					UsbAccessory accessory = UsbManager.getAccessory(intent);
+					if (intent.getBooleanExtra(
+							UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
+						openAccessory(accessory);
+					} else {
+						Log.d(TAG, "permission denied for accessory "
+								+ accessory);
+					}
+					mPermissionRequestPending = false;
+				}
+			} else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {
+				UsbAccessory accessory = UsbManager.getAccessory(intent);
+				if (accessory != null && accessory.equals(mAccessory)) {
+					closeAccessory();
+				}
+			}
+		}
+	};
+
+	/** Called when the activity is first created. */
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		mUsbManager = UsbManager.getInstance(this);
+		mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(
+				ACTION_USB_PERMISSION), 0);
+		IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
+		filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
+		registerReceiver(mUsbReceiver, filter);
+
+		if (getLastNonConfigurationInstance() != null) {
+			mAccessory = (UsbAccessory) getLastNonConfigurationInstance();
+			openAccessory(mAccessory);
+		}
+
+		setContentView(R.layout.main);
+
+		enableControls(false);
+	}
+
+	@Override
+	public Object onRetainNonConfigurationInstance() {
+		if (mAccessory != null) {
+			return mAccessory;
+		} else {
+			return super.onRetainNonConfigurationInstance();
+		}
+	}
+
+	@Override
+	public void onResume() {
+		super.onResume();
+
+		Intent intent = getIntent();
+		if (mInputStream != null && mOutputStream != null) {
+			return;
+		}
+
+		UsbAccessory[] accessories = mUsbManager.getAccessoryList();
+		UsbAccessory accessory = (accessories == null ? null : accessories[0]);
+		if (accessory != null) {
+			if (mUsbManager.hasPermission(accessory)) {
+				openAccessory(accessory);
+			} else {
+				synchronized (mUsbReceiver) {
+					if (!mPermissionRequestPending) {
+						mUsbManager.requestPermission(accessory,
+								mPermissionIntent);
+						mPermissionRequestPending = true;
+					}
+				}
+			}
+		} else {
+			Log.d(TAG, "mAccessory is null");
+		}
+	}
+
+	@Override
+	public void onPause() {
+		super.onPause();
+		closeAccessory();
+	}
+
+	@Override
+	public void onDestroy() {
+		unregisterReceiver(mUsbReceiver);
+		super.onDestroy();
+	}
+
+	private void openAccessory(UsbAccessory accessory) {
+		mFileDescriptor = mUsbManager.openAccessory(accessory);
+		if (mFileDescriptor != null) {
+			mAccessory = accessory;
+			FileDescriptor fd = mFileDescriptor.getFileDescriptor();
+			mInputStream = new FileInputStream(fd);
+			mOutputStream = new FileOutputStream(fd);
+			Thread thread = new Thread(null, this, "DemoKit");
+			thread.start();
+			Log.d(TAG, "accessory opened");
+			enableControls(true);
+		} else {
+			Log.d(TAG, "accessory open fail");
+		}
+	}
+
+	private void closeAccessory() {
+		enableControls(false);
+
+		try {
+			if (mFileDescriptor != null) {
+				mFileDescriptor.close();
+			}
+		} catch (IOException e) {
+		} finally {
+			mFileDescriptor = null;
+			mAccessory = null;
+		}
+	}
+
+	protected void enableControls(boolean enable) {
+	}
+
+	private int composeInt(byte hi, byte lo) {
+		int val = (int) hi & 0xff;
+		val *= 256;
+		val += (int) lo & 0xff;
+		return val;
+	}
+
+	public void run() {
+		int ret = 0;
+		byte[] buffer = new byte[16384];
+		int i;
+
+		while (ret >= 0) {
+			try {
+				ret = mInputStream.read(buffer);
+			} catch (IOException e) {
+				break;
+			}
+
+			i = 0;
+			while (i < ret) {
+				int len = ret - i;
+
+				switch (buffer[i]) {
+				case 0x1:
+					if (len >= 3) {
+						Message m = Message.obtain(mHandler, MESSAGE_SWITCH);
+						m.obj = new SwitchMsg(buffer[i + 1], buffer[i + 2]);
+						mHandler.sendMessage(m);
+					}
+					i += 3;
+					break;
+
+				case 0x4:
+					if (len >= 3) {
+						Message m = Message.obtain(mHandler,
+								MESSAGE_TEMPERATURE);
+						m.obj = new TemperatureMsg(composeInt(buffer[i + 1],
+								buffer[i + 2]));
+						mHandler.sendMessage(m);
+					}
+					i += 3;
+					break;
+
+				case 0x5:
+					if (len >= 3) {
+						Message m = Message.obtain(mHandler, MESSAGE_LIGHT);
+						m.obj = new LightMsg(composeInt(buffer[i + 1],
+								buffer[i + 2]));
+						mHandler.sendMessage(m);
+					}
+					i += 3;
+					break;
+
+				case 0x6:
+					if (len >= 3) {
+						Message m = Message.obtain(mHandler, MESSAGE_JOY);
+						m.obj = new JoyMsg(buffer[i + 1], buffer[i + 2]);
+						mHandler.sendMessage(m);
+					}
+					i += 3;
+					break;
+
+				default:
+					Log.d(TAG, "unknown msg: " + buffer[i]);
+					i = len;
+					break;
+				}
+			}
+
+		}
+	}
+
+	Handler mHandler = new Handler() {
+		@Override
+		public void handleMessage(Message msg) {
+			switch (msg.what) {
+			case MESSAGE_SWITCH:
+				SwitchMsg o = (SwitchMsg) msg.obj;
+				handleSwitchMessage(o);
+				break;
+
+			case MESSAGE_TEMPERATURE:
+				TemperatureMsg t = (TemperatureMsg) msg.obj;
+				handleTemperatureMessage(t);
+				break;
+
+			case MESSAGE_LIGHT:
+				LightMsg l = (LightMsg) msg.obj;
+				handleLightMessage(l);
+				break;
+
+			case MESSAGE_JOY:
+				JoyMsg j = (JoyMsg) msg.obj;
+				handleJoyMessage(j);
+				break;
+
+			}
+		}
+	};
+
+	public void sendCommand(byte command, byte target, int value) {
+		byte[] buffer = new byte[3];
+		if (value > 255)
+			value = 255;
+
+		buffer[0] = command;
+		buffer[1] = target;
+		buffer[2] = (byte) value;
+		if (mOutputStream != null && buffer[1] != -1) {
+			try {
+				mOutputStream.write(buffer);
+			} catch (IOException e) {
+				Log.e(TAG, "write failed", e);
+			}
+		}
+	}
+
+	protected void handleJoyMessage(JoyMsg j) {
+	}
+
+	protected void handleLightMessage(LightMsg l) {
+	}
+
+	protected void handleTemperatureMessage(TemperatureMsg t) {
+	}
+
+	protected void handleSwitchMessage(SwitchMsg o) {
+	}
+
+	public void onStartTrackingTouch(SeekBar seekBar) {
+	}
+
+	public void onStopTrackingTouch(SeekBar seekBar) {
+	}
+}