[Media, UI] Change MediaNotification style to MediaStyle

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

 // 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 android.app.Notification;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.graphics.Bitmap;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.media.AudioManager;
 import android.os.Build;
 import android.os.IBinder;
-import android.support.v4.app.NotificationCompat;
 import android.support.v4.app.NotificationManagerCompat;
 import android.support.v4.media.MediaMetadataCompat;
 import android.support.v4.media.session.MediaSessionCompat;
 import android.support.v4.media.session.PlaybackStateCompat;
+import android.support.v7.app.NotificationCompat;
 import android.support.v7.media.MediaRouter;
 import android.text.TextUtils;
 import android.util.SparseArray;
 import android.view.KeyEvent;
 import android.view.View;
 import android.widget.RemoteViews;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.R;
+import org.chromium.chrome.browser.ChromeFeatureList;
 
 import javax.annotation.Nullable;
 
 /**
  * A class for notifications that provide information and optional media controls for a given media.
  * Internally implements a Service for transforming notification Intents into
  * {@link MediaNotificationListener} calls for all registered listeners.
  * There's one service started for a distinct notification id.
  */
 public class MediaNotificationManager {
+    private static final String TAG = "MediaNotification";
 
-    private static final String TAG = "MediaNotification";
+    // The background notification size on Android Wear. See:
+    // http://developer.android.com/training/wearables/notifications/creating.html
+    private static final int WEARABLE_NOTIFICATION_BACKGROUND_WIDTH = 400;
+    private static final int WEARABLE_NOTIFICATION_BACKGROUND_HEIGHT = 400;
 
     // We're always used on the UI thread but the LOCK is required by lint when creating the
     // singleton.
     private static final Object LOCK = new Object();
 
     // Maps the notification ids to their corresponding notification managers.
     private static SparseArray<MediaNotificationManager> sManagers;
 
     /**
      * Service used to transform intent requests triggered from the notification into
@@ skipping 417 matching lines @@
         }
         mContext.stopService(createIntent(mContext));
         mMediaNotificationInfo = null;
     }
 
     private void hideNotification(int tabId) {
         if (mMediaNotificationInfo == null || tabId != mMediaNotificationInfo.tabId) return;
         clearNotification();
     }
 
-    private RemoteViews createContentView() {
-        RemoteViews contentView =
-                new RemoteViews(mContext.getPackageName(), R.layout.playback_notification_bar);
-
-        // By default, play/pause button is the only one.
-        int playPauseButtonId = R.id.button1;
-        // On Android pre-L, dismissing the notification when the service is no longer in foreground
-        // doesn't work. Instead, a STOP button is shown.
-        if (mMediaNotificationInfo.supportsSwipeAway()
-                && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP
-                || mMediaNotificationInfo.supportsStop()) {
-            contentView.setOnClickPendingIntent(R.id.button1,
-                    createPendingIntent(ListenerService.ACTION_STOP));
-            contentView.setContentDescription(R.id.button1, mStopDescription);
-
-            // If the play/pause needs to be shown, it moves over to the second button from the end.
-            playPauseButtonId = R.id.button2;
-        }
-
-        contentView.setTextViewText(R.id.title, mMediaNotificationInfo.metadata.getTitle());
-        contentView.setTextViewText(R.id.status, mMediaNotificationInfo.origin);
-        if (mNotificationIcon != null) {
-            contentView.setImageViewBitmap(R.id.icon, mNotificationIcon);
-        } else {
-            contentView.setImageViewResource(R.id.icon, mMediaNotificationInfo.icon);
-        }
-
-        if (mMediaNotificationInfo.supportsPlayPause()) {
-            if (mMediaNotificationInfo.isPaused) {
-                contentView.setImageViewResource(playPauseButtonId, R.drawable.ic_vidcontrol_play);
-                contentView.setContentDescription(playPauseButtonId, mPlayDescription);
-                contentView.setOnClickPendingIntent(playPauseButtonId,
-                        createPendingIntent(ListenerService.ACTION_PLAY));
-            } else {
-                // If we're here, the notification supports play/pause button and is playing.
-                contentView.setImageViewResource(playPauseButtonId, R.drawable.ic_vidcontrol_pause);
-                contentView.setContentDescription(playPauseButtonId, mPauseDescription);
-                contentView.setOnClickPendingIntent(playPauseButtonId,
-                        createPendingIntent(ListenerService.ACTION_PAUSE));
-            }
-
-            contentView.setViewVisibility(playPauseButtonId, View.VISIBLE);
-        } else {
-            contentView.setViewVisibility(playPauseButtonId, View.GONE);
-        }
-
-        return contentView;
-    }
-
     private MediaMetadataCompat createMetadata() {
         MediaMetadataCompat.Builder metadataBuilder = new MediaMetadataCompat.Builder();
 
         // Choose the image to use as the icon.
-        Bitmap mediaSessionImage = mMediaNotificationInfo.image == null ? mDefaultMediaSessionImage
-                : mMediaNotificationInfo.image;
+        Bitmap mediaSessionImage = mMediaNotificationInfo.largeIcon == null
+                ? mDefaultMediaSessionImage
+                : mMediaNotificationInfo.largeIcon;
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE,
                     mMediaNotificationInfo.metadata.getTitle());
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_DISPLAY_SUBTITLE,
                     mMediaNotificationInfo.origin);
             metadataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON,
-                    mediaSessionImage);
+                    scaleBitmapForWearable(mediaSessionImage));
             // METADATA_KEY_ART is optional and should only be used if we can provide something
             // better than the default image.
-            if (mMediaNotificationInfo.image != null) {
-                metadataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART,
-                        mMediaNotificationInfo.image);
+            if (mMediaNotificationInfo.largeIcon != null) {
+                metadataBuilder.putBitmap(
+                        MediaMetadataCompat.METADATA_KEY_ART, mMediaNotificationInfo.largeIcon);
             }
         } else {
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_TITLE,
                     mMediaNotificationInfo.metadata.getTitle());
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_ARTIST,
                     mMediaNotificationInfo.origin);
             metadataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ART, mediaSessionImage);
         }
 
         if (!TextUtils.isEmpty(mMediaNotificationInfo.metadata.getArtist())) {
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_ARTIST,
                     mMediaNotificationInfo.metadata.getArtist());
         }
         if (!TextUtils.isEmpty(mMediaNotificationInfo.metadata.getAlbum())) {
             metadataBuilder.putString(MediaMetadataCompat.METADATA_KEY_ALBUM,
                     mMediaNotificationInfo.metadata.getAlbum());
         }
 
         return metadataBuilder.build();
     }
 
     private void updateNotification() {
         if (mService == null) return;
 
         if (mMediaNotificationInfo == null) return;
 
-        // Android doesn't badge the icons for RemoteViews automatically when
-        // running the app under the Work profile.
-        if (mNotificationIcon == null) {
-            Drawable notificationIconDrawable = ApiCompatibilityUtils.getUserBadgedIcon(
-                    mContext, mMediaNotificationInfo.icon);
-            mNotificationIcon = drawableToBitmap(notificationIconDrawable);
+        updateMediaSession();
+
+        mNotificationBuilder = new NotificationCompat.Builder(mContext);
+        if (ChromeFeatureList.isEnabled(ChromeFeatureList.MEDIA_STYLE_NOTIFICATION)) {
+            setMediaStyleLayoutForNotificationBuilder(mNotificationBuilder);
+        } else {
+            setCustomLayoutForNotificationBuilder(mNotificationBuilder);
         }
-
-        if (mNotificationBuilder == null) {
-            mNotificationBuilder = new NotificationCompat.Builder(mContext)
-                .setSmallIcon(mMediaNotificationInfo.icon)
-                .setAutoCancel(false)
-                .setLocalOnly(true)
-                .setDeleteIntent(createPendingIntent(ListenerService.ACTION_STOP));
-        }
+        mNotificationBuilder.setSmallIcon(mMediaNotificationInfo.icon);
+        mNotificationBuilder.setAutoCancel(false);
+        mNotificationBuilder.setLocalOnly(true);
 
         if (mMediaNotificationInfo.supportsSwipeAway()) {
             mNotificationBuilder.setOngoing(!mMediaNotificationInfo.isPaused);
         }
 
         // The intent will currently only be null when using a custom tab.
         // TODO(avayvod) work out what we should do in this case. See https://crbug.com/585395.
         if (mMediaNotificationInfo.contentIntent != null) {
             mNotificationBuilder.setContentIntent(PendingIntent.getActivity(mContext,
                     mMediaNotificationInfo.tabId,
                     mMediaNotificationInfo.contentIntent, 0));
         }
 
-        mNotificationBuilder.setContent(createContentView());
         mNotificationBuilder.setVisibility(
                 mMediaNotificationInfo.isPrivate ? NotificationCompat.VISIBILITY_PRIVATE
                                                  : NotificationCompat.VISIBILITY_PUBLIC);
 
-
-        if (mMediaNotificationInfo.supportsPlayPause()) {
-
-            if (mMediaSession == null) mMediaSession = createMediaSession();
-            try {
-                // Tell the MediaRouter about the session, so that Chrome can control the volume
-                // on the remote cast device (if any).
-                // Pre-MR1 versions of JB do not have the complete MediaRouter APIs,
-                // so getting the MediaRouter instance will throw an exception.
-                MediaRouter.getInstance(mContext).setMediaSessionCompat(mMediaSession);
-            } catch (NoSuchMethodError e) {
-                // Do nothing. Chrome can't be casting without a MediaRouter, so there is nothing
-                // to do here.
-            }
-            mMediaSession.setMetadata(createMetadata());
-
-            PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder()
-                    .setActions(PlaybackStateCompat.ACTION_PLAY | PlaybackStateCompat.ACTION_PAUSE);
-            if (mMediaNotificationInfo.isPaused) {
-                playbackStateBuilder.setState(PlaybackStateCompat.STATE_PAUSED,
-                        PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 1.0f);
-            } else {
-                playbackStateBuilder.setState(PlaybackStateCompat.STATE_PLAYING,
-                        PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 1.0f);
-            }
-            mMediaSession.setPlaybackState(playbackStateBuilder.build());
-        }
-
         Notification notification = mNotificationBuilder.build();
 
         // We keep the service as a foreground service while the media is playing. When it is not,
         // the service isn't stopped but is no longer in foreground, thus at a lower priority.
         // While the service is in foreground, the associated notification can't be swipped away.
         // Moving it back to background allows the user to remove the notification.
         if (mMediaNotificationInfo.supportsSwipeAway() && mMediaNotificationInfo.isPaused) {
             mService.stopForeground(false /* removeNotification */);
 
             NotificationManagerCompat manager = NotificationManagerCompat.from(mContext);
             manager.notify(mMediaNotificationInfo.id, notification);
         } else {
             mService.startForeground(mMediaNotificationInfo.id, notification);
         }
     }
 
