/*
|
* 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 android.content.ContentResolver;
|
import android.content.Context;
|
import android.provider.Settings;
|
import android.widget.Toast;
|
import org.linphone.LinphoneContext;
|
import org.linphone.LinphoneManager;
|
import org.linphone.R;
|
import org.linphone.contacts.ContactsManager;
|
import org.linphone.contacts.LinphoneContact;
|
import org.linphone.core.Address;
|
import org.linphone.core.Call;
|
import org.linphone.core.CallParams;
|
import org.linphone.core.Core;
|
import org.linphone.core.MediaEncryption;
|
import org.linphone.core.ProxyConfig;
|
import org.linphone.core.tools.Log;
|
import org.linphone.dialer.views.AddressType;
|
import org.linphone.mediastream.Version;
|
import org.linphone.settings.LinphonePreferences;
|
import org.linphone.utils.FileUtils;
|
import org.linphone.utils.LinphoneUtils;
|
|
/** Handle call updating, reinvites. */
|
public class CallManager {
|
private Context mContext;
|
private CallActivityInterface mCallInterface;
|
private BandwidthManager mBandwidthManager;
|
|
public CallManager(Context context) {
|
mContext = context;
|
mBandwidthManager = new BandwidthManager();
|
}
|
|
public void destroy() {
|
mBandwidthManager.destroy();
|
}
|
|
public void terminateCurrentCallOrConferenceOrAll() {
|
Core core = LinphoneManager.getCore();
|
Call call = core.getCurrentCall();
|
if (call != null) {
|
call.terminate();
|
} else if (core.isInConference()) {
|
core.terminateConference();
|
} else {
|
core.terminateAllCalls();
|
}
|
}
|
|
public void addVideo() {
|
Call call = LinphoneManager.getCore().getCurrentCall();
|
if (call.getState() == Call.State.End || call.getState() == Call.State.Released) return;
|
if (!call.getCurrentParams().videoEnabled()) {
|
enableCamera(call, true);
|
reinviteWithVideo();
|
}
|
}
|
|
public void removeVideo() {
|
Core core = LinphoneManager.getCore();
|
Call call = core.getCurrentCall();
|
CallParams params = core.createCallParams(call);
|
params.enableVideo(false);
|
call.update(params);
|
}
|
|
public void switchCamera() {
|
Core core = LinphoneManager.getCore();
|
if (core == null) return;
|
|
String currentDevice = core.getVideoDevice();
|
Log.i("[Call Manager] Current camera device is " + currentDevice);
|
|
String[] devices = core.getVideoDevicesList();
|
for (String d : devices) {
|
if (!d.equals(currentDevice) && !d.equals("StaticImage: Static picture")) {
|
Log.i("[Call Manager] New camera device will be " + d);
|
core.setVideoDevice(d);
|
break;
|
}
|
}
|
|
Call call = core.getCurrentCall();
|
if (call == null) {
|
Log.i("[Call Manager] Switching camera while not in call");
|
return;
|
}
|
call.update(null);
|
}
|
|
public boolean acceptCall(Call call) {
|
if (call == null) return false;
|
|
Core core = LinphoneManager.getCore();
|
CallParams params = core.createCallParams(call);
|
|
boolean isLowBandwidthConnection =
|
!LinphoneUtils.isHighBandwidthConnection(
|
LinphoneContext.instance().getApplicationContext());
|
|
if (params != null) {
|
params.enableLowBandwidth(isLowBandwidthConnection);
|
params.setRecordFile(
|
FileUtils.getCallRecordingFilename(mContext, call.getRemoteAddress()));
|
} else {
|
Log.e("[Call Manager] Could not create call params for call");
|
return false;
|
}
|
|
call.acceptWithParams(params);
|
return true;
|
}
|
|
public void acceptCallUpdate(boolean accept) {
|
Core core = LinphoneManager.getCore();
|
Call call = core.getCurrentCall();
|
if (call == null) {
|
return;
|
}
|
|
CallParams params = core.createCallParams(call);
|
if (accept) {
|
params.enableVideo(true);
|
core.enableVideoCapture(true);
|
core.enableVideoDisplay(true);
|
}
|
|
call.acceptUpdate(params);
|
}
|
|
public void inviteAddress(Address address, boolean forceZRTP) {
|
boolean isLowBandwidthConnection =
|
!LinphoneUtils.isHighBandwidthConnection(
|
LinphoneContext.instance().getApplicationContext());
|
|
inviteAddress(address, false, isLowBandwidthConnection, forceZRTP);
|
}
|
|
public void inviteAddress(Address address, boolean videoEnabled, boolean lowBandwidth) {
|
inviteAddress(address, videoEnabled, lowBandwidth, false);
|
}
|
|
public void newOutgoingCall(AddressType address) {
|
String to = address.getText().toString();
|
newOutgoingCall(to, address.getDisplayedName());
|
}
|
|
public void newOutgoingCall(String to, String displayName) {
|
if (to == null) return;
|
|
// If to is only a username, try to find the contact to get an alias if existing
|
if (!to.startsWith("sip:") || !to.contains("@")) {
|
LinphoneContact contact = ContactsManager.getInstance().findContactFromPhoneNumber(to);
|
if (contact != null) {
|
String alias = contact.getContactFromPresenceModelForUriOrTel(to);
|
if (alias != null) {
|
to = alias;
|
}
|
}
|
}
|
|
LinphonePreferences preferences = LinphonePreferences.instance();
|
Core core = LinphoneManager.getCore();
|
Address address;
|
address = core.interpretUrl(to); // InterpretUrl does normalizePhoneNumber
|
if (address == null) {
|
Log.e("[Call Manager] Couldn't convert to String to Address : " + to);
|
return;
|
}
|
|
ProxyConfig lpc = core.getDefaultProxyConfig();
|
if (mContext.getResources().getBoolean(R.bool.forbid_self_call)
|
&& lpc != null
|
&& address.weakEqual(lpc.getIdentityAddress())) {
|
return;
|
}
|
address.setDisplayName(displayName);
|
|
boolean isLowBandwidthConnection =
|
!LinphoneUtils.isHighBandwidthConnection(
|
LinphoneContext.instance().getApplicationContext());
|
|
if (core.isNetworkReachable()) {
|
if (Version.isVideoCapable()) {
|
boolean prefVideoEnable = preferences.isVideoEnabled();
|
boolean prefInitiateWithVideo = preferences.shouldInitiateVideoCall();
|
inviteAddress(
|
address,
|
prefVideoEnable && prefInitiateWithVideo,
|
isLowBandwidthConnection);
|
} else {
|
inviteAddress(address, false, isLowBandwidthConnection);
|
}
|
} else {
|
Toast.makeText(
|
mContext,
|
mContext.getString(R.string.error_network_unreachable),
|
Toast.LENGTH_LONG)
|
.show();
|
Log.e(
|
"[Call Manager] Error: "
|
+ mContext.getString(R.string.error_network_unreachable));
|
}
|
}
|
|
public void playDtmf(ContentResolver r, char dtmf) {
|
try {
|
if (Settings.System.getInt(r, Settings.System.DTMF_TONE_WHEN_DIALING) == 0) {
|
// audible touch disabled: don't play on speaker, only send in outgoing stream
|
return;
|
}
|
} catch (Settings.SettingNotFoundException e) {
|
Log.e("[Call Manager] playDtmf exception: " + e);
|
}
|
|
LinphoneManager.getCore().playDtmf(dtmf, -1);
|
}
|
|
public boolean shouldShowAcceptCallUpdateDialog(Call call) {
|
if (call == null) return true;
|
|
boolean remoteVideo = call.getRemoteParams().videoEnabled();
|
boolean localVideo = call.getCurrentParams().videoEnabled();
|
boolean autoAcceptCameraPolicy =
|
LinphonePreferences.instance().shouldAutomaticallyAcceptVideoRequests();
|
return remoteVideo
|
&& !localVideo
|
&& !autoAcceptCameraPolicy
|
&& !call.getCore().isInConference();
|
}
|
|
public void setCallInterface(CallActivityInterface callInterface) {
|
mCallInterface = callInterface;
|
}
|
|
public void resetCallControlsHidingTimer() {
|
if (mCallInterface != null) {
|
mCallInterface.resetCallControlsHidingTimer();
|
}
|
}
|
|
public void refreshInCallActions() {
|
if (mCallInterface != null) {
|
mCallInterface.refreshInCallActions();
|
}
|
}
|
|
public void removeCallFromConference(Call call) {
|
if (call == null || call.getConference() == null) {
|
return;
|
}
|
call.getConference().removeParticipant(call.getRemoteAddress());
|
|
if (call.getCore().getConferenceSize() <= 1) {
|
call.getCore().leaveConference();
|
}
|
}
|
|
public void pauseConference() {
|
Core core = LinphoneManager.getCore();
|
if (core == null) return;
|
if (core.isInConference()) {
|
Log.i("[Call Manager] Pausing conference");
|
core.leaveConference();
|
} else {
|
Log.w("[Call Manager] Core isn't in a conference, can't pause it");
|
}
|
}
|
|
public void resumeConference() {
|
Core core = LinphoneManager.getCore();
|
if (core == null) return;
|
if (!core.isInConference()) {
|
Log.i("[Call Manager] Resuming conference");
|
core.enterConference();
|
} else {
|
Log.w("[Call Manager] Core is already in a conference, can't resume it");
|
}
|
}
|
|
private void inviteAddress(
|
Address address, boolean videoEnabled, boolean lowBandwidth, boolean forceZRTP) {
|
Core core = LinphoneManager.getCore();
|
|
CallParams params = core.createCallParams(null);
|
mBandwidthManager.updateWithProfileSettings(params);
|
|
if (videoEnabled && params.videoEnabled()) {
|
params.enableVideo(true);
|
} else {
|
params.enableVideo(false);
|
}
|
|
if (lowBandwidth) {
|
params.enableLowBandwidth(true);
|
Log.d("[Call Manager] Low bandwidth enabled in call params");
|
}
|
|
if (forceZRTP) {
|
params.setMediaEncryption(MediaEncryption.ZRTP);
|
}
|
|
String recordFile =
|
FileUtils.getCallRecordingFilename(
|
LinphoneContext.instance().getApplicationContext(), address);
|
params.setRecordFile(recordFile);
|
|
core.inviteAddressWithParams(address, params);
|
}
|
|
private boolean reinviteWithVideo() {
|
Core core = LinphoneManager.getCore();
|
Call call = core.getCurrentCall();
|
if (call == null) {
|
Log.e("[Call Manager] Trying to add video while not in call");
|
return false;
|
}
|
if (call.getRemoteParams().lowBandwidthEnabled()) {
|
Log.e("[Call Manager] Remote has low bandwidth, won't be able to do video");
|
return false;
|
}
|
|
CallParams params = core.createCallParams(call);
|
if (params.videoEnabled()) return false;
|
|
// Check if video possible regarding bandwidth limitations
|
mBandwidthManager.updateWithProfileSettings(params);
|
|
// Abort if not enough bandwidth...
|
if (!params.videoEnabled()) {
|
return false;
|
}
|
|
// Not yet in video call: try to re-invite with video
|
call.update(params);
|
return true;
|
}
|
|
private void enableCamera(Call call, boolean enable) {
|
if (call != null) {
|
call.enableCamera(enable);
|
if (mContext.getResources().getBoolean(R.bool.enable_call_notification))
|
LinphoneContext.instance()
|
.getNotificationManager()
|
.displayCallNotification(LinphoneManager.getCore().getCurrentCall());
|
}
|
}
|
}
|
