From 89ed39f1f460ad84291182fdea39eae1e9d8b666 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Wed, 14 Aug 2013 12:39:32 -0700
Subject: Fix NullPointerException in InCallUI with CallTimer.

bug: 10325158
Change-Id: Ie7e89c2e1e3038df89387e99de6849ed12203824
---
 InCallUI/src/com/android/incallui/CallCardPresenter.java | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallCardPresenter.java b/InCallUI/src/com/android/incallui/CallCardPresenter.java
index 330957e80..60486f454 100644
--- a/InCallUI/src/com/android/incallui/CallCardPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallCardPresenter.java
@@ -150,13 +150,15 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
         final CallCardUi ui = getUi();
 
         if (ui == null || mPrimary == null || mPrimary.getState() != Call.State.ACTIVE) {
-            ui.setPrimaryCallElapsedTime(false, null);
+            if (ui != null) {
+                ui.setPrimaryCallElapsedTime(false, null);
+            }
             mCallTimer.cancel();
+        } else {
+            final long callStart = mPrimary.getConnectTime();
+            final long duration = System.currentTimeMillis() - callStart;
+            ui.setPrimaryCallElapsedTime(true, DateUtils.formatElapsedTime(duration / 1000));
         }
-
-        final long callStart = mPrimary.getConnectTime();
-        final long duration = System.currentTimeMillis() - callStart;
-        ui.setPrimaryCallElapsedTime(true, DateUtils.formatElapsedTime(duration / 1000));
     }
 
 
-- 
cgit v1.2.3


From 0334afdda39cccbb0488d2d6d32b852923c621d9 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Mon, 19 Aug 2013 20:12:16 -0700
Subject: Support connecting and disconnecting from Phone app.

Phone app now connects/disconnects from the UI when there are no active
calls but UI did not previously support being disconnected.  This change
adds the following functionality to support dis/reconnection:

- CallCommandClient now supports setting new ICallCommandService
  instances.
- CallCommandClient now checks if mCommandService is null before
  executing a method.
- CallHandlerService performs more careful ordered cleanup with
  destroyed including removing pending messages and clearing any
  existing calls from the call list.
- InCallActivity now performs tearDown of the presenters with onDestroy
  instead of finish() to reduce NPE instances.
- InCallActivity not notifies InCallPresenter when is finishes, and not
  just when it starts.
- InCallPresenter tears itself down after two things happen: the UI is
  destroyed and the service is disconnected.
- InCallPresenter now issues a full-screen restart of the UI if the
  UI was previously hidden (except for new outgoing calls). This allows
  the UI to come back to the foreground if it was in the foreground when
  the app went down.

The above changes also now protect against the phone app crashing or the
incall UI crashing.

bug: 10363682
Change-Id: I9b785f906f29015827e8e53e64cd5f5c72cd7981
---
 .../com/android/incallui/CallButtonPresenter.java  |  1 -
 .../com/android/incallui/CallCommandClient.java    | 60 ++++++++++++---
 .../com/android/incallui/CallHandlerService.java   | 39 +++++++++-
 InCallUI/src/com/android/incallui/CallList.java    | 19 +++++
 .../src/com/android/incallui/InCallActivity.java   | 12 +--
 .../src/com/android/incallui/InCallPresenter.java  | 90 +++++++++++++++-------
 6 files changed, 175 insertions(+), 46 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallButtonPresenter.java b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
