Fix problem with AsyncQueryHandler

AsyncQueryHandler uses Looper.myLooper(), which does not work in our
case when invoked from an arbitrary thread. Changed so its ctor is
invoked on the main thread.

And various other similar problems.

Bug: 19941246
Change-Id: I324f09a5161e26593c0d24d5311a371d8971870d
diff --git a/src/com/android/server/telecom/InCallAdapter.java b/src/com/android/server/telecom/InCallAdapter.java
index d84c87e..9239288 100644
--- a/src/com/android/server/telecom/InCallAdapter.java
+++ b/src/com/android/server/telecom/InCallAdapter.java
@@ -16,11 +16,9 @@
 
 package com.android.server.telecom;
 
-import android.os.Handler;
-import android.os.Message;
+import android.os.Binder;
 import android.telecom.PhoneAccountHandle;
 
-import com.android.internal.os.SomeArgs;
 import com.android.internal.telecom.IInCallAdapter;
 
 /**
@@ -34,7 +32,8 @@
     private final TelecomSystem.SyncRoot mLock;
 
     /** Persists the specified parameters. */
-    public InCallAdapter(CallsManager callsManager, CallIdMapper callIdMapper, TelecomSystem.SyncRoot lock) {
+    public InCallAdapter(CallsManager callsManager, CallIdMapper callIdMapper,
+            TelecomSystem.SyncRoot lock) {
         mCallsManager = callsManager;
         mCallIdMapper = callIdMapper;
         mLock = lock;
@@ -42,221 +41,306 @@
 
     @Override
     public void answerCall(String callId, int videoState) {
-        synchronized (mLock) {
-            Log.d(this, "answerCall(%s,%d)", callId, videoState);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.answerCall(call, videoState);
-                } else {
-                    Log.w(this, "answerCall, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.d(this, "answerCall(%s,%d)", callId, videoState);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.answerCall(call, videoState);
+                    } else {
+                        Log.w(this, "answerCall, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void rejectCall(String callId, boolean rejectWithMessage, String textMessage) {
-        synchronized (this) {
-            Log.d(this, "rejectCall(%s,%b,%s)", callId, rejectWithMessage, textMessage);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.rejectCall(call, rejectWithMessage, textMessage);
-                } else {
-                    Log.w(this, "setRingback, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.d(this, "rejectCall(%s,%b,%s)", callId, rejectWithMessage, textMessage);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.rejectCall(call, rejectWithMessage, textMessage);
+                    } else {
+                        Log.w(this, "setRingback, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void playDtmfTone(String callId, char digit) {
-        synchronized (mLock) {
-            Log.d(this, "playDtmfTone(%s,%c)", callId, digit);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.playDtmfTone(call, digit);
-                } else {
-                    Log.w(this, "playDtmfTone, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.d(this, "playDtmfTone(%s,%c)", callId, digit);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.playDtmfTone(call, digit);
+                    } else {
+                        Log.w(this, "playDtmfTone, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void stopDtmfTone(String callId) {
-        synchronized (mLock) {
-            Log.d(this, "stopDtmfTone(%s)", callId);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.stopDtmfTone(call);
-                } else {
-                    Log.w(this, "stopDtmfTone, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.d(this, "stopDtmfTone(%s)", callId);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.stopDtmfTone(call);
+                    } else {
+                        Log.w(this, "stopDtmfTone, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void postDialContinue(String callId, boolean proceed) {
-        synchronized (mLock) {
-            Log.d(this, "postDialContinue(%s)", callId);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.postDialContinue(call, proceed);
-                } else {
-                    Log.w(this, "postDialContinue, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.d(this, "postDialContinue(%s)", callId);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.postDialContinue(call, proceed);
+                    } else {
+                        Log.w(this, "postDialContinue, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void disconnectCall(String callId) {
-        synchronized (mLock) {
-            Log.v(this, "disconnectCall: %s", callId);
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.disconnectCall(call);
-                } else {
-                    Log.w(this, "disconnectCall, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                Log.v(this, "disconnectCall: %s", callId);
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.disconnectCall(call);
+                    } else {
+                        Log.w(this, "disconnectCall, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void holdCall(String callId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.holdCall(call);
-                } else {
-                    Log.w(this, "holdCall, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.holdCall(call);
+                    } else {
+                        Log.w(this, "holdCall, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void unholdCall(String callId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.unholdCall(call);
-                } else {
-                    Log.w(this, "unholdCall, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.unholdCall(call);
+                    } else {
+                        Log.w(this, "unholdCall, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void phoneAccountSelected(String callId, PhoneAccountHandle accountHandle,
             boolean setDefault) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    mCallsManager.phoneAccountSelected(call, accountHandle, setDefault);
-                } else {
-                    Log.w(this, "phoneAccountSelected, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        mCallsManager.phoneAccountSelected(call, accountHandle, setDefault);
+                    } else {
+                        Log.w(this, "phoneAccountSelected, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void mute(boolean shouldMute) {
-        synchronized (mLock) {
-            mCallsManager.mute(shouldMute);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                mCallsManager.mute(shouldMute);
+            }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void setAudioRoute(int route) {
-        synchronized (mLock) {
-            mCallsManager.setAudioRoute(route);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                mCallsManager.setAudioRoute(route);
+            }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void conference(String callId, String otherCallId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId) &&
-                    mCallIdMapper.isValidCallId(otherCallId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                Call otherCall = mCallIdMapper.getCall(otherCallId);
-                if (call != null && otherCall != null) {
-                    mCallsManager.conference(call, otherCall);
-                } else {
-                    Log.w(this, "conference, unknown call id: %s or %s", callId, otherCallId);
-                }
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId) &&
+                        mCallIdMapper.isValidCallId(otherCallId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    Call otherCall = mCallIdMapper.getCall(otherCallId);
+                    if (call != null && otherCall != null) {
+                        mCallsManager.conference(call, otherCall);
+                    } else {
+                        Log.w(this, "conference, unknown call id: %s or %s", callId, otherCallId);
+                    }
 
+                }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void splitFromConference(String callId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    call.splitFromConference();
-                } else {
-                    Log.w(this, "splitFromConference, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        call.splitFromConference();
+                    } else {
+                        Log.w(this, "splitFromConference, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void mergeConference(String callId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    call.mergeConference();
-                } else {
-                    Log.w(this, "mergeConference, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        call.mergeConference();
+                    } else {
+                        Log.w(this, "mergeConference, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void swapConference(String callId) {
-        synchronized (mLock) {
-            if (mCallIdMapper.isValidCallId(callId)) {
-                Call call = mCallIdMapper.getCall(callId);
-                if (call != null) {
-                    call.swapConference();
-                } else {
-                    Log.w(this, "swapConference, unknown call id: %s", callId);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                if (mCallIdMapper.isValidCallId(callId)) {
+                    Call call = mCallIdMapper.getCall(callId);
+                    if (call != null) {
+                        call.swapConference();
+                    } else {
+                        Log.w(this, "swapConference, unknown call id: %s", callId);
+                    }
                 }
             }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void turnOnProximitySensor() {
-        synchronized (mLock) {
-            mCallsManager.turnOnProximitySensor();
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                mCallsManager.turnOnProximitySensor();
+            }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 
     @Override
     public void turnOffProximitySensor(boolean screenOnImmediately) {
-        synchronized (mLock) {
-            mCallsManager.turnOffProximitySensor(screenOnImmediately);
+        long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mLock) {
+                mCallsManager.turnOffProximitySensor(screenOnImmediately);
+            }
+        } finally {
+            Binder.restoreCallingIdentity(token);
         }
     }
 }