haskal
/
jiti-meet
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Comply w/ coding style 

- Maximum of 80 characters per line.
- Group first and then sort in alphabetical order.
- Fields should begin with a lowercase letter.
This commit is contained in:
Lyubomir Marinov 2017-01-26 20:12:58 -06:00
parent 2edaaac7bf
commit ef39baab47
4 changed files with 284 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
android/app/src/main/AndroidManifest.xml
View File

@ -3,7 +3,7 @@
android:versionCode="1"
android:versionName="1.0">
<!-- XXX: ACCESS_NETWORK_STATE is needed by react-native-webrtc -->
<!-- XXX: ACCESS_NETWORK_STATE is required by WebRTC. -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.CAMERA" />

345
android/app/src/main/java/org/jitsi/meet/audiomode/AudioModeModule.java
View File

@ -22,33 +22,43 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Module implementing a simple API to select the appropriate audio device for a conference call.
* Module implementing a simple API to select the appropriate audio device for a
* conference call.
*
* Audio calls should use <tt>AudioModeModule.AUDIO_CALL</tt>, which uses the builtin earpiece,
* wired headset or bluetooth headset. The builtin earpiece is the default audio device.
* Audio calls should use <tt>AudioModeModule.AUDIO_CALL</tt>, which uses the
* builtin earpiece, wired headset or bluetooth headset. The builtin earpiece is
* the default audio device.
*
* Video calls should should use <tt>AudioModeModule.VIDEO_CALL</tt>, which uses the builtin
* speaker, earpiece, wired headset or bluetooth headset. The builtin speaker is the default
* audio device.
* Video calls should should use <tt>AudioModeModule.VIDEO_CALL</tt>, which uses
* the builtin speaker, earpiece, wired headset or bluetooth headset. The
* builtin speaker is the default audio device.
*
* Before a call has started and after it has ended the <tt>AudioModeModule.DEFAULT</tt> mode
* should be used.
* Before a call has started and after it has ended the
* <tt>AudioModeModule.DEFAULT</tt> mode should be used.
*/
public class AudioModeModule extends ReactContextBaseJavaModule {
/**
* Constants representing the audio mode.
* - DEFAULT: Used before and after every call. It represents the default audio routing scheme.
* - AUDIO_CALL: Used for audio only calls. It will use the earpiece by default, unless a
* wired or Bluetooth headset is connected.
* - VIDEO_CALL: Used for video calls. It will use the speaker by default, unless a wired or
* Bluetooth headset is connected.
* - DEFAULT: Used before and after every call. It represents the default
* audio routing scheme.
* - AUDIO_CALL: Used for audio only calls. It will use the earpiece by
* default, unless a wired or Bluetooth headset is connected.
* - VIDEO_CALL: Used for video calls. It will use the speaker by default,
* unless a wired or Bluetooth headset is connected.
*/
private static final int DEFAULT = 0;
private static final int AUDIO_CALL = 1;
private static final int VIDEO_CALL = 2;
/**
*
*/
private static final String ACTION_HEADSET_PLUG
= (android.os.Build.VERSION.SDK_INT >= 21)
? AudioManager.ACTION_HEADSET_PLUG
: Intent.ACTION_HEADSET_PLUG;
/**
* React Native module name.
*/
@ -60,15 +70,17 @@ public class AudioModeModule extends ReactContextBaseJavaModule {
static final String TAG = MODULE_NAME;
/**
* Audio mode currently in use.
*/
private int mode = -1;
/**
* {@link AudioManager} instance used to interact with the Android audio subsystem.
* {@link AudioManager} instance used to interact with the Android audio
* subsystem.
*/
private final AudioManager audioManager;
/**
* {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in
* old (< M) Android versions.
*/
private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
/**
* {@link Handler} for running all operations on the main thread.
*/
@ -80,27 +92,23 @@ public class AudioModeModule extends ReactContextBaseJavaModule {
private final Runnable mainThreadRunner;
/**
* {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in old (< M)
* Android versions.
* Audio mode currently in use.
*/
private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
private int mode = -1;
/**
* Initializes a new module instance. There shall be a single instance of
* this module throughout the lifetime of the application.
*
*/
private static final String ACTION_HEADSET_PLUG = (android.os.Build.VERSION.SDK_INT >= 21) ?
AudioManager.ACTION_HEADSET_PLUG : Intent.ACTION_HEADSET_PLUG;
/**
* Initializes a new module instance. There shall be a single instance of this module throughout
* the lifetime of the application.
*
* @param reactContext the {@link ReactApplicationContext} where this module is created.
* @param reactContext the {@link ReactApplicationContext} where this module
* is created.
*/
public AudioModeModule(ReactApplicationContext reactContext) {
super(reactContext);
audioManager = ((AudioManager) reactContext.getSystemService(Context.AUDIO_SERVICE));
audioManager
= (AudioManager)
reactContext.getSystemService(Context.AUDIO_SERVICE);
mainThreadHandler = new Handler(Looper.getMainLooper());
mainThreadRunner = new Runnable() {
@Override
@ -111,10 +119,27 @@ public class AudioModeModule extends ReactContextBaseJavaModule {
}
};
// Setup runtime device change detection
// Setup runtime device change detection.
setupAudioRouteChangeDetection();
}
/**
* Gets a mapping with the constants this module is exporting.
*
* @return a {@link Map} mapping the constants to be exported with their
* values.
*/
@Override
public Map<String, Object> getConstants() {
Map<String, Object> constants = new HashMap<>();
constants.put("AUDIO_CALL", AUDIO_CALL);
constants.put("DEFAULT", DEFAULT);
constants.put("VIDEO_CALL", VIDEO_CALL);
return constants;
}
/**
* Gets the name for this module, to be used in the React Native bridge.
*
@ -126,24 +151,126 @@ public class AudioModeModule extends ReactContextBaseJavaModule {
}
/**
* Gets a mapping with the constants this module is exporting.
*
* @return a {@link Map} mapping the constants to be exported with their values.
* Helper method to trigger an audio route update when devices change. It
* makes sure the operation is performed on the main thread.
*/
void onAudioDeviceChange() {
mainThreadHandler.post(mainThreadRunner);
}
/**
* Helper method to set the output route to a Bluetooth device.
*
* @param enabled true if Bluetooth should use used, false otherwise.
*/
private void setBluetoothAudioRoute(boolean enabled) {
if (enabled) {
audioManager.startBluetoothSco();
audioManager.setBluetoothScoOn(true);
} else {
audioManager.setBluetoothScoOn(false);
audioManager.stopBluetoothSco();
}
}
/**
* Public method to set the current audio mode.
*
* @param mode the desired audio mode.
* @param promise a {@link Promise} which will be resolved if the audio mode
* could be updated successfully, and it will be rejected otherwise.
*/
@ReactMethod
public void setMode(final int mode, final Promise promise) {
if (mode != DEFAULT && mode != AUDIO_CALL && mode != VIDEO_CALL) {
promise.reject("setMode", "Invalid audio mode " + mode);
return;
}
Runnable r = new Runnable() {
@Override
public Map<String, Object> getConstants() {
Map<String, Object> constants = new HashMap<>();
constants.put("DEFAULT", DEFAULT);
constants.put("AUDIO_CALL", AUDIO_CALL);
constants.put("VIDEO_CALL", VIDEO_CALL);
return constants;
public void run() {
if (updateAudioRoute(mode)) {
AudioModeModule.this.mode = mode;
promise.resolve(null);
} else {
promise.reject(
"setMode",
"Failed to set the requested audio mode");
}
}
};
mainThreadHandler.post(r);
}
/**
* Setup the audio route change detection mechanism. We use the
* {@link android.media.AudioDeviceCallback} API on Android >= 23 only.
*/
private void setupAudioRouteChangeDetection() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
setupAudioRouteChangeDetectionM();
} else {
setupAudioRouteChangeDetectionPreM();
}
}
/**
* Audio route change detection mechanism for Android API >= 23.
*/
@TargetApi(Build.VERSION_CODES.M)
private void setupAudioRouteChangeDetectionM() {
android.media.AudioDeviceCallback audioDeviceCallback =
new android.media.AudioDeviceCallback() {
@Override
public void onAudioDevicesAdded(
AudioDeviceInfo[] addedDevices) {
Log.d(TAG, "Audio devices added");
onAudioDeviceChange();
}
@Override
public void onAudioDevicesRemoved(
AudioDeviceInfo[] removedDevices) {
Log.d(TAG, "Audio devices removed");
onAudioDeviceChange();
}
};
audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
}
/**
* Audio route change detection mechanism for Android API < 23.
*/
private void setupAudioRouteChangeDetectionPreM() {
ReactContext reactContext = getReactApplicationContext();
// Detect changes in wired headset connections.
IntentFilter wiredHeadSetFilter = new IntentFilter(ACTION_HEADSET_PLUG);
BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "Wired headset added / removed");
onAudioDeviceChange();
}
};
reactContext.registerReceiver(wiredHeadsetReceiver, wiredHeadSetFilter);
// Detect Bluetooth device changes.
bluetoothHeadsetMonitor
= new BluetoothHeadsetMonitor(
this,
getReactApplicationContext());
bluetoothHeadsetMonitor.start();
}
/**
* Updates the audio route for the given mode.
*
* @param mode the audio mode to be used when computing the audio route.
* @return true if the audio route was updated successfully, false otherwise.
* @return true if the audio route was updated successfully, false
* otherwise.
*/
private boolean updateAudioRoute(int mode) {
Log.d(TAG, "Update audio route for mode: " + mode);
@ -173,133 +300,29 @@ public class AudioModeModule extends ReactContextBaseJavaModule {
boolean useSpeaker = (mode == VIDEO_CALL);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
// On Android >= M we use the AudioDeviceCallback API, so turn on Bluetooth SCO
// from the start.
// On Android >= M we use the AudioDeviceCallback API, so turn on
// Bluetooth SCO from the start.
if (audioManager.isBluetoothScoAvailableOffCall()) {
audioManager.startBluetoothSco();
}
} else {
// On older Android versions we must set the Bluetooth route manually. Also disable
// the speaker in that case.
setBluetoothAudioRoute(bluetoothHeadsetMonitor.isHeadsetAvailable());
// On older Android versions we must set the Bluetooth route
// manually. Also disable the speaker in that case.
setBluetoothAudioRoute(
bluetoothHeadsetMonitor.isHeadsetAvailable());
if (bluetoothHeadsetMonitor.isHeadsetAvailable()) {
useSpeaker = false;
}
}
// XXX: isWiredHeadsetOn is not deprecated when used just for knowing if there is a wired
// headset connected, regardless of audio being routed to it.
audioManager.setSpeakerphoneOn(useSpeaker &&
!(audioManager.isWiredHeadsetOn() || audioManager.isBluetoothScoOn()));
// XXX: isWiredHeadsetOn is not deprecated when used just for knowing if
// there is a wired headset connected, regardless of audio being routed
// to it.
audioManager.setSpeakerphoneOn(
useSpeaker
&& !(audioManager.isWiredHeadsetOn()
|| audioManager.isBluetoothScoOn()));
return true;
}
/**
* Public method to set the current audio mode.
*
* @param mode the desired audio mode.
* @param promise a {@link Promise} which will be resolved if the audio mode could be updated
* successfully, and it will be rejected otherwise.
*/
@ReactMethod
public void setMode(final int mode, final Promise promise) {
if (mode != DEFAULT && mode != AUDIO_CALL && mode != VIDEO_CALL) {
promise.reject("setMode", "Invalid audio mode " + mode);
return;
}
Runnable r = new Runnable() {
@Override
public void run() {
if (updateAudioRoute(mode)) {
AudioModeModule.this.mode = mode;
promise.resolve(null);
} else {
promise.reject("setMode", "Failed to set the requested audio mode");
}
}
};
mainThreadHandler.post(r);
}
/**
* Setup the audio route change detection mechanism. We use the
* {@link android.media.AudioDeviceCallback} API on Android >= 23 only.
*/
private void setupAudioRouteChangeDetection() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
setupAudioRouteChangeDetectionM();
} else {
setupAudioRouteChangeDetectionOld();
}
}
/**
* Audio route change detection mechanism for Android API >= 23.
*/
@TargetApi(Build.VERSION_CODES.M)
private void setupAudioRouteChangeDetectionM() {
android.media.AudioDeviceCallback audioDeviceCallback =
new android.media.AudioDeviceCallback() {
@Override
public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
Log.d(TAG, "Audio devices added");
onAudioDeviceChange();
}
@Override
public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
Log.d(TAG, "Audio devices removed");
onAudioDeviceChange();
}
};
audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
}
/**
* Audio route change detection mechanism for Android API < 23.
*/
private void setupAudioRouteChangeDetectionOld() {
ReactContext reactContext = getReactApplicationContext();
// Detect changes in wired headset connections
IntentFilter wiredHeadSetFilter = new IntentFilter(ACTION_HEADSET_PLUG);
BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
Log.d(TAG, "Wired headset added / removed");
onAudioDeviceChange();
}
};
reactContext.registerReceiver(wiredHeadsetReceiver, wiredHeadSetFilter);
// Detect Bluetooth device changes
bluetoothHeadsetMonitor =
new BluetoothHeadsetMonitor(this, this.getReactApplicationContext());
bluetoothHeadsetMonitor.start();
}
/**
* Helper method to set the output route to a Bluetooth device.
* @param enabled true if Bluetooth should use used, false otherwise.
*/
private void setBluetoothAudioRoute(boolean enabled) {
if (enabled) {
audioManager.startBluetoothSco();
audioManager.setBluetoothScoOn(true);
} else {
audioManager.setBluetoothScoOn(false);
audioManager.stopBluetoothSco();
}
}
/**
* Helper method to trigger an audio route update when devices change. It makes sure the
* operation is performed on the main thread.
*/
void onAudioDeviceChange() {
mainThreadHandler.post(mainThreadRunner);
}
}

