Log to webrtc logging stream from java code.

talk/app/webrtc/java/android/org/webrtc/VideoCapturerAndroid.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 18 matching lines @@
 
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.hardware.Camera;
 import android.hardware.Camera.PreviewCallback;
 import android.opengl.GLES11Ext;
 import android.opengl.GLES20;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.SystemClock;
-import android.util.Log;
 import android.view.Surface;
 import android.view.WindowManager;
 
 import org.json.JSONException;
 import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
+import org.webrtc.Logging;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Exchanger;
 import java.util.concurrent.TimeUnit;
@@ skipping 43 matching lines @@
   private final Camera.ErrorCallback cameraErrorCallback =
       new Camera.ErrorCallback() {
     @Override
     public void onError(int error, Camera camera) {
       String errorMessage;
       if (error == android.hardware.Camera.CAMERA_ERROR_SERVER_DIED) {
         errorMessage = "Camera server died!";
       } else {
         errorMessage = "Camera error: " + error;
       }
-      Log.e(TAG, errorMessage);
+      Logging.e(TAG, errorMessage);
       if (errorHandler != null) {
         errorHandler.onCameraError(errorMessage);
       }
     }
   };
 
   // Camera observer - monitors camera framerate and amount of available
   // camera buffers. Observer is excecuted on camera thread.
   private final Runnable cameraObserver = new Runnable() {
     @Override
     public void run() {
       int cameraFps = (cameraFramesCount * 1000 + CAMERA_OBSERVER_PERIOD_MS / 2)
           / CAMERA_OBSERVER_PERIOD_MS;
       double averageCaptureBuffersCount = 0;
       if (cameraFramesCount > 0) {
         averageCaptureBuffersCount =
             (double)captureBuffersCount / cameraFramesCount;
       }
-      Log.d(TAG, "Camera fps: " + cameraFps + ". CaptureBuffers: " +
+      Logging.d(TAG, "Camera fps: " + cameraFps + ". CaptureBuffers: " +
           String.format("%.1f", averageCaptureBuffersCount) +
           ". Pending buffers: " + videoBuffers.pendingFramesTimeStamps());
       if (cameraFramesCount == 0) {
-        Log.e(TAG, "Camera freezed.");
+        Logging.e(TAG, "Camera freezed.");
         if (errorHandler != null) {
           errorHandler.onCameraError("Camera failure.");
         }
       } else {
         cameraFramesCount = 0;
         captureBuffersCount = 0;
         if (cameraThreadHandler != null) {
           cameraThreadHandler.postDelayed(this, CAMERA_OBSERVER_PERIOD_MS);
         }
       }
@@ skipping 19 matching lines @@
 
   // Switch camera to the next valid camera id. This can only be called while
   // the camera is running.
   // Returns true on success. False if the next camera does not support the
   // current resolution.
   public synchronized boolean switchCamera(final Runnable switchDoneEvent) {
     if (Camera.getNumberOfCameras() < 2 )
       return false;
 
     if (cameraThreadHandler == null) {
-        Log.e(TAG, "Calling switchCamera() for stopped camera.");
+        Logging.e(TAG, "Calling switchCamera() for stopped camera.");
         return false;
     }
     if (pendingCameraSwitch) {
       // Do not handle multiple camera switch request to avoid blocking
       // camera thread by handling too many switch request from a queue.
-      Log.w(TAG, "Ignoring camera switch request.");
+      Logging.w(TAG, "Ignoring camera switch request.");
       return false;
     }
 
     pendingCameraSwitch = true;
     id = (id + 1) % Camera.getNumberOfCameras();
     cameraThreadHandler.post(new Runnable() {
       @Override public void run() {
         switchCameraOnCameraThread(switchDoneEvent);
       }
     });
     return true;
   }
 
   // Requests a new output format from the video capturer. Captured frames
   // by the camera will be scaled/or dropped by the video capturer.
   public synchronized void onOutputFormatRequest(
       final int width, final int height, final int fps) {
     if (cameraThreadHandler == null) {
-      Log.e(TAG, "Calling onOutputFormatRequest() for already stopped camera.");
+      Logging.e(TAG, "Calling onOutputFormatRequest() for already stopped camera.");
       return;
     }
     cameraThreadHandler.post(new Runnable() {
       @Override public void run() {
         onOutputFormatRequestOnCameraThread(width, height, fps);
       }
     });
   }
 
   // Reconfigure the camera to capture in a new format. This should only be called while the camera
   // is running.
   public synchronized void changeCaptureFormat(
       final int width, final int height, final int framerate) {
     if (cameraThreadHandler == null) {
-      Log.e(TAG, "Calling changeCaptureFormat() for already stopped camera.");
+      Logging.e(TAG, "Calling changeCaptureFormat() for already stopped camera.");
       return;
     }
     cameraThreadHandler.post(new Runnable() {
       @Override public void run() {
         startPreviewOnCameraThread(width, height, framerate);
       }
     });
   }
 
   public synchronized List<CaptureFormat> getSupportedFormats() {
     return CameraEnumerationAndroid.getSupportedFormats(id);
   }
 
   // Return a list of timestamps for the frames that have been sent out, but not returned yet.
   // Useful for logging and testing.
   public String pendingFramesTimeStamps() {
     return videoBuffers.pendingFramesTimeStamps();
   }
 
   private VideoCapturerAndroid() {
-    Log.d(TAG, "VideoCapturerAndroid");
+    Logging.d(TAG, "VideoCapturerAndroid");
   }
 
   // Called by native code.
   // Initializes local variables for the camera named |deviceName|. If |deviceName| is empty, the
   // first available device is used in order to be compatible with the generic VideoCapturer class.
   synchronized boolean init(String deviceName) {
-    Log.d(TAG, "init: " + deviceName);
+    Logging.d(TAG, "init: " + deviceName);
     if (deviceName == null)
       return false;
 
     boolean foundDevice = false;
     if (deviceName.isEmpty()) {
       this.id = 0;
       foundDevice = true;
     } else {
       for (int i = 0; i < Camera.getNumberOfCameras(); ++i) {
         String existing_device = CameraEnumerationAndroid.getDeviceName(i);
@@ skipping 24 matching lines @@
   }
 
   // Called by native code.  Returns true if capturer is started.
   //
   // Note that this actually opens the camera, and Camera callbacks run on the
   // thread that calls open(), so this is done on the CameraThread.  Since the
   // API needs a synchronous success return value we wait for the result.
   synchronized void startCapture(
       final int width, final int height, final int framerate,
       final Context applicationContext, final CapturerObserver frameObserver) {
-    Log.d(TAG, "startCapture requested: " + width + "x" + height
+    Logging.d(TAG, "startCapture requested: " + width + "x" + height
         + "@" + framerate);
     if (applicationContext == null) {
       throw new RuntimeException("applicationContext not set.");
     }
     if (frameObserver == null) {
       throw new RuntimeException("frameObserver not set.");
     }
     if (cameraThreadHandler != null) {
       throw new RuntimeException("Camera has already been started.");
     }
@@ skipping 10 matching lines @@
     });
   }
 
   private void startCaptureOnCameraThread(
       int width, int height, int framerate, CapturerObserver frameObserver,
       Context applicationContext) {
     Throwable error = null;
     this.applicationContext = applicationContext;
     this.frameObserver = frameObserver;
     try {
-      Log.d(TAG, "Opening camera " + id);
+      Logging.d(TAG, "Opening camera " + id);
       camera = Camera.open(id);
       info = new Camera.CameraInfo();
       Camera.getCameraInfo(id, info);
       // No local renderer (we only care about onPreviewFrame() buffers, not a
       // directly-displayed UI element).  Camera won't capture without
       // setPreview{Texture,Display}, so we create a SurfaceTexture and hand
       // it over to Camera, but never listen for frame-ready callbacks,
       // and never call updateTexImage on it.
       try {
         cameraGlTexture = GlUtil.generateTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
         cameraSurfaceTexture = new SurfaceTexture(cameraGlTexture);
         cameraSurfaceTexture.setOnFrameAvailableListener(null);
 
         camera.setPreviewTexture(cameraSurfaceTexture);
       } catch (IOException e) {
-        Log.e(TAG, "setPreviewTexture failed", error);
+        Logging.e(TAG, "setPreviewTexture failed", error);
         throw new RuntimeException(e);
       }
 
-      Log.d(TAG, "Camera orientation: " + info.orientation +
+      Logging.d(TAG, "Camera orientation: " + info.orientation +
           " .Device orientation: " + getDeviceOrientation());
       camera.setErrorCallback(cameraErrorCallback);
       startPreviewOnCameraThread(width, height, framerate);
       frameObserver.OnCapturerStarted(true);
 
       // Start camera observer.
       cameraFramesCount = 0;
       captureBuffersCount = 0;
       cameraThreadHandler.postDelayed(cameraObserver, CAMERA_OBSERVER_PERIOD_MS);
       return;
     } catch (RuntimeException e) {
       error = e;
     }
-    Log.e(TAG, "startCapture failed", error);
+    Logging.e(TAG, "startCapture failed", error);
     stopCaptureOnCameraThread();
     cameraThreadHandler = null;
     frameObserver.OnCapturerStarted(false);
     if (errorHandler != null) {
       errorHandler.onCameraError("Camera can not be started.");
     }
     return;
   }
 
   // (Re)start preview with the closest supported format to |width| x |height| @ |framerate|.
   private void startPreviewOnCameraThread(int width, int height, int framerate) {
-    Log.d(
+    Logging.d(
         TAG, "startPreviewOnCameraThread requested: " + width + "x" + height + "@" + framerate);
     if (camera == null) {
-      Log.e(TAG, "Calling startPreviewOnCameraThread on stopped camera.");
+      Logging.e(TAG, "Calling startPreviewOnCameraThread on stopped camera.");
       return;
     }
 
     requestedWidth = width;
     requestedHeight = height;
     requestedFramerate = framerate;
 
     // Find closest supported format for |width| x |height| @ |framerate|.
     final Camera.Parameters parameters = camera.getParameters();
     final int[] range = CameraEnumerationAndroid.getFramerateRange(parameters, framerate * 1000);
     final Camera.Size previewSize = CameraEnumerationAndroid.getClosestSupportedSize(
         parameters.getSupportedPreviewSizes(), width, height);
     final CaptureFormat captureFormat = new CaptureFormat(
         previewSize.width, previewSize.height,
         range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX],
         range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]);
 
     // Check if we are already using this capture format, then we don't need to do anything.
     if (captureFormat.equals(this.captureFormat)) {
       return;
     }
 
     // Update camera parameters.
-    Log.d(TAG, "isVideoStabilizationSupported: " +
+    Logging.d(TAG, "isVideoStabilizationSupported: " +
         parameters.isVideoStabilizationSupported());
     if (parameters.isVideoStabilizationSupported()) {
       parameters.setVideoStabilization(true);
     }
     // Note: setRecordingHint(true) actually decrease frame rate on N5.
     // parameters.setRecordingHint(true);
     if (captureFormat.maxFramerate > 0) {
       parameters.setPreviewFpsRange(captureFormat.minFramerate, captureFormat.maxFramerate);
     }
     parameters.setPreviewSize(captureFormat.width, captureFormat.height);
     parameters.setPreviewFormat(captureFormat.imageFormat);
     // Picture size is for taking pictures and not for preview/video, but we need to set it anyway
     // as a workaround for an aspect ratio problem on Nexus 7.
     final Camera.Size pictureSize = CameraEnumerationAndroid.getClosestSupportedSize(
         parameters.getSupportedPictureSizes(), width, height);
     parameters.setPictureSize(pictureSize.width, pictureSize.height);
 
     // Temporarily stop preview if it's already running.
     if (this.captureFormat != null) {
       camera.stopPreview();
       // Calling |setPreviewCallbackWithBuffer| with null should clear the internal camera buffer
       // queue, but sometimes we receive a frame with the old resolution after this call anyway.
       camera.setPreviewCallbackWithBuffer(null);
     }
 
     // (Re)start preview.
-    Log.d(TAG, "Start capturing: " + captureFormat);
+    Logging.d(TAG, "Start capturing: " + captureFormat);
     this.captureFormat = captureFormat;
     camera.setParameters(parameters);
     videoBuffers.queueCameraBuffers(captureFormat.frameSize(), camera);
     camera.setPreviewCallbackWithBuffer(this);
     camera.startPreview();
   }
 
   // Called by native code.  Returns true when camera is known to be stopped.
   synchronized void stopCapture() throws InterruptedException {
     if (cameraThreadHandler == null) {
-      Log.e(TAG, "Calling stopCapture() for already stopped camera.");
+      Logging.e(TAG, "Calling stopCapture() for already stopped camera.");
       return;
     }
-    Log.d(TAG, "stopCapture");
+    Logging.d(TAG, "stopCapture");
     cameraThreadHandler.post(new Runnable() {
         @Override public void run() {
           stopCaptureOnCameraThread();
         }
     });
     cameraThread.join();
     cameraThreadHandler = null;
-    Log.d(TAG, "stopCapture done");
+    Logging.d(TAG, "stopCapture done");
   }
 
   private void stopCaptureOnCameraThread() {
     doStopCaptureOnCameraThread();
     Looper.myLooper().quit();
     return;
   }
 
   private void doStopCaptureOnCameraThread() {
-    Log.d(TAG, "stopCaptureOnCameraThread");
+    Logging.d(TAG, "stopCaptureOnCameraThread");
     if (camera == null) {
       return;
     }
     try {
       cameraThreadHandler.removeCallbacks(cameraObserver);
-      Log.d(TAG, "Stop preview.");
+      Logging.d(TAG, "Stop preview.");
       camera.stopPreview();
       camera.setPreviewCallbackWithBuffer(null);
       videoBuffers.stopReturnBuffersToCamera();
       captureFormat = null;
 
       camera.setPreviewTexture(null);
       cameraSurfaceTexture = null;
       if (cameraGlTexture != 0) {
         GLES20.glDeleteTextures(1, new int[] {cameraGlTexture}, 0);
         cameraGlTexture = 0;
       }
-      Log.d(TAG, "Release camera.");
+      Logging.d(TAG, "Release camera.");
       camera.release();
       camera = null;
     } catch (IOException e) {
-      Log.e(TAG, "Failed to stop camera", e);
+      Logging.e(TAG, "Failed to stop camera", e);
     }
   }
 
   private void switchCameraOnCameraThread(Runnable switchDoneEvent) {
-    Log.d(TAG, "switchCameraOnCameraThread");
+    Logging.d(TAG, "switchCameraOnCameraThread");
 
     doStopCaptureOnCameraThread();
     startCaptureOnCameraThread(requestedWidth, requestedHeight, requestedFramerate, frameObserver,
         applicationContext);
     pendingCameraSwitch = false;
-    Log.d(TAG, "switchCameraOnCameraThread done");
+    Logging.d(TAG, "switchCameraOnCameraThread done");
     if (switchDoneEvent != null) {
       switchDoneEvent.run();
     }
   }
 
   private void onOutputFormatRequestOnCameraThread(
       int width, int height, int fps) {
     if (camera == null) {
       return;
     }
-    Log.d(TAG, "onOutputFormatRequestOnCameraThread: " + width + "x" + height +
+    Logging.d(TAG, "onOutputFormatRequestOnCameraThread: " + width + "x" + height +
         "@" + fps);
     frameObserver.OnOutputFormatRequest(width, height, fps);
   }
 
   void returnBuffer(long timeStamp) {
     videoBuffers.returnBuffer(timeStamp);
   }
 
   private int getDeviceOrientation() {
     int orientation = 0;
@@ skipping 41 matching lines @@
     }
     rotation = (info.orientation + rotation) % 360;
     // Mark the frame owning |data| as used.
     // Note that since data is directBuffer,
     // data.length >= videoBuffers.frameSize.
     if (videoBuffers.reserveByteBuffer(data, captureTimeNs)) {
       cameraFramesCount++;
       frameObserver.OnFrameCaptured(data, videoBuffers.frameSize, captureFormat.width,
           captureFormat.height, rotation, captureTimeNs);
     } else {
-      Log.w(TAG, "reserveByteBuffer failed - dropping frame.");
+      Logging.w(TAG, "reserveByteBuffer failed - dropping frame.");
     }
   }
 
   // runCameraThreadUntilIdle make sure all posted messages to the cameraThread
   // is processed before returning. It does that by itself posting a message to
   // to the message queue and waits until is has been processed.
   // It is used in tests.
   void runCameraThreadUntilIdle() {
     if (cameraThreadHandler == null)
       return;
@@ skipping 42 matching lines @@
     synchronized void queueCameraBuffers(int frameSize, Camera camera) {
       this.camera = camera;
       this.frameSize = frameSize;
 
       queuedBuffers.clear();
       for (int i = 0; i < numCaptureBuffers; ++i) {
         final ByteBuffer buffer = ByteBuffer.allocateDirect(frameSize);
         camera.addCallbackBuffer(buffer.array());
         queuedBuffers.put(buffer.array(), buffer);
       }
-      Log.d(TAG, "queueCameraBuffers enqueued " + numCaptureBuffers
+      Logging.d(TAG, "queueCameraBuffers enqueued " + numCaptureBuffers
           + " buffers of size " + frameSize + ".");
     }
 
     synchronized String pendingFramesTimeStamps() {
       List<Long> timeStampsMs = new ArrayList<Long>();
       for (Long timeStampNs : pendingBuffers.keySet()) {
         timeStampsMs.add(TimeUnit.NANOSECONDS.toMillis(timeStampNs));
       }
       return timeStampsMs.toString();
     }
 
     synchronized void stopReturnBuffersToCamera() {
       this.camera = null;
       queuedBuffers.clear();
       // Frames in |pendingBuffers| need to be kept alive until they are returned.
-      Log.d(TAG, "stopReturnBuffersToCamera called."
+      Logging.d(TAG, "stopReturnBuffersToCamera called."
             + (pendingBuffers.isEmpty() ?
                    " All buffers have been returned."
                    : " Pending buffers: " + pendingFramesTimeStamps() + "."));
     }
 
     synchronized boolean reserveByteBuffer(byte[] data, long timeStamp) {
       final ByteBuffer buffer = queuedBuffers.remove(data);
       if (buffer == null) {
         // Frames might be posted to |onPreviewFrame| with the previous format while changing
         // capture format in |startPreviewOnCameraThread|. Drop these old frames.
-        Log.w(TAG, "Received callback buffer from previous configuration with length: "
+        Logging.w(TAG, "Received callback buffer from previous configuration with length: "
             + (data == null ? "null" : data.length));
         return false;
       }
       if (buffer.capacity() != frameSize) {
         throw new IllegalStateException("Callback buffer has unexpected frame size");
       }
       if (pendingBuffers.containsKey(timeStamp)) {
-        Log.e(TAG, "Timestamp already present in pending buffers - they need to be unique");
+        Logging.e(TAG, "Timestamp already present in pending buffers - they need to be unique");
         return false;
       }
       pendingBuffers.put(timeStamp, buffer);
       if (queuedBuffers.isEmpty()) {
-        Log.v(TAG, "Camera is running out of capture buffers."
+        Logging.v(TAG, "Camera is running out of capture buffers."
             + " Pending buffers: " + pendingFramesTimeStamps());
       }
       return true;
     }
 
     synchronized void returnBuffer(long timeStamp) {
       final ByteBuffer returnedFrame = pendingBuffers.remove(timeStamp);
       if (returnedFrame == null) {
         throw new RuntimeException("unknown data buffer with time stamp "
             + timeStamp + "returned?!?");
       }
 
       if (camera != null && returnedFrame.capacity() == frameSize) {
         camera.addCallbackBuffer(returnedFrame.array());
         if (queuedBuffers.isEmpty()) {
-          Log.v(TAG, "Frame returned when camera is running out of capture"
+          Logging.v(TAG, "Frame returned when camera is running out of capture"
               + " buffers for TS " + TimeUnit.NANOSECONDS.toMillis(timeStamp));
         }
         queuedBuffers.put(returnedFrame.array(), returnedFrame);
         return;
       }
 
       if (returnedFrame.capacity() != frameSize) {
-        Log.d(TAG, "returnBuffer with time stamp "
+        Logging.d(TAG, "returnBuffer with time stamp "
             + TimeUnit.NANOSECONDS.toMillis(timeStamp)
             + " called with old frame size, " + returnedFrame.capacity() + ".");
         // Since this frame has the wrong size, don't requeue it. Frames with the correct size are
         // created in queueCameraBuffers so this must be an old buffer.
         return;
       }
 
-      Log.d(TAG, "returnBuffer with time stamp "
+      Logging.d(TAG, "returnBuffer with time stamp "
           + TimeUnit.NANOSECONDS.toMillis(timeStamp)
           + " called after camera has been stopped.");
     }
   }
 
   // Interface used for providing callbacks to an observer.
   interface CapturerObserver {
     // Notify if the camera have been started successfully or not.
     // Called on a Java thread owned by VideoCapturerAndroid.
     abstract void OnCapturerStarted(boolean success);
@@ skipping 35 matching lines @@
     }
 
     private native void nativeCapturerStarted(long nativeCapturer,
         boolean success);
     private native void nativeOnFrameCaptured(long nativeCapturer,
         byte[] data, int length, int width, int height, int rotation, long timeStamp);
     private native void nativeOnOutputFormatRequest(long nativeCapturer,
         int width, int height, int fps);
   }
 }