Merged remote changes

MyTracks/src/com/google/android/apps/mytracks/AntPreference.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * 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.apps.mytracks;
+
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.preference.Preference;
+import android.util.AttributeSet;
+
+/**
+ * A preference for an ANT device pairing.
+ * Currently this shows the ID and lets the user clear that ID for future pairing.
+ * TODO: Support pairing from this preference.
+ *
+ * @author Sandor Dornbush
+ */
+public class AntPreference extends Preference {
+
+  public AntPreference(Context context) {
+    super(context);
+    init();
+  }
+
+  public AntPreference(Context context, AttributeSet attrs) {
+    super(context, attrs);
+    init();
+  }
+
+  private void init() {
+    int sensorId = getPersistedInt(0);
+    if (sensorId == 0) {
+      setSummary(R.string.settings_ant_not_paired);
+    } else {
+      setSummary(String.format(getContext().getString(R.string.settings_ant_paired), sensorId));
+    }
+
+    // Add actions to allow repairing.
+    setOnPreferenceClickListener(
+        new OnPreferenceClickListener() {
+          @Override
+          public boolean onPreferenceClick(Preference preference) {
+            AntPreference.this.persistInt(0);
+            setSummary(R.string.settings_ant_not_paired);
+            return true;
+          }
+        });
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/CheckUnits.java

@@ -16,6 +16,7 @@
 
 package com.google.android.apps.mytracks;
 
+import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.maps.mytracks.R;
 
 import android.app.Activity;
@@ -82,7 +83,8 @@ class CheckUnits {
   }
 
   private static void recordCheckPerformed(SharedPreferences preferences) {
-    preferences.edit().putBoolean(PREFERENCE_UNITS_CHECKED, true).commit();
+    ApiFeatures.getInstance().getApiPlatformAdapter().applyPreferenceChanges(
+        preferences.edit().putBoolean(PREFERENCE_UNITS_CHECKED, true));
   }
 
   private CheckUnits() {

MyTracks/src/com/google/android/apps/mytracks/Eula.java

@@ -15,6 +15,7 @@
  */
 package com.google.android.apps.mytracks;
 
+import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.apps.mytracks.util.ResourceUtils;
 import com.google.android.maps.mytracks.R;
 
@@ -77,7 +78,8 @@ class Eula {
   }
 
   private static void accept(Activity activity, SharedPreferences preferences) {
-    preferences.edit().putBoolean(PREFERENCE_EULA_ACCEPTED, true).commit();
+    ApiFeatures.getInstance().getApiPlatformAdapter().applyPreferenceChanges(
+        preferences.edit().putBoolean(PREFERENCE_EULA_ACCEPTED, true));
     Intent startIntent = new Intent(activity, WelcomeActivity.class);
     activity.startActivityForResult(startIntent, MyTracksConstants.WELCOME);
   }

MyTracks/src/com/google/android/apps/mytracks/MyTracks.java

@@ -41,6 +41,7 @@ import com.google.android.apps.mytracks.services.StatusAnnouncerFactory;
 import com.google.android.apps.mytracks.services.TrackRecordingService;
 import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.MyTracksUtils;
 import com.google.android.maps.mytracks.R;
 
 import android.app.Activity;
@@ -251,6 +252,11 @@ public class MyTracks extends TabActivity implements OnTouchListener,
     Log.d(MyTracksConstants.TAG, "MyTracks.onCreate");
     super.onCreate(savedInstanceState);
     instance = this;
+    ApiFeatures apiFeatures = ApiFeatures.getInstance();
+    if (!MyTracksUtils.isRelease(this)) {
+      apiFeatures.getApiPlatformAdapter().enableStrictMode();
+    }
+
     providerUtils = MyTracksProviderUtils.Factory.get(this);
     menuManager = new MenuManager(this);
     sharedPreferences = getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
@@ -258,7 +264,7 @@ public class MyTracks extends TabActivity implements OnTouchListener,
 
     // The volume we want to control is the Text-To-Speech volume
     int volumeStream =
-        new StatusAnnouncerFactory(ApiFeatures.getInstance()).getVolumeStream();
+        new StatusAnnouncerFactory(apiFeatures).getVolumeStream();
     setVolumeControlStream(volumeStream);
 
     // We don't need a window title bar:
@@ -1058,10 +1064,10 @@ public class MyTracks extends TabActivity implements OnTouchListener,
    * @param trackId the id of the track
    */
   public void setSelectedTrackId(final long trackId) {
-    sharedPreferences
-        .edit()
-        .putLong(getString(R.string.selected_track_key), trackId)
-        .commit();
+    ApiFeatures.getInstance().getApiPlatformAdapter().applyPreferenceChanges(
+        sharedPreferences
+            .edit()
+            .putLong(getString(R.string.selected_track_key), trackId));
   }
 
   long getSelectedTrackId() {

MyTracks/src/com/google/android/apps/mytracks/MyTracksDeleteAllTracks.java

@@ -16,6 +16,7 @@
 package com.google.android.apps.mytracks;
 
 import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.maps.mytracks.R;
 
 import android.app.AlertDialog;
@@ -63,7 +64,7 @@ public class MyTracksDeleteAllTracks extends Handler {
                 context.getSharedPreferences(MyTracksSettings.SETTINGS_NAME, 0);
             SharedPreferences.Editor editor = prefs.edit();
             editor.putLong(context.getString(R.string.selected_track_key), -1);
-            editor.commit();
+            ApiFeatures.getInstance().getApiPlatformAdapter().applyPreferenceChanges(editor);
             if (done != null) {
               Handler h = new Handler();
               h.post(done);

MyTracks/src/com/google/android/apps/mytracks/services/TrackRecordingService.java

@@ -644,7 +644,6 @@ public class TrackRecordingService extends Service implements LocationListener {
     locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
     splitManager = new SplitManager(this);
 
-    sensorManager = SensorManagerFactory.getSensorManager(this);
     prefManager = new PreferenceManager(this);
     registerLocationListener();
 
@@ -731,7 +730,7 @@ public class TrackRecordingService extends Service implements LocationListener {
     splitManager.shutdown();
     splitManager = null;
     if (sensorManager != null) {
-      sensorManager.onDestroy();
+      sensorManager.shutdown();
       sensorManager = null;
     }
 
@@ -1080,6 +1079,7 @@ public class TrackRecordingService extends Service implements LocationListener {
     showNotification();
     registerLocationListener();
     splitManager.restore();
+    sensorManager = SensorManagerFactory.getSensorManager(this);
     if (sensorManager != null) {
       sensorManager.onStartTrack();
     }
@@ -1128,6 +1128,7 @@ public class TrackRecordingService extends Service implements LocationListener {
     
     if (sensorManager != null) {
       sensorManager.shutdown();
+      sensorManager = null;
     }
     
     releaseWakeLock();

MyTracks/src/com/google/android/apps/mytracks/services/sensors/AntDirectSensorManager.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * 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.apps.mytracks.services.sensors;
+
+import static com.google.android.apps.mytracks.MyTracksConstants.TAG;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.maps.mytracks.R;
+
+import com.dsi.ant.AntDefine;
+import com.dsi.ant.AntMesg;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+/**
+ * A sensor manager to connect ANT+ sensors.
+ * This can include heart rate monitors.
+ *
+ * @author Sandor Dornbush
+ */
+public class AntDirectSensorManager extends AntSensorManager {
+
+  /*
+   * These constants are defined by the ANT+ heart rate monitor spec.
+   */
+  public static final byte HRM_CHANNEL = 0;
+  public static final byte NETWORK_NUMBER = 1;
+  public static final byte HEART_RATE_DEVICE_TYPE = 120;
+  public static final byte POWER_DEVICE_TYPE = 11;
+  public static final byte MANUFACTURER_ID = 1;
+  public static final short CHANNEL_PERIOD = 8070;
+  public static final byte RF_FREQUENCY = 57;
+
+  private short deviceNumberHRM;
+
+  public AntDirectSensorManager(Context context) {
+    super(context);
+    
+    deviceNumberHRM = WILDCARD;
+
+    // First read the the device id that we will be pairing with.
+    SharedPreferences prefs = context.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    if (prefs != null) {
+      deviceNumberHRM = 
+        (short) prefs.getInt(context.getString(R.string.ant_heart_rate_sensor_id_key), 0);
+    }
+    Log.i(TAG, "Pairing with heart rate monitor: " + deviceNumberHRM);
+  }
+
+  @Override
+  public void handleMessage(byte[] antMessage) {
+    int channel =
+      antMessage[AntMesg.MESG_DATA_OFFSET] & AntDefine.CHANNEL_NUMBER_MASK;
+    switch (channel) {
+      case HRM_CHANNEL:
+        antDecodeHRM(antMessage);
+        break;
+      default:
+        Log.d(TAG, "Unhandled message: " + channel);
+    }
+  }
+
+  /**
+   * Decode an ant heart rate monitor message.
+   * @param antMessage The byte array received from the heart rate monitor.
+   */
+  private void antDecodeHRM(byte[] antMessage) {
+    // message ID == broadcast
+    switch (antMessage[AntMesg.MESG_ID_OFFSET]) {
+      case AntMesg.MESG_BROADCAST_DATA_ID:
+        handleBroadcastData(antMessage);
+        break;
+      case AntMesg.MESG_RESPONSE_EVENT_ID:
+        handleMessageResponse(antMessage);
+        break;
+      case AntMesg.MESG_CHANNEL_ID_ID:
+        handleChannelId(antMessage);
+        break;
+      default:
+        Log.e(TAG, "Unexpected message id: " + antMessage[3]);
+    }
+  }
+
+  private void handleBroadcastData(byte[] antMessage) {
+    if (deviceNumberHRM == WILDCARD) {
+      getAntReceiver().ANTRequestMessage(HRM_CHANNEL,
+          AntMesg.MESG_CHANNEL_ID_ID);
+      Log.d(TAG, "Requesting channel id id.");
+    }
+
+    setSensorState(Sensor.SensorState.CONNECTED);
+    int bpm = (int) antMessage[10] & 0xFF;
+    Sensor.SensorData.Builder b = Sensor.SensorData.newBuilder()
+      .setValue(bpm)
+      .setState(Sensor.SensorState.SENDING);
+    sensorData =
+      Sensor.SensorDataSet.newBuilder()
+      .setCreationTime(System.currentTimeMillis())
+      .setHeartRate(b)
+      .build();
+  }
+
+  void handleChannelId(byte[] antMessage) {
+    // Store the device id.
+    deviceNumberHRM =
+        (short) (((int) antMessage[3] & 0xFF  |
+                  ((int) (antMessage[4] & 0xFF) << 8)) & 0xFFFF);
+    Log.i(TAG, "Found device id: " + deviceNumberHRM);
+
+    SharedPreferences prefs = context.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = prefs.edit();
+    editor.putInt(context.getString(R.string.ant_heart_rate_sensor_id_key), deviceNumberHRM);
+    editor.commit();
+  }
+
+  private void handleMessageResponse(byte[] antMessage) {
+    if (antMessage[3] == AntMesg.MESG_EVENT_ID &&
+        antMessage[4] == AntDefine.EVENT_RX_SEARCH_TIMEOUT) {
+      // Search timeout
+      Log.w(TAG, "Search timed out. Unassigning channel.");
+      getAntReceiver().ANTUnassignChannel((byte) 0);
+      setSensorState(Sensor.SensorState.DISCONNECTED);
+    } else if (antMessage[3] == AntMesg.MESG_UNASSIGN_CHANNEL_ID) {
+      setSensorState(Sensor.SensorState.DISCONNECTED);
+      Log.i(TAG, "Disconnected from the sensor: " + getSensorState());
+    }
+  }
+
+  /**
+   * Open a channel to the SRM head unit.
+   */
+  @Override
+  public void setupChannel() {
+    super.setupChannel();
+    antChannelSetup(NETWORK_NUMBER,
+        HRM_CHANNEL,
+        deviceNumberHRM,
+        HEART_RATE_DEVICE_TYPE,
+        (byte) 0x01,
+        CHANNEL_PERIOD,
+        RF_FREQUENCY,
+        (byte) 0);
+    setSensorState(Sensor.SensorState.CONNECTING);
+  }
+
+  public short getDeviceNumberHRM() {
+    return deviceNumberHRM;
+  }
+
+  void setDeviceNumberHRM(short deviceNumberHRM) {
+    this.deviceNumberHRM = deviceNumberHRM;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/sensors/AntSRMSensorManager.java

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * 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.apps.mytracks.services.sensors;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.maps.mytracks.R;
+
+import com.dsi.ant.AntDefine;
+import com.dsi.ant.AntMesg;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.util.Log;
+
+/**
+ * A sensor manager that can connect to an SRM Power Control 7 head unit.
+ *
+ * @author Sandor Dornbush
+ */
+public class AntSRMSensorManager extends AntSensorManager {
+
+  /*
+   * These constants are defined by the SRM Headunit spec.
+   */
+  public static final byte NETWORK_NUMBER = (byte) 0;
+  public static final byte DEVICE_TYPE = (byte) 12;
+  public static final byte MANUFACTURER_ID = (byte) 1;
+  public static final short CHANNEL_PERIOD = (short) 8192;
+  public static final byte RF_FREQUENCY = (byte) 50;
+
+  public static final int MESSAGE_TYPE_INDEX = 3;
+  public static final int INITIALS_MESSAGE_TYPE = 5;
+  public static final int SENSOR_DATA_MESSAGE_TYPE = 6;
+
+  public static final int MESSAGE_ID_INDEX = 4;
+
+  /**
+   * This can be any value between 0..8
+   */
+  private byte channel = (byte) 5;
+
+  /**
+   * This is the id of this device.
+   * The head unit must be programmed to expect this number.
+   */
+  private byte deviceId;
+
+  /**
+   * The id of the last message received from the SRM head unit.
+   */
+  private int lastMessageId;
+
+  public AntSRMSensorManager(Context context) {
+    super(context);
+
+    // First read the the device id that we will be announcing.
+    SharedPreferences prefs = context.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    if (prefs != null) {
+      deviceId = (byte) prefs.getInt(
+          context.getString(R.string.ant_srm_bridge_sensor_id_key),
+          WILDCARD);
+    }
+  }
+
+  @Override
+  public void handleMessage(byte[] antMessage) {
+    // Parse channel number
+    byte recievedChannel = (byte) (antMessage[AntMesg.MESG_DATA_OFFSET]
+                               & AntDefine.CHANNEL_NUMBER_MASK);
+    if (recievedChannel != channel) {
+      Log.d(MyTracksConstants.TAG, "Unexpected channel: " + recievedChannel);
+      return;
+    }
+    switch (antMessage[AntMesg.MESG_ID_OFFSET]) {
+      case AntMesg.MESG_BROADCAST_DATA_ID:
+        handleBroadcastData(antMessage);
+        break;
+      case AntMesg.MESG_RESPONSE_EVENT_ID:
+        handleMessageResponse(antMessage);
+        break;
+      case AntMesg.MESG_CHANNEL_ID_ID:
+        handleChannelId(antMessage);
+        break;
+      default:
+        Log.e(MyTracksConstants.TAG,
+            "Unexpected message id: " + antMessage[3]);
+    }
+  }
+
+  private void handleBroadcastData(byte[] antMessage) {
+    if (deviceId == WILDCARD) {
+       getAntReceiver().ANTRequestMessage(channel, AntMesg.MESG_CHANNEL_ID_ID);
+      Log.d(MyTracksConstants.TAG, "Requesting channel id id.");
+    }
+    setSensorState(Sensor.SensorState.CONNECTED);
+    switch(antMessage[MESSAGE_TYPE_INDEX]) {
+      case INITIALS_MESSAGE_TYPE:
+        // TODO handle initials message.
+        break;
+      case SENSOR_DATA_MESSAGE_TYPE:
+        parseSensorData(antMessage);
+        break;
+      default:
+        Log.e(MyTracksConstants.TAG,
+            "Unexpected message type: " + antMessage[MESSAGE_TYPE_INDEX]);
+    }
+  }
+
+  private void handleChannelId(byte[] antMessage) {
+    // Store the device id.
+    deviceId = antMessage[3];
+    Log.i(MyTracksConstants.TAG, "Found device id: " + deviceId);
+
+    SharedPreferences prefs = context.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, Context.MODE_PRIVATE);
+    SharedPreferences.Editor editor = prefs.edit();
+    editor.putInt(context.getString(R.string.ant_srm_bridge_sensor_id_key), deviceId);
+    editor.commit();
+  }
+
+  private void handleMessageResponse(byte[] antMessage) {
+    if (antMessage[3] == AntMesg.MESG_EVENT_ID
+        && antMessage[4] == AntDefine.EVENT_RX_SEARCH_TIMEOUT) {
+      // Search timeout
+      Log.w(MyTracksConstants.TAG, "Search timed out. Unassigning channel.");
+      getAntReceiver().ANTUnassignChannel(channel);
+      setSensorState(Sensor.SensorState.DISCONNECTED);
+    } else if (antMessage[3] == AntMesg.MESG_UNASSIGN_CHANNEL_ID) {
+      setSensorState(Sensor.SensorState.DISCONNECTED);
+      Log.i(MyTracksConstants.TAG,
+          "Disconnected from the sensor: " + getSensorState());
+    }
+  }
+
+  private void parseSensorData(byte[] antMessage) {
+    if (antMessage.length != 11) {
+      Log.e(MyTracksConstants.TAG,
+          "Unexpected ant message length: " + antMessage.length);
+      return;
+    }
+
+    int newMessageId = antMessage[MESSAGE_ID_INDEX] & 0xFF;
+    if (lastMessageId == newMessageId) {
+      // Repeated message.
+      Log.i(MyTracksConstants.TAG,
+          String.format("SRM ignoring repeat: 0x%X", newMessageId));
+      return;
+    }
+    if (newMessageId < lastMessageId) {
+      if (!(newMessageId < 20 && lastMessageId > 200)) {
+        Log.i(MyTracksConstants.TAG,
+            String.format("SRM ignoring repeat: 0x%X", newMessageId));
+        return;
+      } // else assume the byte overflowed to 0.
+    }
+    lastMessageId = newMessageId;
+
+    Sensor.SensorDataSet.Builder builder = Sensor.SensorDataSet.newBuilder()
+      .setCreationTime(System.currentTimeMillis());
+
+    int power = SensorUtils.unsignedShortToInt(antMessage, 5);
+    if (power >= 0) {
+      Sensor.SensorData.Builder b = Sensor.SensorData.newBuilder()
+        .setValue(power)
+        .setState(Sensor.SensorState.SENDING);
+      builder.setPower(b);
+    }
+
+    int speed = SensorUtils.unsignedShortToInt(antMessage, 7);
+    if (speed >= 0) {
+      // The speed from srm is in 1/10 km/hr.
+      // Sensor data expects the speed as m/s.
+      // TODO finish this.
+      //sensorData.setWheelSpeed(UnitConversions.TENTH_KMH_TO_MPS * speed);
+    }
+
+    int cadence = antMessage[9] & 0xFF;
+    if (cadence >= 0) {
+      Sensor.SensorData.Builder b = Sensor.SensorData.newBuilder()
+        .setValue(cadence)
+        .setState(Sensor.SensorState.SENDING);
+      builder.setCadence(b);
+    }
+
+    int bpm = antMessage[10] & 0xFF;
+    if (bpm > 0) {
+      Sensor.SensorData.Builder b = Sensor.SensorData.newBuilder()
+        .setValue(bpm)
+        .setState(Sensor.SensorState.SENDING);
+      builder.setHeartRate(b);
+    }
+    sensorData = builder.build();
+  }
+
+  /**
+   * Open a channel to the SRM head unit.
+   */
+  @Override
+  public void setupChannel() {
+    antChannelSetup(NETWORK_NUMBER,
+        channel,
+        deviceId,
+        DEVICE_TYPE,
+        MANUFACTURER_ID,
+        CHANNEL_PERIOD,
+        RF_FREQUENCY,
+        (byte) 0);
+    lastMessageId = 0;
+    setSensorState(Sensor.SensorState.CONNECTING);
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/sensors/AntSensorManager.java

@@ -0,0 +1,228 @@
+/*
+ * Copyright 2009 Google Inc.
+ * 
+ * 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.apps.mytracks.services.sensors;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+import com.google.android.apps.mytracks.content.Sensor.SensorDataSet;
+
+import com.dsi.ant.AntDefine;
+import com.dsi.ant.AntInterface;
+import com.dsi.ant.AntInterfaceIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+/**
+ * An abstract class for ANT+ based sensors.
+ *
+ * @author Sandor Dornbush
+ */
+public abstract class AntSensorManager extends SensorManager {
+
+  // ANT Service
+  public static final int EVENT_ANT_ENABLED = 1;
+  public static final int EVENT_ANT_DISABLED = 2;
+
+  // Pairing
+  protected static final short WILDCARD = 0;
+
+  private AntInterface antReceiver;
+
+  private boolean status;
+
+  // Flag to know if the ANT App was interrupted
+  // TODO: This code path is not used but probably should be.
+  private boolean antInterrupted;
+
+  /**
+   * The data from the sensors.
+   */
+  protected SensorDataSet sensorData;
+
+  protected Context context;
+  
+  private static final boolean DEBUGGING = false;
+
+  /**
+   * Receives all of the ANT intents and dispatches to the proper handler.
+   */
+  private final BroadcastReceiver receiver = new BroadcastReceiver() {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      String antAction = intent.getAction();
+
+      Log.i(MyTracksConstants.TAG, "enter onReceive" + antAction);
+      if (antAction.equals(AntInterfaceIntent.ANT_ENABLED_ACTION)) {
+        Log.i(MyTracksConstants.TAG, "enter onReceive ANT_ENABLED_ACTION "
+            + antAction);
+        handler.sendMessage(handler.obtainMessage(EVENT_ANT_ENABLED, 0));
+      }
+      if (antAction.equals(AntInterfaceIntent.ANT_DISABLED_ACTION)) {
+        Log.i(MyTracksConstants.TAG, "enter onReceive ANT_DISABLED_ACTION "
+            + antAction);
+        handler.sendMessage(handler.obtainMessage(EVENT_ANT_DISABLED, 0));
+      }
+
+      if (antAction.equals(AntInterfaceIntent.ANT_RX_MESSAGE_ACTION)) {
+        byte[] antMessage =
+            intent.getByteArrayExtra(AntInterfaceIntent.ANT_MESSAGE);
+        if (DEBUGGING) {
+          StringBuilder sb = 
+              new StringBuilder("ANT_RX_MESSAGE_ACTION Rx:");
+  
+          for (int i = 0; i < antMessage.length; i++)
+            sb.append(String.format("[%X]]", (antMessage[i] & 0xFF)));
+  
+          Log.d(MyTracksConstants.TAG, sb.toString());
+        }
+
+        handleMessage(antMessage);
+      }
+    }
+  };
+
+  /**
+   * Handler for all the ANT related events. The events will be handled only
+   * when we are in the ANT application main menu
+   **/
+  private Handler handler = new Handler() {
+    @Override
+    public void handleMessage(Message msg) {
+      switch (msg.what) {
+        case EVENT_ANT_ENABLED:
+          Log.i(MyTracksConstants.TAG,
+              "enter handleMessage ----EVENT_ANT_ENABLED");
+          break;
+        case EVENT_ANT_DISABLED:
+          Log.i(MyTracksConstants.TAG,
+              "enter handleMessage ----EVENT_ANT_DISABLED");
+          break;
+      }
+    }
+  };
+
+  public AntSensorManager(Context context) {
+    this.context = context;
+
+    // Need to enable the ANT if it is not enabled earlier
+    antReceiver = AntInterface.getInstance(context, null);
+    if (antReceiver == null) {
+      return;
+    }
+
+    status = antReceiver.isEnabled();
+    if (!status) {
+      // Make sure not to call AntInterface.enable() again, if it has been
+      // already called before
+      if (antInterrupted == false) {
+        status = antReceiver.enable();
+        if (!status) {
+          Log.e(MyTracksConstants.TAG, "Can not enable ANT interface");
+        } else {
+          Log.i(MyTracksConstants.TAG, "Powering on Radio");
+        }
+      } else {
+        Log.i(MyTracksConstants.TAG, "Radio already enabled");
+      }
+    }
+  }
+
+  @Override
+  public void setupChannel() {
+    Log.i(MyTracksConstants.TAG, "Registering for ant intents.");
+    // Register for ANT intent broadcasts.
+    IntentFilter intentFilter = new IntentFilter();
+    intentFilter.addAction(AntInterfaceIntent.ANT_ENABLED_ACTION);
+    intentFilter.addAction(AntInterfaceIntent.ANT_DISABLED_ACTION);
+    intentFilter.addAction(AntInterfaceIntent.ANT_RX_MESSAGE_ACTION);
+    context.registerReceiver(receiver, intentFilter);
+  }
+
+  @Override
+  public SensorDataSet getSensorDataSet() {
+    return sensorData;
+  }
+
+  @Override
+  public boolean isEnabled() {
+    return true;
+  }
+
+  public abstract void handleMessage(byte[] antMessage);
+
+  @Override
+  public void onDestroy() {
+    Log.i(MyTracksConstants.TAG, "Unregistering for ant intents.");
+    context.unregisterReceiver(receiver);
+  }
+
+  /**
+   * Set up an ANT+ channel.
+   * 
+   * @return True on success.
+   */
+  protected boolean antChannelSetup(byte networkNumber, byte channelNumber,
+      short deviceNumber, byte deviceType, byte txType, short channelPeriod,
+      byte radioFreq, byte proxSearch) {
+
+    // Assign as slave channel on selected network (0 = public, 1 = ANT+, 2 =
+    // ANTFS)
+    if (!antReceiver.ANTAssignChannel(channelNumber,
+        AntDefine.PARAMETER_RX_NOT_TX, networkNumber)) {
+      return false;
+    }
+
+    if (!antReceiver.ANTSetChannelId(channelNumber, deviceNumber, deviceType,
+        txType)) {
+      return false;
+    }
+
+    if (!antReceiver.ANTSetChannelPeriod(channelNumber, channelPeriod)) {
+      return false;
+    }
+
+    if (!antReceiver.ANTSetChannelRFFreq(channelNumber, radioFreq)) {
+      return false;
+    }
+
+    // Disable high priority search
+    if (!antReceiver.ANTSetChannelSearchTimeout(channelNumber, (byte) 0)) {
+      return false;
+    }
+
+    // Set search timeout to 30 seconds (low priority search))
+    if (!antReceiver.ANTSetLowPriorityChannelSearchTimeout(channelNumber, (byte) 12)) {
+      return false;
+    }
+
+    if (deviceNumber == WILDCARD) {
+      // Configure proximity search, if using wild card search
+      if (!antReceiver.ANTSetProximitySearch(channelNumber, proxSearch)) {
+        return false;
+      }
+    }
+
+    return !antReceiver.ANTOpenChannel(channelNumber);
+  }
+
+  public AntInterface getAntReceiver() {
+    return antReceiver;
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/services/sensors/SensorManagerFactory.java

@@ -13,7 +13,6 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-
 package com.google.android.apps.mytracks.services.sensors;
 
 import com.google.android.apps.mytracks.MyTracksConstants;
@@ -46,15 +45,19 @@ public class SensorManagerFactory {
       return null;
     }
     
-    String sensor = prefs.getString(context.getString(R.string.sensor_type_key),
-          null);
+    String sensor = prefs.getString(context.getString(R.string.sensor_type_key), null);
     Log.i(MyTracksConstants.TAG, "Creating sensor of type: " + sensor);
 
     if (sensor == null) {
       return null;
+    } else if (sensor.equals(context.getString(R.string.ant_sensor_type))) {
+      return new AntDirectSensorManager(context);
+    } else if (sensor.equals(context.getString(R.string.srm_ant_bridge_sensor_type))) {
+      return new AntSRMSensorManager(context);
     } else if (sensor.equals(context.getString(R.string.zephyr_sensor_type))) {
       return new ZephyrSensorManager(context);
     } else  {
+      Log.w(MyTracksConstants.TAG, "Unable to find sensor type: " + sensor);
       return null;
     }
   }

MyTracks/src/com/google/android/apps/mytracks/services/sensors/ZephyrMessageParser.java

@@ -35,8 +35,9 @@ public class ZephyrMessageParser implements MessageParser {
     }
     Log.w(MyTracksConstants.TAG, "Got zephyr data: " + sb);
     // The provided units are 1/16 strides per minute.
-    int cadence = SensorUtils.unsignedShortToInt(buffer, 56);
-      // Heart Rate
+    // TODO: Fix the cadence calculation.
+    // int cadence = SensorUtils.unsignedShortToInt(buffer, 56);
+    // Heart Rate
     Sensor.SensorData.Builder b = Sensor.SensorData.newBuilder()
       .setValue(buffer[12] & 0xFF)
       .setState(Sensor.SensorState.SENDING);

MyTracks/src/com/google/android/apps/mytracks/util/ApiFeatures.java

@@ -62,24 +62,18 @@ public class ApiFeatures {
    * Allow subclasses for mocking, but no direct instantiation.
    */
   protected ApiFeatures() {
-    if (getApiLevel() >= 5) {
-      try {
-        Class<?> clazz = Class.forName(
-            "com.google.android.apps.mytracks.util.EclairPlatformAdapter");
-        apiPlatformAdapter = (ApiPlatformAdapter) clazz.newInstance();
-      } catch (Exception e) {
-        Log.i(MyTracksConstants.TAG, "ApiFeatures: Unable to instantiate Eclair"
-            + " platform adapter", e);
-      }
-    }
-    if (apiPlatformAdapter == null) {
+    if (getApiLevel() >= 9) {
+      apiPlatformAdapter = new GingerbreadPlatformAdapter();
+    } else if (getApiLevel() >= 5) {
+      apiPlatformAdapter = new EclairPlatformAdapter();
+    } else {
       Log.i(MyTracksConstants.TAG,
           "ApiFeatures: Using default platform adapter");
       // Cupcake adapter is always supported, so it's safe to do static linkage.
       apiPlatformAdapter = new CupcakePlatformAdapter();
     }
   }
-  
+
   public ApiPlatformAdapter getApiPlatformAdapter() {
     return apiPlatformAdapter;
   }
@@ -107,7 +101,11 @@ public class ApiFeatures {
 
     return true;
   }
-  
+
+  public boolean hasStrictMode() {
+    return getApiLevel() >= 9;
+  }
+
   // Visible for testing.
   protected int getApiLevel() {
     return ANDROID_API_LEVEL;

MyTracks/src/com/google/android/apps/mytracks/util/ApiPlatformAdapter.java

@@ -18,6 +18,7 @@ package com.google.android.apps.mytracks.util;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.Service;
+import android.content.SharedPreferences;
 import android.os.HandlerThread;
 
 /**
@@ -57,4 +58,15 @@ public interface ApiPlatformAdapter {
    * @return true whether the handler has been stopped or not.
    */
   boolean stopHandlerThread(HandlerThread handlerThread);
+
+  /**
+   * Applies all changes done to the given preferences editor.
+   * Changes may or may not be applied immediately.
+   */
+  void applyPreferenceChanges(SharedPreferences.Editor editor);
+  
+  /**
+   * Enables strict mode where supported, only if this is a development build.
+   */
+  void enableStrictMode();
 }

MyTracks/src/com/google/android/apps/mytracks/util/CupcakePlatformAdapter.java

@@ -18,6 +18,7 @@ package com.google.android.apps.mytracks.util;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.Service;
+import android.content.SharedPreferences.Editor;
 import android.os.HandlerThread;
 
 /**
@@ -50,4 +51,14 @@ public class CupcakePlatformAdapter implements ApiPlatformAdapter {
     // Do nothing, as Cupcake doesn't provide quit().
     return false;
   }
+
+  @Override
+  public void applyPreferenceChanges(Editor editor) {
+    editor.commit();
+  }
+
+  @Override
+  public void enableStrictMode() {
+    // Not supported
+  }
 }

MyTracks/src/com/google/android/apps/mytracks/util/EclairPlatformAdapter.java

@@ -18,6 +18,7 @@ package com.google.android.apps.mytracks.util;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.Service;
+import android.content.SharedPreferences.Editor;
 import android.os.HandlerThread;
 
 /**
@@ -45,4 +46,14 @@ public class EclairPlatformAdapter implements ApiPlatformAdapter {
   public boolean stopHandlerThread(HandlerThread handlerThread) {
     return handlerThread.quit();
   }
+
+  @Override
+  public void applyPreferenceChanges(Editor editor) {
+    editor.commit();
+  }
+
+  @Override
+  public void enableStrictMode() {
+    // Not supported
+  }
 }

MyTracks/src/com/google/android/apps/mytracks/util/GingerbreadPlatformAdapter.java

@@ -0,0 +1,36 @@
+package com.google.android.apps.mytracks.util;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.content.SharedPreferences.Editor;
+import android.os.StrictMode;
+import android.util.Log;
+
+/**
+ * The Gingerbread (API level 9) specific implememntation of the
+ * {@link ApiPlatformAdapter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class GingerbreadPlatformAdapter extends EclairPlatformAdapter {
+  @Override
+  public void applyPreferenceChanges(Editor editor) {
+    // Apply asynchronously
+    editor.apply();
+  }
+
+  @Override
+  public void enableStrictMode() {
+    Log.d(MyTracksConstants.TAG, "Enabling strict mode");
+    StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
+        .detectDiskWrites()
+        .detectNetwork()
+        .penaltyLog()
+        .build());
+    StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
+        .detectAll()
+        .penaltyLog()
+        .penaltyDeath()
+        .build());
+  }
+}

MyTracks/src/com/google/android/apps/mytracks/util/MyTracksUtils.java

@@ -21,7 +21,12 @@ import com.google.android.apps.mytracks.stats.TripStatistics;
 
 import com.google.android.maps.GeoPoint;
 
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.Signature;
 import android.location.Location;
+import android.os.StrictMode;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -34,6 +39,7 @@ import java.util.Stack;
  * @author Leif Hendrik Wilden
  */
 public class MyTracksUtils {
+  private static final int RELEASE_SIGNATURE_HASHCODE = -1855564782;
 
   /**
    * Computes the distance on the two sphere between the point c0 and the line
@@ -246,6 +252,25 @@ public class MyTracksUtils {
                         (int) (location.getLongitude() * 1E6));
   }
 
+  /**
+   * Returns whether or not this is a release build.
+   */
+  public static boolean isRelease(Context context) {
+    try {
+      Signature [] sigs = context.getPackageManager().getPackageInfo(
+          context.getPackageName(), PackageManager.GET_SIGNATURES).signatures;
+      for (Signature sig : sigs) {
+        if (sig.hashCode() == RELEASE_SIGNATURE_HASHCODE) {
+          return true;
+        }
+      }
+    } catch (NameNotFoundException e) {
+      Log.e(MyTracksConstants.TAG, "Unable to get signatures", e);
+    }
+
+    return false;
+  }
+  
   /**
    * This is a utility class w/ only static memebers.
    */