33
android/app/src/main/java/org/jitsi/meet/audiomode/AudioModePackage.java
View File

@ -10,19 +10,10 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class AudioModePackage implements ReactPackage {
/**
* {@inheritDoc}
* @return List of native modules to be exposed by React Native.
/**
* Implements {@link ReactPackage} for {@link AudioModeModule}.
*/
@Override
public List<NativeModule> createNativeModules(
ReactApplicationContext reactContext) {
List<NativeModule> modules = new ArrayList<>();
modules.add(new AudioModeModule(reactContext));
return modules;
}
public class AudioModePackage implements ReactPackage {
/**
* {@inheritDoc}
*/
@ -33,9 +24,25 @@ public class AudioModePackage implements ReactPackage {
/**
* {@inheritDoc}
*
* @return List of native modules to be exposed by React Native.
*/
@Override
public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
public List<NativeModule> createNativeModules(
ReactApplicationContext reactContext) {
List<NativeModule> modules = new ArrayList<>();
modules.add(new AudioModeModule(reactContext));
return modules;
}
/**
* {@inheritDoc}
*/
@Override
public List<ViewManager> createViewManagers(
ReactApplicationContext reactContext) {
return Collections.emptyList();
}
}

128
android/app/src/main/java/org/jitsi/meet/audiomode/BluetoothHeadsetMonitor.java
View File

@ -18,28 +18,25 @@ import com.facebook.react.bridge.ReactContext;
import java.util.List;
/**
* Helper class to detect and handle Bluetooth device changes. It monitors Bluetooth headsets
* being connected / disconnected and notifies the module about device changes when this occurs.
* Helper class to detect and handle Bluetooth device changes. It monitors
* Bluetooth headsets being connected / disconnected and notifies the module
* about device changes when this occurs.
*/
public class BluetoothHeadsetMonitor {
/**
* {@link AudioModeModule} where this monitor reports.
*/
private final AudioModeModule AudioModeModule;
/**
* {@link AudioManager} instance used to interact with the Android audio subsystem.
* {@link AudioManager} instance used to interact with the Android audio
* subsystem.
*/
private final AudioManager audioManager;
/**
* {@link ReactContext} instance where the main module runs.
* {@link AudioModeModule} where this monitor reports.
*/
private final ReactContext reactContext;
private final AudioModeModule audioModeModule;
/**
* Reference to the Bluetooth adapter, needed for managing <tt>BluetoothProfile.HEADSET</tt>
* devices.
* Reference to the Bluetooth adapter, needed for managing
* <tt>BluetoothProfile.HEADSET</tt> devices.
*/
private BluetoothAdapter bluetoothAdapter;
@ -49,37 +46,56 @@ public class BluetoothHeadsetMonitor {
private BluetoothHeadset bluetoothHeadset;
/**
* Listener for Bluetooth service profiles, allows us to get the proxy object to
* {@link BluetoothHeadset}.
* Listener for Bluetooth service profiles, allows us to get the proxy
* object to {@link BluetoothHeadset}.
*/
private BluetoothProfile.ServiceListener bluetoothProfileListener;
/**
* {@link Handler} for running all operations on the main thread.
*/
private final Handler mainThreadHandler;
/**
* Helper for running Bluetooth operations on the main thread.
*/
private Runnable bluetoothRunnable;
/**
* Flag indicating if there are any Bluetooth headset devices currently available.
* Flag indicating if there are any Bluetooth headset devices currently
* available.
*/
private boolean headsetAvailable = false;
public BluetoothHeadsetMonitor(AudioModeModule audioModeModule, ReactContext reactContext) {
this.AudioModeModule = audioModeModule;
/**
* {@link Handler} for running all operations on the main thread.
*/
private final Handler mainThreadHandler;
/**
* {@link ReactContext} instance where the main module runs.
*/
private final ReactContext reactContext;
public BluetoothHeadsetMonitor(
AudioModeModule audioModeModule,
ReactContext reactContext) {
this.audioModeModule = audioModeModule;
this.reactContext = reactContext;
audioManager = ((AudioManager) reactContext.getSystemService(Context.AUDIO_SERVICE));
audioManager
= (AudioManager)
reactContext.getSystemService(Context.AUDIO_SERVICE);
bluetoothAdapter = null;
bluetoothHeadset = null;
bluetoothProfileListener = null;
mainThreadHandler = new Handler(Looper.getMainLooper());
}
/**
* Returns the current headset availability.
*
* @return true if there is a Bluetooth headset connected, false otherwise.
*/
public boolean isHeadsetAvailable() {
return headsetAvailable;
}
/**
* Start monitoring Bluetooth device activity.
*/
@ -90,10 +106,11 @@ public class BluetoothHeadsetMonitor {
if (bluetoothHeadset == null) {
headsetAvailable = false;
} else {
List<BluetoothDevice> devices = bluetoothHeadset.getConnectedDevices();
List<BluetoothDevice> devices
= bluetoothHeadset.getConnectedDevices();
headsetAvailable = !devices.isEmpty();
}
BluetoothHeadsetMonitor.this.AudioModeModule.onAudioDeviceChange();
audioModeModule.onAudioDeviceChange();
}
};
@ -108,11 +125,14 @@ public class BluetoothHeadsetMonitor {
return;
}
// XXX: The profile listener listens for system services of the given type being available
// to the application. That is, if our Bluetooth adapter has the "headset" profile.
// XXX: The profile listener listens for system services of the given
// type being available to the application. That is, if our Bluetooth
// adapter has the "headset" profile.
bluetoothProfileListener = new BluetoothProfile.ServiceListener() {
@Override
public void onServiceConnected(int profile, BluetoothProfile proxy) {
public void onServiceConnected(
int profile,
BluetoothProfile proxy) {
if (profile == BluetoothProfile.HEADSET) {
bluetoothHeadset = (BluetoothHeadset) proxy;
updateDevices();
@ -133,33 +153,47 @@ public class BluetoothHeadsetMonitor {
IntentFilter bluetoothFilter = new IntentFilter();
bluetoothFilter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
bluetoothFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
bluetoothFilter.addAction(
BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
final String action = intent.getAction();
if (action.equals(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)) {
// XXX: This action will be fired when a Bluetooth headset is connected or
// disconnected to the system. This is not related to audio routing.
final int state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, -99);
if (action.equals(
BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)) {
// XXX: This action will be fired when a Bluetooth headset
// is connected or disconnected to the system. This is not
// related to audio routing.
final int state
= intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, -99);
switch (state) {
case BluetoothHeadset.STATE_CONNECTED:
case BluetoothHeadset.STATE_DISCONNECTED:
Log.d(AudioModeModule.TAG, "BT headset connection state changed: " + state);
Log.d(
AudioModeModule.TAG,
"BT headset connection state changed: "
+ state);
updateDevices();
break;
default:
break;
}
} else if (action.equals(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)) {
// XXX: This action will be fired when the connection established with a
// Bluetooth headset (called a SCO connection) changes state. When the SCO
// connection is active we route audio to it.
final int state = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -99);
} else if (action.equals(
AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)) {
// XXX: This action will be fired when the connection
// established with a Bluetooth headset (called a SCO
// connection) changes state. When the SCO connection is
// active we route audio to it.
final int state
= intent.getIntExtra(
AudioManager.EXTRA_SCO_AUDIO_STATE,
-99);
switch (state) {
case AudioManager.SCO_AUDIO_STATE_CONNECTED:
case AudioManager.SCO_AUDIO_STATE_DISCONNECTED:
Log.d(AudioModeModule.TAG, "BT SCO connection state changed: " + state);
Log.d(
AudioModeModule.TAG,
"BT SCO connection state changed: " + state);
updateDevices();
break;
default:
@ -170,23 +204,15 @@ public class BluetoothHeadsetMonitor {
};
reactContext.registerReceiver(bluetoothReceiver, bluetoothFilter);
// Initial detection
// Initial detection.
updateDevices();
}
/**
* Detect if there are new devices connected / disconnected and fires the
* <tt>onAudioDeviceChange</tt> callback.
* Detects if there are new devices connected / disconnected and fires the
* {@link AudioModeModule#onAudioDeviceChange()} callback.
*/
private void updateDevices() {
mainThreadHandler.post(bluetoothRunnable);
}
/**
* Returns the current headset availability.
* @return true if there is a Bluetooth headset connected, false otherwise.
*/
public boolean isHeadsetAvailable() {
return headsetAvailable;
}
}