7f3d41fd12
+ Add a hidden "UNKNOWN" default type to ToneGenerator. - Hide the Telephony DisconnectCause from the public API. + Add a Telecomm DisconnectCause. This is parcelable, and contains information (code, user facing message, non-user facing reason, and tone) to help describe the disconnect state and what behaviors an application can implement for the user experience. This reduces the causes for a disconnect to a more generic set. + Lots of work to pipe this through. DisconnectCause replaces the code and message which were formerly passed around. Bug: 17241433 Bug: 17329632 Change-Id: I9d337e478a8784bcc0ade02267c2df52cac9bf17
899 lines
30 KiB
Java
899 lines
30 KiB
Java
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.telecom;
|
|
|
|
import com.android.internal.telecom.IConnectionService;
|
|
import com.android.internal.telecom.IVideoCallback;
|
|
import com.android.internal.telecom.IVideoProvider;
|
|
|
|
import android.net.Uri;
|
|
import android.os.IBinder;
|
|
import android.os.RemoteException;
|
|
import android.view.Surface;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
/**
|
|
* A connection provided to a {@link ConnectionService} by another {@code ConnectionService}
|
|
* running in a different process.
|
|
*
|
|
* @see ConnectionService#createRemoteOutgoingConnection(PhoneAccountHandle, ConnectionRequest)
|
|
* @see ConnectionService#createRemoteIncomingConnection(PhoneAccountHandle, ConnectionRequest)
|
|
*/
|
|
public final class RemoteConnection {
|
|
|
|
public static abstract class Callback {
|
|
/**
|
|
* Invoked when the state of this {@code RemoteConnection} has changed. See
|
|
* {@link #getState()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param state The new state of the {@code RemoteConnection}.
|
|
*/
|
|
public void onStateChanged(RemoteConnection connection, int state) {}
|
|
|
|
/**
|
|
* Invoked when this {@code RemoteConnection} is disconnected.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param disconnectCause The ({@see DisconnectCause}) associated with this failed
|
|
* connection.
|
|
*/
|
|
public void onDisconnected(
|
|
RemoteConnection connection,
|
|
DisconnectCause disconnectCause) {}
|
|
|
|
/**
|
|
* Invoked when this {@code RemoteConnection} is requesting ringback. See
|
|
* {@link #isRingbackRequested()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param ringback Whether the {@code RemoteConnection} is requesting ringback.
|
|
*/
|
|
public void onRingbackRequested(RemoteConnection connection, boolean ringback) {}
|
|
|
|
/**
|
|
* Indicates that the call capabilities of this {@code RemoteConnection} have changed.
|
|
* See {@link #getCallCapabilities()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param callCapabilities The new call capabilities of the {@code RemoteConnection}.
|
|
*/
|
|
public void onCallCapabilitiesChanged(RemoteConnection connection, int callCapabilities) {}
|
|
|
|
/**
|
|
* Invoked when the post-dial sequence in the outgoing {@code Connection} has reached a
|
|
* pause character. This causes the post-dial signals to stop pending user confirmation. An
|
|
* implementation should present this choice to the user and invoke
|
|
* {@link RemoteConnection#postDialContinue(boolean)} when the user makes the choice.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param remainingPostDialSequence The post-dial characters that remain to be sent.
|
|
*/
|
|
public void onPostDialWait(RemoteConnection connection, String remainingPostDialSequence) {}
|
|
|
|
/**
|
|
* Indicates that the VOIP audio status of this {@code RemoteConnection} has changed.
|
|
* See {@link #isVoipAudioMode()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param isVoip Whether the new audio state of the {@code RemoteConnection} is VOIP.
|
|
*/
|
|
public void onVoipAudioChanged(RemoteConnection connection, boolean isVoip) {}
|
|
|
|
/**
|
|
* Indicates that the status hints of this {@code RemoteConnection} have changed. See
|
|
* {@link #getStatusHints()} ()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param statusHints The new status hints of the {@code RemoteConnection}.
|
|
*/
|
|
public void onStatusHintsChanged(RemoteConnection connection, StatusHints statusHints) {}
|
|
|
|
/**
|
|
* Indicates that the address (e.g., phone number) of this {@code RemoteConnection} has
|
|
* changed. See {@link #getAddress()} and {@link #getAddressPresentation()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param address The new address of the {@code RemoteConnection}.
|
|
* @param presentation The presentation requirements for the address.
|
|
* See {@link TelecomManager} for valid values.
|
|
*/
|
|
public void onAddressChanged(RemoteConnection connection, Uri address, int presentation) {}
|
|
|
|
/**
|
|
* Indicates that the caller display name of this {@code RemoteConnection} has changed.
|
|
* See {@link #getCallerDisplayName()} and {@link #getCallerDisplayNamePresentation()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param callerDisplayName The new caller display name of the {@code RemoteConnection}.
|
|
* @param presentation The presentation requirements for the handle.
|
|
* See {@link TelecomManager} for valid values.
|
|
*/
|
|
public void onCallerDisplayNameChanged(
|
|
RemoteConnection connection, String callerDisplayName, int presentation) {}
|
|
|
|
/**
|
|
* Indicates that the video state of this {@code RemoteConnection} has changed.
|
|
* See {@link #getVideoState()}.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param videoState The new video state of the {@code RemoteConnection}.
|
|
* @hide
|
|
*/
|
|
public void onVideoStateChanged(RemoteConnection connection, int videoState) {}
|
|
|
|
/**
|
|
* Indicates that this {@code RemoteConnection} has been destroyed. No further requests
|
|
* should be made to the {@code RemoteConnection}, and references to it should be cleared.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
*/
|
|
public void onDestroyed(RemoteConnection connection) {}
|
|
|
|
/**
|
|
* Indicates that the {@code RemoteConnection}s with which this {@code RemoteConnection}
|
|
* may be asked to create a conference has changed.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param conferenceableConnections The {@code RemoteConnection}s with which this
|
|
* {@code RemoteConnection} may be asked to create a conference.
|
|
*/
|
|
public void onConferenceableConnectionsChanged(
|
|
RemoteConnection connection,
|
|
List<RemoteConnection> conferenceableConnections) {}
|
|
|
|
/**
|
|
* Indicates that the {@code VideoProvider} associated with this {@code RemoteConnection}
|
|
* has changed.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param videoProvider The new {@code VideoProvider} associated with this
|
|
* {@code RemoteConnection}.
|
|
* @hide
|
|
*/
|
|
public void onVideoProviderChanged(
|
|
RemoteConnection connection, VideoProvider videoProvider) {}
|
|
|
|
/**
|
|
* Indicates that the {@code RemoteConference} that this {@code RemoteConnection} is a part
|
|
* of has changed.
|
|
*
|
|
* @param connection The {@code RemoteConnection} invoking this method.
|
|
* @param conference The {@code RemoteConference} of which this {@code RemoteConnection} is
|
|
* a part, which may be {@code null}.
|
|
*/
|
|
public void onConferenceChanged(
|
|
RemoteConnection connection,
|
|
RemoteConference conference) {}
|
|
}
|
|
|
|
/** {@hide} */
|
|
public static class VideoProvider {
|
|
|
|
public abstract static class Listener {
|
|
public void onReceiveSessionModifyRequest(
|
|
VideoProvider videoProvider,
|
|
VideoProfile videoProfile) {}
|
|
|
|
public void onReceiveSessionModifyResponse(
|
|
VideoProvider videoProvider,
|
|
int status,
|
|
VideoProfile requestedProfile,
|
|
VideoProfile responseProfile) {}
|
|
|
|
public void onHandleCallSessionEvent(VideoProvider videoProvider, int event) {}
|
|
|
|
public void onPeerDimensionsChanged(VideoProvider videoProvider, int width, int height) {}
|
|
|
|
public void onCallDataUsageChanged(VideoProvider videoProvider, int dataUsage) {}
|
|
|
|
public void onCameraCapabilitiesChanged(
|
|
VideoProvider videoProvider,
|
|
CameraCapabilities cameraCapabilities) {}
|
|
}
|
|
|
|
private final IVideoCallback mVideoCallbackDelegate = new IVideoCallback() {
|
|
@Override
|
|
public void receiveSessionModifyRequest(VideoProfile videoProfile) {
|
|
for (Listener l : mListeners) {
|
|
l.onReceiveSessionModifyRequest(VideoProvider.this, videoProfile);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void receiveSessionModifyResponse(int status, VideoProfile requestedProfile,
|
|
VideoProfile responseProfile) {
|
|
for (Listener l : mListeners) {
|
|
l.onReceiveSessionModifyResponse(
|
|
VideoProvider.this,
|
|
status,
|
|
requestedProfile,
|
|
responseProfile);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void handleCallSessionEvent(int event) {
|
|
for (Listener l : mListeners) {
|
|
l.onHandleCallSessionEvent(VideoProvider.this, event);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void changePeerDimensions(int width, int height) {
|
|
for (Listener l : mListeners) {
|
|
l.onPeerDimensionsChanged(VideoProvider.this, width, height);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void changeCallDataUsage(int dataUsage) {
|
|
for (Listener l : mListeners) {
|
|
l.onCallDataUsageChanged(VideoProvider.this, dataUsage);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void changeCameraCapabilities(CameraCapabilities cameraCapabilities) {
|
|
for (Listener l : mListeners) {
|
|
l.onCameraCapabilitiesChanged(VideoProvider.this, cameraCapabilities);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public IBinder asBinder() {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
private final VideoCallbackServant mVideoCallbackServant =
|
|
new VideoCallbackServant(mVideoCallbackDelegate);
|
|
|
|
private final IVideoProvider mVideoProviderBinder;
|
|
|
|
/**
|
|
* ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is
|
|
* load factor before resizing, 1 means we only expect a single thread to
|
|
* access the map so make only a single shard
|
|
*/
|
|
private final Set<Listener> mListeners = Collections.newSetFromMap(
|
|
new ConcurrentHashMap<Listener, Boolean>(8, 0.9f, 1));
|
|
|
|
public VideoProvider(IVideoProvider videoProviderBinder) {
|
|
mVideoProviderBinder = videoProviderBinder;
|
|
try {
|
|
mVideoProviderBinder.setVideoCallback(mVideoCallbackServant.getStub().asBinder());
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void addListener(Listener l) {
|
|
mListeners.add(l);
|
|
}
|
|
|
|
public void removeListener(Listener l) {
|
|
mListeners.remove(l);
|
|
}
|
|
|
|
public void setCamera(String cameraId) {
|
|
try {
|
|
mVideoProviderBinder.setCamera(cameraId);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void setPreviewSurface(Surface surface) {
|
|
try {
|
|
mVideoProviderBinder.setPreviewSurface(surface);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void setDisplaySurface(Surface surface) {
|
|
try {
|
|
mVideoProviderBinder.setDisplaySurface(surface);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void setDeviceOrientation(int rotation) {
|
|
try {
|
|
mVideoProviderBinder.setDeviceOrientation(rotation);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void setZoom(float value) {
|
|
try {
|
|
mVideoProviderBinder.setZoom(value);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void sendSessionModifyRequest(VideoProfile reqProfile) {
|
|
try {
|
|
mVideoProviderBinder.sendSessionModifyRequest(reqProfile);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void sendSessionModifyResponse(VideoProfile responseProfile) {
|
|
try {
|
|
mVideoProviderBinder.sendSessionModifyResponse(responseProfile);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void requestCameraCapabilities() {
|
|
try {
|
|
mVideoProviderBinder.requestCameraCapabilities();
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void requestCallDataUsage() {
|
|
try {
|
|
mVideoProviderBinder.requestCallDataUsage();
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
|
|
public void setPauseImage(String uri) {
|
|
try {
|
|
mVideoProviderBinder.setPauseImage(uri);
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
}
|
|
|
|
private IConnectionService mConnectionService;
|
|
private final String mConnectionId;
|
|
/**
|
|
* ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is
|
|
* load factor before resizing, 1 means we only expect a single thread to
|
|
* access the map so make only a single shard
|
|
*/
|
|
private final Set<Callback> mCallbacks = Collections.newSetFromMap(
|
|
new ConcurrentHashMap<Callback, Boolean>(8, 0.9f, 1));
|
|
private final List<RemoteConnection> mConferenceableConnections = new ArrayList<>();
|
|
private final List<RemoteConnection> mUnmodifiableconferenceableConnections =
|
|
Collections.unmodifiableList(mConferenceableConnections);
|
|
|
|
private int mState = Connection.STATE_NEW;
|
|
private DisconnectCause mDisconnectCause;
|
|
private boolean mRingbackRequested;
|
|
private boolean mConnected;
|
|
private int mCallCapabilities;
|
|
private int mVideoState;
|
|
private VideoProvider mVideoProvider;
|
|
private boolean mIsVoipAudioMode;
|
|
private StatusHints mStatusHints;
|
|
private Uri mAddress;
|
|
private int mAddressPresentation;
|
|
private String mCallerDisplayName;
|
|
private int mCallerDisplayNamePresentation;
|
|
private RemoteConference mConference;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
RemoteConnection(
|
|
String id,
|
|
IConnectionService connectionService,
|
|
ConnectionRequest request) {
|
|
mConnectionId = id;
|
|
mConnectionService = connectionService;
|
|
mConnected = true;
|
|
mState = Connection.STATE_INITIALIZING;
|
|
}
|
|
|
|
/**
|
|
* Create a RemoteConnection which is used for failed connections. Note that using it for any
|
|
* "real" purpose will almost certainly fail. Callers should note the failure and act
|
|
* accordingly (moving on to another RemoteConnection, for example)
|
|
*
|
|
* @param disconnectCause The reason for the failed connection.
|
|
* @hide
|
|
*/
|
|
RemoteConnection(DisconnectCause disconnectCause) {
|
|
this("NULL", null, null);
|
|
mConnected = false;
|
|
mState = Connection.STATE_DISCONNECTED;
|
|
mDisconnectCause = disconnectCause;
|
|
}
|
|
|
|
/**
|
|
* Adds a callback to this {@code RemoteConnection}.
|
|
*
|
|
* @param callback A {@code Callback}.
|
|
*/
|
|
public void registerCallback(Callback callback) {
|
|
mCallbacks.add(callback);
|
|
}
|
|
|
|
/**
|
|
* Removes a callback from this {@code RemoteConnection}.
|
|
*
|
|
* @param callback A {@code Callback}.
|
|
*/
|
|
public void unregisterCallback(Callback callback) {
|
|
if (callback != null) {
|
|
mCallbacks.remove(callback);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtains the state of this {@code RemoteConnection}.
|
|
*
|
|
* @return A state value, chosen from the {@code STATE_*} constants.
|
|
*/
|
|
public int getState() {
|
|
return mState;
|
|
}
|
|
|
|
/**
|
|
* @return For a {@link Connection#STATE_DISCONNECTED} {@code RemoteConnection}, the
|
|
* disconnect cause expressed as a code chosen from among those declared in
|
|
* {@link DisconnectCause}.
|
|
*/
|
|
public DisconnectCause getDisconnectCause() {
|
|
return mDisconnectCause;
|
|
}
|
|
|
|
/**
|
|
* @return A bitmask of the capabilities of the {@code RemoteConnection}, as defined in
|
|
* {@link PhoneCapabilities}.
|
|
*/
|
|
public int getCallCapabilities() {
|
|
return mCallCapabilities;
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if the {@code RemoteConnection}'s current audio mode is VOIP.
|
|
*/
|
|
public boolean isVoipAudioMode() {
|
|
return mIsVoipAudioMode;
|
|
}
|
|
|
|
/**
|
|
* @return The current {@link StatusHints} of this {@code RemoteConnection},
|
|
* or {@code null} if none have been set.
|
|
*/
|
|
public StatusHints getStatusHints() {
|
|
return mStatusHints;
|
|
}
|
|
|
|
/**
|
|
* @return The address (e.g., phone number) to which the {@code RemoteConnection} is currently
|
|
* connected.
|
|
*/
|
|
public Uri getAddress() {
|
|
return mAddress;
|
|
}
|
|
|
|
/**
|
|
* @return The presentation requirements for the address. See {@link TelecomManager} for valid
|
|
* values.
|
|
*/
|
|
public int getAddressPresentation() {
|
|
return mAddressPresentation;
|
|
}
|
|
|
|
/**
|
|
* @return The display name for the caller.
|
|
*/
|
|
public CharSequence getCallerDisplayName() {
|
|
return mCallerDisplayName;
|
|
}
|
|
|
|
/**
|
|
* @return The presentation requirements for the caller display name. See
|
|
* {@link TelecomManager} for valid values.
|
|
*/
|
|
public int getCallerDisplayNamePresentation() {
|
|
return mCallerDisplayNamePresentation;
|
|
}
|
|
|
|
/**
|
|
* @return The video state of the {@code RemoteConnection}. See
|
|
* {@link VideoProfile.VideoState}.
|
|
* @hide
|
|
*/
|
|
public int getVideoState() {
|
|
return mVideoState;
|
|
}
|
|
|
|
/**
|
|
* @return The video provider associated with this {@code RemoteConnection}.
|
|
* @hide
|
|
*/
|
|
public final VideoProvider getVideoProvider() {
|
|
return mVideoProvider;
|
|
}
|
|
|
|
/**
|
|
* @return Whether the {@code RemoteConnection} is requesting that the framework play a
|
|
* ringback tone on its behalf.
|
|
*/
|
|
public boolean isRingbackRequested() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to abort.
|
|
*/
|
|
public void abort() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.abort(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link Connection#STATE_RINGING} {@code RemoteConnection} to answer.
|
|
*/
|
|
public void answer() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.answer(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link Connection#STATE_RINGING} {@code RemoteConnection} to answer.
|
|
* @param videoState The video state in which to answer the call.
|
|
* @hide
|
|
*/
|
|
public void answer(int videoState) {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.answerVideo(mConnectionId, videoState);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link Connection#STATE_RINGING} {@code RemoteConnection} to reject.
|
|
*/
|
|
public void reject() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.reject(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to go on hold.
|
|
*/
|
|
public void hold() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.hold(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@link Connection#STATE_HOLDING} call to release from hold.
|
|
*/
|
|
public void unhold() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.unhold(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to disconnect.
|
|
*/
|
|
public void disconnect() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.disconnect(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to play a dual-tone multi-frequency signaling
|
|
* (DTMF) tone.
|
|
*
|
|
* Any other currently playing DTMF tone in the specified call is immediately stopped.
|
|
*
|
|
* @param digit A character representing the DTMF digit for which to play the tone. This
|
|
* value must be one of {@code '0'} through {@code '9'}, {@code '*'} or {@code '#'}.
|
|
*/
|
|
public void playDtmfTone(char digit) {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.playDtmfTone(mConnectionId, digit);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to stop any dual-tone multi-frequency signaling
|
|
* (DTMF) tone currently playing.
|
|
*
|
|
* DTMF tones are played by calling {@link #playDtmfTone(char)}. If no DTMF tone is
|
|
* currently playing, this method will do nothing.
|
|
*/
|
|
public void stopDtmfTone() {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.stopDtmfTone(mConnectionId);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Instructs this {@code RemoteConnection} to continue playing a post-dial DTMF string.
|
|
*
|
|
* A post-dial DTMF string is a string of digits following the first instance of either
|
|
* {@link TelecomManager#DTMF_CHARACTER_WAIT} or {@link TelecomManager#DTMF_CHARACTER_PAUSE}.
|
|
* These digits are immediately sent as DTMF tones to the recipient as soon as the
|
|
* connection is made.
|
|
*
|
|
* If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_PAUSE} symbol, this
|
|
* {@code RemoteConnection} will temporarily pause playing the tones for a pre-defined period
|
|
* of time.
|
|
*
|
|
* If the DTMF string contains a {@link TelecomManager#DTMF_CHARACTER_WAIT} symbol, this
|
|
* {@code RemoteConnection} will pause playing the tones and notify callbackss via
|
|
* {@link Callback#onPostDialWait(RemoteConnection, String)}. At this point, the in-call app
|
|
* should display to the user an indication of this state and an affordance to continue
|
|
* the postdial sequence. When the user decides to continue the postdial sequence, the in-call
|
|
* app should invoke the {@link #postDialContinue(boolean)} method.
|
|
*
|
|
* @param proceed Whether or not to continue with the post-dial sequence.
|
|
*/
|
|
public void postDialContinue(boolean proceed) {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.onPostDialContinue(mConnectionId, proceed);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the audio state of this {@code RemoteConnection}.
|
|
*
|
|
* @param state The audio state of this {@code RemoteConnection}.
|
|
*/
|
|
public void setAudioState(AudioState state) {
|
|
try {
|
|
if (mConnected) {
|
|
mConnectionService.onAudioStateChanged(mConnectionId, state);
|
|
}
|
|
} catch (RemoteException ignored) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtain the {@code RemoteConnection}s with which this {@code RemoteConnection} may be
|
|
* successfully asked to create a conference with.
|
|
*
|
|
* @return The {@code RemoteConnection}s with which this {@code RemoteConnection} may be
|
|
* merged into a {@link RemoteConference}.
|
|
*/
|
|
public List<RemoteConnection> getConferenceableConnections() {
|
|
return mUnmodifiableconferenceableConnections;
|
|
}
|
|
|
|
/**
|
|
* Obtain the {@code RemoteConference} that this {@code RemoteConnection} may be a part
|
|
* of, or {@code null} if there is no such {@code RemoteConference}.
|
|
*
|
|
* @return A {@code RemoteConference} or {@code null};
|
|
*/
|
|
public RemoteConference getConference() {
|
|
return mConference;
|
|
}
|
|
|
|
/** {@hide} */
|
|
String getId() {
|
|
return mConnectionId;
|
|
}
|
|
|
|
/** {@hide} */
|
|
IConnectionService getConnectionService() {
|
|
return mConnectionService;
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setState(int state) {
|
|
if (mState != state) {
|
|
mState = state;
|
|
for (Callback c: mCallbacks) {
|
|
c.onStateChanged(this, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setDisconnected(DisconnectCause disconnectCause) {
|
|
if (mState != Connection.STATE_DISCONNECTED) {
|
|
mState = Connection.STATE_DISCONNECTED;
|
|
mDisconnectCause = disconnectCause;
|
|
|
|
for (Callback c : mCallbacks) {
|
|
c.onDisconnected(this, mDisconnectCause);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setRingbackRequested(boolean ringback) {
|
|
if (mRingbackRequested != ringback) {
|
|
mRingbackRequested = ringback;
|
|
for (Callback c : mCallbacks) {
|
|
c.onRingbackRequested(this, ringback);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setCallCapabilities(int callCapabilities) {
|
|
mCallCapabilities = callCapabilities;
|
|
for (Callback c : mCallbacks) {
|
|
c.onCallCapabilitiesChanged(this, callCapabilities);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setDestroyed() {
|
|
if (!mCallbacks.isEmpty()) {
|
|
// Make sure that the callbacks are notified that the call is destroyed first.
|
|
if (mState != Connection.STATE_DISCONNECTED) {
|
|
setDisconnected(
|
|
new DisconnectCause(DisconnectCause.ERROR, "Connection destroyed."));
|
|
}
|
|
|
|
for (Callback c : mCallbacks) {
|
|
c.onDestroyed(this);
|
|
}
|
|
mCallbacks.clear();
|
|
|
|
mConnected = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setPostDialWait(String remainingDigits) {
|
|
for (Callback c : mCallbacks) {
|
|
c.onPostDialWait(this, remainingDigits);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setVideoState(int videoState) {
|
|
mVideoState = videoState;
|
|
for (Callback c : mCallbacks) {
|
|
c.onVideoStateChanged(this, videoState);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
void setVideoProvider(VideoProvider videoProvider) {
|
|
mVideoProvider = videoProvider;
|
|
for (Callback c : mCallbacks) {
|
|
c.onVideoProviderChanged(this, videoProvider);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setIsVoipAudioMode(boolean isVoip) {
|
|
mIsVoipAudioMode = isVoip;
|
|
for (Callback c : mCallbacks) {
|
|
c.onVoipAudioChanged(this, isVoip);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setStatusHints(StatusHints statusHints) {
|
|
mStatusHints = statusHints;
|
|
for (Callback c : mCallbacks) {
|
|
c.onStatusHintsChanged(this, statusHints);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setAddress(Uri address, int presentation) {
|
|
mAddress = address;
|
|
mAddressPresentation = presentation;
|
|
for (Callback c : mCallbacks) {
|
|
c.onAddressChanged(this, address, presentation);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setCallerDisplayName(String callerDisplayName, int presentation) {
|
|
mCallerDisplayName = callerDisplayName;
|
|
mCallerDisplayNamePresentation = presentation;
|
|
for (Callback c : mCallbacks) {
|
|
c.onCallerDisplayNameChanged(this, callerDisplayName, presentation);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setConferenceableConnections(List<RemoteConnection> conferenceableConnections) {
|
|
mConferenceableConnections.clear();
|
|
mConferenceableConnections.addAll(conferenceableConnections);
|
|
for (Callback c : mCallbacks) {
|
|
c.onConferenceableConnectionsChanged(this, mUnmodifiableconferenceableConnections);
|
|
}
|
|
}
|
|
|
|
/** @hide */
|
|
void setConference(RemoteConference conference) {
|
|
if (mConference != conference) {
|
|
mConference = conference;
|
|
for (Callback c : mCallbacks) {
|
|
c.onConferenceChanged(this, conference);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a RemoteConnection represents a failure, and which will be in
|
|
* {@link Connection#STATE_DISCONNECTED}. Attempting to use it for anything will almost
|
|
* certainly result in bad things happening. Do not do this.
|
|
*
|
|
* @return a failed {@link RemoteConnection}
|
|
*
|
|
* @hide
|
|
*/
|
|
public static RemoteConnection failure(DisconnectCause disconnectCause) {
|
|
return new RemoteConnection(disconnectCause);
|
|
}
|
|
}
|