[Android] A prototype of the interactive media notification.

chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java

Index: chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java
diff --git a/chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java b/chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed4bcfa734f77c9fc289658f81835c32bfb0f576
--- /dev/null
+++ b/chrome/android/java/src/org/chromium/chrome/browser/media/ui/MediaSessionTabHelper.java
@@ -0,0 +1,124 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chrome.browser.media.ui;
+
+import org.chromium.base.ApplicationStatus;
+import org.chromium.base.Log;
+import org.chromium.chrome.browser.EmptyTabObserver;
+import org.chromium.chrome.browser.Tab;
+import org.chromium.chrome.browser.TabObserver;
+import org.chromium.chrome.browser.UrlUtilities;
+import org.chromium.content_public.browser.WebContents;
+import org.chromium.content_public.browser.WebContentsObserver;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/**
+ * A tab helper responsible for enabling/disabling media controls and passing
+ * media actions from the controls to the {@link org.chromium.content.browser.MediaSession}
+ */
+public class MediaSessionTabHelper {
+    private static final String TAG = "cr.MediaSession";
+
+    private Tab mTab;
+    private WebContents mWebContents;
+    private WebContentsObserver mWebContentsObserver;
+
+    private MediaPlaybackListener mControlsListener = new MediaPlaybackListener() {
+        @Override
+        public void onPlay() {
+            assert mWebContents != null;
+            mWebContents.resumeMediaSession();
+        }
+
+        @Override
+        public void onPause() {
+            assert mWebContents != null;
+            mWebContents.suspendMediaSession();
+        }
+    };
+
+    private WebContentsObserver createWebContentsObserver(WebContents webContents) {
+        return new WebContentsObserver(webContents) {
+            @Override
+            public void destroy() {
+                int tabId = mTab == null ? Tab.INVALID_TAB_ID : mTab.getId();

[Ted C, 2015/07/06 22:18:28]

you want to call super.destroy() as well.

[whywhat, 2015/07/07 15:44:57]

Oops, didn't expect any of the WebContentsObserver methods to be anything but
no-op :)

+                NotificationMediaPlaybackControls.hide(tabId);
+            }
+
+            @Override
+            public void mediaSessionStateChanged(boolean isControllable, boolean isPaused) {
+                assert mTab != null;
+                if (!isControllable) {
+                    NotificationMediaPlaybackControls.hide(mTab.getId());
+                    return;
+                }
+                String origin = mTab.getUrl();
+                try {
+                    origin = UrlUtilities.getOriginForDisplay(new URI(origin), true);
+                } catch (URISyntaxException e) {
+                    Log.e(TAG, "Wrong syntax for the tab URL when playing media. Showing the URL.");

[Ted C, 2015/07/06 22:18:28]

I would say, "Unable to parse the origin from the URL.  Showing the full URL
instead."

[whywhat, 2015/07/07 15:44:57]

Done.

+                }
+                NotificationMediaPlaybackControls.show(
+                        ApplicationStatus.getApplicationContext(),
+                        new MediaInfo(
+                                mTab.getTitle(),
+                                isPaused,
+                                origin,
+                                mTab.getId(),
+                                mControlsListener));
+            }
+        };
+
+    }
+
+    private void cleanupWebContents() {
+        if (mWebContents != null && mWebContentsObserver != null) {

[Ted C, 2015/07/06 22:18:28]

here, just check mWebContentsObserver != null and then call .destroy() on it.

[whywhat, 2015/07/07 15:44:57]

Done.

+            mWebContents.removeObserver(mWebContentsObserver);
+        }
+        mWebContentsObserver = null;
+        mWebContents = null;
+    }
+
+    private final TabObserver mTabObserver = new EmptyTabObserver() {
+        @Override
+        public void onContentChanged(Tab tab) {
+            assert tab == mTab;
+
+            // Usually means that tab's web contents changed.

[Ted C, 2015/07/06 22:18:28]

this also happens when you navigate to a native page or to a renderer drawn page
(if on a native page).

You could just do:

if (mWebContents == tab.getWebContents()) return;

Then you do not need to destroy and recreate it.

[whywhat, 2015/07/07 15:44:57]

Isn't this included in "web contents changed" as in changed from/to null?
Done. I still need to detach and attach the observer to it though, right? Why
would the web contents be equal when onContentChanged is called? Is it called
anytime some state of WebContents changes?

[Ted C, 2015/07/07 17:11:19]

No, the webcontents only changes for a tab when you prerender and it
gets swapped in (maybe reader mode as well), but going to a native
page doesn't actually change the web contents.
Per my comment above, the web contents actually changes very infrequently and
onContentChanged is really onTabView changed which can either be from a new
ContentViewCore or switching to a native page such as the NTP.

[whywhat, 2015/07/07 19:19:04]

I think I understand now but just to be clear - there's nothing to fix here in
the code? The case when web contents is the same happens more often than not, so
having this early return is important.

[Ted C, 2015/07/07 20:04:12]

Correct, nothing to change.  Just wanted to fully explain it.

+            cleanupWebContents();
+            mWebContents = tab.getWebContents();
+            if (mWebContents != null) {
+                mWebContentsObserver = createWebContentsObserver(mWebContents);
+                mWebContents.addObserver(mWebContentsObserver);

[whywhat, 2015/07/07 15:44:57]

Also wasn't needed - WebContentsObserver adds itself to the WebContents.

+            }
+        }
+
+        @Override
+        public void onDestroyed(Tab tab) {
+            assert mTab == tab;
+
+            cleanupWebContents();
+
+            NotificationMediaPlaybackControls.hide(mTab.getId());
+            mTab.removeObserver(this);
+            mTab = null;
+        }
+    };
+
+    private MediaSessionTabHelper(Tab tab) {
+        mTab = tab;
+        mTab.addObserver(mTabObserver);

[Ted C, 2015/07/06 22:18:28]

For safety sake, I would do

if (tab.getWebContents() != null) {
    // create web contents observer here too...
}

Then you can handle the case where the tab has been initialized prior to calling
this.

[whywhat, 2015/07/07 15:44:57]

Done.

+    }
+
+    /**
+     * Creates the {@link MediaSessionTabHelper} for the given {@link Tab}.
+     * @param tab the tab to attach the helper to.
+     */
+    public static void createForTab(Tab tab) {
+        new MediaSessionTabHelper(tab);
+    }
+}