apps/SdkController/src/com/android/tools/sdkcontroller/handlers/SensorChannel.java - platform/sdk - Git at Google

 /*
  * Copyright (C) 2012 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.tools.sdkcontroller.handlers;

 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;

 import android.content.Context;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.os.Message;
 import android.os.SystemClock;
 import android.util.Log;

 import com.android.tools.sdkcontroller.lib.Channel;
 import com.android.tools.sdkcontroller.lib.ProtocolConstants;
 import com.android.tools.sdkcontroller.service.ControllerService;

 /**
  * Implements sensors emulation.
  */
 public class SensorChannel extends Channel {

     @SuppressWarnings("hiding")
     private static String TAG = SensorChannel.class.getSimpleName();
     @SuppressWarnings("hiding")
     private static boolean DEBUG = false;
     /**
      * The target update time per sensor. Ignored if 0 or negative.
      * Sensor updates that arrive faster than this delay are ignored.
      * Ideally the emulator can be updated at up to 50 fps, however
      * for average power devices something like 20 fps is more
      * reasonable.
      * Default value should match res/values/strings.xml > sensors_default_sample_rate.
      */
     private long mUpdateTargetMs = 1000/20; // 20 fps in milliseconds
     /** Accumulates average update frequency. */
     private long mGlobalAvgUpdateMs = 0;

     /** Array containing monitored sensors. */
     private final List<MonitoredSensor> mSensors = new ArrayList<MonitoredSensor>();
     /** Sensor manager. */
     private SensorManager mSenMan;

     /*
      * Messages exchanged with the UI.
      */

     /**
      * Sensor "enabled by emulator" state has changed. Parameter {@code obj} is
      * the {@link MonitoredSensor}.
      */
     public static final int SENSOR_STATE_CHANGED = 1;
     /**
      * Sensor display value has changed. Parameter {@code obj} is the
      * {@link MonitoredSensor}.
      */
     public static final int SENSOR_DISPLAY_MODIFIED = 2;

     /**
      * Constructs SensorChannel instance.
      *
      * @param service Service context.
      */
     public SensorChannel(ControllerService service) {
         super(service, Channel.SENSOR_CHANNEL);
         mSenMan = (SensorManager) service.getSystemService(Context.SENSOR_SERVICE);
         // Iterate through the available sensors, adding them to the array.
         List<Sensor> sensors = mSenMan.getSensorList(Sensor.TYPE_ALL);
         int cur_index = 0;
         for (int n = 0; n < sensors.size(); n++) {
             Sensor avail_sensor = sensors.get(n);

             // There can be multiple sensors of the same type. We need only one.
             if (!isSensorTypeAlreadyMonitored(avail_sensor.getType())) {
                 // The first sensor we've got for the given type is not
                 // necessarily the right one. So, use the default sensor
                 // for the given type.
                 Sensor def_sens = mSenMan.getDefaultSensor(avail_sensor.getType());
                 MonitoredSensor to_add = new MonitoredSensor(def_sens);
                 cur_index++;
                 mSensors.add(to_add);
                 if (DEBUG)
                     Log.d(TAG, String.format(
                             "Monitoring sensor #%02d: Name = '%s', Type = 0x%x",
                             cur_index, def_sens.getName(), def_sens.getType()));
             }
         }
     }

     /**
      * Returns the list of sensors found on the device.
      * The list is computed once by {@link #SensorChannel(ControllerService)}.
      *
      * @return A non-null possibly-empty list of sensors.
      */
     public List<MonitoredSensor> getSensors() {
         return mSensors;
     }

     /**
      * Set the target update delay throttling per-sensor, in milliseconds.
      * <p/>
      * For example setting it to 1000/50 means that updates for a <em>given</em> sensor
      * faster than 50 fps is discarded.
      *
      * @param updateTargetMs 0 to disable throttling, otherwise a > 0 millisecond minimum
      *   between sensor updates.
      */
     public void setUpdateTargetMs(long updateTargetMs) {
         mUpdateTargetMs = updateTargetMs;
     }

     /**
      * Returns the actual average time in milliseconds between same-sensor updates.
      *
      * @return The actual average time in milliseconds between same-sensor updates or 0.
      */
     public long getActualUpdateMs() {
         return mGlobalAvgUpdateMs;
     }

     /*
      * Channel abstract implementation.
      */

     /**
      * This method is invoked when this channel is fully connected with its
      * counterpart in the emulator.
      */
     @Override
     public void onEmulatorConnected() {
         // Emulation is now possible. Note though that it will start only after
         // emulator tells us so with SENSORS_START command.
         enable();
     }

     /**
      * This method is invoked when this channel loses connection with its
      * counterpart in the emulator.
      */
     @Override
     public void onEmulatorDisconnected() {
         // Stop sensor event callbacks.
         stopSensors();
     }

     /**
      * A query has been received from the emulator.
      *
      * @param query_id Identifies the query. This ID should be used when
      *            replying to the query.
      * @param query_type Query type.
      * @param query_data Query data.
      */
     @Override
     public void onEmulatorQuery(int query_id, int query_type, ByteBuffer query_data) {
         switch (query_type) {
             case ProtocolConstants.SENSORS_QUERY_LIST:
                 // Preallocate large response buffer.
                 ByteBuffer resp = ByteBuffer.allocate(1024);
                 resp.order(getEndian());
                 // Iterate through the list of monitored sensors, dumping them
                 // into the response buffer.
                 for (MonitoredSensor sensor : mSensors) {
                     // Entry for each sensor must contain:
                     // - an integer for its ID
                     // - a zero-terminated emulator-friendly name.
                     final byte[] name = sensor.getEmulatorFriendlyName().getBytes();
                     final int required_size = 4 + name.length + 1;
                     resp = ExpandIf(resp, required_size);
                     resp.putInt(sensor.getType());
                     resp.put(name);
                     resp.put((byte) 0);
                 }
                 // Terminating entry contains single -1 integer.
                 resp = ExpandIf(resp, 4);
                 resp.putInt(-1);
                 sendQueryResponse(query_id, resp);
                 return;

             default:
                 Loge("Unknown query " + query_type);
                 return;
         }
     }

     /**
      * A message has been received from the emulator.
      *
      * @param msg_type Message type.
      * @param msg_data Packet received from the emulator.
      */
     @Override
     public void onEmulatorMessage(int msg_type, ByteBuffer msg_data) {
         switch (msg_type) {
             case ProtocolConstants.SENSORS_START:
                 Log.v(TAG, "Starting sensors emulation.");
                 startSensors();
                 break;
             case ProtocolConstants.SENSORS_STOP:
                 Log.v(TAG, "Stopping sensors emulation.");
                 stopSensors();
                 break;
             case ProtocolConstants.SENSORS_ENABLE:
                 String enable_name = new String(msg_data.array());
                 Log.v(TAG, "Enabling sensor: " + enable_name);
                 onEnableSensor(enable_name);
                 break;
             case ProtocolConstants.SENSORS_DISABLE:
                 String disable_name = new String(msg_data.array());
                 Log.v(TAG, "Disabling sensor: " + disable_name);
                 onDisableSensor(disable_name);
                 break;
             default:
                 Loge("Unknown message type " + msg_type);
                 break;
         }
     }

     /**
      * Handles 'enable' message.
      *
      * @param name Emulator-friendly name of a sensor to enable, or "all" to
      *            enable all sensors.
      */
     private void onEnableSensor(String name) {
         if (name.contentEquals("all")) {
             // Enable all sensors.
             for (MonitoredSensor sensor : mSensors) {
                 sensor.enableSensor();
             }
         } else {
             // Lookup sensor by emulator-friendly name.
             final MonitoredSensor sensor = getSensorByEFN(name);
             if (sensor != null) {
                 sensor.enableSensor();
             }
         }
     }

     /**
      * Handles 'disable' message.
      *
      * @param name Emulator-friendly name of a sensor to disable, or "all" to
      *            disable all sensors.
      */
     private void onDisableSensor(String name) {
         if (name.contentEquals("all")) {
             // Disable all sensors.
             for (MonitoredSensor sensor : mSensors) {
                 sensor.disableSensor();
             }
         } else {
             // Lookup sensor by emulator-friendly name.
             MonitoredSensor sensor = getSensorByEFN(name);
             if (sensor != null) {
                 sensor.disableSensor();
             }
         }
     }

     /**
      * Start listening to all monitored sensors.
      */
     private void startSensors() {
         for (MonitoredSensor sensor : mSensors) {
             sensor.startListening();
         }
     }

     /**
      * Stop listening to all monitored sensors.
      */
     private void stopSensors() {
         for (MonitoredSensor sensor : mSensors) {
             sensor.stopListening();
         }
     }

     /***************************************************************************
      * Internals
      **************************************************************************/

     /**
      * Checks if a sensor for the given type is already monitored.
      *
      * @param type Sensor type (one of the Sensor.TYPE_XXX constants)
      * @return true if a sensor for the given type is already monitored, or
      *         false if the sensor is not monitored.
      */
     private boolean isSensorTypeAlreadyMonitored(int type) {
         for (MonitoredSensor sensor : mSensors) {
             if (sensor.getType() == type) {
                 return true;
             }
         }
         return false;
     }

     /**
      * Looks up a monitored sensor by its emulator-friendly name.
      *
      * @param name Emulator-friendly name to look up the monitored sensor for.
      * @return Monitored sensor for the fiven name, or null if sensor was not
      *         found.
      */
     private MonitoredSensor getSensorByEFN(String name) {
         for (MonitoredSensor sensor : mSensors) {
             if (sensor.mEmulatorFriendlyName.contentEquals(name)) {
                 return sensor;
             }
         }
         return null;
     }

     /**
      * Encapsulates a sensor that is being monitored. To monitor sensor changes
      * each monitored sensor registers with sensor manager as a sensor listener.
      * To control sensor monitoring from the UI, each monitored sensor has two
      * UI controls associated with it: - A check box (named after sensor) that
      * can be used to enable, or disable listening to the sensor changes. - A
      * text view where current sensor value is displayed.
      */
     public class MonitoredSensor {
         /** Sensor to monitor. */
         private final Sensor mSensor;
         /** The sensor name to display in the UI. */
         private String mUiName = "";
         /** Text view displaying the value of the sensor. */
         private String mValue = null;
         /** Emulator-friendly name for the sensor. */
         private String mEmulatorFriendlyName;
         /** Formats string to show in the TextView. */
         private String mTextFmt;
         /** Sensor values. */
         private float[] mValues = new float[3];
         /**
          * Enabled state. This state is controlled by the emulator, that
          * maintains its own list of sensors. So, if a sensor is missing, or is
          * disabled in the emulator, it should be disabled in this application.
          */
         private boolean mEnabledByEmulator = false;
         /** User-controlled enabled state. */
         private boolean mEnabledByUser = true;
         /** Sensor event listener for this sensor. */
         private final OurSensorEventListener mListener = new OurSensorEventListener();

         /**
          * Constructs MonitoredSensor instance, and register the listeners.
          *
          * @param sensor Sensor to monitor.
          */
         MonitoredSensor(Sensor sensor) {
             mSensor = sensor;
             mEnabledByUser = true;

             // Set appropriate sensor name depending on the type. Unfortunately,
             // we can't really use sensor.getName() here, since the value it
             // returns (although resembles the purpose) is a bit vaguer than it
             // should be. Also choose an appropriate format for the strings that
             // display sensor's value.
             switch (sensor.getType()) {
                 case Sensor.TYPE_ACCELEROMETER:
                     mUiName = "Accelerometer";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "acceleration";
                     break;
                 case 9: // Sensor.TYPE_GRAVITY is missing in API 7
                     mUiName = "Gravity";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "gravity";
                     break;
                 case Sensor.TYPE_GYROSCOPE:
                     mUiName = "Gyroscope";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "gyroscope";
                     break;
                 case Sensor.TYPE_LIGHT:
                     mUiName = "Light";
                     mTextFmt = "%.0f";
                     mEmulatorFriendlyName = "light";
                     break;
                 case 10: // Sensor.TYPE_LINEAR_ACCELERATION is missing in API 7
                     mUiName = "Linear acceleration";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "linear-acceleration";
                     break;
                 case Sensor.TYPE_MAGNETIC_FIELD:
                     mUiName = "Magnetic field";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "magnetic-field";
                     break;
                 case Sensor.TYPE_ORIENTATION:
                     mUiName = "Orientation";
                     mTextFmt = "%+03.0f %+03.0f %+03.0f";
                     mEmulatorFriendlyName = "orientation";
                     break;
                 case Sensor.TYPE_PRESSURE:
                     mUiName = "Pressure";
                     mTextFmt = "%.0f";
                     mEmulatorFriendlyName = "pressure";
                     break;
                 case Sensor.TYPE_PROXIMITY:
                     mUiName = "Proximity";
                     mTextFmt = "%.0f";
                     mEmulatorFriendlyName = "proximity";
                     break;
                 case 11: // Sensor.TYPE_ROTATION_VECTOR is missing in API 7
                     mUiName = "Rotation";
                     mTextFmt = "%+.2f %+.2f %+.2f";
                     mEmulatorFriendlyName = "rotation";
                     break;
                 case Sensor.TYPE_TEMPERATURE:
                     mUiName = "Temperature";
                     mTextFmt = "%.0f";
                     mEmulatorFriendlyName = "temperature";
                     break;
                 default:
                     mUiName = "<Unknown>";
                     mTextFmt = "N/A";
                     mEmulatorFriendlyName = "unknown";
                     if (DEBUG) Loge("Unknown sensor type " + mSensor.getType() +
                             " for sensor " + mSensor.getName());
                     break;
             }
         }

         /**
          * Get name for this sensor to display.
          *
          * @return Name for this sensor to display.
          */
         public String getUiName() {
             return mUiName;
         }

         /**
          * Gets current sensor value to display.
          *
          * @return Current sensor value to display.
          */
         public String getValue() {
             if (mValue == null) {
                 float[] values = mValues;
                 mValue = String.format(mTextFmt, values[0], values[1], values[2]);
             }
             return mValue == null ? "??" : mValue;
         }

         /**
          * Checks if monitoring of this this sensor has been enabled by
          * emulator.
          *
          * @return true if monitoring of this this sensor has been enabled by
          *         emulator, or false if emulator didn't enable this sensor.
          */
         public boolean isEnabledByEmulator() {
             return mEnabledByEmulator;
         }

         /**
          * Checks if monitoring of this this sensor has been enabled by user.
          *
          * @return true if monitoring of this this sensor has been enabled by
          *         user, or false if user didn't enable this sensor.
          */
         public boolean isEnabledByUser() {
             return mEnabledByUser;
         }

         /**
          * Handles checked state change for the associated CheckBox. If check
          * box is checked we will register sensor change listener. If it is
          * unchecked, we will unregister sensor change listener.
          */
         public void onCheckedChanged(boolean isChecked) {
             mEnabledByUser = isChecked;
             if (isChecked) {
                 startListening();
             } else {
                 stopListening();
             }
         }

         /**
          * Gets sensor type.
          *
          * @return Sensor type as one of the Sensor.TYPE_XXX constants.
          */
         private int getType() {
             return mSensor.getType();
         }

         /**
          * Gets sensor's emulator-friendly name.
          *
          * @return Sensor's emulator-friendly name.
          */
         private String getEmulatorFriendlyName() {
             return mEmulatorFriendlyName;
         }

         /**
          * Starts monitoring the sensor.
          * NOTE: This method is called from outside of the UI thread.
          */
         private void startListening() {
             if (mEnabledByEmulator && mEnabledByUser) {
                 if (DEBUG) Log.d(TAG, "+++ Sensor " + getEmulatorFriendlyName() + " is started.");
                 mSenMan.registerListener(mListener, mSensor, SensorManager.SENSOR_DELAY_FASTEST);
             }
         }

         /**
          * Stops monitoring the sensor.
          * NOTE: This method is called from outside of the UI thread.
          */
         private void stopListening() {
             if (DEBUG) Log.d(TAG, "--- Sensor " + getEmulatorFriendlyName() + " is stopped.");
             mSenMan.unregisterListener(mListener);
         }

         /**
          * Enables sensor events.
          * NOTE: This method is called from outside of the UI thread.
          */
         private void enableSensor() {
             if (DEBUG) Log.d(TAG, ">>> Sensor " + getEmulatorFriendlyName() + " is enabled.");
             mEnabledByEmulator = true;
             mValue = null;

             Message msg = Message.obtain();
             msg.what = SENSOR_STATE_CHANGED;
             msg.obj = MonitoredSensor.this;
             notifyUiHandlers(msg);
         }

         /**
          * Disables sensor events.
          * NOTE: This method is called from outside of the UI thread.
          */
         private void disableSensor() {
             if (DEBUG) Log.w(TAG, "<<< Sensor " + getEmulatorFriendlyName() + " is disabled.");
             mEnabledByEmulator = false;
             mValue = "Disabled by emulator";

             Message msg = Message.obtain();
             msg.what = SENSOR_STATE_CHANGED;
             msg.obj = MonitoredSensor.this;
             notifyUiHandlers(msg);
         }

         private class OurSensorEventListener implements SensorEventListener {
             /** Last update's time-stamp in local thread millisecond time. */
             private long mLastUpdateTS = 0;
             /** Last display update time-stamp. */
             private long mLastDisplayTS = 0;
             /** Preallocated buffer for change notification message. */
             private final ByteBuffer mChangeMsg = ByteBuffer.allocate(64);

             /**
              * Handles "sensor changed" event.
              * This is an implementation of the SensorEventListener interface.
              */
             @Override
             public void onSensorChanged(SensorEvent event) {
                 long now = SystemClock.elapsedRealtime();

                 long deltaMs = 0;
                 if (mLastUpdateTS != 0) {
                     deltaMs = now - mLastUpdateTS;
                     if (mUpdateTargetMs > 0 && deltaMs < mUpdateTargetMs) {
                         // New sample is arriving too fast. Discard it.
                         return;
                     }
                 }

                 // Format and post message for the emulator.
                 float[] values = event.values;
                 final int len = values.length;

                 mChangeMsg.order(getEndian());
                 mChangeMsg.position(0);
                 mChangeMsg.putInt(getType());
                 mChangeMsg.putFloat(values[0]);
                 if (len > 1) {
                     mChangeMsg.putFloat(values[1]);
                     if (len > 2) {
                         mChangeMsg.putFloat(values[2]);
                     }
                 }
                 postMessage(ProtocolConstants.SENSORS_SENSOR_EVENT, mChangeMsg);

                 // Computes average update time for this sensor and average globally.
                 if (mLastUpdateTS != 0) {
                     if (mGlobalAvgUpdateMs != 0) {
                         mGlobalAvgUpdateMs = (mGlobalAvgUpdateMs + deltaMs) / 2;
                     } else {
                         mGlobalAvgUpdateMs = deltaMs;
                     }
                 }
                 mLastUpdateTS = now;

                 // Update the UI for the sensor, with a static throttling of 10 fps max.
                 if (hasUiHandler()) {
                     if (mLastDisplayTS != 0) {
                         long uiDeltaMs = now - mLastDisplayTS;
                         if (uiDeltaMs < 1000 / 4 /* 4fps in ms */) {
                             // Skip this UI update
                             return;
                         }
                     }
                     mLastDisplayTS = now;

                     mValues[0] = values[0];
                     if (len > 1) {
                         mValues[1] = values[1];
                         if (len > 2) {
                             mValues[2] = values[2];
                         }
                     }
                     mValue = null;

                     Message msg = Message.obtain();
                     msg.what = SENSOR_DISPLAY_MODIFIED;
                     msg.obj = MonitoredSensor.this;
                     notifyUiHandlers(msg);
                 }

                 if (DEBUG) {
                     long now2 = SystemClock.elapsedRealtime();
                     long processingTimeMs = now2 - now;
                     Log.d(TAG, String.format("glob %d - local %d > target %d - processing %d -- %s",
                             mGlobalAvgUpdateMs, deltaMs, mUpdateTargetMs, processingTimeMs,
                             mSensor.getName()));
                 }
             }

             /**
              * Handles "sensor accuracy changed" event.
              * This is an implementation of the SensorEventListener interface.
              */
             @Override
             public void onAccuracyChanged(Sensor sensor, int accuracy) {
             }
         }
     } // MonitoredSensor

     /***************************************************************************
      * Logging wrappers
      **************************************************************************/

     private void Loge(String log) {
         mService.addError(log);
         Log.e(TAG, log);
     }
 }
	/*
	* Copyright (C) 2012 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.tools.sdkcontroller.handlers;

	import java.nio.ByteBuffer;
	import java.util.ArrayList;
	import java.util.List;

	import android.content.Context;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.os.Message;
	import android.os.SystemClock;
	import android.util.Log;

	import com.android.tools.sdkcontroller.lib.Channel;
	import com.android.tools.sdkcontroller.lib.ProtocolConstants;
	import com.android.tools.sdkcontroller.service.ControllerService;

	/**
	* Implements sensors emulation.
	*/
	public class SensorChannel extends Channel {

	@SuppressWarnings("hiding")
	private static String TAG = SensorChannel.class.getSimpleName();
	@SuppressWarnings("hiding")
	private static boolean DEBUG = false;
	/**
	* The target update time per sensor. Ignored if 0 or negative.
	* Sensor updates that arrive faster than this delay are ignored.
	* Ideally the emulator can be updated at up to 50 fps, however
	* for average power devices something like 20 fps is more
	* reasonable.
	* Default value should match res/values/strings.xml > sensors_default_sample_rate.
	*/
	private long mUpdateTargetMs = 1000/20; // 20 fps in milliseconds
	/** Accumulates average update frequency. */
	private long mGlobalAvgUpdateMs = 0;

	/** Array containing monitored sensors. */
	private final List<MonitoredSensor> mSensors = new ArrayList<MonitoredSensor>();
	/** Sensor manager. */
	private SensorManager mSenMan;

	/*
	* Messages exchanged with the UI.
	*/

	/**
	* Sensor "enabled by emulator" state has changed. Parameter {@code obj} is
	* the {@link MonitoredSensor}.
	*/
	public static final int SENSOR_STATE_CHANGED = 1;
	/**
	* Sensor display value has changed. Parameter {@code obj} is the
	* {@link MonitoredSensor}.
	*/
	public static final int SENSOR_DISPLAY_MODIFIED = 2;

	/**
	* Constructs SensorChannel instance.
	*
	* @param service Service context.
	*/
	public SensorChannel(ControllerService service) {
	super(service, Channel.SENSOR_CHANNEL);
	mSenMan = (SensorManager) service.getSystemService(Context.SENSOR_SERVICE);
	// Iterate through the available sensors, adding them to the array.
	List<Sensor> sensors = mSenMan.getSensorList(Sensor.TYPE_ALL);
	int cur_index = 0;
	for (int n = 0; n < sensors.size(); n++) {
	Sensor avail_sensor = sensors.get(n);

	// There can be multiple sensors of the same type. We need only one.
	if (!isSensorTypeAlreadyMonitored(avail_sensor.getType())) {
	// The first sensor we've got for the given type is not
	// necessarily the right one. So, use the default sensor
	// for the given type.
	Sensor def_sens = mSenMan.getDefaultSensor(avail_sensor.getType());
	MonitoredSensor to_add = new MonitoredSensor(def_sens);
	cur_index++;
	mSensors.add(to_add);
	if (DEBUG)
	Log.d(TAG, String.format(
	"Monitoring sensor #%02d: Name = '%s', Type = 0x%x",
	cur_index, def_sens.getName(), def_sens.getType()));
	}
	}
	}

	/**
	* Returns the list of sensors found on the device.
	* The list is computed once by {@link #SensorChannel(ControllerService)}.
	*
	* @return A non-null possibly-empty list of sensors.
	*/
	public List<MonitoredSensor> getSensors() {
	return mSensors;
	}

	/**
	* Set the target update delay throttling per-sensor, in milliseconds.
	* <p/>
	* For example setting it to 1000/50 means that updates for a <em>given</em> sensor
	* faster than 50 fps is discarded.
	*
	* @param updateTargetMs 0 to disable throttling, otherwise a > 0 millisecond minimum
	* between sensor updates.
	*/
	public void setUpdateTargetMs(long updateTargetMs) {
	mUpdateTargetMs = updateTargetMs;
	}

	/**
	* Returns the actual average time in milliseconds between same-sensor updates.
	*
	* @return The actual average time in milliseconds between same-sensor updates or 0.
	*/
	public long getActualUpdateMs() {
	return mGlobalAvgUpdateMs;
	}

	/*
	* Channel abstract implementation.
	*/

	/**
	* This method is invoked when this channel is fully connected with its
	* counterpart in the emulator.
	*/
	@Override
	public void onEmulatorConnected() {
	// Emulation is now possible. Note though that it will start only after
	// emulator tells us so with SENSORS_START command.
	enable();
	}

	/**
	* This method is invoked when this channel loses connection with its
	* counterpart in the emulator.
	*/
	@Override
	public void onEmulatorDisconnected() {
	// Stop sensor event callbacks.
	stopSensors();
	}

	/**
	* A query has been received from the emulator.
	*
	* @param query_id Identifies the query. This ID should be used when
	* replying to the query.
	* @param query_type Query type.
	* @param query_data Query data.
	*/
	@Override
	public void onEmulatorQuery(int query_id, int query_type, ByteBuffer query_data) {
	switch (query_type) {
	case ProtocolConstants.SENSORS_QUERY_LIST:
	// Preallocate large response buffer.
	ByteBuffer resp = ByteBuffer.allocate(1024);
	resp.order(getEndian());
	// Iterate through the list of monitored sensors, dumping them
	// into the response buffer.
	for (MonitoredSensor sensor : mSensors) {
	// Entry for each sensor must contain:
	// - an integer for its ID
	// - a zero-terminated emulator-friendly name.
	final byte[] name = sensor.getEmulatorFriendlyName().getBytes();
	final int required_size = 4 + name.length + 1;
	resp = ExpandIf(resp, required_size);
	resp.putInt(sensor.getType());
	resp.put(name);
	resp.put((byte) 0);
	}
	// Terminating entry contains single -1 integer.
	resp = ExpandIf(resp, 4);
	resp.putInt(-1);
	sendQueryResponse(query_id, resp);
	return;

	default:
	Loge("Unknown query " + query_type);
	return;
	}
	}

	/**
	* A message has been received from the emulator.
	*
	* @param msg_type Message type.
	* @param msg_data Packet received from the emulator.
	*/
	@Override
	public void onEmulatorMessage(int msg_type, ByteBuffer msg_data) {
	switch (msg_type) {
	case ProtocolConstants.SENSORS_START:
	Log.v(TAG, "Starting sensors emulation.");
	startSensors();
	break;
	case ProtocolConstants.SENSORS_STOP:
	Log.v(TAG, "Stopping sensors emulation.");
	stopSensors();
	break;
	case ProtocolConstants.SENSORS_ENABLE:
	String enable_name = new String(msg_data.array());
	Log.v(TAG, "Enabling sensor: " + enable_name);
	onEnableSensor(enable_name);
	break;
	case ProtocolConstants.SENSORS_DISABLE:
	String disable_name = new String(msg_data.array());
	Log.v(TAG, "Disabling sensor: " + disable_name);
	onDisableSensor(disable_name);
	break;
	default:
	Loge("Unknown message type " + msg_type);
	break;
	}
	}

	/**
	* Handles 'enable' message.
	*
	* @param name Emulator-friendly name of a sensor to enable, or "all" to
	* enable all sensors.
	*/
	private void onEnableSensor(String name) {
	if (name.contentEquals("all")) {
	// Enable all sensors.
	for (MonitoredSensor sensor : mSensors) {
	sensor.enableSensor();
	}
	} else {
	// Lookup sensor by emulator-friendly name.
	final MonitoredSensor sensor = getSensorByEFN(name);
	if (sensor != null) {
	sensor.enableSensor();
	}
	}
	}

	/**
	* Handles 'disable' message.
	*
	* @param name Emulator-friendly name of a sensor to disable, or "all" to
	* disable all sensors.
	*/
	private void onDisableSensor(String name) {
	if (name.contentEquals("all")) {
	// Disable all sensors.
	for (MonitoredSensor sensor : mSensors) {
	sensor.disableSensor();
	}
	} else {
	// Lookup sensor by emulator-friendly name.
	MonitoredSensor sensor = getSensorByEFN(name);
	if (sensor != null) {
	sensor.disableSensor();
	}
	}
	}

	/**
	* Start listening to all monitored sensors.
	*/
	private void startSensors() {
	for (MonitoredSensor sensor : mSensors) {
	sensor.startListening();
	}
	}

	/**
	* Stop listening to all monitored sensors.
	*/
	private void stopSensors() {
	for (MonitoredSensor sensor : mSensors) {
	sensor.stopListening();
	}
	}

	/***************************************************************************
	* Internals
	**************************************************************************/

	/**
	* Checks if a sensor for the given type is already monitored.
	*
	* @param type Sensor type (one of the Sensor.TYPE_XXX constants)
	* @return true if a sensor for the given type is already monitored, or
	* false if the sensor is not monitored.
	*/
	private boolean isSensorTypeAlreadyMonitored(int type) {
	for (MonitoredSensor sensor : mSensors) {
	if (sensor.getType() == type) {
	return true;
	}
	}
	return false;
	}

	/**
	* Looks up a monitored sensor by its emulator-friendly name.
	*
	* @param name Emulator-friendly name to look up the monitored sensor for.
	* @return Monitored sensor for the fiven name, or null if sensor was not
	* found.
	*/
	private MonitoredSensor getSensorByEFN(String name) {
	for (MonitoredSensor sensor : mSensors) {
	if (sensor.mEmulatorFriendlyName.contentEquals(name)) {
	return sensor;
	}
	}
	return null;
	}

	/**
	* Encapsulates a sensor that is being monitored. To monitor sensor changes
	* each monitored sensor registers with sensor manager as a sensor listener.
	* To control sensor monitoring from the UI, each monitored sensor has two
	* UI controls associated with it: - A check box (named after sensor) that
	* can be used to enable, or disable listening to the sensor changes. - A
	* text view where current sensor value is displayed.
	*/
	public class MonitoredSensor {
	/** Sensor to monitor. */
	private final Sensor mSensor;
	/** The sensor name to display in the UI. */
	private String mUiName = "";
	/** Text view displaying the value of the sensor. */
	private String mValue = null;
	/** Emulator-friendly name for the sensor. */
	private String mEmulatorFriendlyName;
	/** Formats string to show in the TextView. */
	private String mTextFmt;
	/** Sensor values. */
	private float[] mValues = new float[3];
	/**
	* Enabled state. This state is controlled by the emulator, that
	* maintains its own list of sensors. So, if a sensor is missing, or is
	* disabled in the emulator, it should be disabled in this application.
	*/
	private boolean mEnabledByEmulator = false;
	/** User-controlled enabled state. */
	private boolean mEnabledByUser = true;
	/** Sensor event listener for this sensor. */
	private final OurSensorEventListener mListener = new OurSensorEventListener();

	/**
	* Constructs MonitoredSensor instance, and register the listeners.
	*
	* @param sensor Sensor to monitor.
	*/
	MonitoredSensor(Sensor sensor) {
	mSensor = sensor;
	mEnabledByUser = true;

	// Set appropriate sensor name depending on the type. Unfortunately,
	// we can't really use sensor.getName() here, since the value it
	// returns (although resembles the purpose) is a bit vaguer than it
	// should be. Also choose an appropriate format for the strings that
	// display sensor's value.
	switch (sensor.getType()) {
	case Sensor.TYPE_ACCELEROMETER:
	mUiName = "Accelerometer";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "acceleration";
	break;
	case 9: // Sensor.TYPE_GRAVITY is missing in API 7
	mUiName = "Gravity";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "gravity";
	break;
	case Sensor.TYPE_GYROSCOPE:
	mUiName = "Gyroscope";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "gyroscope";
	break;
	case Sensor.TYPE_LIGHT:
	mUiName = "Light";
	mTextFmt = "%.0f";
	mEmulatorFriendlyName = "light";
	break;
	case 10: // Sensor.TYPE_LINEAR_ACCELERATION is missing in API 7
	mUiName = "Linear acceleration";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "linear-acceleration";
	break;
	case Sensor.TYPE_MAGNETIC_FIELD:
	mUiName = "Magnetic field";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "magnetic-field";
	break;
	case Sensor.TYPE_ORIENTATION:
	mUiName = "Orientation";
	mTextFmt = "%+03.0f %+03.0f %+03.0f";
	mEmulatorFriendlyName = "orientation";
	break;
	case Sensor.TYPE_PRESSURE:
	mUiName = "Pressure";
	mTextFmt = "%.0f";
	mEmulatorFriendlyName = "pressure";
	break;
	case Sensor.TYPE_PROXIMITY:
	mUiName = "Proximity";
	mTextFmt = "%.0f";
	mEmulatorFriendlyName = "proximity";
	break;
	case 11: // Sensor.TYPE_ROTATION_VECTOR is missing in API 7
	mUiName = "Rotation";
	mTextFmt = "%+.2f %+.2f %+.2f";
	mEmulatorFriendlyName = "rotation";
	break;
	case Sensor.TYPE_TEMPERATURE:
	mUiName = "Temperature";
	mTextFmt = "%.0f";
	mEmulatorFriendlyName = "temperature";
	break;
	default:
	mUiName = "<Unknown>";
	mTextFmt = "N/A";
	mEmulatorFriendlyName = "unknown";
	if (DEBUG) Loge("Unknown sensor type " + mSensor.getType() +
	" for sensor " + mSensor.getName());
	break;
	}
	}

	/**
	* Get name for this sensor to display.
	*
	* @return Name for this sensor to display.
	*/
	public String getUiName() {
	return mUiName;
	}

	/**
	* Gets current sensor value to display.
	*
	* @return Current sensor value to display.
	*/
	public String getValue() {
	if (mValue == null) {
	float[] values = mValues;
	mValue = String.format(mTextFmt, values[0], values[1], values[2]);
	}
	return mValue == null ? "??" : mValue;
	}

	/**
	* Checks if monitoring of this this sensor has been enabled by
	* emulator.
	*
	* @return true if monitoring of this this sensor has been enabled by
	* emulator, or false if emulator didn't enable this sensor.
	*/
	public boolean isEnabledByEmulator() {
	return mEnabledByEmulator;
	}

	/**
	* Checks if monitoring of this this sensor has been enabled by user.
	*
	* @return true if monitoring of this this sensor has been enabled by
	* user, or false if user didn't enable this sensor.
	*/
	public boolean isEnabledByUser() {
	return mEnabledByUser;
	}

	/**
	* Handles checked state change for the associated CheckBox. If check
	* box is checked we will register sensor change listener. If it is
	* unchecked, we will unregister sensor change listener.
	*/
	public void onCheckedChanged(boolean isChecked) {
	mEnabledByUser = isChecked;
	if (isChecked) {
	startListening();
	} else {
	stopListening();
	}
	}

	/**
	* Gets sensor type.
	*
	* @return Sensor type as one of the Sensor.TYPE_XXX constants.
	*/
	private int getType() {
	return mSensor.getType();
	}

	/**
	* Gets sensor's emulator-friendly name.
	*
	* @return Sensor's emulator-friendly name.
	*/
	private String getEmulatorFriendlyName() {
	return mEmulatorFriendlyName;
	}

	/**
	* Starts monitoring the sensor.
	* NOTE: This method is called from outside of the UI thread.
	*/
	private void startListening() {
	if (mEnabledByEmulator && mEnabledByUser) {
	if (DEBUG) Log.d(TAG, "+++ Sensor " + getEmulatorFriendlyName() + " is started.");
	mSenMan.registerListener(mListener, mSensor, SensorManager.SENSOR_DELAY_FASTEST);
	}
	}

	/**
	* Stops monitoring the sensor.
	* NOTE: This method is called from outside of the UI thread.
	*/
	private void stopListening() {
	if (DEBUG) Log.d(TAG, "--- Sensor " + getEmulatorFriendlyName() + " is stopped.");
	mSenMan.unregisterListener(mListener);
	}

	/**
	* Enables sensor events.
	* NOTE: This method is called from outside of the UI thread.
	*/
	private void enableSensor() {
	if (DEBUG) Log.d(TAG, ">>> Sensor " + getEmulatorFriendlyName() + " is enabled.");
	mEnabledByEmulator = true;
	mValue = null;

	Message msg = Message.obtain();
	msg.what = SENSOR_STATE_CHANGED;
	msg.obj = MonitoredSensor.this;
	notifyUiHandlers(msg);
	}

	/**
	* Disables sensor events.
	* NOTE: This method is called from outside of the UI thread.
	*/
	private void disableSensor() {
	if (DEBUG) Log.w(TAG, "<<< Sensor " + getEmulatorFriendlyName() + " is disabled.");
	mEnabledByEmulator = false;
	mValue = "Disabled by emulator";

	Message msg = Message.obtain();
	msg.what = SENSOR_STATE_CHANGED;
	msg.obj = MonitoredSensor.this;
	notifyUiHandlers(msg);
	}

	private class OurSensorEventListener implements SensorEventListener {
	/** Last update's time-stamp in local thread millisecond time. */
	private long mLastUpdateTS = 0;
	/** Last display update time-stamp. */
	private long mLastDisplayTS = 0;
	/** Preallocated buffer for change notification message. */
	private final ByteBuffer mChangeMsg = ByteBuffer.allocate(64);

	/**
	* Handles "sensor changed" event.
	* This is an implementation of the SensorEventListener interface.
	*/
	@Override
	public void onSensorChanged(SensorEvent event) {
	long now = SystemClock.elapsedRealtime();

	long deltaMs = 0;
	if (mLastUpdateTS != 0) {
	deltaMs = now - mLastUpdateTS;
	if (mUpdateTargetMs > 0 && deltaMs < mUpdateTargetMs) {
	// New sample is arriving too fast. Discard it.
	return;
	}
	}

	// Format and post message for the emulator.
	float[] values = event.values;
	final int len = values.length;

	mChangeMsg.order(getEndian());
	mChangeMsg.position(0);
	mChangeMsg.putInt(getType());
	mChangeMsg.putFloat(values[0]);
	if (len > 1) {
	mChangeMsg.putFloat(values[1]);
	if (len > 2) {
	mChangeMsg.putFloat(values[2]);
	}
	}
	postMessage(ProtocolConstants.SENSORS_SENSOR_EVENT, mChangeMsg);

	// Computes average update time for this sensor and average globally.
	if (mLastUpdateTS != 0) {
	if (mGlobalAvgUpdateMs != 0) {
	mGlobalAvgUpdateMs = (mGlobalAvgUpdateMs + deltaMs) / 2;
	} else {
	mGlobalAvgUpdateMs = deltaMs;
	}
	}
	mLastUpdateTS = now;

	// Update the UI for the sensor, with a static throttling of 10 fps max.
	if (hasUiHandler()) {
	if (mLastDisplayTS != 0) {
	long uiDeltaMs = now - mLastDisplayTS;
	if (uiDeltaMs < 1000 / 4 /* 4fps in ms */) {
	// Skip this UI update
	return;
	}
	}
	mLastDisplayTS = now;

	mValues[0] = values[0];
	if (len > 1) {
	mValues[1] = values[1];
	if (len > 2) {
	mValues[2] = values[2];
	}
	}
	mValue = null;

	Message msg = Message.obtain();
	msg.what = SENSOR_DISPLAY_MODIFIED;
	msg.obj = MonitoredSensor.this;
	notifyUiHandlers(msg);
	}

	if (DEBUG) {
	long now2 = SystemClock.elapsedRealtime();
	long processingTimeMs = now2 - now;
	Log.d(TAG, String.format("glob %d - local %d > target %d - processing %d -- %s",
	mGlobalAvgUpdateMs, deltaMs, mUpdateTargetMs, processingTimeMs,
	mSensor.getName()));
	}
	}

	/**
	* Handles "sensor accuracy changed" event.
	* This is an implementation of the SensorEventListener interface.
	*/
	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	}
	}
	} // MonitoredSensor

	/***************************************************************************
	* Logging wrappers
	**************************************************************************/

	private void Loge(String log) {
	mService.addError(log);
	Log.e(TAG, log);
	}
	}