Revert of AppRTCDemo: Render each video in a separate SurfaceView

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 org.appspot.apprtc.util.LooperExecutor;
 
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.FragmentTransaction;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.net.Uri;
 import android.opengl.GLSurfaceView;
 import android.os.Bundle;
-import android.os.Handler;
 import android.util.Log;
 import android.view.View;
 import android.view.Window;
 import android.view.WindowManager.LayoutParams;
 import android.widget.Toast;
 
-import org.webrtc.EglBase;
 import org.webrtc.IceCandidate;
 import org.webrtc.SessionDescription;
 import org.webrtc.StatsReport;
-import org.webrtc.SurfaceViewRenderer;
-import org.webrtc.RendererCommon.ScalingType;
+import org.webrtc.VideoRenderer;
+import org.webrtc.VideoRendererGui;
+import org.webrtc.VideoRendererGui.ScalingType;
 
 /**
  * Activity for peer connection call setup, call waiting
  * and call view.
  */
 public class CallActivity extends Activity
     implements AppRTCClient.SignalingEvents,
       PeerConnectionClient.PeerConnectionEvents,
       CallFragment.OnCallEvents {
 
@@ skipping 53 matching lines @@
   // Remote video screen position
   private static final int REMOTE_X = 0;
   private static final int REMOTE_Y = 0;
   private static final int REMOTE_WIDTH = 100;
   private static final int REMOTE_HEIGHT = 100;
 
   private PeerConnectionClient peerConnectionClient = null;
   private AppRTCClient appRtcClient;
   private SignalingParameters signalingParameters;
   private AppRTCAudioManager audioManager = null;
-  private EglBase rootEglBase;
-  private SurfaceViewRenderer localRender;
-  private SurfaceViewRenderer remoteRender;
-  private PercentFrameLayout localRenderLayout;
-  private PercentFrameLayout remoteRenderLayout;
+  private VideoRenderer.Callbacks localRender;
+  private VideoRenderer.Callbacks remoteRender;
   private ScalingType scalingType;
   private Toast logToast;
   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;
 
   // Controls
+  private GLSurfaceView videoView;
   CallFragment callFragment;
   HudFragment hudFragment;
 
   @Override
   public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     Thread.setDefaultUncaughtExceptionHandler(
         new UnhandledExceptionHandler(this));
 
     // Set window styles for fullscreen-window size. Needs to be done before
     // adding content.
     requestWindowFeature(Window.FEATURE_NO_TITLE);
     getWindow().addFlags(
         LayoutParams.FLAG_FULLSCREEN
         | LayoutParams.FLAG_KEEP_SCREEN_ON
         | LayoutParams.FLAG_DISMISS_KEYGUARD
         | LayoutParams.FLAG_SHOW_WHEN_LOCKED
         | LayoutParams.FLAG_TURN_SCREEN_ON);
     getWindow().getDecorView().setSystemUiVisibility(
         View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
         | View.SYSTEM_UI_FLAG_FULLSCREEN
         | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
     setContentView(R.layout.activity_call);
 
     iceConnected = false;
     signalingParameters = null;
     scalingType = ScalingType.SCALE_ASPECT_FILL;
 
     // Create UI controls.
-    localRender = (SurfaceViewRenderer) findViewById(R.id.local_video_view);
-    remoteRender = (SurfaceViewRenderer) findViewById(R.id.remote_video_view);
-    localRenderLayout = (PercentFrameLayout) findViewById(R.id.local_video_layout);
-    remoteRenderLayout = (PercentFrameLayout) findViewById(R.id.remote_video_layout);
+    videoView = (GLSurfaceView) findViewById(R.id.glview_call);
     callFragment = new CallFragment();
     hudFragment = new HudFragment();
 
+    // Create video renderers.
+    VideoRendererGui.setView(videoView, new Runnable() {
+      @Override
+      public void run() {
+        createPeerConnectionFactory();
+      }
+    });
+    remoteRender = VideoRendererGui.create(
+        REMOTE_X, REMOTE_Y,
+        REMOTE_WIDTH, REMOTE_HEIGHT, scalingType, false);
+    localRender = VideoRendererGui.create(
+        LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING,
+        LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING, scalingType, true);
+
     // Show/hide call control fragment on view click.
-    View.OnClickListener listener = new View.OnClickListener() {
+    videoView.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View view) {
         toggleCallControlFragmentVisibility();
       }
-    };
-    localRender.setOnClickListener(listener);
-    remoteRender.setOnClickListener(listener);
-
-    // Create video renderers.
-    rootEglBase = new EglBase();
-    localRender.init(rootEglBase.getContext());
-    remoteRender.init(rootEglBase.getContext());
-    localRender.setZOrderMediaOverlay(true);
-    updateVideoView();
+    });
 
     // Check for mandatory permissions.
     for (String permission : MANDATORY_PERMISSIONS) {
       if (checkCallingOrSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
         logAndToast("Permission " + permission + " is not granted");
         setResult(RESULT_CANCELED);
         finish();
         return;
       }
     }
