xref: /external/chromium_org/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.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothManager;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.database.ContentObserver;
import android.media.AudioFormat;
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.Looper;
import android.os.Process;
import android.provider.Settings;
import android.util.Log;

import org.chromium.base.CalledByNative;
import org.chromium.base.JNINamespace;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@JNINamespace("media")
class AudioManagerAndroid {
    private static final String TAG = "AudioManagerAndroid";

    // Set to true to enable debug logs. Always check in as false.
    private static final boolean DEBUG = false;

    /** Simple container for device information. */
    private static class AudioDeviceName {
        private final int mId;
        private final String mName;

        private AudioDeviceName(int id, String name) {
            mId = id;
            mName = name;
        }

        @CalledByNative("AudioDeviceName")
        private String id() { return String.valueOf(mId); }

        @CalledByNative("AudioDeviceName")
        private String name() { return mName; }
    }

    // Supported audio device types.
    private static final int DEVICE_INVALID = -1;
    private static final int DEVICE_SPEAKERPHONE = 0;
    private static final int DEVICE_WIRED_HEADSET = 1;
    private static final int DEVICE_EARPIECE = 2;
    private static final int DEVICE_BLUETOOTH_HEADSET = 3;
    private static final int DEVICE_COUNT = 4;

    // Maps audio device types to string values. This map must be in sync
    // with the device types above.
    // TODO(henrika): add support for proper detection of device names and
    // localize the name strings by using resource strings.
    private static final String[] DEVICE_NAMES = new String[] {
        "Speakerphone",
        "Wired headset",    // With or without microphone
        "Headset earpiece", // Only available on mobile phones
        "Bluetooth headset",
    };

    // List of valid device types.
    private static final Integer[] VALID_DEVICES = new Integer[] {
        DEVICE_SPEAKERPHONE,
        DEVICE_WIRED_HEADSET,
        DEVICE_EARPIECE,
        DEVICE_BLUETOOTH_HEADSET,
    };

    // The device does not have any audio device.
    static final int STATE_NO_DEVICE_SELECTED = 0;
    // The speakerphone is on and an associated microphone is used.
    static final int STATE_SPEAKERPHONE_ON = 1;
    // The phone's earpiece is on and an associated microphone is used.
    static final int STATE_EARPIECE_ON = 2;
    // A wired headset (with or without a microphone) is plugged in.
    static final int STATE_WIRED_HEADSET_ON = 3;
    // The audio stream is being directed to a Bluetooth headset.
    static final int STATE_BLUETOOTH_ON = 4;
    // We've requested that the audio stream be directed to Bluetooth, but
    // have not yet received a response from the framework.
    static final int STATE_BLUETOOTH_TURNING_ON = 5;
    // We've requested that the audio stream stop being directed to
    // Bluetooth, but have not yet received a response from the framework.
    static final int STATE_BLUETOOTH_TURNING_OFF = 6;
    // TODO(henrika): document the valid state transitions.

    // 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;

    private boolean mHasBluetoothPermission = false;
    private boolean mIsInitialized = false;
    private boolean mSavedIsSpeakerphoneOn;
    private boolean mSavedIsMicrophoneMute;

    private Integer mAudioDeviceState = STATE_NO_DEVICE_SELECTED;

    // Lock to protect |mAudioDevices| which can be accessed from the main
    // thread and the audio manager thread.
    private final Object mLock = new Object();

    // Contains a list of currently available audio devices.
    private boolean[] mAudioDevices = new boolean[DEVICE_COUNT];

    private final ContentResolver mContentResolver;
    private SettingsObserver mSettingsObserver = null;
    private SettingsObserverThread mSettingsObserverThread = null;
    private int mCurrentVolume;
    private final Object mSettingsObserverLock = new Object();

    // Broadcast receiver for wired headset intent broadcasts.
    private BroadcastReceiver mWiredHeadsetReceiver;

    /** Construction */
    @CalledByNative
    private static AudioManagerAndroid createAudioManagerAndroid(
            Context context,
            long nativeAudioManagerAndroid) {
        return new AudioManagerAndroid(context, nativeAudioManagerAndroid);
    }

