Make PeerConnectionClient non-singleton.

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

 /*
  *  Copyright 2014 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.
  */
 
@@ skipping 85 matching lines @@
   private static final String AUDIO_ECHO_CANCELLATION_CONSTRAINT = "googEchoCancellation";
   private static final String AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT = "googAutoGainControl";
   private static final String AUDIO_HIGH_PASS_FILTER_CONSTRAINT = "googHighpassFilter";
   private static final String AUDIO_NOISE_SUPPRESSION_CONSTRAINT = "googNoiseSuppression";
   private static final String AUDIO_LEVEL_CONTROL_CONSTRAINT = "levelControl";
   private static final String DTLS_SRTP_KEY_AGREEMENT_CONSTRAINT = "DtlsSrtpKeyAgreement";
   private static final int HD_VIDEO_WIDTH = 1280;
   private static final int HD_VIDEO_HEIGHT = 720;
   private static final int BPS_IN_KBPS = 1000;
 
-  private static final PeerConnectionClient instance = new PeerConnectionClient();
+  // Executor thread is started once in private ctor and is used for all
+  // peer connection API calls to ensure new peer connection factory is
+  // created on the same thread as previously destroyed factory.

[magjed_webrtc, 2017/08/31 11:28:59]

Do we need this to avoid the crash in issue 8135? Isn't PeerConnectionFactory
.dispose() synchronous?

[sakal, 2017/08/31 14:18:55]

This is needed because close in asynchronous.

+  private static final ExecutorService executor = Executors.newSingleThreadExecutor();
+
   private final PCObserver pcObserver = new PCObserver();
   private final SDPObserver sdpObserver = new SDPObserver();
-  private final ExecutorService executor;
 
+  private final EglBase rootEglBase;
   private PeerConnectionFactory factory;
   private PeerConnection peerConnection;
   PeerConnectionFactory.Options options = null;
   private AudioSource audioSource;
   private VideoSource videoSource;
   private boolean videoCallEnabled;
   private boolean preferIsac;
   private String preferredVideoCodec;
   private boolean videoCapturerStopped;
   private boolean isError;
@@ skipping 160 matching lines @@
      * Callback fired once peer connection statistics is ready.
      */
     void onPeerConnectionStatsReady(final StatsReport[] reports);
 
     /**
      * Callback fired once peer connection error happened.
      */
     void onPeerConnectionError(final String description);
   }
 
