SurfaceViewRenderer: Add resource name to log outputs and exceptions

talk/app/webrtc/java/android/org/webrtc/SurfaceViewRenderer.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 10 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
 import android.content.Context;
+import android.content.res.Resources.NotFoundException;
 import android.graphics.Point;
 import android.graphics.SurfaceTexture;
 import android.opengl.GLES20;
 import android.opengl.Matrix;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.AttributeSet;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 
@@ skipping 104 matching lines @@
   }
 
   /**
    * Initialize this class, sharing resources with |sharedContext|. It is allowed to call init() to
    * reinitialize the renderer after a previous init()/release() cycle.
    */
   public void init(
       EGLContext sharedContext, RendererCommon.RendererEvents rendererEvents) {
     synchronized (handlerLock) {
       if (renderThreadHandler != null) {
-        throw new IllegalStateException("Already initialized");
+        throw new IllegalStateException(getResourceName() + "Already initialized");
       }
-      Logging.d(TAG, "Initializing");
+      Logging.d(TAG, getResourceName() + "Initializing.");
       this.rendererEvents = rendererEvents;
       renderThread = new HandlerThread(TAG);
       renderThread.start();
       drawer = new GlRectDrawer();
       eglBase = new EglBase(sharedContext, EglBase.ConfigType.PLAIN);
       renderThreadHandler = new Handler(renderThread.getLooper());
     }
     tryCreateEglSurface();
   }
 
