diff --git a/src/com/android/bluetooth/avrcp/BrowsablePlayerConnector.java b/src/com/android/bluetooth/avrcp/BrowsablePlayerConnector.java
index b5886c2..486610f 100644
--- a/src/com/android/bluetooth/avrcp/BrowsablePlayerConnector.java
+++ b/src/com/android/bluetooth/avrcp/BrowsablePlayerConnector.java
@@ -74,6 +74,7 @@
         for (ResolveInfo info : players) {
             BrowsedPlayerWrapper player = BrowsedPlayerWrapper.wrap(
                             context,
+                            looper,
                             info.serviceInfo.packageName,
                             info.serviceInfo.name);
             newWrapper.mPendingPlayers.add(player);
diff --git a/src/com/android/bluetooth/avrcp/BrowsedPlayerWrapper.java b/src/com/android/bluetooth/avrcp/BrowsedPlayerWrapper.java
index b704aae..783da64 100644
--- a/src/com/android/bluetooth/avrcp/BrowsedPlayerWrapper.java
+++ b/src/com/android/bluetooth/avrcp/BrowsedPlayerWrapper.java
@@ -16,9 +16,14 @@
 
 package com.android.bluetooth.avrcp;
 
+import android.annotation.Nullable;
 import android.content.ComponentName;
 import android.content.Context;
 import android.media.browse.MediaBrowser.MediaItem;
+import android.media.session.PlaybackState;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -34,7 +39,7 @@
  */
 class BrowsedPlayerWrapper {
     private static final String TAG = "AvrcpBrowsedPlayerWrapper";
-    private static final boolean DEBUG = true;
+    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
 
     enum ConnectionState {
         DISCONNECTED,
@@ -46,6 +51,10 @@
         void run(int status, BrowsedPlayerWrapper wrapper);
     }
 
+    interface PlaybackCallback {
+        void run(int status);
+    }
+
     interface BrowseCallback {
         void run(int status, String mediaId, List<ListItem> results);
     }
@@ -53,13 +62,16 @@
     public static final int STATUS_SUCCESS = 0;
     public static final int STATUS_CONN_ERROR = 1;
     public static final int STATUS_LOOKUP_ERROR = 2;
+    public static final int STATUS_PLAYBACK_TIMEOUT_ERROR = 3;
 
     private MediaBrowser mWrappedBrowser;
 
     // TODO (apanicke): Store the context in the factories so that we don't need to save this.
     // As long as the service is alive those factories will have a valid context.
-    private Context mContext;
-    private String mPackageName;
+    private final Context mContext;
+    private final Looper mLooper;
+    private final String mPackageName;
+    private final Object mCallbackLock = new Object();
     private ConnectionCallback mCallback;
 
     // TODO(apanicke): We cache this because normally you can only grab the root
@@ -91,10 +103,11 @@
     // TODO (apanicke): Investigate if there is a way to create this just by passing in the
     // MediaBrowser. Right now there is no obvious way to create the browser then update the
     // connection callback without being forced to re-create the object every time.
-    private BrowsedPlayerWrapper(Context context, String packageName, String className) {
+    private BrowsedPlayerWrapper(Context context, Looper looper, String packageName,
+                    String className) {
         mContext = context;
         mPackageName = packageName;
-
+        mLooper = looper;
         mWrappedBrowser = MediaBrowserFactory.make(
                 context,
                 new ComponentName(packageName, className),
@@ -102,35 +115,79 @@
                 null);
     }
 
-    static BrowsedPlayerWrapper wrap(Context context, String packageName, String className) {
+    static BrowsedPlayerWrapper wrap(Context context, Looper looper, String packageName,
+                    String className) {
         Log.i(TAG, "Wrapping Media Browser " + packageName);
         BrowsedPlayerWrapper wrapper =
-                new BrowsedPlayerWrapper(context, packageName, className);
+                new BrowsedPlayerWrapper(context, looper, packageName, className);
         return wrapper;
     }
 
-    void connect(ConnectionCallback cb) {
+    /**
+     * Connect to the media application's MediaBrowserService
+     *
+     * Connections are asynchronous in nature. The given callback will be invoked once the
+     * connection is established. The connection will be torn down once your callback is executed
+     * when using this function. If you wish to control the lifecycle of the connection on your own
+     * then use {@link #setCallbackAndConnect(ConnectionCallback)} instead.
+     *
+     * @param cb A callback to execute once the connection is established
+     * @return True if we successfully make a connection attempt, False otherwise
+     */
+    boolean connect(ConnectionCallback cb) {
         if (cb == null) {
             Log.wtfStack(TAG, "connect: Trying to connect to " + mPackageName
                     + "with null callback");
         }
-        if (mCallback != null) {
-            Log.w(TAG, "connect: Already trying to connect to " + mPackageName);
-            return;
-        }
-
-        if (DEBUG) Log.d(TAG, "connect: Connecting to browsable player: " + mPackageName);
-        mCallback = (int status, BrowsedPlayerWrapper wrapper) -> {
+        return setCallbackAndConnect((int status, BrowsedPlayerWrapper wrapper) -> {
             cb.run(status, wrapper);
-            wrapper.disconnect();
-        };
-        mWrappedBrowser.connect();
+            disconnect();
+        });
     }
 
+    /**
+     * Disconnect from the media application's MediaBrowserService
+     *
+     * This clears any pending requests. This function is safe to call even if a connection isn't
+     * currently open.
+     */
     void disconnect() {
         if (DEBUG) Log.d(TAG, "disconnect: Disconnecting from " + mPackageName);
         mWrappedBrowser.disconnect();
-        mCallback = null;
+        clearCallback();
+    }
+
+    boolean setCallbackAndConnect(ConnectionCallback callback) {
+        synchronized (mCallbackLock) {
+            if (mCallback != null) {
+                Log.w(TAG, "setCallbackAndConnect: Already trying to connect to ");
+                return false;
+            }
+            mCallback = callback;
+        }
+        if (DEBUG) Log.d(TAG, "Set mCallback, connecting to " + mPackageName);
+        mWrappedBrowser.connect();
+        return true;
+    }
+
+    void executeCallback(int status, BrowsedPlayerWrapper player) {
+        final ConnectionCallback callback;
+        synchronized (mCallbackLock) {
+            if (mCallback == null) {
+                Log.w(TAG, "Callback is NULL. Cannot execute");
+                return;
+            }
+            callback = mCallback;
+        }
+        if (DEBUG) Log.d(TAG, "Executing callback");
+        callback.run(status, player);
+    }
+
+    void clearCallback() {
+        synchronized (mCallbackLock) {
+            mCallback = null;
+        }
+        if (DEBUG) Log.d(TAG, "mCallback = null");
     }
 
     public String getPackageName() {
@@ -141,23 +198,39 @@
         return mRoot;
     }
 
-    public void playItem(String mediaId) {
-        if (DEBUG) Log.d(TAG, "playItem: Play Item from media ID: " + mediaId);
-        connect((int status, BrowsedPlayerWrapper wrapper) -> {
+    /**
+     * Requests to play a media item with a given media ID
+     *
+     * @param mediaId A string indicating the piece of media you would like to play
+     * @return False if any other requests are being serviced, True otherwise
+     */
+    public boolean playItem(String mediaId) {
+        if (DEBUG) Log.d(TAG, "playItem: Play item from media ID: " + mediaId);
+        return setCallbackAndConnect((int status, BrowsedPlayerWrapper wrapper) -> {
             if (DEBUG) Log.d(TAG, "playItem: Connected to browsable player " + mPackageName);
-
             MediaController controller = MediaControllerFactory.make(mContext,
                     wrapper.mWrappedBrowser.getSessionToken());
             MediaController.TransportControls ctrl = controller.getTransportControls();
             Log.i(TAG, "playItem: Playing " + mediaId);
             ctrl.playFromMediaId(mediaId, null);
+
+            MediaPlaybackListener mpl = new MediaPlaybackListener(mLooper, controller);
+            mpl.waitForPlayback((int playbackStatus) -> {
+                Log.i(TAG, "playItem: Media item playback returned, status: " + playbackStatus);
+                disconnect();
+            });
         });
-        return;
     }
 
-    // Returns false if the player is in the connecting state. Wait for it to either be
-    // connected or disconnected.
-    //
+    /**
+     * Request the contents of a folder item identified by the given media ID
+     *
+     * Contents must be loaded from a service and are returned asynchronously.
+     *
+     * @param mediaId A string indicating the piece of media you would like to play
+     * @param cb A Callback that returns the loaded contents of the requested media ID
+     * @return False if any other requests are being serviced, True otherwise
+     */
     // TODO (apanicke): Determine what happens when we subscribe to the same item while a
     // callback is in flight.
     //
@@ -172,27 +245,18 @@
         }
 
         if (cb == null) {
-            Log.wtfStack(TAG, "connect: Trying to connect to " + mPackageName
-                    + "with null callback");
-        }
-        if (mCallback != null) {
-            Log.w(TAG, "connect: Already trying to connect to " + mPackageName);
-            return false;
+            Log.wtfStack(TAG, "getFolderItems: Trying to connect to " + mPackageName
+                    + "with null browse callback");
         }
 
-        if (DEBUG) Log.d(TAG, "connect: Connecting to browsable player: " + mPackageName);
-        mCallback = (int status, BrowsedPlayerWrapper wrapper) -> {
+        if (DEBUG) Log.d(TAG, "getFolderItems: Connecting to browsable player: " + mPackageName);
+        return setCallbackAndConnect((int status, BrowsedPlayerWrapper wrapper) -> {
             Log.i(TAG, "getFolderItems: Connected to browsable player: " + mPackageName);
             if (status != STATUS_SUCCESS) {
                 cb.run(status, "", new ArrayList<ListItem>());
             }
-
-            // This will disconnect when the callback is called
             getFolderItemsInternal(mediaId, cb);
-        };
-        mWrappedBrowser.connect();
-
-        return true;
+        });
     }
 
     // Internal function to call once the Browser is connected
@@ -208,44 +272,128 @@
             // Get the root while connected because we may need to use it when disconnected.
             mRoot = mWrappedBrowser.getRoot();
 
-            if (mCallback == null) return;
-
             if (mRoot == null || mRoot.isEmpty()) {
-                mCallback.run(STATUS_CONN_ERROR, BrowsedPlayerWrapper.this);
+                executeCallback(STATUS_CONN_ERROR, BrowsedPlayerWrapper.this);
                 return;
             }
 
-            mCallback.run(STATUS_SUCCESS, BrowsedPlayerWrapper.this);
-            mCallback = null;
+            executeCallback(STATUS_SUCCESS, BrowsedPlayerWrapper.this);
         }
 
 
         @Override
         public void onConnectionFailed() {
             Log.w(TAG, "onConnectionFailed: Connection Failed with " + mPackageName);
-            if (mCallback != null) mCallback.run(STATUS_CONN_ERROR, BrowsedPlayerWrapper.this);
-            mCallback = null;
+            executeCallback(STATUS_CONN_ERROR, BrowsedPlayerWrapper.this);
+            // No need to call disconnect as we never connected. Just need to remove our callback.
+            clearCallback();
         }
 
         // TODO (apanicke): Add a check to list a player as unbrowsable if it suspends immediately
         // after connection.
         @Override
         public void onConnectionSuspended() {
-            mWrappedBrowser.disconnect();
+            executeCallback(STATUS_CONN_ERROR, BrowsedPlayerWrapper.this);
+            disconnect();
             Log.i(TAG, "onConnectionSuspended: Connection Suspended with " + mPackageName);
         }
     }
 
+    class TimeoutHandler extends Handler {
+        static final int MSG_TIMEOUT = 0;
+        static final long CALLBACK_TIMEOUT_MS = 5000;
+
+        private PlaybackCallback mPlaybackCallback = null;
+
+        TimeoutHandler(Looper looper, PlaybackCallback cb) {
+            super(looper);
+            mPlaybackCallback = cb;
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            if (msg.what != MSG_TIMEOUT) {
+                Log.wtf(TAG, "Unknown message on timeout handler: " + msg.what);
+                return;
+            }
+
+            Log.e(TAG, "Timeout while waiting for playback to begin on " + mPackageName);
+            mPlaybackCallback.run(STATUS_PLAYBACK_TIMEOUT_ERROR);
+        }
+    }
+
+    class MediaPlaybackListener extends MediaController.Callback {
+        private final Object mTimeoutHandlerLock = new Object();
+        private Handler mTimeoutHandler = null;
+        private Looper mLooper = null;
+        private MediaController mController = null;
+        private PlaybackCallback mPlaybackCallback = null;
+
+        MediaPlaybackListener(Looper looper, MediaController controller) {
+            synchronized (mTimeoutHandlerLock) {
+                mController = controller;
+                mLooper = looper;
+            }
+        }
+
+        void waitForPlayback(PlaybackCallback cb) {
+            synchronized (mTimeoutHandlerLock) {
+                mPlaybackCallback = cb;
+
+                // If we don't already have the proper state then register the callbacks to execute
+                // on the same thread as the timeout thread. This prevents a race condition where a
+                // timeout happens at the same time as an update. Then set the timeout
+                PlaybackState state = mController.getPlaybackState();
+                if (state == null || state.getState() != PlaybackState.STATE_PLAYING) {
+                    Log.d(TAG, "MediaPlayback: Waiting for media to play for " + mPackageName);
+                    mTimeoutHandler = new TimeoutHandler(mLooper, mPlaybackCallback);
+                    mController.registerCallback(this, mTimeoutHandler);
+                    mTimeoutHandler.sendEmptyMessageDelayed(TimeoutHandler.MSG_TIMEOUT,
+                                TimeoutHandler.CALLBACK_TIMEOUT_MS);
+                } else {
+                    Log.d(TAG, "MediaPlayback: Media is already playing for " + mPackageName);
+                    mPlaybackCallback.run(STATUS_SUCCESS);
+                    cleanup();
+                }
+            }
+        }
+
+        void cleanup() {
+            synchronized (mTimeoutHandlerLock) {
+                if (mController != null) {
+                    mController.unregisterCallback(this);
+                }
+                mController = null;
+
+                if (mTimeoutHandler != null) {
+                    mTimeoutHandler.removeMessages(TimeoutHandler.MSG_TIMEOUT);
+                }
+                mTimeoutHandler = null;
+                mPlaybackCallback = null;
+            }
+        }
+
+        @Override
+        public void onPlaybackStateChanged(@Nullable PlaybackState state) {
+            if (DEBUG) Log.d(TAG, "MediaPlayback: " + mPackageName + " -> " + state.toString());
+            if (state.getState() == PlaybackState.STATE_PLAYING) {
+                mTimeoutHandler.removeMessages(TimeoutHandler.MSG_TIMEOUT);
+                mPlaybackCallback.run(STATUS_SUCCESS);
+                cleanup();
+            }
+        }
+    }
+
     /**
      * Subscription callback handler. Subscribe to a folder to get its contents. We generate a new
      * instance for this class for each subscribe call to make it easier to differentiate between
      * the callers.
      */
     private class BrowserSubscriptionCallback extends MediaBrowser.SubscriptionCallback {
-        BrowseCallback mCallback = null;
+        BrowseCallback mBrowseCallback = null;
 
         BrowserSubscriptionCallback(BrowseCallback cb) {
-            mCallback = cb;
+            mBrowseCallback = cb;
         }
 
         @Override
@@ -254,7 +402,7 @@
                 Log.d(TAG, "onChildrenLoaded: mediaId=" + parentId + " size= " + children.size());
             }
 
-            if (mCallback == null) {
+            if (mBrowseCallback == null) {
                 Log.w(TAG, "onChildrenLoaded: " + mPackageName
                         + " children loaded while callback is null");
             }
@@ -288,8 +436,8 @@
             mCachedFolders.put(parentId, return_list);
 
             // Clone the list so that the callee can mutate it without affecting the cached data
-            mCallback.run(STATUS_SUCCESS, parentId, Util.cloneList(return_list));
-            mCallback = null;
+            mBrowseCallback.run(STATUS_SUCCESS, parentId, Util.cloneList(return_list));
+            mBrowseCallback = null;
             disconnect();
         }
 
@@ -297,7 +445,7 @@
         @Override
         public void onError(String id) {
             Log.e(TAG, "BrowserSubscriptionCallback: Could not get folder items");
-            mCallback.run(STATUS_LOOKUP_ERROR, id, new ArrayList<ListItem>());
+            mBrowseCallback.run(STATUS_LOOKUP_ERROR, id, new ArrayList<ListItem>());
             disconnect();
         }
     }
diff --git a/src/com/android/bluetooth/avrcp/MediaPlayerWrapper.java b/src/com/android/bluetooth/avrcp/MediaPlayerWrapper.java
index 4e0b812..f0309fd 100644
--- a/src/com/android/bluetooth/avrcp/MediaPlayerWrapper.java
+++ b/src/com/android/bluetooth/avrcp/MediaPlayerWrapper.java
@@ -135,8 +135,9 @@
     }
 
     long getActiveQueueID() {
-        if (mMediaController.getPlaybackState() == null) return -1;
-        return mMediaController.getPlaybackState().getActiveQueueItemId();
+        PlaybackState state = mMediaController.getPlaybackState();
+        if (state == null) return -1;
+        return state.getActiveQueueItemId();
     }
 
     List<Metadata> getCurrentQueue() {
diff --git a/src/com/android/bluetooth/hfp/HeadsetStateMachine.java b/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
index c5485f9..06c4822 100644
--- a/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
+++ b/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
@@ -1198,6 +1198,21 @@
         }
     }
 
+    class MyAudioServerStateCallback extends AudioManager.AudioServerStateCallback {
+        @Override
+        public void onAudioServerDown() {
+            logi("onAudioServerDown");
+        }
+
+        @Override
+        public void onAudioServerUp() {
+            logi("onAudioServerUp restoring audio parameters");
+            setAudioParameters();
+        }
+    }
+
+    MyAudioServerStateCallback mAudioServerStateCallback = new MyAudioServerStateCallback();
+
     class AudioOn extends ConnectedBase {
         @Override
         int getAudioStateInt() {
@@ -1216,10 +1231,21 @@
                 mHeadsetService.setActiveDevice(mDevice);
             }
             setAudioParameters();
+
+            mSystemInterface.getAudioManager().setAudioServerStateCallback(
+                    mHeadsetService.getMainExecutor(), mAudioServerStateCallback);
+
             broadcastStateTransitions();
         }
 
         @Override
+        public void exit() {
+            super.exit();
+
+            mSystemInterface.getAudioManager().clearAudioServerStateCallback();
+        }
+
+        @Override
         public boolean processMessage(Message message) {
             switch (message.what) {
                 case CONNECT: {
diff --git a/src/com/android/bluetooth/opp/BluetoothOppTransfer.java b/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
index 91af9ca..06562e4 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
@@ -474,7 +474,7 @@
             mBatch.mStatus = Constants.BATCH_STATUS_FAILED;
             return;
         }
-
+        registerConnectionreceiver();
         if (mHandlerThread == null) {
             if (V) {
                 Log.v(TAG, "Create handler thread for batch " + mBatch.mId);
@@ -495,7 +495,7 @@
                 startObexSession();
             }
         }
-        registerConnectionreceiver();
+
     }
 
     /**
diff --git a/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java b/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
index fc45d3f..a7c14ac 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
@@ -375,24 +375,13 @@
                             mTransInfo.mID);
                 } else if (mWhichDialog == DIALOG_SEND_COMPLETE_FAIL) {
                     // "try again"
-
                     // make current transfer "hidden"
                     BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
 
                     // clear correspondent notification item
                     ((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(
                             mTransInfo.mID);
-
-                    // retry the failed transfer
-                    Uri uri = BluetoothOppUtility.originalUri(Uri.parse(mTransInfo.mFileUri));
-                    BluetoothOppSendFileInfo sendFileInfo =
-                            BluetoothOppSendFileInfo.generateFileInfo(BluetoothOppTransferActivity
-                            .this, uri, mTransInfo.mFileType, false);
-                    uri = BluetoothOppUtility.generateUri(uri, sendFileInfo);
-                    BluetoothOppUtility.putSendFileInfo(uri, sendFileInfo);
-                    mTransInfo.mFileUri = uri.toString();
-                    BluetoothOppUtility.retryTransfer(this, mTransInfo);
-
+                    retryFailedTrasfer();
                     BluetoothDevice remoteDevice = mAdapter.getRemoteDevice(mTransInfo.mDestAddr);
 
                     // Display toast message
@@ -502,4 +491,23 @@
                     .setText(getString(R.string.upload_fail_cancel));
         }
     }
+
+   /*
+    * Retry the failed transfer in background thread
+    */
+   private void retryFailedTrasfer() {
+        new Thread() {
+            @Override
+            public void run() {
+                Uri uri = BluetoothOppUtility.originalUri(Uri.parse(mTransInfo.mFileUri));
+                BluetoothOppSendFileInfo sendFileInfo =
+                        BluetoothOppSendFileInfo.generateFileInfo(BluetoothOppTransferActivity
+                        .this, uri, mTransInfo.mFileType, false);
+                uri = BluetoothOppUtility.generateUri(uri, sendFileInfo);
+                BluetoothOppUtility.putSendFileInfo(uri, sendFileInfo);
+                mTransInfo.mFileUri = uri.toString();
+                BluetoothOppUtility.retryTransfer(BluetoothOppTransferActivity.this, mTransInfo);
+            }
+        }.start();
+    }
 }
diff --git a/tests/unit/src/com/android/bluetooth/newavrcp/BrowserPlayerWrapperTest.java b/tests/unit/src/com/android/bluetooth/newavrcp/BrowserPlayerWrapperTest.java
index 38d9c58..760edae 100644
--- a/tests/unit/src/com/android/bluetooth/newavrcp/BrowserPlayerWrapperTest.java
+++ b/tests/unit/src/com/android/bluetooth/newavrcp/BrowserPlayerWrapperTest.java
@@ -20,6 +20,9 @@
 
 import android.media.MediaDescription;
 import android.media.browse.MediaBrowser.MediaItem;
+import android.media.session.PlaybackState;
+import android.os.Handler;
+import android.os.HandlerThread;
 
 import androidx.test.filters.SmallTest;
 import androidx.test.runner.AndroidJUnit4;
@@ -42,15 +45,22 @@
 
     @Captor ArgumentCaptor<MediaBrowser.ConnectionCallback> mBrowserConnCb;
     @Captor ArgumentCaptor<MediaBrowser.SubscriptionCallback> mSubscriptionCb;
+    @Captor ArgumentCaptor<MediaController.Callback> mControllerCb;
+    @Captor ArgumentCaptor<Handler> mTimeoutHandler;
     @Captor ArgumentCaptor<List<ListItem>> mWrapperBrowseCb;
     @Mock MediaBrowser mMockBrowser;
     @Mock BrowsedPlayerWrapper.ConnectionCallback mConnCb;
     @Mock BrowsedPlayerWrapper.BrowseCallback mBrowseCb;
+    private HandlerThread mThread;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
+        // Set up Looper thread for the timeout handler
+        mThread = new HandlerThread("MediaPlayerWrapperTestThread");
+        mThread.start();
+
         when(mMockBrowser.getRoot()).thenReturn("root_folder");
 
         MediaBrowserFactory.inject(mMockBrowser);
@@ -58,7 +68,8 @@
 
     @Test
     public void testWrap() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         wrapper.connect(mConnCb);
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         verify(mMockBrowser).connect();
@@ -71,26 +82,54 @@
     }
 
     @Test
