import com.android.settings.R;
import com.android.settings.bluetooth.LocalBluetoothProfileManager.Profile;
+import com.android.settings.bluetooth.LocalBluetoothProfileManager.ServiceListener;
import android.app.AlertDialog;
import android.app.Notification;
public class DockService extends Service implements AlertDialog.OnMultiChoiceClickListener,
DialogInterface.OnClickListener, DialogInterface.OnDismissListener,
- CompoundButton.OnCheckedChangeListener {
+ CompoundButton.OnCheckedChangeListener, ServiceListener {
private static final String TAG = "DockService";
// Created in OnCreate()
private volatile Looper mServiceLooper;
private volatile ServiceHandler mServiceHandler;
+ private Runnable mRunnable;
private DockService mContext;
private LocalBluetoothManager mBtManager;
@Override
public void onDestroy() {
if (DEBUG) Log.d(TAG, "onDestroy");
+ mRunnable = null;
+ LocalBluetoothProfileManager.removeServiceListener(this);
if (mDialog != null) {
mDialog.dismiss();
mDialog = null;
// This method gets messages from both onStartCommand and mServiceHandler/mServiceLooper
private synchronized void processMessage(Message msg) {
int msgType = msg.what;
- int state = msg.arg1;
- int startId = msg.arg2;
+ final int state = msg.arg1;
+ final int startId = msg.arg2;
boolean deferFinishCall = false;
BluetoothDevice device = null;
if (msg.obj != null) {
}
mDevice = device;
- if (mBtManager.getDockAutoConnectSetting(device.getAddress())) {
- // Setting == auto connect
- initBtSettings(mContext, device, state, false);
- applyBtSettings(mDevice, startId);
+
+ // Register first in case LocalBluetoothProfileManager
+ // becomes ready after isManagerReady is called and it
+ // would be too late to register a service listener.
+ LocalBluetoothProfileManager.addServiceListener(this);
+ if (LocalBluetoothProfileManager.isManagerReady()) {
+ handleDocked(device, state, startId);
+ // Not needed after all
+ LocalBluetoothProfileManager.removeServiceListener(this);
} else {
- createDialog(mContext, mDevice, state, startId);
+ final BluetoothDevice d = device;
+ mRunnable = new Runnable() {
+ public void run() {
+ handleDocked(d, state, startId);
+ }
+ };
+ deferFinishCall = true;
}
}
break;
}
}
+ private synchronized void handleDocked(final BluetoothDevice device, final int state,
+ final int startId) {
+ if (mBtManager.getDockAutoConnectSetting(device.getAddress())) {
+ // Setting == auto connect
+ initBtSettings(mContext, device, state, false);
+ applyBtSettings(mDevice, startId);
+ } else {
+ createDialog(mContext, device, state, startId);
+ }
+ }
+
private synchronized void handleUndocked(Context context, LocalBluetoothManager localManager,
BluetoothDevice device) {
+ mRunnable = null;
+ LocalBluetoothProfileManager.removeServiceListener(this);
if (mDialog != null) {
mDialog.dismiss();
mDialog = null;
editor.commit();
return;
}
+
+ public synchronized void onServiceConnected() {
+ if (mRunnable != null) {
+ mRunnable.run();
+ mRunnable = null;
+ LocalBluetoothProfileManager.removeServiceListener(this);
+ }
+ }
+
+ public void onServiceDisconnected() {
+ }
}
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
BluetoothUuid.ObexObjectPush
};
+ /**
+ * An interface for notifying BluetoothHeadset IPC clients when they have
+ * been connected to the BluetoothHeadset service.
+ */
+ public interface ServiceListener {
+ /**
+ * Called to notify the client when this proxy object has been
+ * connected to the BluetoothHeadset service. Clients must wait for
+ * this callback before making IPC calls on the BluetoothHeadset
+ * service.
+ */
+ public void onServiceConnected();
+
+ /**
+ * Called to notify the client that this proxy object has been
+ * disconnected from the BluetoothHeadset service. Clients must not
+ * make IPC calls on the BluetoothHeadset service after this callback.
+ * This callback will currently only occur if the application hosting
+ * the BluetoothHeadset service, but may be called more often in future.
+ */
+ public void onServiceDisconnected();
+ }
+
// TODO: close profiles when we're shutting down
private static Map<Profile, LocalBluetoothProfileManager> sProfileMap =
new HashMap<Profile, LocalBluetoothProfileManager>();
}
}
+ private static LinkedList<ServiceListener> mServiceListeners = new LinkedList<ServiceListener>();
+
+ public static void addServiceListener(ServiceListener l) {
+ mServiceListeners.add(l);
+ }
+
+ public static void removeServiceListener(ServiceListener l) {
+ mServiceListeners.remove(l);
+ }
+
+ public static boolean isManagerReady() {
+ // Getting just the headset profile is fine for now. Will need to deal with A2DP
+ // and others if they aren't always in a ready state.
+ LocalBluetoothProfileManager profileManager = sProfileMap.get(Profile.HEADSET);
+ if (profileManager == null) {
+ return sProfileMap.size() > 0;
+ }
+ return profileManager.isProfileReady();
+ }
+
public static LocalBluetoothProfileManager getProfileManager(LocalBluetoothManager localManager,
Profile profile) {
// Note: This code assumes that "localManager" is same as the
return SettingsBtStatus.isConnectionStatusConnected(getConnectionStatus(device));
}
+ public abstract boolean isProfileReady();
+
// TODO: int instead of enum
public enum Profile {
HEADSET(R.string.bluetooth_profile_headset),
return SettingsBtStatus.CONNECTION_STATUS_UNKNOWN;
}
}
+
+ @Override
+ public boolean isProfileReady() {
+ return true;
+ }
}
/**
implements BluetoothHeadset.ServiceListener {
private BluetoothHeadset mService;
private Handler mUiHandler = new Handler();
+ private boolean profileReady = false;
public HeadsetProfileManager(LocalBluetoothManager localManager) {
super(localManager);
}
public void onServiceConnected() {
+ profileReady = true;
// This could be called on a non-UI thread, funnel to UI thread.
mUiHandler.post(new Runnable() {
public void run() {
BluetoothHeadset.STATE_CONNECTED);
}
});
+
+ if (mServiceListeners.size() > 0) {
+ Iterator<ServiceListener> it = mServiceListeners.iterator();
+ while(it.hasNext()) {
+ it.next().onServiceConnected();
+ }
+ }
}
public void onServiceDisconnected() {
+ profileReady = false;
+ if (mServiceListeners.size() > 0) {
+ Iterator<ServiceListener> it = mServiceListeners.iterator();
+ while(it.hasNext()) {
+ it.next().onServiceDisconnected();
+ }
+ }
+ }
+
+ @Override
+ public boolean isProfileReady() {
+ return profileReady;
}
@Override
}
@Override
+ public boolean isProfileReady() {
+ return true;
+ }
+
+ @Override
public int convertState(int oppState) {
switch (oppState) {
case 0:
OSDN Git Service