    private AudioManagerAndroid(Context context, long nativeAudioManagerAndroid) {
        mContext = context;
        mNativeAudioManagerAndroid = nativeAudioManagerAndroid;
        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
        mContentResolver = mContext.getContentResolver();
    }

    /**
     * Saves the initial speakerphone and microphone state.
     * Populates the list of available audio devices and registers receivers
     * for broadcasted intents related to wired headset and bluetooth devices.
     */
    @CalledByNative
    public void init() {
        if (mIsInitialized)
            return;

        synchronized (mLock) {
            for (int i = 0; i < DEVICE_COUNT; ++i) {
                mAudioDevices[i] = false;
            }
        }

        // Store microphone mute state and speakerphone state so it can
        // be restored when closing.
        mSavedIsSpeakerphoneOn = mAudioManager.isSpeakerphoneOn();
        mSavedIsMicrophoneMute = mAudioManager.isMicrophoneMute();

        // Initialize audio device list with things we know is always available.
        synchronized (mLock) {
            if (hasEarpiece()) {
                mAudioDevices[DEVICE_EARPIECE] = true;
            }
            mAudioDevices[DEVICE_SPEAKERPHONE] = true;
        }

        // Register receiver for broadcasted intents related to adding/
        // removing a wired headset (Intent.ACTION_HEADSET_PLUG).
        // Also starts routing to the wired headset/headphone if one is
        // already attached (can be overridden by a Bluetooth headset).
        registerForWiredHeadsetIntentBroadcast();

        // Start routing to Bluetooth if there's a connected device.
        // TODO(henrika): the actual routing part is not implemented yet.
        // All we do currently is to detect if BT headset is attached or not.
        initBluetooth();

        mIsInitialized = true;

        mSettingsObserverThread = new SettingsObserverThread();
        synchronized (mSettingsObserverLock) {
            try {
                mSettingsObserverThread.start();
                mSettingsObserverLock.wait();
            } catch (InterruptedException e) {
                Log.e(TAG, "unregisterHeadsetReceiver exception: " + e.getMessage());
            }
        }
    }

    /**
     * Unregister all previously registered intent receivers and restore
     * the stored state (stored in {@link #init()}).
     */
    @CalledByNative
    public void close() {
        if (!mIsInitialized)
            return;

        if (mSettingsObserverThread != null) {
            mSettingsObserverThread = null;
        }
        if (mSettingsObserver != null) {
            mContentResolver.unregisterContentObserver(mSettingsObserver);
            mSettingsObserver = null;
        }

        unregisterForWiredHeadsetIntentBroadcast();

        // Restore previously stored audio states.
        setMicrophoneMute(mSavedIsMicrophoneMute);
        setSpeakerphoneOn(mSavedIsSpeakerphoneOn);

        mIsInitialized = false;
    }

    @CalledByNative
    public void setMode(int mode) {
        try {
            mAudioManager.setMode(mode);
        } catch (SecurityException e) {
            Log.e(TAG, "setMode exception: " + e.getMessage());
            logDeviceInfo();
        }
    }

    /**
     * Activates, i.e., starts routing audio to, the specified audio device.
     *
     * @param deviceId Unique device ID (integer converted to string)
     * representing the selected device. This string is empty if the so-called
     * default device is selected.
     */
    @CalledByNative
    public void setDevice(String deviceId) {
        boolean devices[] = null;
        synchronized (mLock) {
            devices = mAudioDevices.clone();
        }
        if (deviceId.isEmpty()) {
            logd("setDevice: default");
            // Use a special selection scheme if the default device is selected.
            // The "most unique" device will be selected; Bluetooth first, then
            // wired headset and last the speaker phone.
            if (devices[DEVICE_BLUETOOTH_HEADSET]) {
                // TODO(henrika): possibly need improvements here if we are
                // in a STATE_BLUETOOTH_TURNING_OFF state.
                setAudioDevice(DEVICE_BLUETOOTH_HEADSET);
            } else if (devices[DEVICE_WIRED_HEADSET]) {
                setAudioDevice(DEVICE_WIRED_HEADSET);
            } else {
                setAudioDevice(DEVICE_SPEAKERPHONE);
            }
        } else {
            logd("setDevice: " + deviceId);
            // A non-default device is specified. Verify that it is valid
            // device, and if so, start using it.
            List<Integer> validIds = Arrays.asList(VALID_DEVICES);
            Integer id = Integer.valueOf(deviceId);
            if (validIds.contains(id)) {
                setAudioDevice(id.intValue());
            } else {
                loge("Invalid device ID!");
            }
        }
    }