-    public void testConnect() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+    public void testConnect_Successful() {
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         wrapper.connect(mConnCb);
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
-        browserConnCb.onConnectionFailed();
 
-        verify(mConnCb).run(eq(BrowsedPlayerWrapper.STATUS_CONN_ERROR), eq(wrapper));
-
-        wrapper.connect(mConnCb);
-        verify(mMockBrowser, times(2)).connect();
-
+        verify(mMockBrowser, times(1)).connect();
         browserConnCb.onConnected();
         verify(mConnCb).run(eq(BrowsedPlayerWrapper.STATUS_SUCCESS), eq(wrapper));
+        verify(mMockBrowser, times(1)).disconnect();
+    }
+
+    @Test
+    public void testConnect_Suspended() {
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
+        wrapper.connect(mConnCb);
+        verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
+        MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
+
+        verify(mMockBrowser, times(1)).connect();
+        browserConnCb.onConnectionSuspended();
+        verify(mConnCb).run(eq(BrowsedPlayerWrapper.STATUS_CONN_ERROR), eq(wrapper));
+        // Twice because our mConnCb is wrapped when using the plain connect() call and disconnect
+        // is called for us when the callback is invoked in addition to error handling calling
+        // disconnect.
         verify(mMockBrowser, times(2)).disconnect();
     }
 
     @Test
