Add screenshare support to AppRTCMobile.

webrtc/examples/androidapp/src/org/appspot/apprtc/CallActivity.java

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.appspot.apprtc;
 
-import org.appspot.apprtc.AppRTCClient.RoomConnectionParameters;
-import org.appspot.apprtc.AppRTCClient.SignalingParameters;
-import org.appspot.apprtc.PeerConnectionClient.PeerConnectionParameters;
-
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.FragmentTransaction;
+import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.media.projection.MediaProjection;
+import android.media.projection.MediaProjectionManager;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
+import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.View;
 import android.view.Window;
+import android.view.WindowManager;
 import android.view.WindowManager.LayoutParams;
 import android.widget.Toast;
-
 import java.io.IOException;
 import java.lang.RuntimeException;
 import java.util.ArrayList;
 import java.util.List;
-
+import org.appspot.apprtc.AppRTCClient.RoomConnectionParameters;
+import org.appspot.apprtc.AppRTCClient.SignalingParameters;
+import org.appspot.apprtc.PeerConnectionClient.PeerConnectionParameters;
 import org.webrtc.Camera1Enumerator;
 import org.webrtc.Camera2Enumerator;
 import org.webrtc.CameraEnumerator;
 import org.webrtc.EglBase;
 import org.webrtc.FileVideoCapturer;
-import org.webrtc.VideoFileRenderer;
 import org.webrtc.IceCandidate;
 import org.webrtc.Logging;
 import org.webrtc.PeerConnectionFactory;
 import org.webrtc.RendererCommon.ScalingType;
+import org.webrtc.ScreenCapturerAndroid;
 import org.webrtc.SessionDescription;
 import org.webrtc.StatsReport;
 import org.webrtc.SurfaceViewRenderer;
 import org.webrtc.VideoCapturer;
+import org.webrtc.VideoFileRenderer;
 import org.webrtc.VideoRenderer;
 
 /**
  * Activity for peer connection call setup, call waiting
  * and call view.
  */
 public class CallActivity extends Activity implements AppRTCClient.SignalingEvents,
                                                       PeerConnectionClient.PeerConnectionEvents,
                                                       CallFragment.OnCallEvents {
   public static final String EXTRA_ROOMID = "org.appspot.apprtc.ROOMID";
   public static final String EXTRA_LOOPBACK = "org.appspot.apprtc.LOOPBACK";
   public static final String EXTRA_VIDEO_CALL = "org.appspot.apprtc.VIDEO_CALL";
+  public static final String EXTRA_SCREENCAPTURE = "org.appspot.apprtc.SCREENCAPTURE";
   public static final String EXTRA_CAMERA2 = "org.appspot.apprtc.CAMERA2";
   public static final String EXTRA_VIDEO_WIDTH = "org.appspot.apprtc.VIDEO_WIDTH";
   public static final String EXTRA_VIDEO_HEIGHT = "org.appspot.apprtc.VIDEO_HEIGHT";
   public static final String EXTRA_VIDEO_FPS = "org.appspot.apprtc.VIDEO_FPS";
   public static final String EXTRA_VIDEO_CAPTUREQUALITYSLIDER_ENABLED =
       "org.appsopt.apprtc.VIDEO_CAPTUREQUALITYSLIDER";
   public static final String EXTRA_VIDEO_BITRATE = "org.appspot.apprtc.VIDEO_BITRATE";
   public static final String EXTRA_VIDEOCODEC = "org.appspot.apprtc.VIDEOCODEC";
   public static final String EXTRA_HWCODEC_ENABLED = "org.appspot.apprtc.HWCODEC";
   public static final String EXTRA_CAPTURETOTEXTURE_ENABLED = "org.appspot.apprtc.CAPTURETOTEXTURE";
@@ skipping 14 matching lines @@
   public static final String EXTRA_VIDEO_FILE_AS_CAMERA = "org.appspot.apprtc.VIDEO_FILE_AS_CAMERA";
   public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE =
       "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE";
   public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH =
       "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE_WIDTH";
   public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT =
       "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT";
   public static final String EXTRA_USE_VALUES_FROM_INTENT =
       "org.appspot.apprtc.USE_VALUES_FROM_INTENT";
   private static final String TAG = "CallRTCClient";
+  private static final int CAPTURE_PERMISSION_REQUEST_CODE = 1;
 
   // List of mandatory application permissions.
   private static final String[] MANDATORY_PERMISSIONS = {"android.permission.MODIFY_AUDIO_SETTINGS",
       "android.permission.RECORD_AUDIO", "android.permission.INTERNET"};
 
   // Peer connection statistics callback period in ms.
   private static final int STAT_CALLBACK_PERIOD = 1000;
   // Local preview screen position before call is connected.
   private static final int LOCAL_X_CONNECTING = 0;
   private static final int LOCAL_Y_CONNECTING = 0;
@@ skipping 26 matching lines @@
   private boolean commandLineRun;
   private int runTimeMs;
   private boolean activityRunning;
   private RoomConnectionParameters roomConnectionParameters;
   private PeerConnectionParameters peerConnectionParameters;
   private boolean iceConnected;
   private boolean isError;
   private boolean callControlFragmentVisible = true;
   private long callStartedTimeMs = 0;
   private boolean micEnabled = true;
+  private boolean screencaptureEnabled = false;
+  private static Intent mediaProjectionPermissionResultData;
+  private static int mediaProjectionPermissionResultCode;
 
   // Controls
   private CallFragment callFragment;
   private HudFragment hudFragment;
   private CpuMonitor cpuMonitor;
 
   @Override
   public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     Thread.setDefaultUncaughtExceptionHandler(new UnhandledExceptionHandler(this));
@@ skipping 83 matching lines @@
       logAndToast(getString(R.string.missing_url));
       Log.e(TAG, "Incorrect room ID in intent!");
       setResult(RESULT_CANCELED);
       finish();
       return;
     }
 
     boolean loopback = intent.getBooleanExtra(EXTRA_LOOPBACK, false);
     boolean tracing = intent.getBooleanExtra(EXTRA_TRACING, false);
 
