Fixes logging levels in WebRtcAudioXXX.java classes

webrtc/modules/audio_device/android/java/src/org/webrtc/voiceengine/WebRtcAudioRecord.java

 /*
  *  Copyright (c) 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.
  */
 
@@ skipping 52 matching lines @@
   private class AudioRecordThread extends Thread {
     private volatile boolean keepAlive = true;
 
     public AudioRecordThread(String name) {
       super(name);
     }
 
     @Override
     public void run() {
       Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
-      Logging.w(TAG, "AudioRecordThread" + WebRtcAudioUtils.getThreadInfo());
+      Logging.d(TAG, "AudioRecordThread" + WebRtcAudioUtils.getThreadInfo());
       assertTrue(audioRecord.getRecordingState()
           == AudioRecord.RECORDSTATE_RECORDING);
 
       long lastTime = System.nanoTime();
       while (keepAlive) {
         int bytesRead = audioRecord.read(byteBuffer, byteBuffer.capacity());
         if (bytesRead == byteBuffer.capacity()) {
           nativeDataIsRecorded(bytesRead, nativeAudioRecord);
         } else {
           Logging.e(TAG,"AudioRecord.read failed: " + bytesRead);
           if (bytesRead == AudioRecord.ERROR_INVALID_OPERATION) {
             keepAlive = false;
           }
         }
         if (DEBUG) {
           long nowTime = System.nanoTime();
           long durationInMs =
               TimeUnit.NANOSECONDS.toMillis((nowTime - lastTime));
           lastTime = nowTime;
-          Logging.w(TAG, "bytesRead[" + durationInMs + "] " + bytesRead);
+          Logging.d(TAG, "bytesRead[" + durationInMs + "] " + bytesRead);
         }
       }
 
       try {
         audioRecord.stop();
       } catch (IllegalStateException e) {
         Logging.e(TAG,"AudioRecord.stop failed: " + e.getMessage());
       }
     }
 
     public void joinThread() {
       keepAlive = false;
       while (isAlive()) {
         try {
           join();
         } catch (InterruptedException e) {
           // Ignore.
         }
       }
     }
   }
 
   WebRtcAudioRecord(Context context, long nativeAudioRecord) {
-    Logging.w(TAG, "ctor" + WebRtcAudioUtils.getThreadInfo());
+    Logging.d(TAG, "ctor" + WebRtcAudioUtils.getThreadInfo());
     this.context = context;
     this.nativeAudioRecord = nativeAudioRecord;
     if (DEBUG) {
       WebRtcAudioUtils.logDeviceInfo(TAG);
     }
     effects = WebRtcAudioEffects.create();
   }
 
   private boolean enableBuiltInAEC(boolean enable) {
-    Logging.w(TAG, "enableBuiltInAEC(" + enable + ')');
+    Logging.d(TAG, "enableBuiltInAEC(" + enable + ')');
     if (effects == null) {
       Logging.e(TAG,"Built-in AEC is not supported on this platform");
       return false;
     }
     return effects.setAEC(enable);
   }
 
   private boolean enableBuiltInAGC(boolean enable) {
-    Logging.w(TAG, "enableBuiltInAGC(" + enable + ')');
+    Logging.d(TAG, "enableBuiltInAGC(" + enable + ')');
     if (effects == null) {
       Logging.e(TAG,"Built-in AGC is not supported on this platform");
       return false;
     }
     return effects.setAGC(enable);
   }
 
   private boolean enableBuiltInNS(boolean enable) {
-    Logging.w(TAG, "enableBuiltInNS(" + enable + ')');
+    Logging.d(TAG, "enableBuiltInNS(" + enable + ')');
     if (effects == null) {
       Logging.e(TAG,"Built-in NS is not supported on this platform");
       return false;
     }
     return effects.setNS(enable);
   }
 
   private int initRecording(int sampleRate, int channels) {
-    Logging.w(TAG, "initRecording(sampleRate=" + sampleRate + ", channels=" +
+    Logging.d(TAG, "initRecording(sampleRate=" + sampleRate + ", channels=" +
         channels + ")");
     if (!WebRtcAudioUtils.hasPermission(
         context, android.Manifest.permission.RECORD_AUDIO)) {
       Logging.e(TAG,"RECORD_AUDIO permission is missing");
       return -1;
     }
     if (audioRecord != null) {
       Logging.e(TAG,"InitRecording() called twice without StopRecording()");
       return -1;
     }
     final int bytesPerFrame = channels * (BITS_PER_SAMPLE / 8);
     final int framesPerBuffer = sampleRate / BUFFERS_PER_SECOND;
     byteBuffer = ByteBuffer.allocateDirect(bytesPerFrame * framesPerBuffer);
-    Logging.w(TAG, "byteBuffer.capacity: " + byteBuffer.capacity());
+    Logging.d(TAG, "byteBuffer.capacity: " + byteBuffer.capacity());
     // Rather than passing the ByteBuffer with every callback (requiring
     // the potentially expensive GetDirectBufferAddress) we simply have the
     // the native class cache the address to the memory once.
     nativeCacheDirectBufferAddress(byteBuffer, nativeAudioRecord);
 
     // Get the minimum buffer size required for the successful creation of
     // an AudioRecord object, in byte units.
     // Note that this size doesn't guarantee a smooth recording under load.
     int minBufferSize = AudioRecord.getMinBufferSize(
           sampleRate,
           AudioFormat.CHANNEL_IN_MONO,
           AudioFormat.ENCODING_PCM_16BIT);
     if (minBufferSize == AudioRecord.ERROR
         || minBufferSize == AudioRecord.ERROR_BAD_VALUE) {
       Logging.e(TAG, "AudioRecord.getMinBufferSize failed: " + minBufferSize);
       return -1;
     }
-    Logging.w(TAG, "AudioRecord.getMinBufferSize: " + minBufferSize);
+    Logging.d(TAG, "AudioRecord.getMinBufferSize: " + minBufferSize);
 
     // Use a larger buffer size than the minimum required when creating the
     // AudioRecord instance to ensure smooth recording under load. It has been
     // verified that it does not increase the actual recording latency.
     int bufferSizeInBytes =
         Math.max(BUFFER_SIZE_FACTOR * minBufferSize, byteBuffer.capacity());
-    Logging.w(TAG, "bufferSizeInBytes: " + bufferSizeInBytes);
+    Logging.d(TAG, "bufferSizeInBytes: " + bufferSizeInBytes);
     try {
       audioRecord = new AudioRecord(AudioSource.VOICE_COMMUNICATION,
                                     sampleRate,
                                     AudioFormat.CHANNEL_IN_MONO,
                                     AudioFormat.ENCODING_PCM_16BIT,
                                     bufferSizeInBytes);
     } catch (IllegalArgumentException e) {
       Logging.e(TAG,e.getMessage());
       return -1;
     }
     if (audioRecord == null ||
         audioRecord.getState() != AudioRecord.STATE_INITIALIZED) {
       Logging.e(TAG,"Failed to create a new AudioRecord instance");
       return -1;
     }
-    Logging.w(TAG, "AudioRecord "
+    Logging.d(TAG, "AudioRecord "
         + "session ID: " + audioRecord.getAudioSessionId() + ", "
         + "audio format: " + audioRecord.getAudioFormat() + ", "
         + "channels: " + audioRecord.getChannelCount() + ", "
         + "sample rate: " + audioRecord.getSampleRate());
     if (effects != null) {
       effects.enable(audioRecord.getAudioSessionId());
     }
     if (WebRtcAudioUtils.runningOnMOrHigher()) {
       // Returns the frame count of the native AudioRecord buffer. This is
       // greater than or equal to the bufferSizeInBytes converted to frame
       // units. The native frame count may be enlarged to accommodate the
       // requirements of the source on creation or if the AudioRecord is
       // subsequently rerouted.
       Logging.d(TAG, "bufferSizeInFrames: "
           + audioRecord.getBufferSizeInFrames());
     }
     return framesPerBuffer;
   }
 
   private boolean startRecording() {
-    Logging.w(TAG, "startRecording");
+    Logging.d(TAG, "startRecording");
     assertTrue(audioRecord != null);
     assertTrue(audioThread == null);
     try {
       audioRecord.startRecording();
     } catch (IllegalStateException e) {
       Logging.e(TAG,"AudioRecord.startRecording failed: " + e.getMessage());
       return false;
     }
     if (audioRecord.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING) {
       Logging.e(TAG,"AudioRecord.startRecording failed");
       return false;
     }
     audioThread = new AudioRecordThread("AudioRecordJavaThread");
     audioThread.start();
     return true;
   }
 
   private boolean stopRecording() {
-    Logging.w(TAG, "stopRecording");
+    Logging.d(TAG, "stopRecording");
     assertTrue(audioThread != null);
     audioThread.joinThread();
     audioThread = null;
     if (effects != null) {
       effects.release();
     }
     audioRecord.release();
     audioRecord = null;
     return true;
   }
 
   // Helper method which throws an exception  when an assertion has failed.
   private static void assertTrue(boolean condition) {
     if (!condition) {
       throw new AssertionError("Expected condition to be true");
     }
   }
 
   private native void nativeCacheDirectBufferAddress(
       ByteBuffer byteBuffer, long nativeAudioRecord);
 
   private native void nativeDataIsRecorded(int bytes, long nativeAudioRecord);
 }