+    private void updateMediaSession() {
+        if (!mMediaNotificationInfo.supportsPlayPause()) return;
+
+        if (mMediaSession == null) mMediaSession = createMediaSession();
+
+        try {
+            // Tell the MediaRouter about the session, so that Chrome can control the volume
+            // on the remote cast device (if any).
+            // Pre-MR1 versions of JB do not have the complete MediaRouter APIs,
+            // so getting the MediaRouter instance will throw an exception.
+            MediaRouter.getInstance(mContext).setMediaSessionCompat(mMediaSession);
+        } catch (NoSuchMethodError e) {
+            // Do nothing. Chrome can't be casting without a MediaRouter, so there is nothing
+            // to do here.
+        }
+
+        mMediaSession.setMetadata(createMetadata());
+
+        PlaybackStateCompat.Builder playbackStateBuilder =
+                new PlaybackStateCompat.Builder().setActions(
+                        PlaybackStateCompat.ACTION_PLAY | PlaybackStateCompat.ACTION_PAUSE);
+        if (mMediaNotificationInfo.isPaused) {
+            playbackStateBuilder.setState(PlaybackStateCompat.STATE_PAUSED,
+                    PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 1.0f);
+        } else {
+            // If notification only supports stop, still pretend
+            playbackStateBuilder.setState(PlaybackStateCompat.STATE_PLAYING,
+                    PlaybackStateCompat.PLAYBACK_POSITION_UNKNOWN, 1.0f);
+        }
+        mMediaSession.setPlaybackState(playbackStateBuilder.build());
+    }
+
     private MediaSessionCompat createMediaSession() {
         MediaSessionCompat mediaSession = new MediaSessionCompat(
                 mContext,
                 mContext.getString(R.string.app_name),
                 new ComponentName(mContext.getPackageName(),
                         getButtonReceiverClassName()),
                 null);
         mediaSession.setFlags(MediaSessionCompat.FLAG_HANDLES_MEDIA_BUTTONS
                 | MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS);
         mediaSession.setCallback(mMediaSessionCallback);
 
         // TODO(mlamouri): the following code is to work around a bug that hopefully
         // MediaSessionCompat will handle directly. see b/24051980.
         try {
             mediaSession.setActive(true);
         } catch (NullPointerException e) {
             // Some versions of KitKat do not support AudioManager.registerMediaButtonIntent
             // with a PendingIntent. They will throw a NullPointerException, in which case
             // they should be able to activate a MediaSessionCompat with only transport
             // controls.
             mediaSession.setActive(false);
             mediaSession.setFlags(MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS);
             mediaSession.setActive(true);
         }
         return mediaSession;
     }
 