    /**
     * @return the current list of available audio devices.
     * Note that this call does not trigger any update of the list of devices,
     * it only copies the current state in to the output array.
     */
    @CalledByNative
    public AudioDeviceName[] getAudioInputDeviceNames() {
        synchronized (mLock) {
            List<String> devices = new ArrayList<String>();
            AudioDeviceName[] array = new AudioDeviceName[getNumOfAudioDevicesWithLock()];
            int i = 0;
            for (int id = 0; id < DEVICE_COUNT; ++id) {
                if (mAudioDevices[id]) {
                    array[i] = new AudioDeviceName(id, DEVICE_NAMES[id]);
                    devices.add(DEVICE_NAMES[id]);
                    i++;
                }
            }
            logd("getAudioInputDeviceNames: " + devices);
            return array;
        }
    }

    @CalledByNative
    private int getNativeOutputSampleRate() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            String sampleRateString = mAudioManager.getProperty(
                    AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE);
            return (sampleRateString == null ?
                    DEFAULT_SAMPLING_RATE : Integer.parseInt(sampleRateString));
        } else {
            return DEFAULT_SAMPLING_RATE;
        }
    }

  /**
   * Returns the minimum frame size required for audio input.
   *
   * @param sampleRate sampling rate
   * @param channels number of channels
   */
    @CalledByNative
    private static int getMinInputFrameSize(int sampleRate, int channels) {
        int channelConfig;
        if (channels == 1) {
            channelConfig = AudioFormat.CHANNEL_IN_MONO;
        } else if (channels == 2) {
            channelConfig = AudioFormat.CHANNEL_IN_STEREO;
        } else {
            return -1;
        }
        return AudioRecord.getMinBufferSize(
                sampleRate, channelConfig, AudioFormat.ENCODING_PCM_16BIT) / 2 / channels;
    }

  /**
   * Returns the minimum frame size required for audio output.
   *
   * @param sampleRate sampling rate
   * @param channels number of channels
   */
    @CalledByNative
    private static int getMinOutputFrameSize(int sampleRate, int channels) {
        int channelConfig;
        if (channels == 1) {
            channelConfig = AudioFormat.CHANNEL_OUT_MONO;
        } else if (channels == 2) {
            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(
                PackageManager.FEATURE_AUDIO_LOW_LATENCY);
    }

    @CalledByNative
    private int getAudioLowLatencyOutputFrameSize() {
        String framesPerBuffer =
                mAudioManager.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER);
        return (framesPerBuffer == null ?
                DEFAULT_FRAME_PER_BUFFER : Integer.parseInt(framesPerBuffer));
    }

    @CalledByNative
    public static boolean shouldUseAcousticEchoCanceler() {
        // AcousticEchoCanceler was added in API level 16 (Jelly Bean).
        // Next is a list of device models which have been vetted for good
        // quality platform echo cancellation.
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN &&
               AcousticEchoCanceler.isAvailable() &&
               (Build.MODEL.equals("Nexus 5") ||
                Build.MODEL.equals("Nexus 7"));
    }

    /** Sets the speaker phone mode. */
    public void setSpeakerphoneOn(boolean on) {
        boolean wasOn = mAudioManager.isSpeakerphoneOn();
        if (wasOn == on) {
            return;
        }
        mAudioManager.setSpeakerphoneOn(on);
    }

    /** Sets the microphone mute state. */
    public void setMicrophoneMute(boolean on) {
        boolean wasMuted = mAudioManager.isMicrophoneMute();
        if (wasMuted == on) {
            return;
        }
        mAudioManager.setMicrophoneMute(on);
    }

    /** Gets  the current microphone mute state. */
    public boolean isMicrophoneMute() {
        return mAudioManager.isMicrophoneMute();
    }

    /** Gets the current earpice state. */
    private boolean hasEarpiece() {
        return mContext.getPackageManager().hasSystemFeature(
            PackageManager.FEATURE_TELEPHONY);
    }

    /**
     * Registers receiver for the broadcasted intent when a wired headset is
     * plugged in or unplugged. The received intent will have an extra
     * 'state' value where 0 means unplugged, and 1 means plugged.
     */
    private void registerForWiredHeadsetIntentBroadcast() {
        IntentFilter filter = new IntentFilter(Intent.ACTION_HEADSET_PLUG);

        /**
         * Receiver which handles changes in wired headset availablilty.
         */
        mWiredHeadsetReceiver = new BroadcastReceiver() {
            private static final int STATE_UNPLUGGED = 0;
            private static final int STATE_PLUGGED = 1;
            private static final int HAS_NO_MIC = 0;
            private static final int HAS_MIC = 1;

            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (!action.equals(Intent.ACTION_HEADSET_PLUG)) {
                    return;
                }
                int state = intent.getIntExtra("state", STATE_UNPLUGGED);
                int microphone = intent.getIntExtra("microphone", HAS_NO_MIC);
                String name = intent.getStringExtra("name");
                logd("==> onReceive: s=" + state
                        + ", m=" + microphone
                        + ", n=" + name
                        + ", sb=" + isInitialStickyBroadcast());

                switch (state) {
                    case STATE_UNPLUGGED:
                        synchronized (mLock) {
                            // Wired headset and earpiece are mutually exclusive.
                            mAudioDevices[DEVICE_WIRED_HEADSET] = false;
                            if (hasEarpiece()) {
                                mAudioDevices[DEVICE_EARPIECE] = true;
                            }
                        }
                        // If wired headset was used before it was unplugged,
                        // switch to speaker phone. If it was not in use; just
                        // log the change.
                        if (mAudioDeviceState == STATE_WIRED_HEADSET_ON) {
                            setAudioDevice(DEVICE_SPEAKERPHONE);
                        } else {
                            reportUpdate();
                        }
                        break;
                    case STATE_PLUGGED:
                        synchronized (mLock) {
                            // Wired headset and earpiece are mutually exclusive.
                            mAudioDevices[DEVICE_WIRED_HEADSET] = true;
                            mAudioDevices[DEVICE_EARPIECE] = false;
                            setAudioDevice(DEVICE_WIRED_HEADSET);
                        }
                        break;
                    default:
                        loge("Invalid state!");
                        break;
                }
            }
        };

        // 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);
    }

    /** Unregister receiver for broadcasted ACTION_HEADSET_PLUG intent. */
    private void unregisterForWiredHeadsetIntentBroadcast() {
        mContext.unregisterReceiver(mWiredHeadsetReceiver);
        mWiredHeadsetReceiver = null;
    }

    /**
    * Check if Bluetooth device is connected, register Bluetooth receiver
    * and start routing to Bluetooth if a device is connected.
    * TODO(henrika): currently only supports the detecion part at startup.
    */
    private void initBluetooth() {
        // Bail out if we don't have the required permission.
        mHasBluetoothPermission = mContext.checkPermission(
            android.Manifest.permission.BLUETOOTH,
            Process.myPid(),
            Process.myUid()) == PackageManager.PERMISSION_GRANTED;
        if (!mHasBluetoothPermission) {
            loge("BLUETOOTH permission is missing!");
            return;
        }

        // 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.
        // Note: Most methods require the BLUETOOTH permission.
        BluetoothAdapter btAdapter = null;
        if (android.os.Build.VERSION.SDK_INT <=
            android.os.Build.VERSION_CODES.JELLY_BEAN_MR1) {
            // Use static method for Android 4.2 and below to get the
            // BluetoothAdapter.
            btAdapter = BluetoothAdapter.getDefaultAdapter();
        } else {
            // Use BluetoothManager to get the BluetoothAdapter for
            // Android 4.3 and above.
            BluetoothManager btManager = (BluetoothManager) mContext.getSystemService(
                    Context.BLUETOOTH_SERVICE);
            btAdapter = btManager.getAdapter();
        }

        if (btAdapter != null &&
            // android.bluetooth.BluetoothAdapter.getProfileConnectionState
            // requires BLUETOOTH permission.
            android.bluetooth.BluetoothProfile.STATE_CONNECTED ==
                    btAdapter.getProfileConnectionState(
                            android.bluetooth.BluetoothProfile.HEADSET)) {
            synchronized (mLock) {
                mAudioDevices[DEVICE_BLUETOOTH_HEADSET] = true;
            }
            // TODO(henrika): ensure that we set the active audio
            // device to Bluetooth (not trivial).
            setAudioDevice(DEVICE_BLUETOOTH_HEADSET);
        }
    }

    /**
     * Changes selection of the currently active audio device.
     *
     * @param device Specifies the selected audio device.
     */
    public void setAudioDevice(int device) {
        switch (device) {
            case DEVICE_BLUETOOTH_HEADSET:
                // TODO(henrika): add support for turning on an routing to
                // BT here.
                if (DEBUG) logd("--- TO BE IMPLEMENTED ---");
                break;
            case DEVICE_SPEAKERPHONE:
                // TODO(henrika): turn off BT if required.
                mAudioDeviceState = STATE_SPEAKERPHONE_ON;
                setSpeakerphoneOn(true);
                break;
            case DEVICE_WIRED_HEADSET:
                // TODO(henrika): turn off BT if required.
                mAudioDeviceState = STATE_WIRED_HEADSET_ON;
                setSpeakerphoneOn(false);
                break;
            case DEVICE_EARPIECE:
                // TODO(henrika): turn off BT if required.
                mAudioDeviceState = STATE_EARPIECE_ON;
                setSpeakerphoneOn(false);
                break;
            default:
                loge("Invalid audio device selection!");
                break;
        }
        reportUpdate();
    }

    private int getNumOfAudioDevicesWithLock() {
        int count = 0;
        for (int i = 0; i < DEVICE_COUNT; ++i) {
            if (mAudioDevices[i])
                count++;
        }
        return count;
    }

    /**
     * For now, just log the state change but the idea is that we should
     * notify a registered state change listener (if any) that there has
     * been a change in the state.
     * TODO(henrika): add support for state change listener.
     */
    private void reportUpdate() {
        synchronized (mLock) {
            List<String> devices = new ArrayList<String>();
            for (int i = 0; i < DEVICE_COUNT; ++i) {
                if (mAudioDevices[i])
                    devices.add(DEVICE_NAMES[i]);
            }
            logd("reportUpdate: state=" + mAudioDeviceState
                + ", devices=" + devices);
        }
    }

    private void logDeviceInfo() {
        Log.i(TAG, "Manufacturer:" + Build.MANUFACTURER +
                " Board: " + Build.BOARD + " Device: " + Build.DEVICE +
                " Model: " + Build.MODEL + " PRODUCT: " + Build.PRODUCT);
    }

    /** Trivial helper method for debug logging */
    private static void logd(String msg) {
        Log.d(TAG, msg);
    }

    /** Trivial helper method for error logging */
    private static void loge(String msg) {
        Log.e(TAG, msg);
    }

    private class SettingsObserver extends ContentObserver {
        SettingsObserver() {
            super(new Handler());
            mContentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, this);
        }

        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            int volume = mAudioManager.getStreamVolume(AudioManager.STREAM_VOICE_CALL);
            nativeSetMute(mNativeAudioManagerAndroid, (volume == 0));
        }
    }

    private native void nativeSetMute(long nativeAudioManagerAndroid, boolean muted);

    private class SettingsObserverThread extends Thread {
        SettingsObserverThread() {
            super("SettinsObserver");
        }

        @Override
        public void run() {
            // Set this thread up so the handler will work on it.
            Looper.prepare();

            synchronized (mSettingsObserverLock) {
                mSettingsObserver = new SettingsObserver();
                mSettingsObserverLock.notify();
            }

            // Listen for volume change.
            Looper.loop();
        }
    }
}