Android: Remove GetApplicationContext part 4

media/base/android/java/src/org/chromium/media/AudioManagerAndroid.java

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothManager;
 import android.content.BroadcastReceiver;
@@ skipping 11 matching lines @@
 import android.media.AudioManager;
 import android.media.AudioRecord;
 import android.media.AudioTrack;
 import android.media.audiofx.AcousticEchoCanceler;
 import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Process;
 import android.provider.Settings;
 
+import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.SuppressFBWarnings;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
@@ skipping 110 matching lines @@
     private static final int STATE_BLUETOOTH_SCO_TURNING_OFF = 3;
 
     // Use 44.1kHz as the default sampling rate.
     private static final int DEFAULT_SAMPLING_RATE = 44100;
     // Randomly picked up frame size which is close to return value on N4.
     // Return this value when getProperty(PROPERTY_OUTPUT_FRAMES_PER_BUFFER)
     // fails.
     private static final int DEFAULT_FRAME_PER_BUFFER = 256;
 
     private final AudioManager mAudioManager;
-    private final Context mContext;
     private final long mNativeAudioManagerAndroid;
 
     // Enabled during initialization if MODIFY_AUDIO_SETTINGS permission is
     // granted. Required to shift system-wide audio settings.
     private boolean mHasModifyAudioSettingsPermission;
 
     // Enabled during initialization if BLUETOOTH permission is granted.
     private boolean mHasBluetoothPermission;
 
     // Stores the audio states related to Bluetooth SCO audio, where some
@@ skipping 39 matching lines @@
 
     // The UsbManager of this system.
     private final UsbManager mUsbManager;
     // Broadcast receiver for USB audio devices intent broadcasts.
     // Utilized to detect if a USB device is attached or detached.
     private BroadcastReceiver mUsbAudioReceiver;
 
     /** Construction */
     @CalledByNative
     private static AudioManagerAndroid createAudioManagerAndroid(
-            Context context,
             long nativeAudioManagerAndroid) {
-        return new AudioManagerAndroid(context, nativeAudioManagerAndroid);
+        return new AudioManagerAndroid(nativeAudioManagerAndroid);
     }
 
-    private AudioManagerAndroid(Context context, long nativeAudioManagerAndroid) {
-        mContext = context;
+    private AudioManagerAndroid(long nativeAudioManagerAndroid) {
         mNativeAudioManagerAndroid = nativeAudioManagerAndroid;
-        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-        mContentResolver = mContext.getContentResolver();
-        mUsbManager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);
+        mAudioManager = (AudioManager) ContextUtils.getApplicationContext().getSystemService(
+                Context.AUDIO_SERVICE);
+        mContentResolver = ContextUtils.getApplicationContext().getContentResolver();
+        mUsbManager = (UsbManager) ContextUtils.getApplicationContext().getSystemService(
+                Context.USB_SERVICE);
     }
 
     /**
      * Saves the initial speakerphone and microphone state.
      * Populates the list of available audio devices and registers receivers for broadcasting
      * intents related to wired headset and Bluetooth devices and USB audio devices.
      */
     @CalledByNative
     private void init() {
         checkIfCalledOnValidThread();
@@ skipping 257 matching lines @@
             channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
         } else {
             return -1;
         }
         return AudioTrack.getMinBufferSize(
                 sampleRate, channelConfig, AudioFormat.ENCODING_PCM_16BIT) / 2 / channels;
     }
 
     @CalledByNative
     private boolean isAudioLowLatencySupported() {
-        return mContext.getPackageManager().hasSystemFeature(
+        return ContextUtils.getApplicationContext().getPackageManager().hasSystemFeature(
                 PackageManager.FEATURE_AUDIO_LOW_LATENCY);
     }
 
     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
     @CalledByNative
     private int getAudioLowLatencyOutputFrameSize() {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
             return DEFAULT_FRAME_PER_BUFFER;
         }
         String framesPerBuffer =
@@ skipping 82 matching lines @@
         mAudioManager.setMicrophoneMute(on);
     }
 
     /** Gets  the current microphone mute state. */
     private boolean isMicrophoneMute() {
         return mAudioManager.isMicrophoneMute();
     }
 
     /** Gets the current earpiece state. */
     private boolean hasEarpiece() {
-        return mContext.getPackageManager().hasSystemFeature(
-            PackageManager.FEATURE_TELEPHONY);
+        return ContextUtils.getApplicationContext().getPackageManager().hasSystemFeature(
+                PackageManager.FEATURE_TELEPHONY);
     }
 
     /**
      * Checks whether a wired headset is connected or not.
      * This is not a valid indication that audio playback is actually over
      * the wired headset as audio routing depends on other conditions. We
      * only use it as an early indicator (during initialization) of an attached
      * wired headset.
      */
     @Deprecated
     private boolean hasWiredHeadset() {
         return mAudioManager.isWiredHeadsetOn();
     }
 
     /** Checks if the process has as specified permission or not. */
     private boolean hasPermission(String permission) {
-        return mContext.checkPermission(
-                permission,
-                Process.myPid(),
-                Process.myUid()) == PackageManager.PERMISSION_GRANTED;
+        return ContextUtils.getApplicationContext().checkPermission(
+                       permission, Process.myPid(), Process.myUid())
+                == PackageManager.PERMISSION_GRANTED;
     }
 
     /**
      * Gets the current Bluetooth headset state.
      * android.bluetooth.BluetoothAdapter.getProfileConnectionState() requires
      * the BLUETOOTH permission.
      */
     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
     private boolean hasBluetoothHeadset() {
         if (!mHasBluetoothPermission) {
             Log.w(TAG, "hasBluetoothHeadset() requires BLUETOOTH permission");
             return false;
         }
 
         // To get a BluetoothAdapter representing the local Bluetooth adapter,
         // when running on JELLY_BEAN_MR1 (4.2) and below, call the static
         // getDefaultAdapter() method; when running on JELLY_BEAN_MR2 (4.3) and
         // higher, retrieve it through getSystemService(String) with
         // BLUETOOTH_SERVICE.
         BluetoothAdapter btAdapter = null;
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
             // Use BluetoothManager to get the BluetoothAdapter for
             // Android 4.3 and above.
             BluetoothManager btManager =
-                    (BluetoothManager) mContext.getSystemService(
+                    (BluetoothManager) ContextUtils.getApplicationContext().getSystemService(
                             Context.BLUETOOTH_SERVICE);
             btAdapter = btManager.getAdapter();
         } else {
             // Use static method for Android 4.2 and below to get the
             // BluetoothAdapter.
             btAdapter = BluetoothAdapter.getDefaultAdapter();
         }
 
         if (btAdapter == null) {
             // Bluetooth not supported on this platform.
@@ skipping 107 matching lines @@
                     updateDeviceActivation();
                 } else if (DEBUG) {
                     reportUpdate();
                 }
             }
         };
 
         // Note: the intent we register for here is sticky, so it'll tell us
         // immediately what the last action was (plugged or unplugged).
         // It will enable us to set the speakerphone correctly.