@@ skipping 20 matching lines @@
   /**
    * Block until any pending frame is returned and all GL resources released, even if an interrupt
    * occurs. If an interrupt occurs during release(), the interrupt flag will be set. This function
    * should be called before the Activity is destroyed and the EGLContext is still valid. If you
    * don't call this function, the GL resources might leak.
    */
   public void release() {
     final CountDownLatch eglCleanupBarrier = new CountDownLatch(1);
     synchronized (handlerLock) {
       if (renderThreadHandler == null) {
-        Logging.d(TAG, "Already released");
+        Logging.d(TAG, getResourceName() + "Already released");
         return;
       }
       // Release EGL and GL resources on render thread.
       // TODO(magjed): This might not be necessary - all OpenGL resources are automatically deleted
       // when the EGL context is lost. It might be dangerous to delete them manually in
       // Activity.onDestroy().
       renderThreadHandler.postAtFrontOfQueue(new Runnable() {
         @Override public void run() {
           drawer.release();
           drawer = null;
           if (yuvTextures != null) {
             GLES20.glDeleteTextures(3, yuvTextures, 0);
             yuvTextures = null;
           }
           if (eglBase.hasSurface()) {
             // Clear last rendered image to black.
-            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-            eglBase.swapBuffers();
+            makeBlack();
           }
           eglBase.release();
           eglBase = null;
           eglCleanupBarrier.countDown();
         }
       });
       // Don't accept any more frames or messages to the render thread.
       renderThreadHandler = null;
     }
     // Make sure the EGL/GL cleanup posted above is executed.
@@ skipping 43 matching lines @@
   }
 
   // VideoRenderer.Callbacks interface.
   @Override
   public void renderFrame(VideoRenderer.I420Frame frame) {
     synchronized (statisticsLock) {
       ++framesReceived;
     }
     synchronized (handlerLock) {
       if (renderThreadHandler == null) {
-        Logging.d(TAG, "Dropping frame - SurfaceViewRenderer not initialized or already released.");
+        Logging.d(TAG, getResourceName()
+            + "Dropping frame - Not initialized or already released.");
         VideoRenderer.renderFrameDone(frame);
         return;
       }
       synchronized (frameLock) {
         if (pendingFrame != null) {
           // Drop old frame.
           synchronized (statisticsLock) {
             ++framesDropped;
           }
           VideoRenderer.renderFrameDone(pendingFrame);
@@ skipping 39 matching lines @@
       layoutWidth = right - left;
       layoutHeight = bottom - top;
     }
     // Might have a pending frame waiting for a layout of correct size.
     runOnRenderThread(renderFrameRunnable);
   }
 
   // SurfaceHolder.Callback interface.
   @Override
   public void surfaceCreated(final SurfaceHolder holder) {
-    Logging.d(TAG, "Surface created");
+    Logging.d(TAG, getResourceName() + "Surface created.");
     synchronized (layoutLock) {
       isSurfaceCreated = true;
     }
     tryCreateEglSurface();
   }
 
   @Override
   public void surfaceDestroyed(SurfaceHolder holder) {
-    Logging.d(TAG, "Surface destroyed");
+    Logging.d(TAG, getResourceName() + "Surface destroyed.");
     synchronized (layoutLock) {
       isSurfaceCreated = false;
       surfaceWidth = 0;
       surfaceHeight = 0;
     }
     runOnRenderThread(new Runnable() {
       @Override public void run() {
         eglBase.releaseSurface();
       }
     });
   }
 
   @Override
   public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-    Logging.d(TAG, "Surface changed: " + width + "x" + height);
+    Logging.d(TAG, getResourceName() + "Surface changed: " + width + "x" + height);
     synchronized (layoutLock) {
       surfaceWidth = width;
       surfaceHeight = height;
     }
     // Might have a pending frame waiting for a surface of correct size.
     runOnRenderThread(renderFrameRunnable);
   }
 
   /**
    * Private helper function to post tasks safely.
    */
   private void runOnRenderThread(Runnable runnable) {
     synchronized (handlerLock) {
       if (renderThreadHandler != null) {
         renderThreadHandler.post(runnable);
       }
     }
   }
 
+  private String getResourceName() {
+    try {
+      return getResources().getResourceEntryName(getId()) + ": ";
+    } catch (NotFoundException e) {
+      return "";
+    }
+  }
+
+  private void makeBlack() {
+    if (Thread.currentThread() != renderThread) {
+      throw new IllegalStateException(getResourceName() + "Wrong thread.");
+    }
+    GLES20.glClearColor(0, 0, 0, 0);
+    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+    eglBase.swapBuffers();
+  }
+
   /**
    * Requests new layout if necessary. Returns true if layout and surface size are consistent.
    */
   private boolean checkConsistentLayout() {
     synchronized (layoutLock) {
       final Point desiredLayoutSize = getDesiredLayoutSize();
       if (desiredLayoutSize.x != layoutWidth || desiredLayoutSize.y != layoutHeight) {
-        Logging.d(TAG, "Requesting new layout with size: "
+        Logging.d(TAG, getResourceName() + "Requesting new layout with size: "
             + desiredLayoutSize.x + "x" + desiredLayoutSize.y);
         // Request layout update on UI thread.
         post(new Runnable() {
           @Override public void run() {
             requestLayout();
           }
         });
         return false;
       }
       // Wait for requestLayout() to propagate through this sequence before returning true:
       // requestLayout() -> onMeasure() -> onLayout() -> surfaceChanged().
       return surfaceWidth == layoutWidth && surfaceHeight == layoutHeight;
     }
   }
 
   /**
    * Renders and releases |pendingFrame|.
    */
   private void renderFrameOnRenderThread() {
+    if (Thread.currentThread() != renderThread) {
+      throw new IllegalStateException(getResourceName() + "Wrong thread.");
+    }
     if (eglBase == null || !eglBase.hasSurface()) {
-      Logging.d(TAG, "No surface to draw on");
+      Logging.d(TAG, getResourceName() + "No surface to draw on");
       return;
     }
     if (!checkConsistentLayout()) {
       // Output intermediate black frames while the layout is updated.
-      GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-      eglBase.swapBuffers();
+      makeBlack();
       return;
     }
     // After a surface size change, the EGLSurface might still have a buffer of the old size in the
     // pipeline. Querying the EGLSurface will show if the underlying buffer dimensions haven't yet
     // changed. Such a buffer will be rendered incorrectly, so flush it with a black frame.
     synchronized (layoutLock) {
       if (eglBase.surfaceWidth() != surfaceWidth || eglBase.surfaceHeight() != surfaceHeight) {
-        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-        eglBase.swapBuffers();
+        makeBlack();
       }
     }
     // Fetch and render |pendingFrame|.
     final VideoRenderer.I420Frame frame;
     synchronized (frameLock) {
       if (pendingFrame == null) {
         return;
       }
       frame = pendingFrame;
       pendingFrame = null;
@@ skipping 64 matching lines @@
                                         : (float) frameHeight / frameWidth;
     }
   }
 
   // Update frame dimensions and report any changes to |rendererEvents|.
   private void updateFrameDimensionsAndReportEvents(VideoRenderer.I420Frame frame) {
     synchronized (layoutLock) {
       if (frameWidth != frame.width || frameHeight != frame.height
           || frameRotation != frame.rotationDegree) {
         if (rendererEvents != null) {
-          final String id = getResources().getResourceEntryName(getId());
           if (frameWidth == 0 || frameHeight == 0) {
-            Logging.d(TAG, "ID: " + id + ". Reporting first rendered frame.");
+            Logging.d(TAG, getResourceName() + "Reporting first rendered frame.");
             rendererEvents.onFirstFrameRendered();
           }
-          Logging.d(TAG, "ID: " + id + ". Reporting frame resolution changed to "
+          Logging.d(TAG, getResourceName() + "Reporting frame resolution changed to "
               + frame.width + "x" + frame.height + " with rotation " + frame.rotationDegree);
           rendererEvents.onFrameResolutionChanged(frame.width, frame.height, frame.rotationDegree);
         }
         frameWidth = frame.width;
         frameHeight = frame.height;
         frameRotation = frame.rotationDegree;
       }
     }
   }
 
   private void logStatistics() {
     synchronized (statisticsLock) {
-      Logging.d(TAG, "ID: " + getResources().getResourceEntryName(getId()) + ". Frames received: "
+      Logging.d(TAG, getResourceName() + "Frames received: "
           + framesReceived + ". Dropped: " + framesDropped + ". Rendered: " + framesRendered);
       if (framesReceived > 0 && framesRendered > 0) {
         final long timeSinceFirstFrameNs = System.nanoTime() - firstFrameTimeNs;
-        Logging.d(TAG, "Duration: " + (int) (timeSinceFirstFrameNs / 1e6) +
+        Logging.d(TAG, getResourceName() + "Duration: " + (int) (timeSinceFirstFrameNs / 1e6) +
             " ms. FPS: " + (float) framesRendered * 1e9 / timeSinceFirstFrameNs);
-        Logging.d(TAG, "Average render time: "
+        Logging.d(TAG, getResourceName() + "Average render time: "
             + (int) (renderTimeNs / (1000 * framesRendered)) + " us.");
       }
     }
   }
 }