@@ skipping 43 matching lines @@
     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() {
+      videoView.postDelayed(new Runnable() {
         public void run() {
           disconnect();
         }
       }, runTimeMs);
     }
-    createPeerConnectionFactory();
   }
 
   // Activity interfaces
   @Override
   public void onPause() {
     super.onPause();
+    videoView.onPause();
     activityRunning = false;
     if (peerConnectionClient != null) {
       peerConnectionClient.stopVideoSource();
     }
   }
 
   @Override
   public void onResume() {
     super.onResume();
+    videoView.onResume();
     activityRunning = true;
     if (peerConnectionClient != null) {
       peerConnectionClient.startVideoSource();
     }
   }
 
   @Override
   protected void onDestroy() {
     disconnect();
     super.onDestroy();
     if (logToast != null) {
       logToast.cancel();
     }
     activityRunning = false;
-    localRender.release();
-    localRender = null;
-    remoteRender.release();
-    remoteRender = null;
-    rootEglBase.release();
-    rootEglBase = null;
   }
 
   // CallFragment.OnCallEvents interface implementation.
   @Override
   public void onCallHangUp() {
     disconnect();
   }
 
   @Override
   public void onCameraSwitch() {
@@ skipping 21 matching lines @@
       ft.show(hudFragment);
     } else {
       ft.hide(callFragment);
       ft.hide(hudFragment);
     }
     ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
     ft.commit();
   }
 
   private void updateVideoView() {
-    remoteRenderLayout.setPosition(REMOTE_X, REMOTE_Y, REMOTE_WIDTH, REMOTE_HEIGHT);
-    remoteRender.setScalingType(scalingType);
-    remoteRender.setMirror(false);
-
+    VideoRendererGui.update(remoteRender,
+        REMOTE_X, REMOTE_Y,
+        REMOTE_WIDTH, REMOTE_HEIGHT, scalingType, false);
     if (iceConnected) {
-      localRenderLayout.setPosition(
-          LOCAL_X_CONNECTED, LOCAL_Y_CONNECTED, LOCAL_WIDTH_CONNECTED, LOCAL_HEIGHT_CONNECTED);
-      localRender.setScalingType(ScalingType.SCALE_ASPECT_FIT);
+      VideoRendererGui.update(localRender,
+          LOCAL_X_CONNECTED, LOCAL_Y_CONNECTED,
+          LOCAL_WIDTH_CONNECTED, LOCAL_HEIGHT_CONNECTED,
+          ScalingType.SCALE_ASPECT_FIT, true);
     } else {
-      localRenderLayout.setPosition(
-          LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING, LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING);
-      localRender.setScalingType(scalingType);
+      VideoRendererGui.update(localRender,
+          LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING,
+          LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING, scalingType, true);
     }
-    localRender.setMirror(true);
-
-    localRender.requestLayout();
-    remoteRender.requestLayout();
   }
 
   private void startCall() {
     if (appRtcClient == null) {
       Log.e(TAG, "AppRTC client is not allocated for a call.");
       return;
     }
     callStartedTimeMs = System.currentTimeMillis();
 
     // Start room connection.
@@ skipping 37 matching lines @@
   // Create peer connection factory when EGL context is ready.
   private void createPeerConnectionFactory() {
     runOnUiThread(new Runnable() {
       @Override
       public void run() {
         if (peerConnectionClient == null) {
           final long delta = System.currentTimeMillis() - callStartedTimeMs;
           Log.d(TAG, "Creating peer connection factory, delay=" + delta + "ms");
           peerConnectionClient = PeerConnectionClient.getInstance();
           peerConnectionClient.createPeerConnectionFactory(CallActivity.this,
-              rootEglBase.getContext(), peerConnectionParameters,
+              VideoRendererGui.getEGLContext(), peerConnectionParameters,
               CallActivity.this);
         }
         if (signalingParameters != null) {
           Log.w(TAG, "EGL context is ready after room connection.");
           onConnectedToRoomInternal(signalingParameters);
         }
       }
     });
   }
 
@@ skipping 234 matching lines @@
         }
       }
     });
   }
 
   @Override
   public void onPeerConnectionError(final String description) {
     reportError(description);
   }
 }