diff options
| -rw-r--r-- | core/java/android/app/SystemServiceRegistry.java | 3 | ||||
| -rw-r--r-- | wifi/java/android/net/wifi/RttManager.java | 151 |
2 files changed, 60 insertions, 94 deletions
diff --git a/core/java/android/app/SystemServiceRegistry.java b/core/java/android/app/SystemServiceRegistry.java index cd6e57268907..7cd13ea4ff9d 100644 --- a/core/java/android/app/SystemServiceRegistry.java +++ b/core/java/android/app/SystemServiceRegistry.java @@ -542,7 +542,8 @@ final class SystemServiceRegistry { public RttManager createService(ContextImpl ctx) { IBinder b = ServiceManager.getService(Context.WIFI_RTT_SERVICE); IRttManager service = IRttManager.Stub.asInterface(b); - return new RttManager(ctx.getOuterContext(), service); + return new RttManager(ctx.getOuterContext(), service, + ConnectivityThread.getInstanceLooper()); }}); registerService(Context.ETHERNET_SERVICE, EthernetManager.class, diff --git a/wifi/java/android/net/wifi/RttManager.java b/wifi/java/android/net/wifi/RttManager.java index 2579d9f81b26..a404a90566e3 100644 --- a/wifi/java/android/net/wifi/RttManager.java +++ b/wifi/java/android/net/wifi/RttManager.java @@ -5,7 +5,6 @@ import android.annotation.SystemApi; import android.content.Context; import android.os.Bundle; import android.os.Handler; -import android.os.HandlerThread; import android.os.Looper; import android.os.Message; import android.os.Messenger; @@ -19,8 +18,6 @@ import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.AsyncChannel; import com.android.internal.util.Protocol; -import java.util.concurrent.CountDownLatch; - /** @hide */ @SystemApi public class RttManager { @@ -311,7 +308,7 @@ public class RttManager { } public RttCapabilities getRttCapabilities() { - synchronized (sCapabilitiesLock) { + synchronized (mCapabilitiesLock) { if (mRttCapabilities == null) { try { mRttCapabilities = mService.getRttCapabilities(); @@ -932,13 +929,13 @@ public class RttManager { validateChannel(); ParcelableRttParams parcelableParams = new ParcelableRttParams(params); Log.i(TAG, "Send RTT request to RTT Service"); - sAsyncChannel.sendMessage(CMD_OP_START_RANGING, + mAsyncChannel.sendMessage(CMD_OP_START_RANGING, 0, putListener(listener), parcelableParams); } public void stopRanging(RttListener listener) { validateChannel(); - sAsyncChannel.sendMessage(CMD_OP_STOP_RANGING, 0, removeListener(listener)); + mAsyncChannel.sendMessage(CMD_OP_STOP_RANGING, 0, removeListener(listener)); } /** @@ -975,7 +972,7 @@ public class RttManager { } validateChannel(); int key = putListenerIfAbsent(callback); - sAsyncChannel.sendMessage(CMD_OP_ENABLE_RESPONDER, 0, key); + mAsyncChannel.sendMessage(CMD_OP_ENABLE_RESPONDER, 0, key); } /** @@ -998,7 +995,7 @@ public class RttManager { Log.e(TAG, "responder not enabled yet"); return; } - sAsyncChannel.sendMessage(CMD_OP_DISABLE_RESPONDER, 0, key); + mAsyncChannel.sendMessage(CMD_OP_DISABLE_RESPONDER, 0, key); } /** @@ -1110,23 +1107,17 @@ public class RttManager { public static final int CMD_OP_ENALBE_RESPONDER_FAILED = BASE + 8; - private Context mContext; - private IRttManager mService; - private RttCapabilities mRttCapabilities; - private static final int INVALID_KEY = 0; - private static int sListenerKey = 1; - private static final SparseArray sListenerMap = new SparseArray(); - private static final Object sListenerMapLock = new Object(); - private static final Object sCapabilitiesLock = new Object(); + private final Context mContext; + private final IRttManager mService; + private final SparseArray mListenerMap = new SparseArray(); + private final Object mListenerMapLock = new Object(); + private final Object mCapabilitiesLock = new Object(); - private static AsyncChannel sAsyncChannel; - private static CountDownLatch sConnected; - - private static final Object sThreadRefLock = new Object(); - private static int sThreadRefCount; - private static HandlerThread sHandlerThread; + private RttCapabilities mRttCapabilities; + private int mListenerKey = 1; + private AsyncChannel mAsyncChannel; /** * Create a new WifiScanner instance. @@ -1135,122 +1126,107 @@ public class RttManager { * the standard {@link android.content.Context#WIFI_RTT_SERVICE Context.WIFI_RTT_SERVICE}. * @param context the application context * @param service the Binder interface + * @param looper Looper for running the callbacks. + * * @hide */ - - public RttManager(Context context, IRttManager service) { + public RttManager(Context context, IRttManager service, Looper looper) { mContext = context; mService = service; - init(); - } - - private void init() { - synchronized (sThreadRefLock) { - if (++sThreadRefCount == 1) { - Messenger messenger = null; - try { - Log.d(TAG, "Get the messenger from " + mService); - messenger = mService.getMessenger(); - } catch (RemoteException e) { - throw e.rethrowFromSystemServer(); - } catch (SecurityException e) { - /* do nothing */ - } + Messenger messenger = null; + try { + Log.d(TAG, "Get the messenger from " + mService); + messenger = mService.getMessenger(); + } catch (RemoteException e) { + throw e.rethrowFromSystemServer(); + } - if (messenger == null) { - sAsyncChannel = null; - return; - } + if (messenger == null) { + throw new IllegalStateException("getMessenger() returned null! This is invalid."); + } - sHandlerThread = new HandlerThread("RttManager"); - sAsyncChannel = new AsyncChannel(); - sConnected = new CountDownLatch(1); + mAsyncChannel = new AsyncChannel(); - sHandlerThread.start(); - Handler handler = new ServiceHandler(sHandlerThread.getLooper()); - sAsyncChannel.connect(mContext, handler, messenger); - try { - sConnected.await(); - } catch (InterruptedException e) { - Log.e(TAG, "interrupted wait at init"); - } - } - } + Handler handler = new ServiceHandler(looper); + mAsyncChannel.connectSync(mContext, handler, messenger); + // We cannot use fullyConnectSync because it sends the FULL_CONNECTION message + // synchronously, which causes RttService to receive the wrong replyTo value. + mAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION); } private void validateChannel() { - if (sAsyncChannel == null) throw new IllegalStateException( + if (mAsyncChannel == null) throw new IllegalStateException( "No permission to access and change wifi or a bad initialization"); } - private static int putListener(Object listener) { + private int putListener(Object listener) { if (listener == null) return INVALID_KEY; int key; - synchronized (sListenerMapLock) { + synchronized (mListenerMapLock) { do { - key = sListenerKey++; + key = mListenerKey++; } while (key == INVALID_KEY); - sListenerMap.put(key, listener); + mListenerMap.put(key, listener); } return key; } - // Insert a listener if it doesn't exist in sListenerMap. Returns the key of the listener. - private static int putListenerIfAbsent(Object listener) { + // Insert a listener if it doesn't exist in mListenerMap. Returns the key of the listener. + private int putListenerIfAbsent(Object listener) { if (listener == null) return INVALID_KEY; - synchronized (sListenerMapLock) { + synchronized (mListenerMapLock) { int key = getListenerKey(listener); if (key != INVALID_KEY) { return key; } do { - key = sListenerKey++; + key = mListenerKey++; } while (key == INVALID_KEY); - sListenerMap.put(key, listener); + mListenerMap.put(key, listener); return key; } } - private static Object getListener(int key) { + private Object getListener(int key) { if (key == INVALID_KEY) return null; - synchronized (sListenerMapLock) { - Object listener = sListenerMap.get(key); + synchronized (mListenerMapLock) { + Object listener = mListenerMap.get(key); return listener; } } - private static int getListenerKey(Object listener) { + private int getListenerKey(Object listener) { if (listener == null) return INVALID_KEY; - synchronized (sListenerMapLock) { - int index = sListenerMap.indexOfValue(listener); + synchronized (mListenerMapLock) { + int index = mListenerMap.indexOfValue(listener); if (index == -1) { return INVALID_KEY; } else { - return sListenerMap.keyAt(index); + return mListenerMap.keyAt(index); } } } - private static Object removeListener(int key) { + private Object removeListener(int key) { if (key == INVALID_KEY) return null; - synchronized (sListenerMapLock) { - Object listener = sListenerMap.get(key); - sListenerMap.remove(key); + synchronized (mListenerMapLock) { + Object listener = mListenerMap.get(key); + mListenerMap.remove(key); return listener; } } - private static int removeListener(Object listener) { + private int removeListener(Object listener) { int key = getListenerKey(listener); if (key == INVALID_KEY) return key; - synchronized (sListenerMapLock) { - sListenerMap.remove(key); + synchronized (mListenerMapLock) { + mListenerMap.remove(key); return key; } } - private static class ServiceHandler extends Handler { + private class ServiceHandler extends Handler { ServiceHandler(Looper looper) { super(looper); } @@ -1258,24 +1234,13 @@ public class RttManager { public void handleMessage(Message msg) { Log.i(TAG, "RTT manager get message: " + msg.what); switch (msg.what) { - case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: - if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { - sAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION); - } else { - Log.e(TAG, "Failed to set up channel connection"); - // This will cause all further async API calls on the WifiManager - // to fail and throw an exception - sAsyncChannel = null; - } - return; case AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED: - sConnected.countDown(); return; case AsyncChannel.CMD_CHANNEL_DISCONNECTED: Log.e(TAG, "Channel connection lost"); // This will cause all further async API calls on the WifiManager // to fail and throw an exception - sAsyncChannel = null; + mAsyncChannel = null; getLooper().quit(); return; } |