ScreenCapture for Android phase1, part II

chrome/android/java/src/org/chromium/chrome/browser/media/MediaCaptureNotificationService.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;
 
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.IBinder;
 import android.support.v4.app.NotificationCompat;
 import android.util.SparseIntArray;
 
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.tab.Tab;
+import org.chromium.chrome.browser.tab.TabWebContentsDelegateAndroid;
 
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
 /**
  * Service that creates/destroys the WebRTC notification when media capture starts/stops.
  */
 public class MediaCaptureNotificationService extends Service {
+    private static final String ACTION_MEDIA_CAPTURE_UPDATE =
+            "org.chromium.chrome.browser.media.SCREEN_CAPTURE_UPDATE";
+    private static final String ACTION_SCREEN_CAPTURE_STOP =
+            "org.chromium.chrome.browser.media.SCREEN_CAPTURE_STOP";
 
     private static final String NOTIFICATION_NAMESPACE = "MediaCaptureNotificationService";
 
     private static final String NOTIFICATION_ID_EXTRA = "NotificationId";
     private static final String NOTIFICATION_MEDIA_TYPE_EXTRA = "NotificationMediaType";
     private static final String NOTIFICATION_MEDIA_URL_EXTRA = "NotificationMediaUrl";
 
     private static final String WEBRTC_NOTIFICATION_IDS = "WebRTCNotificationIds";
     private static final String TAG = "MediaCapture";
 
     private static final int MEDIATYPE_NO_MEDIA = 0;
     private static final int MEDIATYPE_AUDIO_AND_VIDEO = 1;
     private static final int MEDIATYPE_VIDEO_ONLY = 2;
     private static final int MEDIATYPE_AUDIO_ONLY = 3;
+    private static final int MEDIATYPE_SCREEN_CAPTURE = 4;
 
     private NotificationManager mNotificationManager;
     private Context mContext;
     private SharedPreferences mSharedPreferences;
     private final SparseIntArray mNotifications = new SparseIntArray();
 
     @Override
     public void onCreate() {
         mContext = getApplicationContext();
         mNotificationManager = (NotificationManager) mContext.getSystemService(
@@ skipping 19 matching lines @@
     private boolean doesNotificationExist(int notificationId) {
         return mNotifications.indexOfKey(notificationId) >= 0;
     }
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         if (intent == null || intent.getExtras() == null) {
             cancelPreviousWebRtcNotifications();
             stopSelf();
         } else {
-            updateNotification(
-                    intent.getIntExtra(NOTIFICATION_ID_EXTRA, Tab.INVALID_TAB_ID),
-                    intent.getIntExtra(NOTIFICATION_MEDIA_TYPE_EXTRA, MEDIATYPE_NO_MEDIA),
-                    intent.getStringExtra(NOTIFICATION_MEDIA_URL_EXTRA));
+            String action = intent.getAction();
+            int notificationId = intent.getIntExtra(NOTIFICATION_ID_EXTRA, Tab.INVALID_TAB_ID);
+            int mediaType = intent.getIntExtra(NOTIFICATION_MEDIA_TYPE_EXTRA, MEDIATYPE_NO_MEDIA);
+            String url = intent.getStringExtra(NOTIFICATION_MEDIA_URL_EXTRA);
+
+            switch (action) {
+                case ACTION_MEDIA_CAPTURE_UPDATE:

[Ted C, 2016/08/16 00:19:19]

since we only have two actions, I think 

if (ACTION_MEDIA_CAPTURE_UPDATE.equals(action)) {
   ...
} else if (ACTION_SCREEN_CAPTURE_STOP.equals(action)) {
   ...
}

is clearer and has less code.

[braveyao, 2016/08/16 23:05:49]

Done.

+                    updateNotification(notificationId, mediaType, url);
+                    break;
+
+                case ACTION_SCREEN_CAPTURE_STOP:
+                    // Notify native to stop screen capture when the STOP button in notification
+                    // is clicked.
+                    TabWebContentsDelegateAndroid.notifyStopped(notificationId);
+                    break;
+
+                default:
+                    break;
+            }
         }
         return super.onStartCommand(intent, flags, startId);
     }
 
     /**
      * Cancel all previously existing notifications. Essential while doing a clean start (may be
      * after a browser crash which caused old notifications to exist).
      */
     private void cancelPreviousWebRtcNotifications() {
         Set<String> notificationIds =
@@ skipping 15 matching lines @@
      * @param mediaType Media type of the notification.
      * @param url Url of the current webrtc call.
      */
     private void updateNotification(int notificationId, int mediaType, String url) {
         if (doesNotificationExist(notificationId)
                 && !doesNotificationNeedUpdate(notificationId, mediaType))  {
             return;
         }
         destroyNotification(notificationId);
         if (mediaType != MEDIATYPE_NO_MEDIA) {
-            createNotification(notificationId, mediaType, url);
+            createNotification(notificationId, mediaType, url, true);

[Ted C, 2016/08/16 00:19:19]

this is only ever called once...and we always pass true.  let's get rid of the
new boolean and simply key it off of MEDIATYPE_SCREEN_CAPTURE

[braveyao, 2016/08/16 23:05:49]

Done.
Once there was another action added, which is removed according to UX
suggestion. I intended to still keep things generic here and there. Sorry about
that.

         }
         if (mNotifications.size() == 0) stopSelf();
     }
 
     /**
      * Destroys the notification for the id notificationId.
      * @param notificationId Unique id of the notification.
      */
     private void destroyNotification(int notificationId) {
         if (doesNotificationExist(notificationId)) {
             mNotificationManager.cancel(NOTIFICATION_NAMESPACE, notificationId);
             mNotifications.delete(notificationId);
             updateSharedPreferencesEntry(notificationId, true);
         }
     }
 
     /**
      * Creates a notification for the provided notificationId and mediaType.
      * @param notificationId Unique id of the notification.
      * @param mediaType Media type of the notification.
      * @param url Url of the current webrtc call.
      */
-    private void createNotification(int notificationId, int mediaType, String url) {
+    private void createNotification(
+            int notificationId, int mediaType, String url, boolean headsup) {
         int notificationContentTextId = 0;
         int notificationIconId = 0;
         if (mediaType == MEDIATYPE_AUDIO_AND_VIDEO) {
             notificationContentTextId = R.string.video_audio_call_notification_text_2;
             notificationIconId = R.drawable.webrtc_video;
         } else if (mediaType == MEDIATYPE_VIDEO_ONLY) {
             notificationContentTextId = R.string.video_call_notification_text_2;
             notificationIconId = R.drawable.webrtc_video;
         } else if (mediaType == MEDIATYPE_AUDIO_ONLY) {
             notificationContentTextId = R.string.audio_call_notification_text_2;
             notificationIconId = R.drawable.webrtc_audio;
+        } else if (mediaType == MEDIATYPE_SCREEN_CAPTURE) {
+            notificationContentTextId = R.string.screen_capture_notification_text;
+            notificationIconId = R.drawable.webrtc_video;
         }
 
         NotificationCompat.Builder builder = new NotificationCompat.Builder(mContext)
                 .setAutoCancel(false)
                 .setOngoing(true)
                 .setContentTitle(mContext.getString(R.string.app_name))
                 .setSmallIcon(notificationIconId)
                 .setLocalOnly(true);
 
-        StringBuilder contentText = new StringBuilder(
-                mContext.getResources().getString(notificationContentTextId)).append('.');
+        StringBuilder contentText =
+                new StringBuilder(mContext.getResources().getString(notificationContentTextId, url))

[Ted C, 2016/08/16 00:19:19]

While extra arguments are dropped in the underlying format call, I'm not a big
fan of passing the url as an argument that is only used by one of the 4 options.

Maybe we should just pull out two helper functions getNotificationContentText
and getNotificationIconId

Then we can make this a bit clearer.

[braveyao, 2016/08/16 23:05:49]

Done.

+                        .append('.');
         Intent tabIntent = Tab.createBringTabToFrontIntent(notificationId);
         if (tabIntent != null) {
             PendingIntent contentIntent = PendingIntent.getActivity(
                     mContext, notificationId, tabIntent, 0);
             builder.setContentIntent(contentIntent);
-            contentText.append(
-                    mContext.getResources().getString(R.string.media_notification_link_text, url));
+            if (mediaType == MEDIATYPE_SCREEN_CAPTURE) {
+                // Add a "Stop" button to the screen capture notification. If necessary, turn the
+                // notification into a high priority one.
+                if (headsup) {
+                    builder.setPriority(Notification.PRIORITY_HIGH);
+                    builder.setVibrate(new long[0]);

[Ted C, 2016/08/16 00:19:19]

we don't vibrate for any other notifications...seems odd to do it here.  And I
think we should pass an explicit duration of what we think is best instead,
maybe 50 or 100

[braveyao, 2016/08/16 23:05:49]

We don't vibrate for screen share too. 'setVibrate' is just necessary to show
the headsup notification. 

+                }
+                builder.addAction(R.drawable.ic_vidcontrol_stop, "Stop",

[Ted C, 2016/08/16 00:19:19]

"Stop" should be translated...and we might already have a Stop that you can use
(ACCESSIBILITY_STOP for example)

[braveyao, 2016/08/16 23:05:49]

Done.

+                        buildPendingIntent(ACTION_SCREEN_CAPTURE_STOP, notificationId, mediaType,

[Ted C, 2016/08/16 00:19:19]

again, let's not make this overly generic for now.  just do
buildStopCapturePendingIntent(int notificationId) and infer the rest

[braveyao, 2016/08/16 23:05:49]

Done.

+                                          url));

[Ted C, 2016/08/16 00:19:19]

clang formatting doesn't work perfectly in java...should be indented 8 from the
start of the previous line

[braveyao, 2016/08/16 23:05:49]

Done.

+            } else {
+                contentText.append(mContext.getResources().getString(
+                        R.string.media_notification_link_text, url));
+            }
         } else {
             contentText.append(" ").append(url);
         }
         builder.setContentText(contentText);
 
         Notification notification = new NotificationCompat.BigTextStyle(builder)
                 .bigText(contentText).build();
         mNotificationManager.notify(NOTIFICATION_NAMESPACE, notificationId, notification);
         mNotifications.put(notificationId, mediaType);
         updateSharedPreferencesEntry(notificationId, false);
@@ skipping 32 matching lines @@
     }
 
     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }
 
     /**
      * @param audio If audio is being captured.
      * @param video If video is being captured.
+     * @param screen If screen is being captured.
      * @return A constant identify what media is being captured.
      */
-    public static int getMediaType(boolean audio, boolean video) {
-        if (audio && video) {
+    public static int getMediaType(boolean audio, boolean video, boolean screen) {
+        if (screen) {
+            return MEDIATYPE_SCREEN_CAPTURE;
+        } else if (audio && video) {
             return MEDIATYPE_AUDIO_AND_VIDEO;
         } else if (audio) {
             return MEDIATYPE_AUDIO_ONLY;
         } else if (video) {
             return MEDIATYPE_VIDEO_ONLY;
         } else {
             return MEDIATYPE_NO_MEDIA;
         }
     }
 
@@ skipping 13 matching lines @@
 
     /**
      * Send an intent to MediaCaptureNotificationService to either create, update or destroy the
      * notification identified by tabId.
      * @param tabId Unique notification id.
      * @param audio If audio is being captured.
      * @param video If video is being captured.
      * @param fullUrl Url of the current webrtc call.
      */
     public static void updateMediaNotificationForTab(
-            Context context, int tabId, boolean audio, boolean video, String fullUrl) {
-        int mediaType = getMediaType(audio, video);
+            Context context, int tabId, int mediaType, String fullUrl) {

[Ted C, 2016/08/16 00:19:19]

update javadoc

[braveyao, 2016/08/16 23:05:49]

Done.

         if (!shouldStartService(context, mediaType, tabId)) return;
         Intent intent = new Intent(context, MediaCaptureNotificationService.class);
+        intent.setAction(ACTION_MEDIA_CAPTURE_UPDATE);
         intent.putExtra(NOTIFICATION_ID_EXTRA, tabId);
         String baseUrl = fullUrl;
         try {
             URL url = new URL(fullUrl);
             baseUrl = url.getProtocol() + "://" + url.getHost();
         } catch (MalformedURLException e) {
             Log.w(TAG, "Error parsing the webrtc url, %s ", fullUrl);
         }
         intent.putExtra(NOTIFICATION_MEDIA_URL_EXTRA, baseUrl);
         intent.putExtra(NOTIFICATION_MEDIA_TYPE_EXTRA, mediaType);
         context.startService(intent);
     }
 
     /**
      * Clear any previous media notifications.
      */
     public static void clearMediaNotifications(Context context) {
         SharedPreferences sharedPreferences =
                 ContextUtils.getAppSharedPreferences();
         Set<String> notificationIds =
                 sharedPreferences.getStringSet(WEBRTC_NOTIFICATION_IDS, null);
         if (notificationIds == null || notificationIds.isEmpty()) return;
 
         context.startService(new Intent(context, MediaCaptureNotificationService.class));
     }
+
+    /**
+     * Build PendingIntent for the actions of screen capture notification.
+     */
+    private PendingIntent buildPendingIntent(
+            String action, int notificationId, int mediaType, String url) {
+        Intent intent = new Intent(this, MediaCaptureNotificationService.class);
+        intent.setAction(action);
+        intent.putExtra(NOTIFICATION_ID_EXTRA, notificationId);
+        intent.putExtra(NOTIFICATION_MEDIA_TYPE_EXTRA, mediaType);
+        intent.putExtra(NOTIFICATION_MEDIA_URL_EXTRA, url);
+        return PendingIntent.getService(
+                mContext, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT);
+    }
 }