/*
|
* Copyright 2014 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.
|
*/
|
|
package org.appspot.apprtc;
|
|
import android.Manifest;
|
import android.annotation.TargetApi;
|
import android.app.Activity;
|
import android.app.AlertDialog;
|
import android.content.DialogInterface;
|
import android.content.Intent;
|
import android.content.SharedPreferences;
|
import android.content.pm.ActivityInfo;
|
import android.content.pm.PackageInfo;
|
import android.content.pm.PackageManager;
|
import android.net.Uri;
|
import android.os.Build;
|
import android.os.Bundle;
|
import android.preference.PreferenceManager;
|
import android.text.TextUtils;
|
import android.util.Log;
|
import android.view.ContextMenu;
|
import android.view.KeyEvent;
|
import android.view.Menu;
|
import android.view.MenuItem;
|
import android.view.View;
|
import android.view.View.OnClickListener;
|
import android.view.inputmethod.EditorInfo;
|
import android.webkit.URLUtil;
|
import android.widget.AdapterView;
|
import android.widget.ArrayAdapter;
|
import android.widget.EditText;
|
import android.widget.ImageButton;
|
import android.widget.ListView;
|
import android.widget.TextView;
|
|
import org.json.JSONArray;
|
import org.json.JSONException;
|
|
import java.util.ArrayList;
|
import java.util.Random;
|
|
/**
|
* Handles the initial setup where the user selects which room to join.
|
*/
|
public class ConnectActivity extends Activity {
|
private static final String TAG = "ConnectActivity";
|
private static final int CONNECTION_REQUEST = 1;
|
private static final int PERMISSION_REQUEST = 2;
|
private static final int REMOVE_FAVORITE_INDEX = 0;
|
private static boolean commandLineRun;
|
|
private ImageButton addFavoriteButton;
|
private EditText roomEditText;
|
private ListView roomListView;
|
private SharedPreferences sharedPref;
|
private String keyprefResolution;
|
private String keyprefFps;
|
private String keyprefVideoBitrateType;
|
private String keyprefVideoBitrateValue;
|
private String keyprefAudioBitrateType;
|
private String keyprefAudioBitrateValue;
|
private String keyprefRoomServerUrl;
|
public static ConnectActivity connectActivity;
|
public static boolean first = true;
|
|
public ConnectActivity() {
|
connectActivity = this;
|
}
|
|
private final AdapterView.OnItemClickListener roomListClickListener =
|
new AdapterView.OnItemClickListener() {
|
@Override
|
public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
|
String roomId = ((TextView) view).getText().toString();
|
connectToRoom(roomId, false, false, false, 0);
|
}
|
};
|
private final OnClickListener connectListener = new OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
connectToRoom(roomEditText.getText().toString(), false, false, false, 0);
|
}
|
};
|
private String keyprefRoom;
|
private String keyprefRoomList;
|
private ArrayList<String> roomList;
|
private ArrayAdapter<String> adapter;
|
private final OnClickListener addFavoriteListener = new OnClickListener() {
|
@Override
|
public void onClick(View view) {
|
String newRoom = roomEditText.getText().toString();
|
if (newRoom.length() > 0 && !roomList.contains(newRoom)) {
|
adapter.add(newRoom);
|
adapter.notifyDataSetChanged();
|
}
|
}
|
};
|
|
@Override
|
public void onCreate(Bundle savedInstanceState) {
|
super.onCreate(savedInstanceState);
|
|
int REQUEST_CAMERA_PERMISSION_RESULT = 1;
|
requestPermissions(new String[]{Manifest.permission.RECORD_AUDIO
|
}, REQUEST_CAMERA_PERMISSION_RESULT);
|
|
|
|
Bundle extras = getIntent().getExtras();
|
String ip = "";
|
if(extras != null) {
|
ip = extras.getString("ip");
|
String cameraIndexStr = extras.getString("cameraIndex");
|
if (!TextUtils.isEmpty(cameraIndexStr)) {
|
try {
|
CallActivity.cameraIndex = Integer.parseInt(cameraIndexStr);
|
} catch (Exception e){
|
e.printStackTrace();
|
}
|
}
|
|
String localCameraRotation = extras.getString("localCameraRotation");
|
if (!TextUtils.isEmpty(localCameraRotation)) {
|
try {
|
CallActivity.localCameraRotation = Integer.parseInt(localCameraRotation);
|
} catch (Exception e){
|
e.printStackTrace();
|
}
|
}
|
|
String remoteCameraRotation = extras.getString("remoteCameraRotation");
|
if (!TextUtils.isEmpty(remoteCameraRotation)) {
|
try {
|
CallActivity.remoteCameraRotation = Integer.parseInt(remoteCameraRotation);
|
} catch (Exception e){
|
e.printStackTrace();
|
}
|
}
|
String isServer = extras.getString("isServer");
|
if (!TextUtils.isEmpty(isServer)) {
|
try {
|
CallActivity.isServer = "true".equals(isServer);
|
} catch (Exception e){
|
e.printStackTrace();
|
}
|
}
|
String orientation = extras.getString("orientation");
|
if (!TextUtils.isEmpty(orientation)) {
|
try {
|
CallActivity.orientation = orientation;
|
if ("landscape".equals(orientation)) {
|
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
|
} else {
|
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
|
}
|
} catch (Exception e){
|
e.printStackTrace();
|
}
|
}
|
}
|
|
|
// Get setting keys.
|
PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
|
sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
|
keyprefResolution = getString(R.string.pref_resolution_key);
|
keyprefFps = getString(R.string.pref_fps_key);
|
keyprefVideoBitrateType = getString(R.string.pref_maxvideobitrate_key);
|
keyprefVideoBitrateValue = getString(R.string.pref_maxvideobitratevalue_key);
|
keyprefAudioBitrateType = getString(R.string.pref_startaudiobitrate_key);
|
keyprefAudioBitrateValue = getString(R.string.pref_startaudiobitratevalue_key);
|
keyprefRoomServerUrl = getString(R.string.pref_room_server_url_key);
|
keyprefRoom = getString(R.string.pref_room_key);
|
keyprefRoomList = getString(R.string.pref_room_list_key);
|
|
setContentView(R.layout.activity_connect);
|
|
roomEditText = findViewById(R.id.room_edittext);
|
roomEditText.setText(ip);
|
roomEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
|
@Override
|
public boolean onEditorAction(TextView textView, int i, KeyEvent keyEvent) {
|
if (i == EditorInfo.IME_ACTION_DONE) {
|
addFavoriteButton.performClick();
|
return true;
|
}
|
return false;
|
}
|
});
|
roomEditText.requestFocus();
|
|
roomListView = findViewById(R.id.room_listview);
|
roomListView.setEmptyView(findViewById(android.R.id.empty));
|
roomListView.setOnItemClickListener(roomListClickListener);
|
registerForContextMenu(roomListView);
|
ImageButton connectButton = findViewById(R.id.connect_button);
|
connectButton.setOnClickListener(connectListener);
|
addFavoriteButton = findViewById(R.id.add_favorite_button);
|
addFavoriteButton.setOnClickListener(addFavoriteListener);
|
|
// If an implicit VIEW intent is launching the app, go directly to that URL.
|
final Intent intent = getIntent();
|
if ("android.intent.action.VIEW".equals(intent.getAction()) && !commandLineRun) {
|
boolean loopback = intent.getBooleanExtra(CallActivity.EXTRA_LOOPBACK, false);
|
int runTimeMs = intent.getIntExtra(CallActivity.EXTRA_RUNTIME, 0);
|
boolean useValuesFromIntent =
|
intent.getBooleanExtra(CallActivity.EXTRA_USE_VALUES_FROM_INTENT, false);
|
String room = sharedPref.getString(keyprefRoom, "");
|
connectToRoom(room, true, loopback, useValuesFromIntent, runTimeMs);
|
}
|
// if (!TextUtils.isEmpty(ip) && first) {
|
// first = false;
|
connectToRoom(roomEditText.getText().toString(), false, false, false, 0);
|
// }
|
}
|
|
@Override
|
public boolean onCreateOptionsMenu(Menu menu) {
|
getMenuInflater().inflate(R.menu.connect_menu, menu);
|
return true;
|
}
|
|
@Override
|
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
|
if (v.getId() == R.id.room_listview) {
|
AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
|
menu.setHeaderTitle(roomList.get(info.position));
|
String[] menuItems = getResources().getStringArray(R.array.roomListContextMenu);
|
for (int i = 0; i < menuItems.length; i++) {
|
menu.add(Menu.NONE, i, i, menuItems[i]);
|
}
|
} else {
|
super.onCreateContextMenu(menu, v, menuInfo);
|
}
|
}
|
|
@Override
|
public boolean onContextItemSelected(MenuItem item) {
|
if (item.getItemId() == REMOVE_FAVORITE_INDEX) {
|
AdapterView.AdapterContextMenuInfo info =
|
(AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
|
roomList.remove(info.position);
|
adapter.notifyDataSetChanged();
|
return true;
|
}
|
|
return super.onContextItemSelected(item);
|
}
|
|
@Override
|
public boolean onOptionsItemSelected(MenuItem item) {
|
// Handle presses on the action bar items.
|
if (item.getItemId() == R.id.action_settings) {
|
Intent intent = new Intent(this, SettingsActivity.class);
|
startActivity(intent);
|
return true;
|
} else if (item.getItemId() == R.id.action_loopback) {
|
connectToRoom(null, false, true, false, 0);
|
return true;
|
} else {
|
return super.onOptionsItemSelected(item);
|
}
|
}
|
|
@Override
|
public void onPause() {
|
super.onPause();
|
String room = roomEditText.getText().toString();
|
String roomListJson = new JSONArray(roomList).toString();
|
SharedPreferences.Editor editor = sharedPref.edit();
|
editor.putString(keyprefRoom, room);
|
editor.putString(keyprefRoomList, roomListJson);
|
editor.commit();
|
}
|
|
@Override
|
public void onResume() {
|
super.onResume();
|
String room = sharedPref.getString(keyprefRoom, "");
|
roomEditText.setText(room);
|
roomList = new ArrayList<>();
|
String roomListJson = sharedPref.getString(keyprefRoomList, null);
|
if (roomListJson != null) {
|
try {
|
JSONArray jsonArray = new JSONArray(roomListJson);
|
for (int i = 0; i < jsonArray.length(); i++) {
|
roomList.add(jsonArray.get(i).toString());
|
}
|
} catch (JSONException e) {
|
Log.e(TAG, "Failed to load room list: " + e.toString());
|
}
|
}
|
adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, roomList);
|
roomListView.setAdapter(adapter);
|
if (adapter.getCount() > 0) {
|
roomListView.requestFocus();
|
roomListView.setItemChecked(0, true);
|
}
|
}
|
|
@Override
|
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
|
if (requestCode == CONNECTION_REQUEST && commandLineRun) {
|
Log.d(TAG, "Return: " + resultCode);
|
setResult(resultCode);
|
commandLineRun = false;
|
finish();
|
}
|
}
|
|
@Override
|
public void onRequestPermissionsResult(
|
int requestCode, String[] permissions, int[] grantResults) {
|
if (requestCode == PERMISSION_REQUEST) {
|
String[] missingPermissions = getMissingPermissions();
|
System.out.println("ConnectActivity.onRequestPermissionsResult " + TextUtils.join(",", missingPermissions));
|
if (missingPermissions.length != 0) {
|
// User didn't grant all the permissions. Warn that the application might not work
|
// correctly.
|
new AlertDialog.Builder(this)
|
.setMessage(R.string.missing_permissions_try_again)
|
.setPositiveButton(R.string.yes,
|
(dialog, id) -> {
|
// User wants to try giving the permissions again.
|
dialog.cancel();
|
requestPermissions();
|
})
|
.setNegativeButton(R.string.no,
|
(dialog, id) -> {
|
// User doesn't want to give the permissions.
|
dialog.cancel();
|
onPermissionsGranted();
|
})
|
.show();
|
} else {
|
// All permissions granted.
|
onPermissionsGranted();
|
}
|
}
|
}
|
|
private void onPermissionsGranted() {
|
// If an implicit VIEW intent is launching the app, go directly to that URL.
|
final Intent intent = getIntent();
|
if ("android.intent.action.VIEW".equals(intent.getAction()) && !commandLineRun) {
|
boolean loopback = intent.getBooleanExtra(CallActivity.EXTRA_LOOPBACK, false);
|
int runTimeMs = intent.getIntExtra(CallActivity.EXTRA_RUNTIME, 0);
|
boolean useValuesFromIntent =
|
intent.getBooleanExtra(CallActivity.EXTRA_USE_VALUES_FROM_INTENT, false);
|
String room = sharedPref.getString(keyprefRoom, "");
|
connectToRoom(room, true, loopback, useValuesFromIntent, runTimeMs);
|
}
|
}
|
|
@TargetApi(Build.VERSION_CODES.M)
|
private void requestPermissions() {
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
|
// Dynamic permissions are not required before Android M.
|
onPermissionsGranted();
|
return;
|
}
|
|
String[] missingPermissions = getMissingPermissions();
|
if (missingPermissions.length != 0) {
|
requestPermissions(missingPermissions, PERMISSION_REQUEST);
|
} else {
|
onPermissionsGranted();
|
}
|
}
|
|
@TargetApi(Build.VERSION_CODES.M)
|
private String[] getMissingPermissions() {
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
|
return new String[0];
|
}
|
|
PackageInfo info;
|
try {
|
info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_PERMISSIONS);
|
} catch (PackageManager.NameNotFoundException e) {
|
Log.w(TAG, "Failed to retrieve permissions.");
|
return new String[0];
|
}
|
|
if (info.requestedPermissions == null) {
|
Log.w(TAG, "No requested permissions.");
|
return new String[0];
|
}
|
|
ArrayList<String> missingPermissions = new ArrayList<>();
|
for (int i = 0; i < info.requestedPermissions.length; i++) {
|
if ((info.requestedPermissionsFlags[i] & PackageInfo.REQUESTED_PERMISSION_GRANTED) == 0) {
|
missingPermissions.add(info.requestedPermissions[i]);
|
}
|
}
|
Log.d(TAG, "Missing permissions: " + missingPermissions);
|
|
return missingPermissions.toArray(new String[missingPermissions.size()]);
|
}
|
|
/**
|
* Get a value from the shared preference or from the intent, if it does not
|
* exist the default is used.
|
*/
|
private String sharedPrefGetString(
|
int attributeId, String intentName, int defaultId, boolean useFromIntent) {
|
String defaultValue = getString(defaultId);
|
if (useFromIntent) {
|
String value = getIntent().getStringExtra(intentName);
|
if (value != null) {
|
return value;
|
}
|
return defaultValue;
|
} else {
|
String attributeName = getString(attributeId);
|
return sharedPref.getString(attributeName, defaultValue);
|
}
|
}
|
|
/**
|
* Get a value from the shared preference or from the intent, if it does not
|
* exist the default is used.
|
*/
|
private boolean sharedPrefGetBoolean(
|
int attributeId, String intentName, int defaultId, boolean useFromIntent) {
|
boolean defaultValue = Boolean.parseBoolean(getString(defaultId));
|
if (useFromIntent) {
|
return getIntent().getBooleanExtra(intentName, defaultValue);
|
} else {
|
String attributeName = getString(attributeId);
|
return sharedPref.getBoolean(attributeName, defaultValue);
|
}
|
}
|
|
/**
|
* Get a value from the shared preference or from the intent, if it does not
|
* exist the default is used.
|
*/
|
private int sharedPrefGetInteger(
|
int attributeId, String intentName, int defaultId, boolean useFromIntent) {
|
String defaultString = getString(defaultId);
|
int defaultValue = Integer.parseInt(defaultString);
|
if (useFromIntent) {
|
return getIntent().getIntExtra(intentName, defaultValue);
|
} else {
|
String attributeName = getString(attributeId);
|
String value = sharedPref.getString(attributeName, defaultString);
|
try {
|
return Integer.parseInt(value);
|
} catch (NumberFormatException e) {
|
Log.e(TAG, "Wrong setting for: " + attributeName + ":" + value);
|
return defaultValue;
|
}
|
}
|
}
|
|
@SuppressWarnings("StringSplitter")
|
private void connectToRoom(String roomId, boolean commandLineRun, boolean loopback,
|
boolean useValuesFromIntent, int runTimeMs) {
|
ConnectActivity.commandLineRun = commandLineRun;
|
|
// roomId is random for loopback.
|
if (loopback) {
|
roomId = Integer.toString((new Random()).nextInt(100000000));
|
}
|
|
String roomUrl = sharedPref.getString(
|
keyprefRoomServerUrl, getString(R.string.pref_room_server_url_default));
|
|
// Video call enabled flag.
|
boolean videoCallEnabled = sharedPrefGetBoolean(R.string.pref_videocall_key,
|
CallActivity.EXTRA_VIDEO_CALL, R.string.pref_videocall_default, useValuesFromIntent);
|
|
// Use screencapture option.
|
boolean useScreencapture = sharedPrefGetBoolean(R.string.pref_screencapture_key,
|
CallActivity.EXTRA_SCREENCAPTURE, R.string.pref_screencapture_default, useValuesFromIntent);
|
|
// Use Camera2 option.
|
boolean useCamera2 = sharedPrefGetBoolean(R.string.pref_camera2_key, CallActivity.EXTRA_CAMERA2,
|
R.string.pref_camera2_default, useValuesFromIntent);
|
|
// Get default codecs.
|
String videoCodec = sharedPrefGetString(R.string.pref_videocodec_key,
|
CallActivity.EXTRA_VIDEOCODEC, R.string.pref_videocodec_default, useValuesFromIntent);
|
String audioCodec = sharedPrefGetString(R.string.pref_audiocodec_key,
|
CallActivity.EXTRA_AUDIOCODEC, R.string.pref_audiocodec_default, useValuesFromIntent);
|
|
// Check HW codec flag.
|
boolean hwCodec = sharedPrefGetBoolean(R.string.pref_hwcodec_key,
|
CallActivity.EXTRA_HWCODEC_ENABLED, R.string.pref_hwcodec_default, useValuesFromIntent);
|
|
// Check Capture to texture.
|
boolean captureToTexture = sharedPrefGetBoolean(R.string.pref_capturetotexture_key,
|
CallActivity.EXTRA_CAPTURETOTEXTURE_ENABLED, R.string.pref_capturetotexture_default,
|
useValuesFromIntent);
|
|
// Check FlexFEC.
|
boolean flexfecEnabled = sharedPrefGetBoolean(R.string.pref_flexfec_key,
|
CallActivity.EXTRA_FLEXFEC_ENABLED, R.string.pref_flexfec_default, useValuesFromIntent);
|
|
// Check Disable Audio Processing flag.
|
boolean noAudioProcessing = sharedPrefGetBoolean(R.string.pref_noaudioprocessing_key,
|
CallActivity.EXTRA_NOAUDIOPROCESSING_ENABLED, R.string.pref_noaudioprocessing_default,
|
useValuesFromIntent);
|
|
boolean aecDump = sharedPrefGetBoolean(R.string.pref_aecdump_key,
|
CallActivity.EXTRA_AECDUMP_ENABLED, R.string.pref_aecdump_default, useValuesFromIntent);
|
|
boolean saveInputAudioToFile =
|
sharedPrefGetBoolean(R.string.pref_enable_save_input_audio_to_file_key,
|
CallActivity.EXTRA_SAVE_INPUT_AUDIO_TO_FILE_ENABLED,
|
R.string.pref_enable_save_input_audio_to_file_default, useValuesFromIntent);
|
|
// Check OpenSL ES enabled flag.
|
boolean useOpenSLES = sharedPrefGetBoolean(R.string.pref_opensles_key,
|
CallActivity.EXTRA_OPENSLES_ENABLED, R.string.pref_opensles_default, useValuesFromIntent);
|
|
// Check Disable built-in AEC flag.
|
boolean disableBuiltInAEC = sharedPrefGetBoolean(R.string.pref_disable_built_in_aec_key,
|
CallActivity.EXTRA_DISABLE_BUILT_IN_AEC, R.string.pref_disable_built_in_aec_default,
|
useValuesFromIntent);
|
|
// Check Disable built-in AGC flag.
|
boolean disableBuiltInAGC = sharedPrefGetBoolean(R.string.pref_disable_built_in_agc_key,
|
CallActivity.EXTRA_DISABLE_BUILT_IN_AGC, R.string.pref_disable_built_in_agc_default,
|
useValuesFromIntent);
|
|
// Check Disable built-in NS flag.
|
boolean disableBuiltInNS = sharedPrefGetBoolean(R.string.pref_disable_built_in_ns_key,
|
CallActivity.EXTRA_DISABLE_BUILT_IN_NS, R.string.pref_disable_built_in_ns_default,
|
useValuesFromIntent);
|
|
// Check Disable gain control
|
boolean disableWebRtcAGCAndHPF = sharedPrefGetBoolean(
|
R.string.pref_disable_webrtc_agc_and_hpf_key, CallActivity.EXTRA_DISABLE_WEBRTC_AGC_AND_HPF,
|
R.string.pref_disable_webrtc_agc_and_hpf_key, useValuesFromIntent);
|
|
// Get video resolution from settings.
|
int videoWidth = 0;
|
int videoHeight = 0;
|
if (useValuesFromIntent) {
|
videoWidth = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_WIDTH, 0);
|
videoHeight = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_HEIGHT, 0);
|
}
|
if (videoWidth == 0 && videoHeight == 0) {
|
String resolution =
|
sharedPref.getString(keyprefResolution, getString(R.string.pref_resolution_default));
|
String[] dimensions = resolution.split("[ x]+");
|
if (dimensions.length == 2) {
|
try {
|
videoWidth = Integer.parseInt(dimensions[0]);
|
videoHeight = Integer.parseInt(dimensions[1]);
|
} catch (NumberFormatException e) {
|
videoWidth = 0;
|
videoHeight = 0;
|
Log.e(TAG, "Wrong video resolution setting: " + resolution);
|
}
|
}
|
}
|
|
// Get camera fps from settings.
|
int cameraFps = 0;
|
if (useValuesFromIntent) {
|
cameraFps = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_FPS, 0);
|
}
|
if (cameraFps == 0) {
|
String fps = sharedPref.getString(keyprefFps, getString(R.string.pref_fps_default));
|
String[] fpsValues = fps.split("[ x]+");
|
if (fpsValues.length == 2) {
|
try {
|
cameraFps = Integer.parseInt(fpsValues[0]);
|
} catch (NumberFormatException e) {
|
cameraFps = 0;
|
Log.e(TAG, "Wrong camera fps setting: " + fps);
|
}
|
}
|
}
|
|
// Check capture quality slider flag.
|
boolean captureQualitySlider = sharedPrefGetBoolean(R.string.pref_capturequalityslider_key,
|
CallActivity.EXTRA_VIDEO_CAPTUREQUALITYSLIDER_ENABLED,
|
R.string.pref_capturequalityslider_default, useValuesFromIntent);
|
|
// Get video and audio start bitrate.
|
int videoStartBitrate = 0;
|
if (useValuesFromIntent) {
|
videoStartBitrate = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_BITRATE, 0);
|
}
|
if (videoStartBitrate == 0) {
|
String bitrateTypeDefault = getString(R.string.pref_maxvideobitrate_default);
|
String bitrateType = sharedPref.getString(keyprefVideoBitrateType, bitrateTypeDefault);
|
if (!bitrateType.equals(bitrateTypeDefault)) {
|
String bitrateValue = sharedPref.getString(
|
keyprefVideoBitrateValue, getString(R.string.pref_maxvideobitratevalue_default));
|
videoStartBitrate = Integer.parseInt(bitrateValue);
|
}
|
}
|
|
int audioStartBitrate = 0;
|
if (useValuesFromIntent) {
|
audioStartBitrate = getIntent().getIntExtra(CallActivity.EXTRA_AUDIO_BITRATE, 0);
|
}
|
if (audioStartBitrate == 0) {
|
String bitrateTypeDefault = getString(R.string.pref_startaudiobitrate_default);
|
String bitrateType = sharedPref.getString(keyprefAudioBitrateType, bitrateTypeDefault);
|
if (!bitrateType.equals(bitrateTypeDefault)) {
|
String bitrateValue = sharedPref.getString(
|
keyprefAudioBitrateValue, getString(R.string.pref_startaudiobitratevalue_default));
|
audioStartBitrate = Integer.parseInt(bitrateValue);
|
}
|
}
|
|
// Check statistics display option.
|
boolean displayHud = sharedPrefGetBoolean(R.string.pref_displayhud_key,
|
CallActivity.EXTRA_DISPLAY_HUD, R.string.pref_displayhud_default, useValuesFromIntent);
|
|
boolean tracing = sharedPrefGetBoolean(R.string.pref_tracing_key, CallActivity.EXTRA_TRACING,
|
R.string.pref_tracing_default, useValuesFromIntent);
|
|
// Check Enable RtcEventLog.
|
boolean rtcEventLogEnabled = sharedPrefGetBoolean(R.string.pref_enable_rtceventlog_key,
|
CallActivity.EXTRA_ENABLE_RTCEVENTLOG, R.string.pref_enable_rtceventlog_default,
|
useValuesFromIntent);
|
|
// Get datachannel options
|
boolean dataChannelEnabled = sharedPrefGetBoolean(R.string.pref_enable_datachannel_key,
|
CallActivity.EXTRA_DATA_CHANNEL_ENABLED, R.string.pref_enable_datachannel_default,
|
useValuesFromIntent);
|
boolean ordered = sharedPrefGetBoolean(R.string.pref_ordered_key, CallActivity.EXTRA_ORDERED,
|
R.string.pref_ordered_default, useValuesFromIntent);
|
boolean negotiated = sharedPrefGetBoolean(R.string.pref_negotiated_key,
|
CallActivity.EXTRA_NEGOTIATED, R.string.pref_negotiated_default, useValuesFromIntent);
|
int maxRetrMs = sharedPrefGetInteger(R.string.pref_max_retransmit_time_ms_key,
|
CallActivity.EXTRA_MAX_RETRANSMITS_MS, R.string.pref_max_retransmit_time_ms_default,
|
useValuesFromIntent);
|
int maxRetr =
|
sharedPrefGetInteger(R.string.pref_max_retransmits_key, CallActivity.EXTRA_MAX_RETRANSMITS,
|
R.string.pref_max_retransmits_default, useValuesFromIntent);
|
int id = sharedPrefGetInteger(R.string.pref_data_id_key, CallActivity.EXTRA_ID,
|
R.string.pref_data_id_default, useValuesFromIntent);
|
String protocol = sharedPrefGetString(R.string.pref_data_protocol_key,
|
CallActivity.EXTRA_PROTOCOL, R.string.pref_data_protocol_default, useValuesFromIntent);
|
|
// Start AppRTCMobile activity.
|
Log.d(TAG, "Connecting to room " + roomId + " at URL " + roomUrl);
|
if (validateUrl(roomUrl)) {
|
Uri uri = Uri.parse(roomUrl);
|
Intent intent = new Intent(this, CallActivity.class);
|
intent.setData(uri);
|
intent.putExtra(CallActivity.EXTRA_ROOMID, roomId);
|
intent.putExtra(CallActivity.EXTRA_LOOPBACK, loopback);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_CALL, videoCallEnabled);
|
intent.putExtra(CallActivity.EXTRA_SCREENCAPTURE, useScreencapture);
|
intent.putExtra(CallActivity.EXTRA_CAMERA2, useCamera2);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_WIDTH, videoWidth);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_HEIGHT, videoHeight);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_FPS, cameraFps);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_CAPTUREQUALITYSLIDER_ENABLED, captureQualitySlider);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_BITRATE, videoStartBitrate);
|
intent.putExtra(CallActivity.EXTRA_VIDEOCODEC, videoCodec);
|
intent.putExtra(CallActivity.EXTRA_HWCODEC_ENABLED, hwCodec);
|
intent.putExtra(CallActivity.EXTRA_CAPTURETOTEXTURE_ENABLED, captureToTexture);
|
intent.putExtra(CallActivity.EXTRA_FLEXFEC_ENABLED, flexfecEnabled);
|
intent.putExtra(CallActivity.EXTRA_NOAUDIOPROCESSING_ENABLED, noAudioProcessing);
|
intent.putExtra(CallActivity.EXTRA_AECDUMP_ENABLED, aecDump);
|
intent.putExtra(CallActivity.EXTRA_SAVE_INPUT_AUDIO_TO_FILE_ENABLED, saveInputAudioToFile);
|
intent.putExtra(CallActivity.EXTRA_OPENSLES_ENABLED, useOpenSLES);
|
intent.putExtra(CallActivity.EXTRA_DISABLE_BUILT_IN_AEC, disableBuiltInAEC);
|
intent.putExtra(CallActivity.EXTRA_DISABLE_BUILT_IN_AGC, disableBuiltInAGC);
|
intent.putExtra(CallActivity.EXTRA_DISABLE_BUILT_IN_NS, disableBuiltInNS);
|
intent.putExtra(CallActivity.EXTRA_DISABLE_WEBRTC_AGC_AND_HPF, disableWebRtcAGCAndHPF);
|
intent.putExtra(CallActivity.EXTRA_AUDIO_BITRATE, audioStartBitrate);
|
intent.putExtra(CallActivity.EXTRA_AUDIOCODEC, audioCodec);
|
intent.putExtra(CallActivity.EXTRA_DISPLAY_HUD, displayHud);
|
intent.putExtra(CallActivity.EXTRA_TRACING, tracing);
|
intent.putExtra(CallActivity.EXTRA_ENABLE_RTCEVENTLOG, rtcEventLogEnabled);
|
intent.putExtra(CallActivity.EXTRA_CMDLINE, commandLineRun);
|
intent.putExtra(CallActivity.EXTRA_RUNTIME, runTimeMs);
|
intent.putExtra(CallActivity.EXTRA_DATA_CHANNEL_ENABLED, dataChannelEnabled);
|
|
if (dataChannelEnabled) {
|
intent.putExtra(CallActivity.EXTRA_ORDERED, ordered);
|
intent.putExtra(CallActivity.EXTRA_MAX_RETRANSMITS_MS, maxRetrMs);
|
intent.putExtra(CallActivity.EXTRA_MAX_RETRANSMITS, maxRetr);
|
intent.putExtra(CallActivity.EXTRA_PROTOCOL, protocol);
|
intent.putExtra(CallActivity.EXTRA_NEGOTIATED, negotiated);
|
intent.putExtra(CallActivity.EXTRA_ID, id);
|
}
|
|
if (useValuesFromIntent) {
|
if (getIntent().hasExtra(CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA)) {
|
String videoFileAsCamera =
|
getIntent().getStringExtra(CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA);
|
intent.putExtra(CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA, videoFileAsCamera);
|
}
|
|
if (getIntent().hasExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE)) {
|
String saveRemoteVideoToFile =
|
getIntent().getStringExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE);
|
intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE, saveRemoteVideoToFile);
|
}
|
|
if (getIntent().hasExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH)) {
|
int videoOutWidth =
|
getIntent().getIntExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH, 0);
|
intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH, videoOutWidth);
|
}
|
|
if (getIntent().hasExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT)) {
|
int videoOutHeight =
|
getIntent().getIntExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT, 0);
|
intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT, videoOutHeight);
|
}
|
}
|
|
startActivityForResult(intent, CONNECTION_REQUEST);
|
}
|
}
|
|
private boolean validateUrl(String url) {
|
if (URLUtil.isHttpsUrl(url) || URLUtil.isHttpUrl(url)) {
|
return true;
|
}
|
|
new AlertDialog.Builder(this)
|
.setTitle(getText(R.string.invalid_url_title))
|
.setMessage(getString(R.string.invalid_url_text, url))
|
.setCancelable(false)
|
.setNeutralButton(R.string.ok,
|
new DialogInterface.OnClickListener() {
|
@Override
|
public void onClick(DialogInterface dialog, int id) {
|
dialog.cancel();
|
}
|
})
|
.create()
|
.show();
|
return false;
|
}
|
}
|