index 3c1ada1fc..12cc65663 100644
--- a/InCallUI/src/com/android/incallui/CallButtonPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
@@ -54,7 +54,6 @@ public class CallButtonPresenter extends Presenter<CallButtonPresenter.CallButto
 
     @Override
     public void onStateChange(InCallState state, CallList callList) {
-
         if (state == InCallState.OUTGOING) {
             mCall = callList.getOutgoingCall();
         } else if (state == InCallState.INCALL) {
diff --git a/InCallUI/src/com/android/incallui/CallCommandClient.java b/InCallUI/src/com/android/incallui/CallCommandClient.java
index 280bab32c..308776cb6 100644
--- a/InCallUI/src/com/android/incallui/CallCommandClient.java
+++ b/InCallUI/src/com/android/incallui/CallCommandClient.java
@@ -28,27 +28,27 @@ public class CallCommandClient {
 
     private static CallCommandClient sInstance;
 
-    public static CallCommandClient getInstance() {
+    public static synchronized CallCommandClient getInstance() {
         if (sInstance == null) {
-            throw new IllegalStateException("CallCommandClient has not been initialized.");
+            sInstance = new CallCommandClient();
         }
         return sInstance;
     }
 
-    // TODO(klp): Not sure if static call is ok. Might need to switch to normal service binding.
-    public static void init(ICallCommandService service) {
-        Preconditions.checkState(sInstance == null);
-        sInstance = new CallCommandClient(service);
-    }
-
-
     private ICallCommandService mCommandService;
 
-    private CallCommandClient(ICallCommandService service) {
+    private CallCommandClient() {
+    }
+
+    public void setService(ICallCommandService service) {
         mCommandService = service;
     }
 
     public void answerCall(int callId) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot answer call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.answerCall(callId);
         } catch (RemoteException e) {
@@ -57,6 +57,10 @@ public class CallCommandClient {
     }
 
     public void rejectCall(int callId, boolean rejectWithMessage, String message) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot reject call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.rejectCall(callId, rejectWithMessage, message);
         } catch (RemoteException e) {
@@ -65,6 +69,10 @@ public class CallCommandClient {
     }
 
     public void disconnectCall(int callId) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot disconnect call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.disconnectCall(callId);
         } catch (RemoteException e) {
@@ -73,6 +81,10 @@ public class CallCommandClient {
     }
 
     public void mute(boolean onOff) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot mute call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.mute(onOff);
         } catch (RemoteException e) {
@@ -81,6 +93,10 @@ public class CallCommandClient {
     }
 
     public void hold(int callId, boolean onOff) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot hold call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.hold(callId, onOff);
         } catch (RemoteException e) {
@@ -89,6 +105,10 @@ public class CallCommandClient {
     }
 
     public void merge() {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot merge call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.merge();
         } catch (RemoteException e) {
@@ -97,6 +117,10 @@ public class CallCommandClient {
     }
 
     public void swap() {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot swap call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.swap();
         } catch (RemoteException e) {
@@ -105,6 +129,10 @@ public class CallCommandClient {
     }
 
     public void addCall() {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot add call; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.addCall();
         } catch (RemoteException e) {
@@ -113,6 +141,10 @@ public class CallCommandClient {
     }
 
     public void setAudioMode(int mode) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot set audio mode; CallCommandService == null");
+            return;
+        }
         try {
             mCommandService.setAudioMode(mode);
         } catch (RemoteException e) {
@@ -121,6 +153,10 @@ public class CallCommandClient {
     }
 
     public void playDtmfTone(char digit, boolean timedShortTone) {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot start dtmf tone; CallCommandService == null");
+            return;
+        }
         try {
             Logger.v(this, "Sending dtmf tone " + digit);
             mCommandService.playDtmfTone(digit, timedShortTone);
@@ -131,6 +167,10 @@ public class CallCommandClient {
     }
 
     public void stopDtmfTone() {
+        if (mCommandService == null) {
+            Logger.e(this, "Cannot stop dtmf tone; CallCommandService == null");
+            return;
+        }
         try {
             Logger.v(this, "Stop dtmf tone ");
             mCommandService.stopDtmfTone();
diff --git a/InCallUI/src/com/android/incallui/CallHandlerService.java b/InCallUI/src/com/android/incallui/CallHandlerService.java
index bdee328f8..f0df1cdc0 100644
--- a/InCallUI/src/com/android/incallui/CallHandlerService.java
+++ b/InCallUI/src/com/android/incallui/CallHandlerService.java
@@ -44,6 +44,8 @@ public class CallHandlerService extends Service {
     private static final int ON_SUPPORTED_AUDIO_MODE = 5;
     private static final int ON_DISCONNECT_CALL = 6;
 
+    private static final int LARGEST_MSG_ID = ON_DISCONNECT_CALL;
+
 
     private CallList mCallList;
     private Handler mMainHandler;
@@ -52,6 +54,7 @@ public class CallHandlerService extends Service {
 
     @Override
     public void onCreate() {
+        Logger.d(this, "onCreate started");
         super.onCreate();
 
         mCallList = new CallList();
@@ -59,28 +62,52 @@ public class CallHandlerService extends Service {
         mAudioModeProvider = new AudioModeProvider();
         mInCallPresenter = InCallPresenter.getInstance();
         mInCallPresenter.setUp(getApplicationContext(), mCallList, mAudioModeProvider);
+        Logger.d(this, "onCreate finished");
     }
 
     @Override
     public void onDestroy() {
+        Logger.d(this, "onDestroy started");
+
+        // Remove all pending messages before nulling out handler
+        for (int i = 1; i <= LARGEST_MSG_ID; i++) {
+            mMainHandler.removeMessages(i);
+        }
+        mMainHandler = null;
+
+        // The service gets disconnected under two circumstances:
+        // 1. When there are no more calls
+        // 2. When the phone app crashes.
+        // If (2) happens, we can't leave the UI thinking that there are still
+        // live calls.  So we will tell the callList to clear as a final request.
+        mCallList.clearOnDisconnect();
+        mCallList = null;
+
         mInCallPresenter.tearDown();
         mInCallPresenter = null;
         mAudioModeProvider = null;
-        mMainHandler = null;
-        mCallList = null;
+
+        Logger.d(this, "onDestroy finished");
     }
 
     @Override
     public IBinder onBind(Intent intent) {
+        Logger.d(this, "onBind");
         return mBinder;
     }
 
+    @Override
+    public boolean onUnbind(Intent intent) {
+        Logger.d(this, "onUnbind");
+        return true;
+    }
+
     private final ICallHandlerService.Stub mBinder = new ICallHandlerService.Stub() {
 
         @Override
         public void setCallCommandService(ICallCommandService service) {
             Logger.d(CallHandlerService.this, "onConnected: " + service.toString());
-            CallCommandClient.init(service);
+            CallCommandClient.getInstance().setService(service);
         }
 
         @Override
@@ -146,6 +173,12 @@ public class CallHandlerService extends Service {
     }
 
     private void executeMessage(Message msg) {
+        if (msg.what > LARGEST_MSG_ID) {
+            // If you got here, you may have added a new message and forgotten to
+            // update LARGEST_MSG_ID
+            Logger.wtf(this, "Cannot handle message larger than LARGEST_MSG_ID.");
+        }
+
         Logger.d(this, "executeMessage " + msg.what);
 
         switch (msg.what) {
diff --git a/InCallUI/src/com/android/incallui/CallList.java b/InCallUI/src/com/android/incallui/CallList.java
index f692bf683..a3cee5f98 100644
--- a/InCallUI/src/com/android/incallui/CallList.java
+++ b/InCallUI/src/com/android/incallui/CallList.java
@@ -224,6 +224,25 @@ public class CallList {
         return retval;
     }
 
+    /**
+     * This is called when the service disconnects, either expectedly or unexpectedly.
+     * For the expected case, it's because we have no calls left.  For the unexpected case,
+     * it is likely a crash of phone and we need to clean up our calls manually.  Without phone,
+     * there can be no active calls, so this is relatively safe thing to do.
+     */
+    public void clearOnDisconnect() {
+        for (Call call : mCallMap.values()) {
+            final int state = call.getState();
+            if (state != Call.State.IDLE &&
+                    state != Call.State.INVALID &&
+                    state != Call.State.DISCONNECTED) {
+                call.setState(Call.State.DISCONNECTED);
+                updateCallInMap(call);
+            }
+        }
+        notifyListenersOfChange();
+    }
+
     /**
      * Sends a generic notification to all listeners that something has changed.
      * It is up to the listeners to call back to determine what changed.
diff --git a/InCallUI/src/com/android/incallui/InCallActivity.java b/InCallUI/src/com/android/incallui/InCallActivity.java
index e1a979693..5edfaa32a 100644
--- a/InCallUI/src/com/android/incallui/InCallActivity.java
+++ b/InCallUI/src/com/android/incallui/InCallActivity.java
@@ -88,6 +88,9 @@ public class InCallActivity extends Activity {
     @Override
     protected void onDestroy() {
         Logger.d(this, "onDestroy()...  this = " + this);
+
+        tearDownPresenters();
+
         super.onDestroy();
     }
 
@@ -116,13 +119,7 @@ public class InCallActivity extends Activity {
     @Override
     public void finish() {
         Logger.d(this, "finish()...");
-        tearDownPresenters();
-
         super.finish();
-
-        // TODO(klp): Actually finish the activity for now.  Revisit performance implications of
-        // this before launch.
-        // moveTaskToBack(true);
     }
 
     @Override
@@ -299,11 +296,14 @@ public class InCallActivity extends Activity {
     }
 
     private void tearDownPresenters() {
+        Logger.d(this, "Tearing down presenters.");
         InCallPresenter mainPresenter = InCallPresenter.getInstance();
 
         mainPresenter.removeListener(mCallButtonFragment.getPresenter());
         mainPresenter.removeListener(mCallCardFragment.getPresenter());
         mainPresenter.removeListener(mAnswerFragment.getPresenter());
+
+        mainPresenter.setActivity(null);
     }
 
     private void toast(String text) {
diff --git a/InCallUI/src/com/android/incallui/InCallPresenter.java b/InCallUI/src/com/android/incallui/InCallPresenter.java
index d709ba49f..3b400ef7b 100644
--- a/InCallUI/src/com/android/incallui/InCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/InCallPresenter.java
@@ -47,7 +47,7 @@ public class InCallPresenter implements CallList.Listener {
     private Context mContext;
     private CallList mCallList;
     private InCallActivity mInCallActivity;
-
+    private boolean mServiceConnected = false;
     private InCallState mInCallState = InCallState.HIDDEN;
 
     public static synchronized InCallPresenter getInstance() {
@@ -71,34 +71,44 @@ public class InCallPresenter implements CallList.Listener {
 
         mAudioModeProvider = audioModeProvider;
 
+        // This only gets called by the service so this is okay.
+        mServiceConnected = true;
+
         Logger.d(this, "Finished InCallPresenter.setUp");
     }
 
+    /**
+     * Called when the telephony service has disconnected from us.  This will happen when there are
+     * no more active calls. However, we may still want to continue showing the UI for
+     * certain cases like showing "Call Ended".
+     * What we really want is to wait for the activity and the service to both disconnect before we
+     * tear things down. This method sets a serviceConnected boolean and calls a secondary method
+     * that performs the aforementioned logic.
+     */
     public void tearDown() {
-        mAudioModeProvider = null;
-
-        removeListener(mStatusBarNotifier);
-        mStatusBarNotifier = null;
-
-        mCallList.removeListener(this);
-        mCallList = null;
-
-        mContext = null;
-        mInCallActivity = null;
-
-        mListeners.clear();
-
-        Logger.d(this, "Finished InCallPresenter.tearDown");
+        Logger.d(this, "tearDown");
+        mServiceConnected = false;
+        attemptCleanup();
     }
 
+    /**
+     * Called when the UI begins or ends. Starts the callstate callbacks if the UI just began.
+     * Attempts to tear down everything if the UI just ended. See #tearDown for more insight on
+     * the tear-down process.
+     */
     public void setActivity(InCallActivity inCallActivity) {
         mInCallActivity = inCallActivity;
 
-        Logger.d(this, "UI Initialized");
+        if (mInCallActivity != null) {
+            Logger.d(this, "UI Initialized");
 
-        // Since the UI just came up, imitate an update from the call list
-        // to set the proper UI state.
-        onCallListChange(mCallList);
+            // Since the UI just came up, imitate an update from the call list
+            // to set the proper UI state.
+            onCallListChange(mCallList);
+        } else {
+            Logger.d(this, "setActivity(null)");
+            attemptCleanup();
+        }
     }
 
     /**
@@ -187,7 +197,9 @@ public class InCallPresenter implements CallList.Listener {
     public void onUiShowing(boolean showing) {
         // We need to update the notification bar when we leave the UI because that
         // could trigger it to show again.
-        mStatusBarNotifier.updateNotification(mInCallState, mCallList);
+        if (mStatusBarNotifier != null) {
+            mStatusBarNotifier.updateNotification(mInCallState, mCallList);
+        }
     }
 
     /**
@@ -195,7 +207,7 @@ public class InCallPresenter implements CallList.Listener {
      * the UI needs to be started or finished depending on the new state and does it.
      */
     private InCallState startOrFinishUi(InCallState newState) {
-        Logger.d(this, "startOrFInishUi: " + newState.toString());
+        Logger.d(this, "startOrFinishUi: " + newState.toString());
 
         // TODO(klp): Consider a proper state machine implementation
 
@@ -228,8 +240,10 @@ public class InCallPresenter implements CallList.Listener {
         //          [ AND NOW YOU'RE IN THE CALL. voila! ]
         //
         // Our app is started using a fullScreen notification.  We need to do this whenever
-        // we get an incoming call.
-        final boolean startStartupSequence = (InCallState.INCOMING == newState);
+        // we get an incoming call or if this is the first time we are displaying (the previous
+        // state was HIDDEN).
+        final boolean startStartupSequence = (InCallState.INCOMING == newState ||
+                InCallState.HIDDEN == mInCallState);
 
         // A new outgoing call indicates that the user just now dialed a number and when that
         // happens we need to display the screen immediateley.
@@ -242,10 +256,10 @@ public class InCallPresenter implements CallList.Listener {
         Logger.v(this, "startStartupSequence: ", startStartupSequence);
 
 
-        if (startStartupSequence) {
-            mStatusBarNotifier.updateNotificationAndLaunchIncomingCallUi(newState, mCallList);
-        } else if (showCallUi) {
+        if (showCallUi) {
             showInCall();
+        } else if (startStartupSequence) {
+            mStatusBarNotifier.updateNotificationAndLaunchIncomingCallUi(newState, mCallList);
         } else if (newState == InCallState.HIDDEN) {
 
             // The new state is the hidden state (no calls).  Tear everything down.
@@ -265,6 +279,30 @@ public class InCallPresenter implements CallList.Listener {
         return newState;
     }
 
+    /**
+     * Checks to see if both the UI is gone and the service is disconnected. If so, tear it all
+     * down.
+     */
+    private void attemptCleanup() {
+        if (mInCallActivity == null && !mServiceConnected) {
+            Logger.d(this, "Start InCallPresenter.CleanUp");
+            mAudioModeProvider = null;
+
+            removeListener(mStatusBarNotifier);
+            mStatusBarNotifier = null;
+
+            mCallList.removeListener(this);
+            mCallList = null;
+
+            mContext = null;
+            mInCallActivity = null;
+
+            mListeners.clear();
+
+            Logger.d(this, "Finished InCallPresenter.CleanUp");
+        }
+    }
+
     private void showInCall() {
         Logger.d(this, "Showing in call manually.");
         mContext.startActivity(getInCallIntent());
-- 
cgit v1.2.3


From 7b87a85abf483599c956820c06791da78c9ff5e0 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Tue, 20 Aug 2013 15:07:51 -0700
Subject: Adding proximity sensor code to in-call UI.

Many of these changes are verbatim code copies from what used to exist
in services/Telephony.  The rest of them are straight logic copies that
should do the exact same things.

New class ProximitySensor manages the proximity behavior.  It receives
device state from InCallPresenter, AudioModeProvider, CallButtonPresenter,
and AcceleromterListener, the last of which is a transplanted class from
services/Telephony.

ProximitySensor listens for the following events:
1. Change in the call state
2. Change in the audio mode
3. Change in the device orientation (from AccelerometerListener)
4. Change in the dialpad visibility
5. Change in hard keyboard open/close events.
6. Change in foreground position of InCall UI app.

It uses these to figure out when to enable/disable proximity sensor.

CL that removes code from TeleService: I77e0d15ad1a8f5a090c1368db98edaa246dbcd72

bug: 10366512
Change-Id: I5c2ea6daa9443e7ad77c67f272bc0bafdb060e5e
---
 InCallUI/AndroidManifest.xml                       |   1 +
 .../android/incallui/AccelerometerListener.java    | 161 ++++++++++++++
 .../com/android/incallui/CallButtonPresenter.java  |   6 +
 .../src/com/android/incallui/InCallActivity.java   |  11 +
 .../src/com/android/incallui/InCallPresenter.java  |  13 ++
 .../src/com/android/incallui/ProximitySensor.java  | 232 +++++++++++++++++++++
 6 files changed, 424 insertions(+)
 create mode 100644 InCallUI/src/com/android/incallui/AccelerometerListener.java
 create mode 100644 InCallUI/src/com/android/incallui/ProximitySensor.java

diff --git a/InCallUI/AndroidManifest.xml b/InCallUI/AndroidManifest.xml
index 3196dba60..42d8e3173 100644
--- a/InCallUI/AndroidManifest.xml
+++ b/InCallUI/AndroidManifest.xml
@@ -23,6 +23,7 @@
     <uses-permission android:name="android.permission.READ_CONTACTS" />
     <uses-permission android:name="android.permission.VIBRATE"/>
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
 
     <application
             android:name="InCallApp"
diff --git a/InCallUI/src/com/android/incallui/AccelerometerListener.java b/InCallUI/src/com/android/incallui/AccelerometerListener.java
new file mode 100644
index 000000000..1a7077866
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AccelerometerListener.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2009 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.incallui;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+/**
+ * This class is used to listen to the accelerometer to monitor the
+ * orientation of the phone. The client of this class is notified when
+ * the orientation changes between horizontal and vertical.
+ */
+public final class AccelerometerListener {
+    private static final String TAG = "AccelerometerListener";
+    private static final boolean DEBUG = true;
+    private static final boolean VDEBUG = false;
+
+    private SensorManager mSensorManager;
+    private Sensor mSensor;
+
+    // mOrientation is the orientation value most recently reported to the client.
+    private int mOrientation;
+
+    // mPendingOrientation is the latest orientation computed based on the sensor value.
+    // This is sent to the client after a rebounce delay, at which point it is copied to
+    // mOrientation.
+    private int mPendingOrientation;
+
+    private OrientationListener mListener;
+
+    // Device orientation
+    public static final int ORIENTATION_UNKNOWN = 0;
+    public static final int ORIENTATION_VERTICAL = 1;
+    public static final int ORIENTATION_HORIZONTAL = 2;
+
+    private static final int ORIENTATION_CHANGED = 1234;
+
+    private static final int VERTICAL_DEBOUNCE = 100;
+    private static final int HORIZONTAL_DEBOUNCE = 500;
+    private static final double VERTICAL_ANGLE = 50.0;
+
+    public interface OrientationListener {
+        public void orientationChanged(int orientation);
+    }
+
+    public AccelerometerListener(Context context, OrientationListener listener) {
+        mListener = listener;
+        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
+        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+    }
+
+    public void enable(boolean enable) {
+        if (DEBUG) Log.d(TAG, "enable(" + enable + ")");
+        synchronized (this) {
+            if (enable) {
+                mOrientation = ORIENTATION_UNKNOWN;
+                mPendingOrientation = ORIENTATION_UNKNOWN;
+                mSensorManager.registerListener(mSensorListener, mSensor,
+                        SensorManager.SENSOR_DELAY_NORMAL);
+            } else {
+                mSensorManager.unregisterListener(mSensorListener);
+                mHandler.removeMessages(ORIENTATION_CHANGED);
+            }
+        }
+    }
+
+    private void setOrientation(int orientation) {
+        synchronized (this) {
+            if (mPendingOrientation == orientation) {
+                // Pending orientation has not changed, so do nothing.
+                return;
+            }
+
+            // Cancel any pending messages.
+            // We will either start a new timer or cancel alltogether
+            // if the orientation has not changed.
+            mHandler.removeMessages(ORIENTATION_CHANGED);
+
+            if (mOrientation != orientation) {
+                // Set timer to send an event if the orientation has changed since its
+                // previously reported value.
+                mPendingOrientation = orientation;
+                final Message m = mHandler.obtainMessage(ORIENTATION_CHANGED);
+                // set delay to our debounce timeout
+                int delay = (orientation == ORIENTATION_VERTICAL ? VERTICAL_DEBOUNCE
+                                                                 : HORIZONTAL_DEBOUNCE);
+                mHandler.sendMessageDelayed(m, delay);
+            } else {
+                // no message is pending
+                mPendingOrientation = ORIENTATION_UNKNOWN;
+            }
+        }
+    }
+
+    private void onSensorEvent(double x, double y, double z) {
+        if (VDEBUG) Log.d(TAG, "onSensorEvent(" + x + ", " + y + ", " + z + ")");
+
+        // If some values are exactly zero, then likely the sensor is not powered up yet.
+        // ignore these events to avoid false horizontal positives.
+        if (x == 0.0 || y == 0.0 || z == 0.0) return;
+
+        // magnitude of the acceleration vector projected onto XY plane
+        final double xy = Math.sqrt(x*x + y*y);
+        // compute the vertical angle
+        double angle = Math.atan2(xy, z);
+        // convert to degrees
+        angle = angle * 180.0 / Math.PI;
+        final int orientation = (angle >  VERTICAL_ANGLE ? ORIENTATION_VERTICAL : ORIENTATION_HORIZONTAL);
+        if (VDEBUG) Log.d(TAG, "angle: " + angle + " orientation: " + orientation);
+        setOrientation(orientation);
+    }
+
+    SensorEventListener mSensorListener = new SensorEventListener() {
+        public void onSensorChanged(SensorEvent event) {
+            onSensorEvent(event.values[0], event.values[1], event.values[2]);
+        }
+
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {
+            // ignore
+        }
+    };
+
+    Handler mHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+            case ORIENTATION_CHANGED:
+                synchronized (this) {
+                    mOrientation = mPendingOrientation;
+                    if (DEBUG) {
+                        Log.d(TAG, "orientation: " +
+                            (mOrientation == ORIENTATION_HORIZONTAL ? "horizontal"
+                                : (mOrientation == ORIENTATION_VERTICAL ? "vertical"
+                                    : "unknown")));
+                    }
+                    mListener.orientationChanged(mOrientation);
+                }
+                break;
+            }
+        }
+    };
+}
diff --git a/InCallUI/src/com/android/incallui/CallButtonPresenter.java b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
index 12cc65663..233231754 100644
--- a/InCallUI/src/com/android/incallui/CallButtonPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
@@ -33,6 +33,7 @@ public class CallButtonPresenter extends Presenter<CallButtonPresenter.CallButto
 
     private Call mCall;
     private AudioModeProvider mAudioModeProvider;
+    private ProximitySensor mProximitySensor;
 
     public CallButtonPresenter() {
     }
@@ -166,6 +167,7 @@ public class CallButtonPresenter extends Presenter<CallButtonPresenter.CallButto
     public void showDialpadClicked(boolean checked) {
         Logger.v(this, "Show dialpad " + String.valueOf(checked));
         getUi().displayDialpad(checked);
+        mProximitySensor.onDialpadVisible(checked);
     }
 
     private void updateUi(InCallState state, Call call) {
@@ -204,6 +206,10 @@ public class CallButtonPresenter extends Presenter<CallButtonPresenter.CallButto
         mAudioModeProvider.addListener(this);
     }
 
+    public void setProximitySensor(ProximitySensor proximitySensor) {
+        mProximitySensor = proximitySensor;
+    }
+
     public interface CallButtonUi extends Ui {
         void setVisible(boolean on);
         void setMute(boolean on);
diff --git a/InCallUI/src/com/android/incallui/InCallActivity.java b/InCallUI/src/com/android/incallui/InCallActivity.java
index 5edfaa32a..776f7e013 100644
--- a/InCallUI/src/com/android/incallui/InCallActivity.java
+++ b/InCallUI/src/com/android/incallui/InCallActivity.java
@@ -19,6 +19,7 @@ package com.android.incallui;
 import android.app.Activity;
 import android.app.Fragment;
 import android.content.Intent;
+import android.content.res.Configuration;
 import android.os.Bundle;
 import android.view.KeyEvent;
 import android.view.View;
@@ -51,6 +52,9 @@ public class InCallActivity extends Activity {
 
         requestWindowFeature(Window.FEATURE_NO_TITLE);
 
+        // TODO(klp): Do we need to add this back when prox sensor is not available?
+        // lp.inputFeatures |= WindowManager.LayoutParams.INPUT_FEATURE_DISABLE_USER_ACTIVITY;
+
         // Inflate everything in incall_screen.xml and add it to the screen.
         setContentView(R.layout.incall_screen);
 
@@ -210,6 +214,11 @@ public class InCallActivity extends Activity {
         return super.onKeyDown(keyCode, event);
     }
 
+    @Override
+    public void onConfigurationChanged(Configuration config) {
+        InCallPresenter.getInstance().getProximitySensor().onConfigurationChanged(config);
+    }
+
     private void internalResolveIntent(Intent intent) {
         final String action = intent.getAction();
 
@@ -282,6 +291,8 @@ public class InCallActivity extends Activity {
 
         mCallButtonFragment.getPresenter().setAudioModeProvider(
                 mainPresenter.getAudioModeProvider());
+        mCallButtonFragment.getPresenter().setProximitySensor(
+                mainPresenter.getProximitySensor());
         mCallCardFragment.getPresenter().setAudioModeProvider(
                 mainPresenter.getAudioModeProvider());
         mCallCardFragment.getPresenter().setContactInfoCache(
diff --git a/InCallUI/src/com/android/incallui/InCallPresenter.java b/InCallUI/src/com/android/incallui/InCallPresenter.java
index 3b400ef7b..1931c1b53 100644
--- a/InCallUI/src/com/android/incallui/InCallPresenter.java
+++ b/InCallUI/src/com/android/incallui/InCallPresenter.java
@@ -49,6 +49,7 @@ public class InCallPresenter implements CallList.Listener {
     private InCallActivity mInCallActivity;
     private boolean mServiceConnected = false;
     private InCallState mInCallState = InCallState.HIDDEN;
+    private ProximitySensor mProximitySensor;
 
     public static synchronized InCallPresenter getInstance() {
         if (sInCallPresenter == null) {
@@ -74,6 +75,9 @@ public class InCallPresenter implements CallList.Listener {
         // This only gets called by the service so this is okay.
         mServiceConnected = true;
 
+        mProximitySensor = new ProximitySensor(context, mAudioModeProvider);
+        addListener(mProximitySensor);
+
         Logger.d(this, "Finished InCallPresenter.setUp");
     }
 
@@ -169,6 +173,10 @@ public class InCallPresenter implements CallList.Listener {
         return mContactInfoCache;
     }
 
+    public ProximitySensor getProximitySensor() {
+        return mProximitySensor;
+    }
+
     /**
      * Hangs up any active or outgoing calls.
      */
@@ -200,6 +208,10 @@ public class InCallPresenter implements CallList.Listener {
         if (mStatusBarNotifier != null) {
             mStatusBarNotifier.updateNotification(mInCallState, mCallList);
         }
+
+        if (mProximitySensor != null) {
+            mProximitySensor.onInCallShowing(showing);
+        }
     }
 
     /**
@@ -286,6 +298,7 @@ public class InCallPresenter implements CallList.Listener {
     private void attemptCleanup() {
         if (mInCallActivity == null && !mServiceConnected) {
             Logger.d(this, "Start InCallPresenter.CleanUp");
+            mProximitySensor = null;
             mAudioModeProvider = null;
 
             removeListener(mStatusBarNotifier);
diff --git a/InCallUI/src/com/android/incallui/ProximitySensor.java b/InCallUI/src/com/android/incallui/ProximitySensor.java
new file mode 100644
index 000000000..48dc43c2f
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ProximitySensor.java
@@ -0,0 +1,232 @@
+/*
+ * 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.incallui;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.PowerManager;
+
+import com.android.incallui.AudioModeProvider.AudioModeListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.services.telephony.common.AudioMode;
+
+/**
+ * Class manages the proximity sensor for the in-call UI.
+ * We enable the proximity sensor while the user in a phone call. The Proximity sensor turns off
+ * the touchscreen and display when the user is close to the screen to prevent user's cheek from
+ * causing touch events.
+ * The class requires special knowledge of the activity and device state to know when the proximity
+ * sensor should be enabled and disabled. Most of that state is fed into this class through
+ * public methods.
+ */
+public class ProximitySensor implements AccelerometerListener.OrientationListener,
+        InCallStateListener, AudioModeListener {
+    private static final String TAG = ProximitySensor.class.getSimpleName();
+
+    private final PowerManager mPowerManager;
+    private final PowerManager.WakeLock mProximityWakeLock;
+    private final AudioModeProvider mAudioModeProvider;
+    private final AccelerometerListener mAccelerometerListener;
+    private int mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+    private boolean mUiShowing = false;
+    private boolean mIsPhoneOffhook = false;
+    private boolean mDialpadVisible;
+
+    // True if the keyboard is currently *not* hidden
+    // Gets updated whenever there is a Configuration change
+    private boolean mIsHardKeyboardOpen;
+
+    public ProximitySensor(Context context, AudioModeProvider audioModeProvider) {
+        mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+
+        if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+            mProximityWakeLock = mPowerManager.newWakeLock(
+                    PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);
+        } else {
+            mProximityWakeLock = null;
+        }
+        Logger.d(this, "onCreate: mProximityWakeLock: ", mProximityWakeLock);
+
+        mAccelerometerListener = new AccelerometerListener(context, this);
+        mAudioModeProvider = audioModeProvider;
+        mAudioModeProvider.addListener(this);
+    }
+
+    /**
+     * Called to identify when the device is laid down flat.
+     */
+    @Override
+    public void orientationChanged(int orientation) {
+        mOrientation = orientation;
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Called to keep track of the overall UI state.
+     */
+    @Override
+    public void onStateChange(InCallState state, CallList callList) {
+        // We ignore incoming state because we do not want to enable proximity
+        // sensor during incoming call screen
+        mIsPhoneOffhook = (InCallState.INCALL == state
+                || InCallState.OUTGOING == state);
+
+        mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+        mAccelerometerListener.enable(mIsPhoneOffhook);
+
+        updateProximitySensorMode();
+    }
+
+    @Override
+    public void onSupportedAudioMode(int modeMask) {
+    }
+
+    /**
+     * Called when the audio mode changes during a call.
+     */
+    @Override
+    public void onAudioMode(int mode) {
+        updateProximitySensorMode();
+    }
+
+    public void onDialpadVisible(boolean visible) {
+        mDialpadVisible = visible;
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Called by InCallActivity to listen for hard keyboard events.
+     */
+    public void onConfigurationChanged(Configuration newConfig) {
+        mIsHardKeyboardOpen = newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO;
+
+        // Update the Proximity sensor based on keyboard state
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Used to save when the UI goes in and out of the foreground.
+     */
+    public void onInCallShowing(boolean showing) {
+        if (showing) {
+            mUiShowing = true;
+
+        // We only consider the UI not showing for instances where another app took the foreground.
+        // If we stopped showing because the screen is off, we still consider that showing.
+        } else if (mPowerManager.isScreenOn()) {
+            mUiShowing = false;
+        }
+        updateProximitySensorMode();
+    }
+
+    /**
+     * @return true if this device supports the "proximity sensor
+     * auto-lock" feature while in-call (see updateProximitySensorMode()).
+     */
+    private boolean proximitySensorModeEnabled() {
+        // TODO(klp): Do we disable notification's expanded view when app is in foreground and
+        // proximity sensor is on? Is it even possible to do this any more?
+        return (mProximityWakeLock != null);
+    }
+
+    /**
+     * Updates the wake lock used to control proximity sensor behavior,
+     * based on the current state of the phone.
+     *
+     * On devices that have a proximity sensor, to avoid false touches
+     * during a call, we hold a PROXIMITY_SCREEN_OFF_WAKE_LOCK wake lock
+     * whenever the phone is off hook.  (When held, that wake lock causes
+     * the screen to turn off automatically when the sensor detects an
+     * object close to the screen.)
+     *
+     * This method is a no-op for devices that don't have a proximity
+     * sensor.
+     *
+     * Proximity wake lock will *not* be held if any one of the
+     * conditions is true while on a call:
+     * 1) If the audio is routed via Bluetooth
+     * 2) If a wired headset is connected
+     * 3) if the speaker is ON
+     * 4) If the slider is open(i.e. the hardkeyboard is *not* hidden)
+     */
+    private void updateProximitySensorMode() {
+        Logger.v(this, "updateProximitySensorMode");
+
+        if (proximitySensorModeEnabled()) {
+            Logger.v(this, "keyboard open: ", mIsHardKeyboardOpen);
+            Logger.v(this, "dialpad visible: ", mDialpadVisible);
+            Logger.v(this, "isOffhook: ", mIsPhoneOffhook);
+
+            synchronized (mProximityWakeLock) {
+
+                final int audioMode = mAudioModeProvider.getAudioMode();
+                Logger.v(this, "audioMode: ", AudioMode.toString(audioMode));
+
+                // turn proximity sensor off and turn screen on immediately if
+                // we are using a headset, the keyboard is open, or the device
+                // is being held in a horizontal position.
+                boolean screenOnImmediately = (AudioMode.WIRED_HEADSET == audioMode
+                        || AudioMode.SPEAKER == audioMode
+                        || AudioMode.BLUETOOTH == audioMode
+                        || mIsHardKeyboardOpen);
+
+                // We do not keep the screen off when the user is outside in-call screen and we are
+                // horizontal, but we do not force it on when we become horizontal until the
+                // proximity sensor goes negative.
+                final boolean horizontal =
+                        (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);
+                Logger.v(this, "horizontal: ", horizontal);
+                screenOnImmediately |= !mUiShowing && horizontal;
+
+                // We do not keep the screen off when dialpad is visible, we are horizontal, and
+                // the in-call screen is being shown.
+                // At that moment we're pretty sure users want to use it, instead of letting the
+                // proximity sensor turn off the screen by their hands.
+                screenOnImmediately |= mDialpadVisible && horizontal;
+
+                Logger.v(this, "screenonImmediately: ", screenOnImmediately);
+
+                if (mIsPhoneOffhook && !screenOnImmediately) {
+                    // Phone is in use!  Arrange for the screen to turn off
+                    // automatically when the sensor detects a close object.
+                    if (!mProximityWakeLock.isHeld()) {
+                        Logger.d(this, "updateProximitySensorMode: acquiring...");
+                        mProximityWakeLock.acquire();
+                    } else {
+                        Logger.v(this, "updateProximitySensorMode: lock already held.");
+                    }
+                } else {
+                    // Phone is either idle, or ringing.  We don't want any
+                    // special proximity sensor behavior in either case.
+                    if (mProximityWakeLock.isHeld()) {
+                        Logger.d(this, "updateProximitySensorMode: releasing...");
+                        // Wait until user has moved the phone away from his head if we are
+                        // releasing due to the phone call ending.
+                        // Qtherwise, turn screen on immediately
+                        int flags =
+                            (screenOnImmediately ? 0 : PowerManager.WAIT_FOR_PROXIMITY_NEGATIVE);
+                        mProximityWakeLock.release(flags);
+                    } else {
+                        Logger.v(this, "updateProximitySensorMode: lock already released.");
+                    }
+                }
+            }
+        }
+    }
+
+}
-- 
cgit v1.2.3


From 716bfae047793e6b8df0867f5683e5a7c2f6f94c Mon Sep 17 00:00:00 2001
From: Chiao Cheng <chiaocheng@google.com>
Date: Fri, 23 Aug 2013 11:24:23 -0700
Subject: Disabling quick response since it's not done yet.

Feature is incomplete. Ui needs to handle case where there are no text
responses and switch to 2 targets.

Bug: 10424370
Change-Id: Iae59ec0adeea6131374a61abe05031eb29da9ca4
---
 InCallUI/res/layout/answer_fragment.xml                | 6 +++---
 InCallUI/src/com/android/incallui/AnswerPresenter.java | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/InCallUI/res/layout/answer_fragment.xml b/InCallUI/res/layout/answer_fragment.xml
index 1594f03b8..f6b132091 100644
--- a/InCallUI/res/layout/answer_fragment.xml
+++ b/InCallUI/res/layout/answer_fragment.xml
@@ -31,9 +31,9 @@
         android:layout_gravity="bottom|center_horizontal"
         android:background="@android:color/black"
 
-        dc:targetDrawables="@array/incoming_call_widget_3way_targets"
-        dc:targetDescriptions="@array/incoming_call_widget_3way_target_descriptions"
-        dc:directionDescriptions="@array/incoming_call_widget_3way_direction_descriptions"
+        dc:targetDrawables="@array/incoming_call_widget_2way_targets"
+        dc:targetDescriptions="@array/incoming_call_widget_2way_target_descriptions"
+        dc:directionDescriptions="@array/incoming_call_widget_2way_direction_descriptions"
         dc:handleDrawable="@drawable/ic_in_call_touch_handle"
         dc:outerRingDrawable="@*android:drawable/ic_lockscreen_outerring"
         dc:outerRadius="@dimen/glowpadview_target_placement_radius"
diff --git a/InCallUI/src/com/android/incallui/AnswerPresenter.java b/InCallUI/src/com/android/incallui/AnswerPresenter.java
index f53807a70..78ee0f1a3 100644
--- a/InCallUI/src/com/android/incallui/AnswerPresenter.java
+++ b/InCallUI/src/com/android/incallui/AnswerPresenter.java
@@ -76,7 +76,8 @@ public class AnswerPresenter extends Presenter<AnswerPresenter.AnswerUi>
     }
 
     public void onText() {
-        getUi().showMessageDialogue();
+        // No-op for now.  b/10424370
+        // getUi().showMessageDialogue();
     }
 
     public void rejectCallWithMessage(String message) {
-- 
cgit v1.2.3


From 9180be4b2671de75c7433cd95ecc717d0ebb2fe4 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Thu, 22 Aug 2013 18:03:39 -0700
Subject: Show gateway UI when dialing via a gateway

Gateway information is not available in the Call object.  Inside
CallCardPresenter, we use this to show the user dialing information when
dialing out through a gateway.  This includes a "Calling via..." notice
above the call state label and the gateway number.

bug: 10393622
Change-Id: Iff1247cd592b0730bb7cfc6d16bd8f60b47f3737
---
 InCallUI/res/layout/primary_call_info.xml          | 77 +++++++++++++++++-----
 InCallUI/res/values/styles.xml                     |  2 +-
 .../src/com/android/incallui/CallCardFragment.java | 20 +++++-
 .../com/android/incallui/CallCardPresenter.java    | 52 +++++++++++++--
 4 files changed, 126 insertions(+), 25 deletions(-)

diff --git a/InCallUI/res/layout/primary_call_info.xml b/InCallUI/res/layout/primary_call_info.xml
index 251ded30b..681519b76 100644
--- a/InCallUI/res/layout/primary_call_info.xml
+++ b/InCallUI/res/layout/primary_call_info.xml
@@ -110,24 +110,67 @@
         </GridLayout>
         <!-- End of call_banner -->
 
+        <LinearLayout android:id="@+id/supplementary_info_container"
+            style="@style/PrimaryCallInfoSupplementaryInfoContainer"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_vertical|right"
+            android:orientation="vertical"
+            android:background="@color/incall_secondary_info_background"
+            android:animateLayoutChanges="true">
+
+            <!-- Shown when a gateway provider is used during any outgoing call. -->
+            <LinearLayout android:id="@+id/providerInfo"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:paddingTop="@dimen/provider_info_top_bottom_padding"
+                android:paddingBottom="@dimen/provider_info_top_bottom_padding"
+                android:paddingStart="@dimen/call_banner_side_padding"
+                android:paddingEnd="@dimen/call_banner_side_padding"
+                android:gravity="end"
+                android:orientation="horizontal"
+                android:background="@android:color/transparent"
+                android:visibility="gone">
+                <TextView android:id="@+id/providerLabel"
+                    android:layout_width="0px"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="6"
+                    android:textAppearance="?android:attr/textAppearanceSmall"
+                    android:textAllCaps="true"
+                    android:textColor="@color/incall_call_banner_text_color"
+                    android:singleLine="true"
+                    android:ellipsize="marquee" />
+                <TextView android:id="@+id/providerAddress"
+                    android:layout_width="0px"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="4"
+                    android:gravity="end"
+                    android:paddingStart="8dp"
+                    android:textAppearance="?android:attr/textAppearanceSmall"
+                    android:textAllCaps="true"
+                    android:textColor="@color/incall_call_banner_text_color"
+                    android:singleLine="true"
+                    android:ellipsize="middle" />
+            </LinearLayout>
 
-        <!-- The "call state label": In some states, this shows a special
-             indication like "Dialing" or "Incoming call" or "Call ended".
-             It's unused for the normal case of an active ongoing call. -->
-        <TextView android:id="@+id/callStateLabel"
-                  android:layout_width="match_parent"
-                  android:layout_height="wrap_content"
-                  android:paddingTop="@dimen/provider_info_top_bottom_padding"
-                  android:paddingBottom="@dimen/provider_info_top_bottom_padding"
-                  android:paddingStart="@dimen/call_banner_side_padding"
-                  android:paddingEnd="@dimen/call_banner_side_padding"
-                  android:gravity="end"
-                  android:textAppearance="?android:attr/textAppearanceSmall"
-                  android:textColor="@color/incall_call_banner_text_color"
-                  android:textAllCaps="true"
-                  android:background="@color/incall_secondary_info_background"
-                  android:singleLine="true"
-                  android:ellipsize="end"/>
+            <!-- The "call state label": In some states, this shows a special
+                 indication like "Dialing" or "Incoming call" or "Call ended".
+                 It's unused for the normal case of an active ongoing call. -->
+            <TextView android:id="@+id/callStateLabel"
+                      android:layout_width="match_parent"
+                      android:layout_height="wrap_content"
+                      android:paddingTop="@dimen/provider_info_top_bottom_padding"
+                      android:paddingBottom="@dimen/provider_info_top_bottom_padding"
+                      android:paddingStart="@dimen/call_banner_side_padding"
+                      android:paddingEnd="@dimen/call_banner_side_padding"
+                      android:gravity="end"
+                      android:textAppearance="?android:attr/textAppearanceSmall"
+                      android:textColor="@color/incall_call_banner_text_color"
+                      android:textAllCaps="true"
+                      android:background="@color/incall_secondary_info_background"
+                      android:singleLine="true"
+                      android:ellipsize="end"/>
+        </LinearLayout>
 
     </LinearLayout>
 
diff --git a/InCallUI/res/values/styles.xml b/InCallUI/res/values/styles.xml
index 415db361d..457065320 100644
--- a/InCallUI/res/values/styles.xml
+++ b/InCallUI/res/values/styles.xml
@@ -152,7 +152,7 @@
     <style name="PrimaryCallInfoPrimaryCallBanner">
         <item name="android:layout_alignParentTop">true</item>
     </style>
-    <style name="PrimaryCallInfoSecondaryInfoContainer">
+    <style name="PrimaryCallInfoSupplementaryInfoContainer">
         <item name="android:layout_below">@id/primary_call_banner</item>
     </style>
 
diff --git a/InCallUI/src/com/android/incallui/CallCardFragment.java b/InCallUI/src/com/android/incallui/CallCardFragment.java
index 65a75d78a..da87f9954 100644
--- a/InCallUI/src/com/android/incallui/CallCardFragment.java
+++ b/InCallUI/src/com/android/incallui/CallCardFragment.java
@@ -46,6 +46,9 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
     private TextView mCallStateLabel;
     private ImageView mPhoto;
     private TextView mElapsedTime;
+    private View mProviderInfo;
+    private TextView mProviderLabel;
+    private TextView mProviderNumber;
 
     // Secondary caller info
     private ViewStub mSecondaryCallInfo;
@@ -69,7 +72,7 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        getPresenter().init(ServiceFactory.newPhoneNumberService(getActivity()));
+        getPresenter().init(getActivity(), ServiceFactory.newPhoneNumberService(getActivity()));
     }
 
     @Override
@@ -93,6 +96,9 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
         mPhoto = (ImageView) view.findViewById(R.id.photo);
         mCallStateLabel = (TextView) view.findViewById(R.id.callStateLabel);
         mElapsedTime = (TextView) view.findViewById(R.id.elapsedTime);
+        mProviderInfo = view.findViewById(R.id.providerInfo);
+        mProviderLabel = (TextView) view.findViewById(R.id.providerLabel);
+        mProviderNumber = (TextView) view.findViewById(R.id.providerAddress);
     }
 
     @Override
@@ -122,7 +128,8 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
 
     @Override
     public void setPrimary(String number, String name, boolean nameIsNumber, String label,
-            Drawable photo, boolean isConference) {
+            Drawable photo, boolean isConference, String gatewayLabel, String gatewayNumber) {
+        Log.d(this, "Setting primary call [" + gatewayLabel + "][" + gatewayNumber + "]");
 
         if (isConference) {
             name = getView().getResources().getString(R.string.card_title_conf_call);
@@ -139,6 +146,15 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
             mPhoneNumber.setTextDirection(View.TEXT_DIRECTION_LTR);
         }
 
+        // Set any gateway information
+        if (!TextUtils.isEmpty(gatewayLabel) && !TextUtils.isEmpty(gatewayNumber)) {
+            mProviderLabel.setText(gatewayLabel);
+            mProviderNumber.setText(gatewayNumber);
+            mProviderInfo.setVisibility(View.VISIBLE);
+        } else {
+            mProviderInfo.setVisibility(View.GONE);
+        }
+
         // Set direction of the name field
 
         // set the name field.
diff --git a/InCallUI/src/com/android/incallui/CallCardPresenter.java b/InCallUI/src/com/android/incallui/CallCardPresenter.java
index 5ab2529ff..f233d78ea 100644
--- a/InCallUI/src/com/android/incallui/CallCardPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallCardPresenter.java
@@ -16,6 +16,9 @@
 
 package com.android.incallui;
 
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
 import android.graphics.drawable.Drawable;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
@@ -54,9 +57,9 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
     private ContactCacheEntry mPrimaryContactInfo;
     private ContactCacheEntry mSecondaryContactInfo;
     private CallTimer mCallTimer;
+    private Context mContext;
 
     public CallCardPresenter() {
-
         // create the call timer
         mCallTimer = new CallTimer(new Runnable() {
             @Override
@@ -66,7 +69,8 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
         });
     }
 
-    public void init(PhoneNumberService phoneNumberService) {
+    public void init(Context context, PhoneNumberService phoneNumberService) {
+        mContext = context;
         mPhoneNumberService = phoneNumberService;
     }
 
@@ -266,11 +270,14 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
             final String name = getNameForCall(mPrimaryContactInfo);
             final String number = getNumberForCall(mPrimaryContactInfo);
             final boolean nameIsNumber = name != null && name.equals(mPrimaryContactInfo.number);
+            final String gatewayLabel = getGatewayLabel();
+            final String gatewayNumber = getGatewayNumber();
             ui.setPrimary(number, name, nameIsNumber, mPrimaryContactInfo.label,
-                    mPrimaryContactInfo.photo, mPrimary.isConferenceCall());
+                    mPrimaryContactInfo.photo, mPrimary.isConferenceCall(), gatewayLabel,
+                    gatewayNumber);
         } else {
             // reset to nothing (like at end of call)
-            ui.setPrimary(null, null, false, null, null, false);
+            ui.setPrimary(null, null, false, null, null, false, null, null);
         }
 
     }
@@ -300,6 +307,41 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
         }
     }
 
+    /**
+     * Returns the gateway number for any existing outgoing call.
+     */
+    private String getGatewayNumber() {
+        if (hasOutgoingGatewayCall()) {
+            return mPrimary.getGatewayNumber();
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns the label for the gateway app for any existing outgoing call.
+     */
+    private String getGatewayLabel() {
+        if (hasOutgoingGatewayCall() && getUi() != null) {
+            final PackageManager pm = mContext.getPackageManager();
+            try {
+                final ApplicationInfo info = pm.getApplicationInfo(mPrimary.getGatewayPackage(), 0);
+                return mContext.getString(R.string.calling_via_template,
+                        pm.getApplicationLabel(info).toString());
+            } catch (PackageManager.NameNotFoundException e) {
+            }
+        }
+        return null;
+    }
+
+    private boolean hasOutgoingGatewayCall() {
+        // We only display the gateway information while DIALING so return false for any othe
+        // call state.
+        return (mPrimary.getState() == Call.State.DIALING &&
+                !TextUtils.isEmpty(mPrimary.getGatewayNumber()) &&
+                !TextUtils.isEmpty(mPrimary.getGatewayPackage()));
+    }
+
     private void fetchImage(final String url) {
         if (url != null) {
             new AsyncTask<Void, Void, Bitmap>() {
@@ -374,7 +416,7 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
     public interface CallCardUi extends Ui {
         void setVisible(boolean on);
         void setPrimary(String number, String name, boolean nameIsNumber, String label,
-                Drawable photo, boolean isConference);
+                Drawable photo, boolean isConference, String gatewayLabel, String gatewayNumber);
         void setSecondary(boolean show, String name, String label, Drawable photo);
         void setCallState(int state, Call.DisconnectCause cause, boolean bluetoothOn);
         void setPrimaryCallElapsedTime(boolean show, String duration);
-- 
cgit v1.2.3


From 73d59963f7dc6b22270c47dacc7e00315cdd4ffb Mon Sep 17 00:00:00 2001
From: Chiao Cheng <chiaocheng@google.com>
Date: Wed, 21 Aug 2013 14:51:04 -0700
Subject: Removing explicit dependency on http calls.

Bug: 10413514
Change-Id: Id4db77f4417827ce4ecc140ea09f3228154f50de
---
 .../src/com/android/incallui/CallCardFragment.java |   4 +-
 .../com/android/incallui/CallCardPresenter.java    |  12 +--
 InCallUI/src/com/android/incallui/Log.java         |   2 +-
 .../incallui/service/PhoneNumberService.java       |   4 +
 .../src/com/android/incallui/util/HttpFetcher.java | 111 ---------------------
 5 files changed, 9 insertions(+), 124 deletions(-)
 delete mode 100644 InCallUI/src/com/android/incallui/util/HttpFetcher.java

diff --git a/InCallUI/src/com/android/incallui/CallCardFragment.java b/InCallUI/src/com/android/incallui/CallCardFragment.java
index da87f9954..b77dc4cde 100644
--- a/InCallUI/src/com/android/incallui/CallCardFragment.java
+++ b/InCallUI/src/com/android/incallui/CallCardFragment.java
@@ -123,7 +123,9 @@ public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPr
 
     @Override
     public void setImage(Bitmap image) {
-        setDrawableToImageView(mPhoto, new BitmapDrawable(getResources(), image));
+        if (image != null) {
+            setDrawableToImageView(mPhoto, new BitmapDrawable(getResources(), image));
+        }
     }
 
     @Override
diff --git a/InCallUI/src/com/android/incallui/CallCardPresenter.java b/InCallUI/src/com/android/incallui/CallCardPresenter.java
index f233d78ea..cc2e3bf54 100644
--- a/InCallUI/src/com/android/incallui/CallCardPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallCardPresenter.java
@@ -21,7 +21,6 @@ import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.graphics.drawable.Drawable;
 import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
 import android.os.AsyncTask;
 import android.text.TextUtils;
 import android.text.format.DateUtils;
@@ -32,12 +31,9 @@ import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
 import com.android.incallui.InCallPresenter.InCallState;
 import com.android.incallui.InCallPresenter.InCallStateListener;
 import com.android.incallui.service.PhoneNumberService;
-import com.android.incallui.util.HttpFetcher;
 import com.android.services.telephony.common.AudioMode;
 import com.android.services.telephony.common.Call;
 
-import java.io.IOException;
-
 /**
  * Presenter for the Call Card Fragment.
  * <p>
@@ -349,13 +345,7 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
                 @Override
                 protected Bitmap doInBackground(Void... params) {
                     // Fetch the image
-                    try {
-                        final byte[] image = HttpFetcher.getRequestAsByteArray(url);
-                        return BitmapFactory.decodeByteArray(image, 0, image.length);
-                    } catch (IOException e) {
-                        Log.e(TAG, "Unable to download/decode photo.", e);
-                    }
-                    return null;
+                    return mPhoneNumberService.fetchImage(url);
                 }
 
                 @Override
diff --git a/InCallUI/src/com/android/incallui/Log.java b/InCallUI/src/com/android/incallui/Log.java
index 029baceeb..bc57ed7d7 100644
--- a/InCallUI/src/com/android/incallui/Log.java
+++ b/InCallUI/src/com/android/incallui/Log.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2006 The Android Open Source Project
+ * 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.
diff --git a/InCallUI/src/com/android/incallui/service/PhoneNumberService.java b/InCallUI/src/com/android/incallui/service/PhoneNumberService.java
index 1e0cb950a..456638809 100644
--- a/InCallUI/src/com/android/incallui/service/PhoneNumberService.java
+++ b/InCallUI/src/com/android/incallui/service/PhoneNumberService.java
@@ -16,12 +16,16 @@
 
 package com.android.incallui.service;
 
+import android.graphics.Bitmap;
+
 /**
  *
  */
 public interface PhoneNumberService {
     public void getPhoneNumberInfo(String phoneNumber, PhoneNumberServiceListener listener);
 
+    public Bitmap fetchImage(String url);
+
     public interface PhoneNumberServiceListener {
 
         /**
diff --git a/InCallUI/src/com/android/incallui/util/HttpFetcher.java b/InCallUI/src/com/android/incallui/util/HttpFetcher.java
deleted file mode 100644
index 6548a5a05..000000000
--- a/InCallUI/src/com/android/incallui/util/HttpFetcher.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * 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.incallui.util;
-
-import android.os.SystemClock;
-
-import com.android.incallui.Log;
-import com.google.common.io.Closeables;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-
-/**
- * Utility for making http requests.
- */
-public class HttpFetcher {
-
-    private static final String TAG = HttpFetcher.class.getSimpleName();
-
-    /**
-     * Send a http request to the given url.
-     *
-     * @param urlString The url to request.
-     * @return The response body as a byte array.  Or {@literal null} if status code is not 2xx.
-     * @throws java.io.IOException when an error occurs.
-     */
-    public static byte[] getRequestAsByteArray(String urlString) throws IOException {
-        Log.d(TAG, "fetching " + urlString);
-        HttpURLConnection conn = null;
-        InputStream is = null;
-        boolean isError = false;
-        final long start = SystemClock.uptimeMillis();
-        try {
-            final URL url = new URL(urlString);
-            conn = (HttpURLConnection) url.openConnection();
-            Log.d(TAG, "response code: " + conn.getResponseCode());
-            // All 2xx codes are successful.
-            if (conn.getResponseCode() / 100 == 2) {
-                is = conn.getInputStream();
-            } else {
-                is = conn.getErrorStream();
-                isError = true;
-            }
-
-            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            final byte[] buffer = new byte[1024];
-            int bytesRead;
-
-            while ((bytesRead = is.read(buffer)) != -1) {
-                baos.write(buffer, 0, bytesRead);
-            }
-
-            if (isError) {
-                handleBadResponse(urlString, baos.toByteArray());
-                return null;
-            }
-
-            final byte[] response = baos.toByteArray();
-            Log.d(TAG, "received " + response.length + " bytes");
-            final long end = SystemClock.uptimeMillis();
-            Log.d(TAG, "fetch took " + (end - start) + " ms");
-            return response;
-        } finally {
-            Closeables.closeQuietly(is);
-            if (conn != null) {
-                conn.disconnect();
-            }
-        }
-    }
-
-    /**
-     * Send a http request to the given url.
-     *
-     * @param urlString The url to request.
-     * @return The response body as a String. Or {@literal null} if status code is not 2xx.
-     * @throws java.io.IOException when an error occurs.
-     */
-    public static String getRequestAsString(String urlString) throws IOException {
-        final byte[] byteArr = getRequestAsByteArray(urlString);
-        if (byteArr == null) {
-            // Encountered error response... just return.
-            return null;
-        }
-        final String response = new String(byteArr);
-        Log.d(TAG, "response body: ");
-        Log.d(TAG, response);
-        return response;
-    }
-
-    private static void handleBadResponse(String url, byte[] response) {
-        Log.w(TAG, "Got bad response code from url: " + url);
-        Log.w(TAG, new String(response));
-    }
-}
-- 
cgit v1.2.3


From 56d8d59aed288616de2a56374e43e2c5a963b18d Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Thu, 29 Aug 2013 12:08:19 -0700
Subject: Move initializeInCall to onStart().

UI for presenters are not ready until after onViewCreated().
However, initializeInCall gets calls before that as as part of the
activity's onCreate.  Move this initialization to onStart so that the
initialize process happens only after all the UI is ready.

bug: 10544690
Change-Id: I6f0db720ff8a5436f560850af7fb1c1fd7795ae5
---
 InCallUI/src/com/android/incallui/InCallActivity.java | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/InCallActivity.java b/InCallUI/src/com/android/incallui/InCallActivity.java
index 5915ecfb4..fee4d9510 100644
--- a/InCallUI/src/com/android/incallui/InCallActivity.java
+++ b/InCallUI/src/com/android/incallui/InCallActivity.java
@@ -57,11 +57,16 @@ public class InCallActivity extends Activity {
         // Inflate everything in incall_screen.xml and add it to the screen.
         setContentView(R.layout.incall_screen);
 
-        initializeInCall();
-
         Log.d(this, "onCreate(): exit");
     }
 
+    @Override
+    protected void onStart() {
+        super.onStart();
+
+        initializeInCall();
+    }
+
     @Override
     protected void onResume() {
         Log.d(this, "onResume()...");
@@ -282,10 +287,10 @@ public class InCallActivity extends Activity {
             mDialpadFragment.getView().setVisibility(View.INVISIBLE);
         }
 
-        setUpPresenters();
+        setUpPresenterCallbacks();
     }
 
-    private void setUpPresenters() {
+    private void setUpPresenterCallbacks() {
         InCallPresenter mainPresenter = InCallPresenter.getInstance();
 
         mCallButtonFragment.getPresenter().setAudioModeProvider(
-- 
cgit v1.2.3


From b6e4da726bbdb538708ec1f4af5e6cad34e7458b Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Thu, 29 Aug 2013 15:04:23 -0700
Subject: Show glowpad for call waiting calls

Two things were happening:
1. AnswerPresenter stopped listening to call event after the first
incoming call
2. It was not checking for CALL_WAITING && INCOMING as valid incoming
call states.

fix both.

bug: 10538445
Change-Id: I491f2381c33c431f0cbfcc0000f50efdc107cce9
---
 InCallUI/src/com/android/incallui/AnswerPresenter.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/AnswerPresenter.java b/InCallUI/src/com/android/incallui/AnswerPresenter.java
index 1c970d7db..76a7b563e 100644
--- a/InCallUI/src/com/android/incallui/AnswerPresenter.java
+++ b/InCallUI/src/com/android/incallui/AnswerPresenter.java
@@ -39,13 +39,10 @@ public class AnswerPresenter extends Presenter<AnswerPresenter.AnswerUi>
         // TODO: change so that answer presenter never starts up if it's not incoming.
         if (call != null) {
             processIncomingCall(call);
-
-            // Listen for call updates for the current call.
-            calls.addCallUpdateListener(mCallId, this);
-
-            // Listen for incoming calls.
-            calls.addListener(this);
         }
+
+        // Listen for incoming calls.
+        calls.addListener(this);
     }
 
     @Override
@@ -67,6 +64,10 @@ public class AnswerPresenter extends Presenter<AnswerPresenter.AnswerUi>
 
     private void processIncomingCall(Call call) {
         mCallId = call.getCallId();
+
+        // Listen for call updates for the current call.
+        CallList.getInstance().addCallUpdateListener(mCallId, this);
+
         Log.d(TAG, "Showing incoming for call id: " + mCallId);
         final ArrayList<String> textMsgs = CallList.getInstance().getTextResponses(
                 call.getCallId());
@@ -84,10 +85,9 @@ public class AnswerPresenter extends Presenter<AnswerPresenter.AnswerUi>
     @Override
     public void onCallStateChanged(Call call) {
         Log.d(TAG, "onCallStateChange() " + call);
-        if (call.getState() != Call.State.INCOMING) {
+        if (call.getState() != Call.State.INCOMING && call.getState() != Call.State.CALL_WAITING) {
             // Stop listening for updates.
             CallList.getInstance().removeCallUpdateListener(mCallId, this);
-            CallList.getInstance().removeListener(this);
 
             getUi().showAnswerUi(false);
             mCallId = Call.INVALID_CALL_ID;
-- 
cgit v1.2.3


From a8e04e6fcda4b6a153bb8ab39ecbb820587445ad Mon Sep 17 00:00:00 2001
From: Chiao Cheng <chiaocheng@google.com>
Date: Thu, 29 Aug 2013 13:55:27 -0700
Subject: Fix null precondition check.

Precondition was making sure call was not null.  But the call could be null in
cases where the call disconnected before the UI comes up.  In this case, we can
simply skip processing.

Bug: 10538437
Change-Id: Ia4ff093f38cdc32bdaf6325d9dc770b302d0060b
---
 .../src/com/android/incallui/CallCardPresenter.java | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallCardPresenter.java b/InCallUI/src/com/android/incallui/CallCardPresenter.java
index 3e1a2ef93..c1820f5ad 100644
--- a/InCallUI/src/com/android/incallui/CallCardPresenter.java
+++ b/InCallUI/src/com/android/incallui/CallCardPresenter.java
@@ -70,18 +70,23 @@ public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
     public void init(Context context, PhoneNumberService phoneNumberService, Call call) {
         mContext = Preconditions.checkNotNull(context);
         mPhoneNumberService = Preconditions.checkNotNull(phoneNumberService);
-        Preconditions.checkNotNull(call);
         mContext = context;
         mPhoneNumberService = phoneNumberService;
-        final CallIdentification identification = call.getIdentification();
 
-        // TODO(klp): Logic to determine which ui field get what data resides in contactInfoCache.
-        // It needs to be moved so it can be re-used.
-        mPrimaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(mContext, identification,
-                call.getState() == Call.State.INCOMING);
+        // Call may be null if disconnect happened already.
+        if (call != null) {
+            final CallIdentification identification = call.getIdentification();
 
-        // start processing lookups right away.
-        startContactInfoSearch(identification, true, false, call.getState() == Call.State.INCOMING);
+            // TODO(klp): Logic to determine which ui field get what data resides in
+            // contactInfoCache.
+            // It needs to be moved so it can be re-used.
+            mPrimaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(mContext, identification,
+                    call.getState() == Call.State.INCOMING);
+
+            // start processing lookups right away.
+            startContactInfoSearch(identification, true, false,
+                    call.getState() == Call.State.INCOMING);
+        }
     }
 
     @Override
-- 
cgit v1.2.3


From 3018c75fa3a37bc4c4babbf68688c82265f4f702 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Tue, 10 Sep 2013 19:56:05 -0700
Subject: Make creations and destruction of InCallUI system queued.

We queue creating and destroying of the world into the message handler
so that it happens in order with the other actions that are queued into the
message handler.

bug: 10682538
Change-Id: I28a21d97861468528186e823ba9021446e9b08c3
---
 .../com/android/incallui/CallHandlerService.java   | 106 +++++++++++++--------
 InCallUI/src/com/android/incallui/Log.java         |   2 +-
 2 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallHandlerService.java b/InCallUI/src/com/android/incallui/CallHandlerService.java
index dccdcdf32..65665494f 100644
--- a/InCallUI/src/com/android/incallui/CallHandlerService.java
+++ b/InCallUI/src/com/android/incallui/CallHandlerService.java
@@ -46,54 +46,51 @@ public class CallHandlerService extends Service {
     private static final int ON_DISCONNECT_CALL = 6;
     private static final int ON_BRING_TO_FOREGROUND = 7;
     private static final int ON_POST_CHAR_WAIT = 8;
+    private static final int ON_CREATE = 9;
+    private static final int ON_DESTROY = 10;
 
-    private static final int LARGEST_MSG_ID = ON_POST_CHAR_WAIT;
+    private static final int LARGEST_MSG_ID = ON_DESTROY;
 
 
     private CallList mCallList;
     private Handler mMainHandler;
+    private Object mHandlerInitLock = new Object();
     private InCallPresenter mInCallPresenter;
     private AudioModeProvider mAudioModeProvider;
 
     @Override
     public void onCreate() {
-        Log.i(this, "creating");
+        Log.i(this, "onCreate");
         super.onCreate();
 
-        mMainHandler = new MainHandler();
-        mCallList = CallList.getInstance();
-        mAudioModeProvider = AudioModeProvider.getInstance();
-        mInCallPresenter = InCallPresenter.getInstance();
+        synchronized(mHandlerInitLock) {
+            if (mMainHandler == null) {
+                mMainHandler = new MainHandler();
+            }
+        }
 
-        mInCallPresenter.setUp(getApplicationContext(), mCallList, mAudioModeProvider);
-        Log.d(this, "onCreate finished");
+        // Creation (and destruction) are sent to the message handler.  The reason for this is that
+        // at any time the service could potentially unbind for both legitimate reasons as well as
+        // app crashes and it's better to queue up create/destroy because:
+        // (1) Previous actions like onUpdate/onDisconnect could be queued up and we dont want to
+        //     destroy the system from a different thread in the middle of executing those actions.
+        // (2) If we queue up destruction we must also queue up creation or else we risk having a
+        //     second "create" happen before the first "destroy".
+        //     (e.g., create1, queue destroy1, create2, do destroy1)
+        mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_CREATE));
+
+        // TODO: consider optimization of checking to see if any ON_DESTROY messages exist
+        // in the queue and in those cases simply remove the pending message.
     }
 
     @Override
     public void onDestroy() {
-        Log.i(this, "destroying");
-
-        // Remove all pending messages before nulling out handler
-        for (int i = 1; i <= LARGEST_MSG_ID; i++) {
-            mMainHandler.removeMessages(i);
-        }
-        mMainHandler = null;
-
-        // The service gets disconnected under two circumstances:
-        // 1. When there are no more calls
-        // 2. When the phone app crashes.
-        // If (2) happens, we can't leave the UI thinking that there are still
-        // live calls.  So we will tell the callList to clear as a final request.
-        mCallList.clearOnDisconnect();
-        mCallList = null;
-
-        mInCallPresenter.tearDown();
-        mInCallPresenter = null;
-        mAudioModeProvider = null;
+        Log.i(this, "onDestroy");
 
-        Log.d(this, "onDestroy finished");
+        mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_DESTROY));
     }
 
+
     @Override
     public IBinder onBind(Intent intent) {
         Log.i(this, "onBind");
@@ -124,7 +121,6 @@ public class CallHandlerService extends Service {
         @Override
         public void onDisconnect(Call call) {
             try {
-                Log.i(CallHandlerService.this, "onDisconnected: " + call);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_DISCONNECT_CALL, call));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onDisconnect() call.", e);
@@ -134,12 +130,8 @@ public class CallHandlerService extends Service {
         @Override
         public void onIncoming(Call call, List<String> textResponses) {
             try {
-                Log.i(CallHandlerService.this, "onIncomingCall: " + call);
-
-                // TODO(klp): Add text responses to the call object.
                 Map.Entry<Call, List<String>> incomingCall
                         = new AbstractMap.SimpleEntry<Call, List<String>>(call, textResponses);
-                Log.d("TEST", mMainHandler.toString());
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(
                         ON_UPDATE_CALL_WITH_TEXT_RESPONSES, incomingCall));
             } catch (Exception e) {
@@ -150,9 +142,6 @@ public class CallHandlerService extends Service {
         @Override
         public void onUpdate(List<Call> calls) {
             try {
-                Log.i(CallHandlerService.this, "onUpdate " + calls.toString());
-
-                // TODO(klp): Add use of fullUpdate to message
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_UPDATE_MULTI_CALL, calls));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onUpdate() call.", e);
@@ -162,7 +151,6 @@ public class CallHandlerService extends Service {
         @Override
         public void onAudioModeChange(int mode, boolean muted) {
             try {
-                Log.i(CallHandlerService.this, "onAudioModeChange : " + AudioMode.toString(mode));
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_AUDIO_MODE, mode,
                             muted ? 1 : 0, null));
             } catch (Exception e) {
@@ -173,9 +161,6 @@ public class CallHandlerService extends Service {
         @Override
         public void onSupportedAudioModeChange(int modeMask) {
             try {
-                Log.i(CallHandlerService.this, "onSupportedAudioModeChange : " + AudioMode.toString(
-                        modeMask));
-
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_SUPPORTED_AUDIO_MODE,
                         modeMask, 0, null));
             } catch (Exception e) {
@@ -195,6 +180,32 @@ public class CallHandlerService extends Service {
         }
     };
 
+    private void doCreate() {
+        Log.i(this, "doCreate");
+
+        mCallList = CallList.getInstance();
+        mAudioModeProvider = AudioModeProvider.getInstance();
+        mInCallPresenter = InCallPresenter.getInstance();
+
+        mInCallPresenter.setUp(getApplicationContext(), mCallList, mAudioModeProvider);
+    }
+
+    public void doDestroy() {
+        Log.i(this, "doDestroy");
+
+        // The service gets disconnected under two circumstances:
+        // 1. When there are no more calls
+        // 2. When the phone app crashes.
+        // If (2) happens, we can't leave the UI thinking that there are still
+        // live calls.  So we will tell the callList to clear as a final request.
+        mCallList.clearOnDisconnect();
+        mCallList = null;
+
+        mInCallPresenter.tearDown();
+        mInCallPresenter = null;
+        mAudioModeProvider = null;
+    }
+
     /**
      * Handles messages from the service so that they get executed on the main thread, where they
      * can interact with UI.
@@ -221,26 +232,35 @@ public class CallHandlerService extends Service {
 
         switch (msg.what) {
             case ON_UPDATE_CALL:
+                Log.i(CallHandlerService.this, "onUpdate: " + msg.obj);
                 mCallList.onUpdate((Call) msg.obj);
                 break;
             case ON_UPDATE_MULTI_CALL:
+                Log.i(CallHandlerService.this, "onUpdateMulti: " + msg.obj);
                 mCallList.onUpdate((List<Call>) msg.obj);
                 break;
             case ON_UPDATE_CALL_WITH_TEXT_RESPONSES:
                 AbstractMap.SimpleEntry<Call, List<String>> entry
                         = (AbstractMap.SimpleEntry<Call, List<String>>) msg.obj;
+                Log.i(CallHandlerService.this, "onIncomingCall: " + entry.getKey());
                 mCallList.onIncoming(entry.getKey(), entry.getValue());
                 break;
             case ON_DISCONNECT_CALL:
+                Log.i(CallHandlerService.this, "onDisconnected: " + msg.obj);
                 mCallList.onDisconnect((Call) msg.obj);
                 break;
             case ON_POST_CHAR_WAIT:
                 mInCallPresenter.onPostDialCharWait(msg.arg1, (String) msg.obj);
                 break;
             case ON_AUDIO_MODE:
+                Log.i(CallHandlerService.this, "onAudioModeChange : " +
+                        AudioMode.toString(msg.arg1) + ", muted (" + (msg.arg2 == 1) + ")");
                 mAudioModeProvider.onAudioModeChange(msg.arg1, msg.arg2 == 1);
                 break;
             case ON_SUPPORTED_AUDIO_MODE:
+                Log.i(CallHandlerService.this, "onSupportedAudioModeChange : " + AudioMode.toString(
+                        msg.arg1));
+
                 mAudioModeProvider.onSupportedAudioModeChange(msg.arg1);
                 break;
             case ON_BRING_TO_FOREGROUND:
@@ -248,6 +268,12 @@ public class CallHandlerService extends Service {
                     mInCallPresenter.bringToForeground();
                 }
                 break;
+            case ON_CREATE:
+                doCreate();
+                break;
+            case ON_DESTROY:
+                doDestroy();
+                break;
             default:
                 break;
         }
diff --git a/InCallUI/src/com/android/incallui/Log.java b/InCallUI/src/com/android/incallui/Log.java
index bc57ed7d7..3099ea56b 100644
--- a/InCallUI/src/com/android/incallui/Log.java
+++ b/InCallUI/src/com/android/incallui/Log.java
@@ -30,7 +30,7 @@ public class Log {
 
     public static void d(String tag, String msg) {
         if (DEBUG) {
-            android.util.Log.d(TAG, tag + msg);
+            android.util.Log.d(TAG, tag + " - " + msg);
         }
     }
 
-- 
cgit v1.2.3


From 65e84d8e872c7697ebd5aade76a3b7a490a7b3e9 Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Thu, 12 Sep 2013 16:33:05 -0700
Subject: Adding logging to capture MessageHandler ordering.

Seeing issues in the wild (not easily reproduced) with ordering
of messages on the handler.  Need logging to better debug.

bug: 10682538
Change-Id: Ifb200e51cc256a8eef62c1fad65daf30532398f1
---
 .../src/com/android/incallui/CallHandlerService.java | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallHandlerService.java b/InCallUI/src/com/android/incallui/CallHandlerService.java
index 65665494f..82702db82 100644
--- a/InCallUI/src/com/android/incallui/CallHandlerService.java
+++ b/InCallUI/src/com/android/incallui/CallHandlerService.java
@@ -121,6 +121,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onDisconnect(Call call) {
             try {
+                Log.i(CallHandlerService.this, "onDisconnected: " + call);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_DISCONNECT_CALL, call));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onDisconnect() call.", e);
@@ -130,6 +131,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onIncoming(Call call, List<String> textResponses) {
             try {
+                Log.i(CallHandlerService.this, "onIncomingCall: " + call);
                 Map.Entry<Call, List<String>> incomingCall
                         = new AbstractMap.SimpleEntry<Call, List<String>>(call, textResponses);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(
@@ -142,6 +144,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onUpdate(List<Call> calls) {
             try {
+                Log.i(CallHandlerService.this, "onUpdate: " + calls);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_UPDATE_MULTI_CALL, calls));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onUpdate() call.", e);
@@ -151,6 +154,8 @@ public class CallHandlerService extends Service {
         @Override
         public void onAudioModeChange(int mode, boolean muted) {
             try {
+                Log.i(CallHandlerService.this, "onAudioModeChange : " +
+                        AudioMode.toString(mode));
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_AUDIO_MODE, mode,
                             muted ? 1 : 0, null));
             } catch (Exception e) {
@@ -161,6 +166,8 @@ public class CallHandlerService extends Service {
         @Override
         public void onSupportedAudioModeChange(int modeMask) {
             try {
+                Log.i(CallHandlerService.this, "onSupportedAudioModeChange : " +
+                        AudioMode.toString(modeMask));
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_SUPPORTED_AUDIO_MODE,
                         modeMask, 0, null));
             } catch (Exception e) {
@@ -232,38 +239,39 @@ public class CallHandlerService extends Service {
 
         switch (msg.what) {
             case ON_UPDATE_CALL:
-                Log.i(CallHandlerService.this, "onUpdate: " + msg.obj);
+                Log.i(CallHandlerService.this, "ON_UPDATE_CALL: " + msg.obj);
                 mCallList.onUpdate((Call) msg.obj);
                 break;
             case ON_UPDATE_MULTI_CALL:
-                Log.i(CallHandlerService.this, "onUpdateMulti: " + msg.obj);
+                Log.i(CallHandlerService.this, "ON_UPDATE_MULTI_CALL: " + msg.obj);
                 mCallList.onUpdate((List<Call>) msg.obj);
                 break;
             case ON_UPDATE_CALL_WITH_TEXT_RESPONSES:
                 AbstractMap.SimpleEntry<Call, List<String>> entry
                         = (AbstractMap.SimpleEntry<Call, List<String>>) msg.obj;
-                Log.i(CallHandlerService.this, "onIncomingCall: " + entry.getKey());
+                Log.i(CallHandlerService.this, "ON_INCOMING_CALL: " + entry.getKey());
                 mCallList.onIncoming(entry.getKey(), entry.getValue());
                 break;
             case ON_DISCONNECT_CALL:
-                Log.i(CallHandlerService.this, "onDisconnected: " + msg.obj);
+                Log.i(CallHandlerService.this, "ON_DISCONNECT_CALL: " + msg.obj);
                 mCallList.onDisconnect((Call) msg.obj);
                 break;
             case ON_POST_CHAR_WAIT:
                 mInCallPresenter.onPostDialCharWait(msg.arg1, (String) msg.obj);
                 break;
             case ON_AUDIO_MODE:
-                Log.i(CallHandlerService.this, "onAudioModeChange : " +
+                Log.i(CallHandlerService.this, "ON_AUDIO_MODE: " +
                         AudioMode.toString(msg.arg1) + ", muted (" + (msg.arg2 == 1) + ")");
                 mAudioModeProvider.onAudioModeChange(msg.arg1, msg.arg2 == 1);
                 break;
             case ON_SUPPORTED_AUDIO_MODE:
-                Log.i(CallHandlerService.this, "onSupportedAudioModeChange : " + AudioMode.toString(
+                Log.i(CallHandlerService.this, "ON_SUPPORTED_AUDIO_MODE: " + AudioMode.toString(
                         msg.arg1));
 
                 mAudioModeProvider.onSupportedAudioModeChange(msg.arg1);
                 break;
             case ON_BRING_TO_FOREGROUND:
+                Log.i(CallHandlerService.this, "ON_BRING_TO_FOREGROUND");
                 if (mInCallPresenter != null) {
                     mInCallPresenter.bringToForeground();
                 }
-- 
cgit v1.2.3


From 00588f3918f95d6481c5c19847bad2ff8ef49acc Mon Sep 17 00:00:00 2001
From: Santos Cordon <santoscordon@google.com>
Date: Thu, 12 Sep 2013 23:25:08 -0700
Subject: Calls to binder safe after disconnection of service.

Calls to the binder can happen after onDestroy since the service methods
and the binder methods have no sequence guarantee. This change makes it
safe (no NPEs) for binder callbacks to happen after destruction.

bug:10682538
Change-Id: I1ca4fcee522a92ae9f86b087239077e4a447d3f7
---
 .../com/android/incallui/CallHandlerService.java   | 115 ++++++++++++---------
 InCallUI/src/com/android/incallui/Log.java         |  15 ++-
 .../src/com/android/incallui/ProximitySensor.java  |   2 +-
 3 files changed, 78 insertions(+), 54 deletions(-)

diff --git a/InCallUI/src/com/android/incallui/CallHandlerService.java b/InCallUI/src/com/android/incallui/CallHandlerService.java
index 82702db82..d50635d99 100644
--- a/InCallUI/src/com/android/incallui/CallHandlerService.java
+++ b/InCallUI/src/com/android/incallui/CallHandlerService.java
@@ -46,7 +46,7 @@ public class CallHandlerService extends Service {
     private static final int ON_DISCONNECT_CALL = 6;
     private static final int ON_BRING_TO_FOREGROUND = 7;
     private static final int ON_POST_CHAR_WAIT = 8;
-    private static final int ON_CREATE = 9;
+    private static final int ON_START = 9;
     private static final int ON_DESTROY = 10;
 
     private static final int LARGEST_MSG_ID = ON_DESTROY;
@@ -57,10 +57,11 @@ public class CallHandlerService extends Service {
     private Object mHandlerInitLock = new Object();
     private InCallPresenter mInCallPresenter;
     private AudioModeProvider mAudioModeProvider;
+    private boolean mServiceStarted = false;
 
     @Override
     public void onCreate() {
-        Log.i(this, "onCreate");
+        Log.i(TAG, "onCreate");
         super.onCreate();
 
         synchronized(mHandlerInitLock) {
@@ -69,50 +70,47 @@ public class CallHandlerService extends Service {
             }
         }
 
-        // Creation (and destruction) are sent to the message handler.  The reason for this is that
-        // at any time the service could potentially unbind for both legitimate reasons as well as
-        // app crashes and it's better to queue up create/destroy because:
-        // (1) Previous actions like onUpdate/onDisconnect could be queued up and we dont want to
-        //     destroy the system from a different thread in the middle of executing those actions.
-        // (2) If we queue up destruction we must also queue up creation or else we risk having a
-        //     second "create" happen before the first "destroy".
-        //     (e.g., create1, queue destroy1, create2, do destroy1)
-        mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_CREATE));
-
-        // TODO: consider optimization of checking to see if any ON_DESTROY messages exist
-        // in the queue and in those cases simply remove the pending message.
     }
 
     @Override
     public void onDestroy() {
-        Log.i(this, "onDestroy");
-
+        Log.i(TAG, "onDestroy");
+
+        // onDestroy will get called when:
+        // 1) there are no more calls
+        // 2) the client (TeleService) crashes.
+        //
+        // Because onDestroy is not sequenced with calls to CallHandlerService binder,
+        // we cannot know which is happening.
+        // Thats okay since in both cases we want to end all calls and let the UI know it can tear
+        // itself down when it's ready. Start the destruction sequence.
         mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_DESTROY));
     }
 
 
     @Override
     public IBinder onBind(Intent intent) {
-        Log.i(this, "onBind");
+        Log.i(TAG, "onBind");
         return mBinder;
     }
 
     @Override
     public boolean onUnbind(Intent intent) {
-        Log.i(this, "onUnbind");
+        Log.i(TAG, "onUnbind");
 
         // Returning true here means we get called on rebind, which is a feature we do not need.
-        // Return false so that all reconections happen with a call to onBind().
+        // Return false so that all reconnections happen with a call to onBind().
         return false;
     }
 
     private final ICallHandlerService.Stub mBinder = new ICallHandlerService.Stub() {
 
         @Override
-        public void setCallCommandService(ICallCommandService service) {
+        public void startCallService(ICallCommandService service) {
             try {
-                Log.d(CallHandlerService.this, "onConnected: " + service.toString());
-                CallCommandClient.getInstance().setService(service);
+                Log.d(TAG, "startCallService: " + service.toString());
+
+                mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_START, service));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing setCallCommandservice() call", e);
             }
@@ -121,7 +119,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onDisconnect(Call call) {
             try {
-                Log.i(CallHandlerService.this, "onDisconnected: " + call);
+                Log.i(TAG, "onDisconnected: " + call);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_DISCONNECT_CALL, call));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onDisconnect() call.", e);
@@ -131,7 +129,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onIncoming(Call call, List<String> textResponses) {
             try {
-                Log.i(CallHandlerService.this, "onIncomingCall: " + call);
+                Log.i(TAG, "onIncomingCall: " + call);
                 Map.Entry<Call, List<String>> incomingCall
                         = new AbstractMap.SimpleEntry<Call, List<String>>(call, textResponses);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(
@@ -144,7 +142,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onUpdate(List<Call> calls) {
             try {
-                Log.i(CallHandlerService.this, "onUpdate: " + calls);
+                Log.i(TAG, "onUpdate: " + calls);
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_UPDATE_MULTI_CALL, calls));
             } catch (Exception e) {
                 Log.e(TAG, "Error processing onUpdate() call.", e);
@@ -154,7 +152,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onAudioModeChange(int mode, boolean muted) {
             try {
-                Log.i(CallHandlerService.this, "onAudioModeChange : " +
+                Log.i(TAG, "onAudioModeChange : " +
                         AudioMode.toString(mode));
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_AUDIO_MODE, mode,
                             muted ? 1 : 0, null));
@@ -166,7 +164,7 @@ public class CallHandlerService extends Service {
         @Override
         public void onSupportedAudioModeChange(int modeMask) {
             try {
-                Log.i(CallHandlerService.this, "onSupportedAudioModeChange : " +
+                Log.i(TAG, "onSupportedAudioModeChange : " +
                         AudioMode.toString(modeMask));
                 mMainHandler.sendMessage(mMainHandler.obtainMessage(ON_SUPPORTED_AUDIO_MODE,
                         modeMask, 0, null));
@@ -187,24 +185,39 @@ public class CallHandlerService extends Service {
         }
     };
 
-    private void doCreate() {
-        Log.i(this, "doCreate");
+    private void doStart(ICallCommandService service) {
+        Log.i(TAG, "doStart");
+
+        // always setup the new callcommandservice
+        CallCommandClient.getInstance().setService(service);
+
+        // If we have a new service when one is already started, we can continue
+        // using the service that we already have.
+        if (mServiceStarted) {
+            Log.i(TAG, "Starting a service before another one is completed");
+            doStop();
+        }
 
         mCallList = CallList.getInstance();
         mAudioModeProvider = AudioModeProvider.getInstance();
         mInCallPresenter = InCallPresenter.getInstance();
 
         mInCallPresenter.setUp(getApplicationContext(), mCallList, mAudioModeProvider);
+
+        mServiceStarted = true;
     }
 
-    public void doDestroy() {
-        Log.i(this, "doDestroy");
+    public void doStop() {
+        Log.i(TAG, "doStop");
 
-        // The service gets disconnected under two circumstances:
-        // 1. When there are no more calls
-        // 2. When the phone app crashes.
-        // If (2) happens, we can't leave the UI thinking that there are still
-        // live calls.  So we will tell the callList to clear as a final request.
+        if (!mServiceStarted) {
+            return;
+        }
+
+        mServiceStarted = false;
+
+        // We are disconnected, clear the call list so that UI can start
+        // tearing itself down.
         mCallList.clearOnDisconnect();
         mCallList = null;
 
@@ -232,55 +245,61 @@ public class CallHandlerService extends Service {
         if (msg.what > LARGEST_MSG_ID) {
             // If you got here, you may have added a new message and forgotten to
             // update LARGEST_MSG_ID
-            Log.wtf(this, "Cannot handle message larger than LARGEST_MSG_ID.");
+            Log.wtf(TAG, "Cannot handle message larger than LARGEST_MSG_ID.");
+        }
+
+        // If we are not initialized, ignore all messages except start up
+        if (!mServiceStarted && msg.what != ON_START) {
+            Log.i(TAG, "System not initialized.  Ignoring message: " + msg.what);
+            return;
         }
 
-        Log.d(this, "executeMessage " + msg.what);
+        Log.d(TAG, "executeMessage " + msg.what);
 
         switch (msg.what) {
             case ON_UPDATE_CALL:
-                Log.i(CallHandlerService.this, "ON_UPDATE_CALL: " + msg.obj);
+                Log.i(TAG, "ON_UPDATE_CALL: " + msg.obj);
                 mCallList.onUpdate((Call) msg.obj);
                 break;
             case ON_UPDATE_MULTI_CALL:
-                Log.i(CallHandlerService.this, "ON_UPDATE_MULTI_CALL: " + msg.obj);
+                Log.i(TAG, "ON_UPDATE_MULTI_CALL: " + msg.obj);
                 mCallList.onUpdate((List<Call>) msg.obj);
                 break;
             case ON_UPDATE_CALL_WITH_TEXT_RESPONSES:
                 AbstractMap.SimpleEntry<Call, List<String>> entry
                         = (AbstractMap.SimpleEntry<Call, List<String>>) msg.obj;
-                Log.i(CallHandlerService.this, "ON_INCOMING_CALL: " + entry.getKey());
+                Log.i(TAG, "ON_INCOMING_CALL: " + entry.getKey());
                 mCallList.onIncoming(entry.getKey(), entry.getValue());
                 break;
             case ON_DISCONNECT_CALL:
-                Log.i(CallHandlerService.this, "ON_DISCONNECT_CALL: " + msg.obj);
+                Log.i(TAG, "ON_DISCONNECT_CALL: " + msg.obj);
                 mCallList.onDisconnect((Call) msg.obj);
                 break;
             case ON_POST_CHAR_WAIT:
                 mInCallPresenter.onPostDialCharWait(msg.arg1, (String) msg.obj);
                 break;
             case ON_AUDIO_MODE:
-                Log.i(CallHandlerService.this, "ON_AUDIO_MODE: " +
+                Log.i(TAG, "ON_AUDIO_MODE: " +
                         AudioMode.toString(msg.arg1) + ", muted (" + (msg.arg2 == 1) + ")");
                 mAudioModeProvider.onAudioModeChange(msg.arg1, msg.arg2 == 1);
                 break;
             case ON_SUPPORTED_AUDIO_MODE:
-                Log.i(CallHandlerService.this, "ON_SUPPORTED_AUDIO_MODE: " + AudioMode.toString(
+                Log.i(TAG, "ON_SUPPORTED_AUDIO_MODE: " + AudioMode.toString(
                         msg.arg1));
 
                 mAudioModeProvider.onSupportedAudioModeChange(msg.arg1);
                 break;
             case ON_BRING_TO_FOREGROUND:
-                Log.i(CallHandlerService.this, "ON_BRING_TO_FOREGROUND");
+                Log.i(TAG, "ON_BRING_TO_FOREGROUND");
                 if (mInCallPresenter != null) {
                     mInCallPresenter.bringToForeground();
                 }
                 break;
-            case ON_CREATE:
-                doCreate();
+            case ON_START:
+                doStart((ICallCommandService) msg.obj);
                 break;
             case ON_DESTROY:
-                doDestroy();
+                doStop();
                 break;
             default:
                 break;
diff --git a/InCallUI/src/com/android/incallui/Log.java b/InCallUI/src/com/android/incallui/Log.java
index 3099ea56b..c859e5c6a 100644
--- a/InCallUI/src/com/android/incallui/Log.java
+++ b/InCallUI/src/com/android/incallui/Log.java
@@ -27,10 +27,11 @@ public class Log {
     public static final boolean DEBUG = android.util.Log.isLoggable(TAG, android.util.Log.DEBUG);
     public static final boolean VERBOSE = android.util.Log.isLoggable(TAG,
             android.util.Log.VERBOSE);
+    public static final String TAG_DELIMETER = " - ";
 
     public static void d(String tag, String msg) {
         if (DEBUG) {
-            android.util.Log.d(TAG, tag + " - " + msg);
+            android.util.Log.d(TAG, delimit(tag) + msg);
         }
     }
 
@@ -59,11 +60,11 @@ public class Log {
     }
 
     public static void e(String tag, String msg, Exception e) {
-        android.util.Log.e(TAG, tag + msg, e);
+        android.util.Log.e(TAG, delimit(tag) + msg, e);
     }
 
     public static void e(String tag, String msg) {
-        android.util.Log.e(TAG, tag + msg);
+        android.util.Log.e(TAG, delimit(tag) + msg);
     }
 
     public static void e(Object obj, String msg, Exception e) {
@@ -75,7 +76,7 @@ public class Log {
     }
 
     public static void i(String tag, String msg) {
-        android.util.Log.i(TAG, tag + msg);
+        android.util.Log.i(TAG, delimit(tag) + msg);
     }
 
     public static void i(Object obj, String msg) {
@@ -91,6 +92,10 @@ public class Log {
     }
 
     private static String getPrefix(Object obj) {
-        return (obj == null ? "" : (obj.getClass().getSimpleName() + " - "));
+        return (obj == null ? "" : (obj.getClass().getSimpleName() + TAG_DELIMETER));
+    }
+
+    private static String delimit(String tag) {
+        return tag + TAG_DELIMETER;
     }
 }
diff --git a/InCallUI/src/com/android/incallui/ProximitySensor.java b/InCallUI/src/com/android/incallui/ProximitySensor.java
index c28a69e5e..0dc54dccb 100644
--- a/InCallUI/src/com/android/incallui/ProximitySensor.java
+++ b/InCallUI/src/com/android/incallui/ProximitySensor.java
@@ -210,7 +210,7 @@ public class ProximitySensor implements AccelerometerListener.OrientationListene
                         .add("hor", horizontal ? 1 : 0).toString());
 
                 if (mIsPhoneOffhook && !screenOnImmediately) {
-                    final String logStr = "turning off proximity sensor: ";
+                    final String logStr = "turning on proximity sensor: ";
                     // Phone is in use!  Arrange for the screen to turn off
                     // automatically when the sensor detects a close object.
                     if (!mProximityWakeLock.isHeld()) {
-- 
cgit v1.2.3