+    int videoWidth = intent.getIntExtra(EXTRA_VIDEO_WIDTH, 0);
+    int videoHeight = intent.getIntExtra(EXTRA_VIDEO_HEIGHT, 0);
+
+    screencaptureEnabled = intent.getBooleanExtra(EXTRA_SCREENCAPTURE, false);
+    // If capturing format is not specified for screencapture, use screen resolution.
+    if (screencaptureEnabled && videoWidth == 0 && videoHeight == 0) {
+      DisplayMetrics displayMetrics = new DisplayMetrics();
+      WindowManager windowManager =
+          (WindowManager) getApplication().getSystemService(Context.WINDOW_SERVICE);
+      windowManager.getDefaultDisplay().getRealMetrics(displayMetrics);
+      videoWidth = displayMetrics.widthPixels;
+      videoHeight = displayMetrics.heightPixels;
+    }
+
     peerConnectionParameters =
         new PeerConnectionParameters(intent.getBooleanExtra(EXTRA_VIDEO_CALL, true), loopback,
-            tracing, intent.getIntExtra(EXTRA_VIDEO_WIDTH, 0),
-            intent.getIntExtra(EXTRA_VIDEO_HEIGHT, 0), intent.getIntExtra(EXTRA_VIDEO_FPS, 0),
+            tracing, videoWidth, videoHeight, intent.getIntExtra(EXTRA_VIDEO_FPS, 0),
             intent.getIntExtra(EXTRA_VIDEO_BITRATE, 0), intent.getStringExtra(EXTRA_VIDEOCODEC),
             intent.getBooleanExtra(EXTRA_HWCODEC_ENABLED, true),
             intent.getIntExtra(EXTRA_AUDIO_BITRATE, 0), intent.getStringExtra(EXTRA_AUDIOCODEC),
             intent.getBooleanExtra(EXTRA_NOAUDIOPROCESSING_ENABLED, false),
             intent.getBooleanExtra(EXTRA_AECDUMP_ENABLED, false),
             intent.getBooleanExtra(EXTRA_OPENSLES_ENABLED, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_AEC, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_AGC, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_NS, false),
             intent.getBooleanExtra(EXTRA_ENABLE_LEVEL_CONTROL, false));
@@ skipping 18 matching lines @@
     hudFragment.setCpuMonitor(cpuMonitor);
 
     // Send intent arguments to fragments.
     callFragment.setArguments(intent.getExtras());
     hudFragment.setArguments(intent.getExtras());
     // Activate call and HUD fragments and start the call.
     FragmentTransaction ft = getFragmentManager().beginTransaction();
     ft.add(R.id.call_fragment_container, callFragment);
     ft.add(R.id.hud_fragment_container, hudFragment);
     ft.commit();
-    startCall();
 
     // For command line execution run connection for <runTimeMs> and exit.
     if (commandLineRun && runTimeMs > 0) {
       (new Handler()).postDelayed(new Runnable() {
         @Override
         public void run() {
           disconnect();
         }
       }, runTimeMs);
     }
 
     peerConnectionClient = PeerConnectionClient.getInstance();
     if (loopback) {
       PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();
       options.networkIgnoreMask = 0;
       peerConnectionClient.setPeerConnectionFactoryOptions(options);
     }
     peerConnectionClient.createPeerConnectionFactory(
         CallActivity.this, peerConnectionParameters, CallActivity.this);
+
+    if (screencaptureEnabled) {
+      MediaProjectionManager mediaProjectionManager =
+          (MediaProjectionManager) getApplication().getSystemService(
+              Context.MEDIA_PROJECTION_SERVICE);
+      startActivityForResult(
+          mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE);
+    } else {
+      startCall();
+    }
+  }
+
+  @Override
+  public void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE)
+      return;
+    mediaProjectionPermissionResultCode = resultCode;
+    mediaProjectionPermissionResultData = data;
+    startCall();
   }
 
   private boolean useCamera2() {
     return Camera2Enumerator.isSupported(this) && getIntent().getBooleanExtra(EXTRA_CAMERA2, true);
   }
 
   private boolean captureToTexture() {
     return getIntent().getBooleanExtra(EXTRA_CAPTURETOTEXTURE_ENABLED, false);
   }
 
@@ skipping 27 matching lines @@
     }
 
     return null;
   }
 
   // Activity interfaces
   @Override
   public void onPause() {
     super.onPause();
     activityRunning = false;
-    if (peerConnectionClient != null) {
+    // Don't stop the video when using screencapture to allow user to show other apps to the remote
+    // end.
+    if (peerConnectionClient != null && !screencaptureEnabled) {
       peerConnectionClient.stopVideoSource();
     }
     cpuMonitor.pause();
   }
 
   @Override
   public void onResume() {
     super.onResume();
     activityRunning = true;
-    if (peerConnectionClient != null) {
+    // Video is not paused for screencapture. See onPause.
+    if (peerConnectionClient != null && !screencaptureEnabled) {
       peerConnectionClient.startVideoSource();
     }
     cpuMonitor.resume();
   }
 
   @Override
   protected void onDestroy() {
     disconnect();
     if (logToast != null) {
       logToast.cancel();
@@ skipping 205 matching lines @@
   private VideoCapturer createVideoCapturer() {
     VideoCapturer videoCapturer = null;
     String videoFileAsCamera = getIntent().getStringExtra(EXTRA_VIDEO_FILE_AS_CAMERA);
     if (videoFileAsCamera != null) {
       try {
         videoCapturer = new FileVideoCapturer(videoFileAsCamera);
       } catch (IOException e) {
         reportError("Failed to open video file for emulated camera");
         return null;
       }
+    } else if (screencaptureEnabled) {
+      if (mediaProjectionPermissionResultCode != Activity.RESULT_OK) {
+        reportError("User didn't give permission to capture the screen.");
+        return null;
+      }
+      return new ScreenCapturerAndroid(
+          mediaProjectionPermissionResultData, new MediaProjection.Callback() {
+            @Override
+            public void onStop() {
+              reportError("User revoked permission to capture the screen.");
+            }
+          });
     } else if (useCamera2()) {
       if (!captureToTexture()) {
         reportError(getString(R.string.camera2_texture_only_error));
         return null;
       }
 
       Logging.d(TAG, "Creating capturer using camera2 API.");
       videoCapturer = createCameraCapturer(new Camera2Enumerator(this));
     } else {
       Logging.d(TAG, "Creating capturer using camera1 API.");
@@ skipping 207 matching lines @@
         }
       }
     });
   }
 
   @Override
   public void onPeerConnectionError(final String description) {
     reportError(description);
   }
 }