+    private void setMediaStyleLayoutForNotificationBuilder(NotificationCompat.Builder builder) {
+        // TODO(zqzhang): After we ship the new style, we should see how to present the
+        // metadata.artist and metadata.album. See http://crbug.com/599937
+        builder.setContentTitle(mMediaNotificationInfo.metadata.getTitle());
+        builder.setContentText(mMediaNotificationInfo.origin);
+        // TODO(zqzhang): Update the default icon when a new one in provided.
+        // See http://crbug.com/600396.
+        if (mMediaNotificationInfo.largeIcon != null) {
+            builder.setLargeIcon(mMediaNotificationInfo.largeIcon);
+        } else {
+            builder.setLargeIcon(mDefaultMediaSessionImage);
+        }
+        // TODO(zqzhang): It's weird that setShowWhen() don't work on K. Calling setWhen() to force
+        // removing the time.
+        builder.setShowWhen(false).setWhen(0);
+
+        // Only apply MediaStyle when NotificationInfo supports play/pause.
+        if (mMediaNotificationInfo.supportsPlayPause()) {
+            NotificationCompat.MediaStyle style = new NotificationCompat.MediaStyle();
+            style.setMediaSession(mMediaSession.getSessionToken());
+
+            if (mMediaNotificationInfo.isPaused) {
+                builder.addAction(R.drawable.ic_vidcontrol_play, mPlayDescription,
+                        createPendingIntent(ListenerService.ACTION_PLAY));
+            } else {
+                // If we're here, the notification supports play/pause button and is playing.
+                builder.addAction(R.drawable.ic_vidcontrol_pause, mPauseDescription,
+                        createPendingIntent(ListenerService.ACTION_PAUSE));
+            }
+            style.setShowActionsInCompactView(0);
+            style.setCancelButtonIntent(createPendingIntent(ListenerService.ACTION_STOP));
+            style.setShowCancelButton(true);
+            builder.setStyle(style);
+        }
+
+        if (mMediaNotificationInfo.supportsStop()) {
+            builder.addAction(R.drawable.ic_vidcontrol_stop, mStopDescription,
+                    createPendingIntent(ListenerService.ACTION_STOP));
+        }
+    }
+
+    private void setCustomLayoutForNotificationBuilder(NotificationCompat.Builder builder) {
+        builder.setContent(createContentView());
+    }
+
+    private RemoteViews createContentView() {
+        RemoteViews contentView =
+                new RemoteViews(mContext.getPackageName(), R.layout.playback_notification_bar);
+
+        // By default, play/pause button is the only one.
+        int playPauseButtonId = R.id.button1;
+        // On Android pre-L, dismissing the notification when the service is no longer in foreground
+        // doesn't work. Instead, a STOP button is shown.
+        if (mMediaNotificationInfo.supportsSwipeAway()
+                        && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP
+                || mMediaNotificationInfo.supportsStop()) {

[Bernhard Bauer, 2016/04/14 12:58:20]

I don't quite see how this code matches the comment. Should the
supportsSwipeAway() condition be negated?

[Zhiqiang Zhang (Slow), 2016/04/14 13:09:17]

MediaNotificationInfo.supportsSwipeAway() means the notification can be
dismissed by swiping away, but on pre-L, it is not possible because of the
service issue, so we have to show a stop button so the user can dismiss the
notification.

BTW, it's from the old code, and should be removed eventually.

+            contentView.setOnClickPendingIntent(
+                    R.id.button1, createPendingIntent(ListenerService.ACTION_STOP));
+            contentView.setContentDescription(R.id.button1, mStopDescription);
+
+            // If the play/pause needs to be shown, it moves over to the second button from the end.
+            playPauseButtonId = R.id.button2;
+        }
+
+        contentView.setTextViewText(R.id.title, mMediaNotificationInfo.metadata.getTitle());
+        contentView.setTextViewText(R.id.status, mMediaNotificationInfo.origin);
+
+        // Android doesn't badge the icons for RemoteViews automatically when
+        // running the app under the Work profile.
+        if (mNotificationIcon == null) {
+            Drawable notificationIconDrawable =
+                    ApiCompatibilityUtils.getUserBadgedIcon(mContext, mMediaNotificationInfo.icon);
+            mNotificationIcon = drawableToBitmap(notificationIconDrawable);
+        }
+
+        if (mNotificationIcon != null) {
+            contentView.setImageViewBitmap(R.id.icon, mNotificationIcon);
+        } else {
+            contentView.setImageViewResource(R.id.icon, mMediaNotificationInfo.icon);
+        }
+
+        if (mMediaNotificationInfo.supportsPlayPause()) {
+            if (mMediaNotificationInfo.isPaused) {
+                contentView.setImageViewResource(playPauseButtonId, R.drawable.ic_vidcontrol_play);
+                contentView.setContentDescription(playPauseButtonId, mPlayDescription);
+                contentView.setOnClickPendingIntent(
+                        playPauseButtonId, createPendingIntent(ListenerService.ACTION_PLAY));
+            } else {
+                // If we're here, the notification supports play/pause button and is playing.
+                contentView.setImageViewResource(playPauseButtonId, R.drawable.ic_vidcontrol_pause);
+                contentView.setContentDescription(playPauseButtonId, mPauseDescription);
+                contentView.setOnClickPendingIntent(
+                        playPauseButtonId, createPendingIntent(ListenerService.ACTION_PAUSE));
+            }
+
+            contentView.setViewVisibility(playPauseButtonId, View.VISIBLE);
+        } else {
+            contentView.setViewVisibility(playPauseButtonId, View.GONE);
+        }
+
+        return contentView;
+    }
+
+    /**
+     * Scales the Bitmap to make the notification background on Wearable devices look better.
+     * The returned Bitmap size will be exactly 400x400.
+     * According to http://developer.android.com/training/wearables/notifications/creating.html,
+     * the background image of Android Wear notifications should be of size 400x400 or 640x400.
+     * Otherwise, it will be scaled to fit the desired size. However for some reason (maybe battery
+     * concern), the smoothing filter is not applied when scaling the image, so we need to manually
+     * scale the image with filter applied before sending to Android Wear.
+     */
+    private Bitmap scaleBitmapForWearable(Bitmap original) {
+        Bitmap result = Bitmap.createScaledBitmap(original, WEARABLE_NOTIFICATION_BACKGROUND_WIDTH,
+                WEARABLE_NOTIFICATION_BACKGROUND_HEIGHT, true);
+        return result;
+    }
+
     private Bitmap drawableToBitmap(Drawable drawable) {
         if (!(drawable instanceof BitmapDrawable)) return null;
 
         BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
         return bitmapDrawable.getBitmap();
     }
 }