-        mContext.registerReceiver(mWiredHeadsetReceiver, filter);
+        ContextUtils.getApplicationContext().registerReceiver(mWiredHeadsetReceiver, filter);
     }
 
     /** Unregister receiver for broadcasted ACTION_HEADSET_PLUG intent. */
     private void unregisterForWiredHeadsetIntentBroadcast() {
-        mContext.unregisterReceiver(mWiredHeadsetReceiver);
+        ContextUtils.getApplicationContext().unregisterReceiver(mWiredHeadsetReceiver);
         mWiredHeadsetReceiver = null;
     }
 
     /**
      * Registers receiver for the broadcasted intent related to BT headset
      * availability or a change in connection state of the local Bluetooth
      * adapter. Example: triggers when the BT device is turned on or off.
      * BLUETOOTH permission is required to receive this one.
      */
     private void registerForBluetoothHeadsetIntentBroadcast() {
@@ skipping 42 matching lines @@
                         loge("Invalid state");
                         break;
                 }
 
                 if (DEBUG) {
                     reportUpdate();
                 }
             }
         };
 
-        mContext.registerReceiver(mBluetoothHeadsetReceiver, filter);
+        ContextUtils.getApplicationContext().registerReceiver(mBluetoothHeadsetReceiver, filter);
     }
 
     private void unregisterForBluetoothHeadsetIntentBroadcast() {
-        mContext.unregisterReceiver(mBluetoothHeadsetReceiver);
+        ContextUtils.getApplicationContext().unregisterReceiver(mBluetoothHeadsetReceiver);
         mBluetoothHeadsetReceiver = null;
     }
 
     /**
      * Registers receiver for the broadcasted intent related the existence
      * of a BT SCO channel. Indicates if BT SCO streaming is on or off.
      */
     private void registerForBluetoothScoIntentBroadcast() {
         IntentFilter filter = new IntentFilter(
                 AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
@@ skipping 31 matching lines @@
                         break;
                     default:
                         loge("Invalid state");
                 }
                 if (DEBUG) {
                     reportUpdate();
                 }
             }
         };
 
-        mContext.registerReceiver(mBluetoothScoReceiver, filter);
+        ContextUtils.getApplicationContext().registerReceiver(mBluetoothScoReceiver, filter);
     }
 
     private void unregisterForBluetoothScoIntentBroadcast() {
-        mContext.unregisterReceiver(mBluetoothScoReceiver);
+        ContextUtils.getApplicationContext().unregisterReceiver(mBluetoothScoReceiver);
         mBluetoothScoReceiver = null;
     }
 
     /** Enables BT audio using the SCO audio channel. */
     private void startBluetoothSco() {
         if (!mHasBluetoothPermission) {
             return;
         }
         if (mBluetoothScoState == STATE_BLUETOOTH_SCO_ON
                 || mBluetoothScoState == STATE_BLUETOOTH_SCO_TURNING_ON) {
@@ skipping 310 matching lines @@
                 } else if (DEBUG) {
                     reportUpdate();
                 }
             }
         };
 
         IntentFilter filter = new IntentFilter();
         filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
         filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
 
-        mContext.registerReceiver(mUsbAudioReceiver, filter);
+        ContextUtils.getApplicationContext().registerReceiver(mUsbAudioReceiver, filter);
     }
 
     /** Unregister receiver for broadcasted ACTION_USB_DEVICE_ATTACHED/DETACHED intent. */
     private void unregisterForUsbAudioIntentBroadcast() {
-        mContext.unregisterReceiver(mUsbAudioReceiver);
+        ContextUtils.getApplicationContext().unregisterReceiver(mUsbAudioReceiver);
         mUsbAudioReceiver = null;
     }
 
     private native void nativeSetMute(long nativeAudioManagerAndroid, boolean muted);
 }