+    public void testConnect_Failed() {
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
+        wrapper.connect(mConnCb);
+        verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
+        MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
+
+        verify(mMockBrowser, times(1)).connect();
+        browserConnCb.onConnectionFailed();
+        verify(mConnCb).run(eq(BrowsedPlayerWrapper.STATUS_CONN_ERROR), eq(wrapper));
+        verify(mMockBrowser, times(1)).disconnect();
+    }
+
+    @Test
     public void testEmptyRoot() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
 
         doReturn("").when(mMockBrowser).getRoot();
 
@@ -107,7 +146,8 @@
 
     @Test
     public void testDisconnect() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         wrapper.connect(mConnCb);
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
@@ -117,7 +157,8 @@
 
     @Test
     public void testGetRootId() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         wrapper.connect(mConnCb);
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
@@ -129,7 +170,8 @@
 
     @Test
     public void testPlayItem() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
 
@@ -144,12 +186,56 @@
 
         browserConnCb.onConnected();
         verify(mockTransport).playFromMediaId(eq("test_item"), eq(null));
-        verify(mMockBrowser).disconnect();
+
+        // Do not immediately disconnect. Non-foreground playback serves will likely fail
+        verify(mMockBrowser, times(0)).disconnect();
+
+        verify(mockController).registerCallback(mControllerCb.capture(), any());
+        MediaController.Callback controllerCb = mControllerCb.getValue();
+        PlaybackState.Builder builder = new PlaybackState.Builder();
+
+        // Do not disconnect on an event that isn't "playing"
+        builder.setState(PlaybackState.STATE_PAUSED, 0, 1);
+        controllerCb.onPlaybackStateChanged(builder.build());
+        verify(mMockBrowser, times(0)).disconnect();
+
+        // Once we're told we're playing, make sure we disconnect
+        builder.setState(PlaybackState.STATE_PLAYING, 0, 1);
+        controllerCb.onPlaybackStateChanged(builder.build());
+        verify(mMockBrowser, times(1)).disconnect();
+    }
+
+    @Test
+    public void testPlayItem_Timeout() {
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
+        verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
+        MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();
+
+        wrapper.playItem("test_item");
+        verify(mMockBrowser, times(1)).connect();
+
+        MediaController mockController = mock(MediaController.class);
+        MediaController.TransportControls mockTransport =
+                mock(MediaController.TransportControls.class);
+        when(mockController.getTransportControls()).thenReturn(mockTransport);
+        MediaControllerFactory.inject(mockController);
+
+        browserConnCb.onConnected();
+        verify(mockTransport).playFromMediaId(eq("test_item"), eq(null));
+
+        verify(mockController).registerCallback(any(), mTimeoutHandler.capture());
+        Handler timeoutHandler = mTimeoutHandler.getValue();
+
+        timeoutHandler.sendEmptyMessage(BrowsedPlayerWrapper.TimeoutHandler.MSG_TIMEOUT);
+
+        verify(mMockBrowser, timeout(2000).times(1)).disconnect();
     }
 
     @Test
     public void testGetFolderItems() {
-        BrowsedPlayerWrapper wrapper = BrowsedPlayerWrapper.wrap(null, "test", "test");
+        BrowsedPlayerWrapper wrapper =
+                BrowsedPlayerWrapper.wrap(null, mThread.getLooper(), "test", "test");
         verify(mMockBrowser).testInit(any(), any(), mBrowserConnCb.capture(), any());
         MediaBrowser.ConnectionCallback browserConnCb = mBrowserConnCb.getValue();