-  private PeerConnectionClient() {
-    // Executor thread is started once in private ctor and is used for all
-    // peer connection API calls to ensure new peer connection factory is
-    // created on the same thread as previously destroyed factory.
-    executor = Executors.newSingleThreadExecutor();
-  }
-
-  public static PeerConnectionClient getInstance() {
-    return instance;
+  public PeerConnectionClient() {
+    rootEglBase = EglBase.create();
   }
 
   public void setPeerConnectionFactoryOptions(PeerConnectionFactory.Options options) {
     this.options = options;
   }
 
   public void createPeerConnectionFactory(final Context context,
       final PeerConnectionParameters peerConnectionParameters, final PeerConnectionEvents events) {
     this.peerConnectionParameters = peerConnectionParameters;
     this.events = events;
@@ skipping 18 matching lines @@
     statsTimer = new Timer();
 
     executor.execute(new Runnable() {
       @Override
       public void run() {
         createPeerConnectionFactoryInternal(context);
       }
     });
   }
 
-  public void createPeerConnection(final EglBase.Context renderEGLContext,
-      final VideoRenderer.Callbacks localRender, final VideoRenderer.Callbacks remoteRender,
-      final VideoCapturer videoCapturer, final SignalingParameters signalingParameters) {
-    createPeerConnection(renderEGLContext, localRender, Collections.singletonList(remoteRender),
-        videoCapturer, signalingParameters);
+  public void createPeerConnection(final VideoRenderer.Callbacks localRender,
+      final VideoRenderer.Callbacks remoteRender, final VideoCapturer videoCapturer,
+      final SignalingParameters signalingParameters) {
+    createPeerConnection(
+        localRender, Collections.singletonList(remoteRender), videoCapturer, signalingParameters);
   }
-  public void createPeerConnection(final EglBase.Context renderEGLContext,
-      final VideoRenderer.Callbacks localRender, final List<VideoRenderer.Callbacks> remoteRenders,
-      final VideoCapturer videoCapturer, final SignalingParameters signalingParameters) {
+  public void createPeerConnection(final VideoRenderer.Callbacks localRender,
+      final List<VideoRenderer.Callbacks> remoteRenders, final VideoCapturer videoCapturer,
+      final SignalingParameters signalingParameters) {
     if (peerConnectionParameters == null) {
       Log.e(TAG, "Creating peer connection without initializing factory.");
       return;
     }
     this.localRender = localRender;
     this.remoteRenders = remoteRenders;
     this.videoCapturer = videoCapturer;
     this.signalingParameters = signalingParameters;
     executor.execute(new Runnable() {
       @Override
       public void run() {
         try {
           createMediaConstraintsInternal();
-          createPeerConnectionInternal(renderEGLContext);
+          createPeerConnectionInternal();
         } catch (Exception e) {
           reportError("Failed to create peer connection: " + e.getMessage());
           throw e;
         }
       }
     });
   }
 
   public void close() {
     executor.execute(new Runnable() {
@@ skipping 205 matching lines @@
         new MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"));
     if (videoCallEnabled || peerConnectionParameters.loopback) {
       sdpMediaConstraints.mandatory.add(
           new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"));
     } else {
       sdpMediaConstraints.mandatory.add(
           new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "false"));
     }
   }
 
-  private void createPeerConnectionInternal(EglBase.Context renderEGLContext) {
+  private void createPeerConnectionInternal() {
     if (factory == null || isError) {
       Log.e(TAG, "Peerconnection factory is not created");
       return;
     }
     Log.d(TAG, "Create peer connection.");
 
     Log.d(TAG, "PCConstraints: " + pcConstraints.toString());
     queuedRemoteCandidates = new LinkedList<IceCandidate>();
 
     if (videoCallEnabled) {
-      Log.d(TAG, "EGLContext: " + renderEGLContext);
-      factory.setVideoHwAccelerationOptions(renderEGLContext, renderEGLContext);
+      factory.setVideoHwAccelerationOptions(
+          rootEglBase.getEglBaseContext(), rootEglBase.getEglBaseContext());
     }
 
     PeerConnection.RTCConfiguration rtcConfig =
         new PeerConnection.RTCConfiguration(signalingParameters.iceServers);
     // TCP candidates are only useful when connecting to a server that supports
     // ICE-TCP.
     rtcConfig.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED;
     rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE;
     rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE;
     rtcConfig.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY;
@@ skipping 82 matching lines @@
       videoSource = null;
     }
     localRender = null;
     remoteRenders = null;
     Log.d(TAG, "Closing peer connection factory.");
     if (factory != null) {
       factory.dispose();
       factory = null;
     }
     options = null;
+    rootEglBase.release();
     Log.d(TAG, "Closing peer connection done.");
     events.onPeerConnectionClosed();
     PeerConnectionFactory.stopInternalTracingCapture();
     PeerConnectionFactory.shutdownInternalTracer();
     events = null;
   }
 
   public boolean isHDVideo() {
     if (!videoCallEnabled) {
       return false;
     }
 
     return videoWidth * videoHeight >= 1280 * 720;
   }
 
+  public EglBase.Context getRenderContext() {
+    return rootEglBase.getEglBaseContext();
+  }
+
   private void getStats() {
     if (peerConnection == null || isError) {
       return;
     }
     boolean success = peerConnection.getStats(new StatsObserver() {
       @Override
       public void onComplete(final StatsReport[] reports) {
         events.onPeerConnectionStatsReady(reports);
       }
     }, null);
@@ skipping 630 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }