/*
* Copyright (c) 2010-2019 Belledonne Communications SARL.
*
* This file is part of linphone-android
* (see https://www.linphone.org).
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.linphone.call;
import static android.media.AudioManager.MODE_RINGTONE;
import static android.media.AudioManager.STREAM_RING;
import static android.media.AudioManager.STREAM_VOICE_CALL;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothHeadset;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Vibrator;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.view.KeyEvent;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;
import org.linphone.LinphoneContext;
import org.linphone.LinphoneManager;
import org.linphone.R;
import org.linphone.compatibility.Compatibility;
import org.linphone.core.Address;
import org.linphone.core.Call;
import org.linphone.core.Core;
import org.linphone.core.CoreListenerStub;
import org.linphone.core.EcCalibratorStatus;
import org.linphone.core.tools.Log;
import org.linphone.receivers.BluetoothReceiver;
import org.linphone.receivers.HeadsetReceiver;
import org.linphone.settings.LinphonePreferences;
public class AndroidAudioManager {
private Context mContext;
private AudioManager mAudioManager;
private Call mRingingCall;
private MediaPlayer mRingerPlayer;
private final Vibrator mVibrator;
private BluetoothAdapter mBluetoothAdapter;
private BluetoothHeadset mBluetoothHeadset;
private BluetoothReceiver mBluetoothReceiver;
private HeadsetReceiver mHeadsetReceiver;
private boolean mHeadsetReceiverRegistered;
private boolean mIsRinging;
private boolean mAudioFocused;
private boolean mEchoTesterIsRunning;
private boolean mIsBluetoothHeadsetConnected;
private boolean mIsBluetoothHeadsetScoConnected;
private CoreListenerStub mListener;
public AndroidAudioManager(Context context) {
mContext = context;
mAudioManager = ((AudioManager) context.getSystemService(Context.AUDIO_SERVICE));
mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
mEchoTesterIsRunning = false;
mHeadsetReceiverRegistered = false;
startBluetooth();
mListener =
new CoreListenerStub() {
@Override
public void onCallStateChanged(
final Core core,
final Call call,
final Call.State state,
final String message) {
if (state == Call.State.IncomingReceived
|| (state == Call.State.IncomingEarlyMedia
&& mContext.getResources()
.getBoolean(
R.bool.allow_ringing_while_early_media))) {
// Brighten screen for at least 10 seconds
if (core.getCallsNb() == 1) {
requestAudioFocus(STREAM_RING);
mRingingCall = call;
startRinging(call.getRemoteAddress());
// otherwise there is the beep
}
} else if (call == mRingingCall && mIsRinging) {
// previous state was ringing, so stop ringing
stopRinging();
}
if (state == Call.State.Connected) {
if (core.getCallsNb() == 1) {
// It is for incoming calls, because outgoing calls enter
// MODE_IN_COMMUNICATION immediately when they start.
// However, incoming call first use the MODE_RINGING to play the
// local ring.
if (call.getDir() == Call.Dir.Incoming) {
setAudioManagerInCallMode();
// mAudioManager.abandonAudioFocus(null);
requestAudioFocus(STREAM_VOICE_CALL);
}
if (!mIsBluetoothHeadsetConnected) {
if (mContext.getResources().getBoolean(R.bool.isTablet)) {
routeAudioToSpeaker();
} else {
// Only force earpiece audio route for incoming audio calls,
// outgoing calls may have manually enabled speaker
if (call.getDir() == Call.Dir.Incoming) {
routeAudioToEarPiece();
}
}
}
// Only register this one when a call is active
enableHeadsetReceiver();
}
} else if (state == Call.State.End || state == Call.State.Error) {
if (core.getCallsNb() == 0) {
if (mAudioFocused) {
int res = mAudioManager.abandonAudioFocus(null);
Log.d(
"[Audio Manager] Audio focus released a bit later: "
+ (res
== AudioManager
.AUDIOFOCUS_REQUEST_GRANTED
? "Granted"
: "Denied"));
mAudioFocused = false;
}
// Only register this one when a call is active
if (mHeadsetReceiver != null && mHeadsetReceiverRegistered) {
Log.i("[Audio Manager] Unregistering headset receiver");
mContext.unregisterReceiver(mHeadsetReceiver);
mHeadsetReceiverRegistered = false;
}
TelephonyManager tm =
(TelephonyManager)
mContext.getSystemService(
Context.TELEPHONY_SERVICE);
if (tm.getCallState() == TelephonyManager.CALL_STATE_IDLE) {
Log.d(
"[Audio Manager] ---AndroidAudioManager: back to MODE_NORMAL");
mAudioManager.setMode(AudioManager.MODE_NORMAL);
Log.d(
"[Audio Manager] All call terminated, routing back to earpiece");
routeAudioToEarPiece();
}
}
}
if (state == Call.State.OutgoingInit) {
// Enter the MODE_IN_COMMUNICATION mode as soon as possible, so that
// ringback is heard normally in earpiece or bluetooth receiver.
setAudioManagerInCallMode();
requestAudioFocus(STREAM_VOICE_CALL);
if (mIsBluetoothHeadsetConnected) {
routeAudioToBluetooth();
}
}
if (state == Call.State.StreamsRunning) {
setAudioManagerInCallMode();
if (mIsBluetoothHeadsetConnected) {
routeAudioToBluetooth();
}
}
}
@Override
public void onEcCalibrationResult(
Core core, EcCalibratorStatus status, int delay_ms) {
mAudioManager.setMode(AudioManager.MODE_NORMAL);
mAudioManager.abandonAudioFocus(null);
Log.i("[Audio Manager] Set audio mode on 'Normal'");
}
};
Core core = LinphoneManager.getCore();
if (core != null) {
core.addListener(mListener);
}
}
public void destroy() {
if (mBluetoothAdapter != null && mBluetoothHeadset != null) {
Log.i("[Audio Manager] [Bluetooth] Closing HEADSET profile proxy");
mBluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, mBluetoothHeadset);
}
Log.i("[Audio Manager] [Bluetooth] Unegistering bluetooth receiver");
if (mBluetoothReceiver != null) {
mContext.unregisterReceiver(mBluetoothReceiver);
}
Core core = LinphoneManager.getCore();
if (core != null) {
core.removeListener(mListener);
}
}
/* Audio routing */
public void setAudioManagerModeNormal() {
mAudioManager.setMode(AudioManager.MODE_NORMAL);
}
public void routeAudioToEarPiece() {
routeAudioToSpeakerHelper(false);
}
public void routeAudioToSpeaker() {
routeAudioToSpeakerHelper(true);
}
public boolean isAudioRoutedToSpeaker() {
return mAudioManager.isSpeakerphoneOn() && !isUsingBluetoothAudioRoute();
}
public boolean isAudioRoutedToEarpiece() {
return !mAudioManager.isSpeakerphoneOn() && !isUsingBluetoothAudioRoute();
}
/* Echo cancellation */
public void startEcCalibration() {
Core core = LinphoneManager.getCore();
if (core == null) {
return;
}
routeAudioToSpeaker();
setAudioManagerInCallMode();
Log.i("[Audio Manager] Set audio mode on 'Voice Communication'");
requestAudioFocus(STREAM_VOICE_CALL);
int oldVolume = mAudioManager.getStreamVolume(STREAM_VOICE_CALL);
int maxVolume = mAudioManager.getStreamMaxVolume(STREAM_VOICE_CALL);
mAudioManager.setStreamVolume(STREAM_VOICE_CALL, maxVolume, 0);
core.startEchoCancellerCalibration();
mAudioManager.setStreamVolume(STREAM_VOICE_CALL, oldVolume, 0);
}
public void startEchoTester() {
Core core = LinphoneManager.getCore();
if (core == null) {
return;
}
routeAudioToSpeaker();
setAudioManagerInCallMode();
Log.i("[Audio Manager] Set audio mode on 'Voice Communication'");
requestAudioFocus(STREAM_VOICE_CALL);
int maxVolume = mAudioManager.getStreamMaxVolume(STREAM_VOICE_CALL);
int sampleRate;
mAudioManager.setStreamVolume(STREAM_VOICE_CALL, maxVolume, 0);
String sampleRateProperty =
mAudioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE);
sampleRate = Integer.parseInt(sampleRateProperty);
core.startEchoTester(sampleRate);
mEchoTesterIsRunning = true;
}
public void stopEchoTester() {
Core core = LinphoneManager.getCore();
if (core == null) {
return;
}
mEchoTesterIsRunning = false;
core.stopEchoTester();
routeAudioToEarPiece();
mAudioManager.setMode(AudioManager.MODE_NORMAL);
Log.i("[Audio Manager] Set audio mode on 'Normal'");
}
public boolean getEchoTesterStatus() {
return mEchoTesterIsRunning;
}
public boolean onKeyVolumeAdjust(int keyCode) {
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
adjustVolume(1);
return true;
} else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
adjustVolume(-1);
return true;
}
return false;
}
private void setAudioManagerInCallMode() {
if (mAudioManager.getMode() == AudioManager.MODE_IN_COMMUNICATION) {
Log.w("[Audio Manager] already in MODE_IN_COMMUNICATION, skipping...");
return;
}
Log.d("[Audio Manager] Mode: MODE_IN_COMMUNICATION");
mAudioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
}
private void requestAudioFocus(int stream) {
if (!mAudioFocused) {
int res =
mAudioManager.requestAudioFocus(
null, stream, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE);
Log.d(
"[Audio Manager] Audio focus requested: "
+ (res == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
? "Granted"
: "Denied"));
if (res == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) mAudioFocused = true;
}
}
private synchronized void startRinging(Address remoteAddress) {
if (!LinphonePreferences.instance().isDeviceRingtoneEnabled()) {
// Enable speaker audio route, linphone library will do the ringing itself automatically
routeAudioToSpeaker();
return;
}
boolean doNotDisturbPolicyAllowsRinging =
Compatibility.isDoNotDisturbPolicyAllowingRinging(mContext, remoteAddress);
if (!doNotDisturbPolicyAllowsRinging) {
Log.e("[Audio Manager] Do not ring as Android Do Not Disturb Policy forbids it");
return;
}
routeAudioToSpeaker();
mAudioManager.setMode(MODE_RINGTONE);
try {
if ((mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_VIBRATE
|| mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_NORMAL)
&& mVibrator != null
&& LinphonePreferences.instance().isIncomingCallVibrationEnabled()) {
Compatibility.vibrate(mVibrator);
}
if (mRingerPlayer == null) {
requestAudioFocus(STREAM_RING);
mRingerPlayer = new MediaPlayer();
mRingerPlayer.setAudioStreamType(STREAM_RING);
String ringtone =
LinphonePreferences.instance()
.getRingtone(Settings.System.DEFAULT_RINGTONE_URI.toString());
try {
if (ringtone.startsWith("content://")) {
mRingerPlayer.setDataSource(mContext, Uri.parse(ringtone));
} else {
FileInputStream fis = new FileInputStream(ringtone);
mRingerPlayer.setDataSource(fis.getFD());
fis.close();
}
} catch (IOException e) {
Log.e(e, "[Audio Manager] Cannot set ringtone");
}
mRingerPlayer.prepare();
mRingerPlayer.setLooping(true);
mRingerPlayer.start();
} else {
Log.w("[Audio Manager] Already ringing");
}
} catch (Exception e) {
Log.e(e, "[Audio Manager] Cannot handle incoming call");
}
mIsRinging = true;
}
private synchronized void stopRinging() {
if (mRingerPlayer != null) {
mRingerPlayer.stop();
mRingerPlayer.release();
mRingerPlayer = null;
}
if (mVibrator != null) {
mVibrator.cancel();
}
mIsRinging = false;
}
private void routeAudioToSpeakerHelper(boolean speakerOn) {
Log.w("[Audio Manager] Routing audio to " + (speakerOn ? "speaker" : "earpiece"));
if (mIsBluetoothHeadsetScoConnected) {
Log.w("[Audio Manager] [Bluetooth] Disabling bluetooth audio route");
changeBluetoothSco(false);
}
mAudioManager.setSpeakerphoneOn(speakerOn);
}
private void adjustVolume(int i) {
if (mAudioManager.isVolumeFixed()) {
Log.e("[Audio Manager] Can't adjust volume, device has it fixed...");
// Keep going just in case...
}
int stream = STREAM_VOICE_CALL;
if (mIsBluetoothHeadsetScoConnected) {
Log.i(
"[Audio Manager] Bluetooth is connected, try to change the volume on STREAM_BLUETOOTH_SCO");
stream = 6; // STREAM_BLUETOOTH_SCO, it's hidden...
}
// starting from ICS, volume must be adjusted by the application,
// at least for STREAM_VOICE_CALL volume stream
mAudioManager.adjustStreamVolume(
stream,
i < 0 ? AudioManager.ADJUST_LOWER : AudioManager.ADJUST_RAISE,
AudioManager.FLAG_SHOW_UI);
}
// Bluetooth
public synchronized void bluetoothHeadetConnectionChanged(boolean connected) {
mIsBluetoothHeadsetConnected = connected;
mAudioManager.setBluetoothScoOn(connected);
if (LinphoneContext.isReady()) LinphoneManager.getCallManager().refreshInCallActions();
}
public synchronized void bluetoothHeadetAudioConnectionChanged(boolean connected) {
mIsBluetoothHeadsetScoConnected = connected;
mAudioManager.setBluetoothScoOn(connected);
}
public synchronized boolean isBluetoothHeadsetConnected() {
return mIsBluetoothHeadsetConnected;
}
public synchronized void bluetoothHeadetScoConnectionChanged(boolean connected) {
mIsBluetoothHeadsetScoConnected = connected;
if (LinphoneContext.isReady()) LinphoneManager.getCallManager().refreshInCallActions();
}
public synchronized boolean isUsingBluetoothAudioRoute() {
return mIsBluetoothHeadsetScoConnected;
}
public synchronized void routeAudioToBluetooth() {
if (!isBluetoothHeadsetConnected()) {
Log.w("[Audio Manager] [Bluetooth] No headset connected");
return;
}
if (mAudioManager.getMode() != AudioManager.MODE_IN_COMMUNICATION) {
Log.w(
"[Audio Manager] [Bluetooth] Changing audio mode to MODE_IN_COMMUNICATION and requesting STREAM_VOICE_CALL focus");
mAudioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
requestAudioFocus(STREAM_VOICE_CALL);
}
changeBluetoothSco(true);
}
private synchronized void changeBluetoothSco(final boolean enable) {
// IT WILL TAKE A CERTAIN NUMBER OF CALLS TO EITHER START/STOP BLUETOOTH SCO FOR IT TO WORK
if (enable && mIsBluetoothHeadsetScoConnected) {
Log.i("[Audio Manager] [Bluetooth] SCO already enabled, skipping");
return;
} else if (!enable && !mIsBluetoothHeadsetScoConnected) {
Log.i("[Audio Manager] [Bluetooth] SCO already disabled, skipping");
return;
}
new Thread() {
@Override
public void run() {
Log.i("[Audio Manager] [Bluetooth] SCO start/stop thread started");
boolean resultAcknowledged;
int retries = 0;
do {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Log.e(e);
}
synchronized (AndroidAudioManager.this) {
if (enable) {
Log.i(
"[Audio Manager] [Bluetooth] Starting SCO: try number "
+ retries);
mAudioManager.startBluetoothSco();
} else {
Log.i(
"[Audio Manager] [Bluetooth] Stopping SCO: try number "
+ retries);
mAudioManager.stopBluetoothSco();
}
resultAcknowledged = isUsingBluetoothAudioRoute() == enable;
retries++;
}
} while (!resultAcknowledged && retries < 10);
}
}.start();
}
public void bluetoothAdapterStateChanged() {
if (mBluetoothAdapter.isEnabled()) {
Log.i("[Audio Manager] [Bluetooth] Adapter enabled");
mIsBluetoothHeadsetConnected = false;
mIsBluetoothHeadsetScoConnected = false;
BluetoothProfile.ServiceListener bluetoothServiceListener =
new BluetoothProfile.ServiceListener() {
public void onServiceConnected(int profile, BluetoothProfile proxy) {
if (profile == BluetoothProfile.HEADSET) {
Log.i("[Audio Manager] [Bluetooth] HEADSET profile connected");
mBluetoothHeadset = (BluetoothHeadset) proxy;
List<BluetoothDevice> devices =
mBluetoothHeadset.getConnectedDevices();
if (devices.size() > 0) {
Log.i(
"[Audio Manager] [Bluetooth] A device is already connected");
bluetoothHeadetConnectionChanged(true);
}
Log.i("[Audio Manager] [Bluetooth] Registering bluetooth receiver");
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
filter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
filter.addAction(
BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT);
Intent sticky =
mContext.registerReceiver(mBluetoothReceiver, filter);
Log.i("[Audio Manager] [Bluetooth] Bluetooth receiver registered");
int state =
sticky.getIntExtra(
AudioManager.EXTRA_SCO_AUDIO_STATE,
AudioManager.SCO_AUDIO_STATE_DISCONNECTED);
if (state == AudioManager.SCO_AUDIO_STATE_CONNECTED) {
Log.i(
"[Audio Manager] [Bluetooth] Bluetooth headset SCO connected");
bluetoothHeadetScoConnectionChanged(true);
} else if (state == AudioManager.SCO_AUDIO_STATE_DISCONNECTED) {
Log.i(
"[Audio Manager] [Bluetooth] Bluetooth headset SCO disconnected");
bluetoothHeadetScoConnectionChanged(false);
} else if (state == AudioManager.SCO_AUDIO_STATE_CONNECTING) {
Log.i(
"[Audio Manager] [Bluetooth] Bluetooth headset SCO connecting");
} else if (state == AudioManager.SCO_AUDIO_STATE_ERROR) {
Log.i(
"[Audio Manager] [Bluetooth] Bluetooth headset SCO connection error");
} else {
Log.w(
"[Audio Manager] [Bluetooth] Bluetooth headset unknown SCO state changed: "
+ state);
}
}
}
public void onServiceDisconnected(int profile) {
if (profile == BluetoothProfile.HEADSET) {
Log.i("[Audio Manager] [Bluetooth] HEADSET profile disconnected");
mBluetoothHeadset = null;
mIsBluetoothHeadsetConnected = false;
mIsBluetoothHeadsetScoConnected = false;
}
}
};
mBluetoothAdapter.getProfileProxy(
mContext, bluetoothServiceListener, BluetoothProfile.HEADSET);
} else {
Log.w("[Audio Manager] [Bluetooth] Adapter disabled");
}
}
private void startBluetooth() {
mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter != null) {
Log.i("[Audio Manager] [Bluetooth] Adapter found");
if (mAudioManager.isBluetoothScoAvailableOffCall()) {
Log.i("[Audio Manager] [Bluetooth] SCO available off call, continue");
} else {
Log.w("[Audio Manager] [Bluetooth] SCO not available off call !");
}
mBluetoothReceiver = new BluetoothReceiver();
IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
mContext.registerReceiver(mBluetoothReceiver, filter);
bluetoothAdapterStateChanged();
}
}
// HEADSET
private void enableHeadsetReceiver() {
mHeadsetReceiver = new HeadsetReceiver();
Log.i("[Audio Manager] Registering headset receiver");
mContext.registerReceiver(
mHeadsetReceiver, new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY));
mContext.registerReceiver(
mHeadsetReceiver, new IntentFilter(AudioManager.ACTION_HEADSET_PLUG));
mHeadsetReceiverRegistered = true;
}
}
