[Media, Android] Fix lockscreen and other remote controls on KK-

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.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 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.util.SparseArray;
 import android.view.KeyEvent;
 import android.view.View;
 import android.widget.RemoteViews;
 
 import org.chromium.base.ApiCompatibilityUtils;
+import org.chromium.base.Log;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.tab.Tab;
 
 /**
  * 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 = "cr_MediaNotification";
+
     // 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
      * {@code MediaNotificationListener} callbacks. We have to create a separate derived class for
      * each type of notification since one class corresponds to one instance of the service only.
      */
     private abstract static class ListenerService extends Service {
         private static final String ACTION_PLAY =
                 "MediaNotificationManager.ListenerService.PLAY";
         private static final String ACTION_PAUSE =
                 "MediaNotificationManager.ListenerService.PAUSE";
         private static final String ACTION_STOP =
                 "MediaNotificationManager.ListenerService.STOP";
         private static final String EXTRA_NOTIFICATION_ID =
-                "MediaNotificationManager.ListenerService.NOTIFICATION_ID";
+                MediaButtonReceiver.EXTRA_NOTIFICATION_ID;
 
         // The notification id this service instance corresponds to.
         private int mNotificationId = MediaNotificationInfo.INVALID_ID;
 
         private PendingIntent getPendingIntent(String action) {
             Intent intent = getIntent(this, mNotificationId).setAction(action);
             return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT);
         }
 
         @Override
@@ skipping 14 matching lines @@
         @Override
         public int onStartCommand(Intent intent, int flags, int startId) {
             if (!processIntent(intent)) stopSelf();
 
             return START_NOT_STICKY;
         }
 
         private boolean processIntent(Intent intent) {
             if (intent == null) return false;
 
-            mNotificationId = intent.getIntExtra(
+            int notificationId = intent.getIntExtra(
                     EXTRA_NOTIFICATION_ID, MediaNotificationInfo.INVALID_ID);
-            if (mNotificationId == MediaNotificationInfo.INVALID_ID) return false;
+
+            // The notification id must always be valid and should match the first notification id
+            // the service got via the intent.
+            if (notificationId == MediaNotificationInfo.INVALID_ID
+                    || (mNotificationId != MediaNotificationInfo.INVALID_ID
+                        && mNotificationId != notificationId)) {
+                Log.w(TAG, "The service intent's notification id is invalid: ", notificationId);
+                return false;
+            }
+
+            // Either the notification id matches or it's the first intent we've got.
+            mNotificationId = notificationId;
+
+            assert mNotificationId != MediaNotificationInfo.INVALID_ID;
 
             MediaNotificationManager manager = getManager(mNotificationId);
             if (manager == null || manager.mMediaNotificationInfo == null) return false;
 
             manager.onServiceStarted(this);
 
             processAction(intent, manager);
             return true;
         }
 
@@ skipping 49 matching lines @@
         private static final int NOTIFICATION_ID = R.id.media_playback_notification;
     }
 
     /**
      * This class is used internally but have to be public to be able to launch the service.
      */
     public static final class PresentationListenerService extends ListenerService {
         private static final int NOTIFICATION_ID = R.id.presentation_notification;
     }
 
+    // Two classes to specify the right notification id in the intent.
+
+    /**
+     * This class is used internally but have to be public to be able to launch the service.
+     */
+    public static final class PlaybackMediaButtonReceiver extends MediaButtonReceiver {
+        @Override
+        public int getNotificationId() {
+            return PlaybackListenerService.NOTIFICATION_ID;
+        }
+    }
+
+    /**
+     * This class is used internally but have to be public to be able to launch the service.
+     */
+    public static final class PresentationMediaButtonReceiver extends MediaButtonReceiver {
+        @Override
+        public int getNotificationId() {
+            return PresentationListenerService.NOTIFICATION_ID;
+        }
+    }
+
     private static Intent getIntent(Context context, int notificationId) {
         Intent intent = null;
         if (notificationId == PlaybackListenerService.NOTIFICATION_ID) {
             intent = new Intent(context, PlaybackListenerService.class);
         } else if (notificationId == PresentationListenerService.NOTIFICATION_ID) {
             intent = new Intent(context, PresentationListenerService.class);
         } else {
             return null;
         }
         return intent.putExtra(ListenerService.EXTRA_NOTIFICATION_ID, notificationId);
     }
 
+    private static String getButtonReceiverClassName(int notificationId) {
+        if (notificationId == PlaybackListenerService.NOTIFICATION_ID) {
+            return PlaybackMediaButtonReceiver.class.getName();
+        }
+
+        if (notificationId == PresentationListenerService.NOTIFICATION_ID) {
+            return PresentationMediaButtonReceiver.class.getName();
+        }
+
+        assert false;
+        return null;
+    }
+
     /**
      * Shows the notification with media controls with the specified media info. Replaces/updates
      * the current notification if already showing. Does nothing if |mediaNotificationInfo| hasn't
      * changed from the last one.
      *
      * @param applicationContext context to create the notification with
      * @param notificationInfoBuilder information to show in the notification
      */
     public static void show(Context applicationContext,
                             MediaNotificationInfo.Builder notificationInfoBuilder) {
@@ skipping 339 matching lines @@
         } else {
             mService.startForeground(mMediaNotificationInfo.id, notification);
         }
     }
 
     private MediaSessionCompat createMediaSession() {
         MediaSessionCompat mediaSession = new MediaSessionCompat(
                 mContext,
                 mContext.getString(R.string.app_name),
                 new ComponentName(mContext.getPackageName(),
-                        MediaButtonReceiver.class.getName()),
+                        getButtonReceiverClassName(mMediaNotificationInfo.id)),
                 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 Bitmap drawableToBitmap(Drawable drawable) {
         if (!(drawable instanceof BitmapDrawable)) return null;
 
         BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
         return bitmapDrawable.getBitmap();
     }
 }