| /* |
| * 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 android.annotation.SystemApi; |
| import android.net.Uri; |
| import android.os.Bundle; |
| |
| import java.lang.String; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.concurrent.CopyOnWriteArrayList; |
| |
| /** |
| * Represents an ongoing phone call that the in-call app should present to the user. |
| * |
| * {@hide} |
| */ |
| @SystemApi |
| public final class Call { |
| /** |
| * The state of a {@code Call} when newly created. |
| */ |
| public static final int STATE_NEW = 0; |
| |
| /** |
| * The state of an outgoing {@code Call} when dialing the remote number, but not yet connected. |
| */ |
| public static final int STATE_DIALING = 1; |
| |
| /** |
| * The state of an incoming {@code Call} when ringing locally, but not yet connected. |
| */ |
| public static final int STATE_RINGING = 2; |
| |
| /** |
| * The state of a {@code Call} when in a holding state. |
| */ |
| public static final int STATE_HOLDING = 3; |
| |
| /** |
| * The state of a {@code Call} when actively supporting conversation. |
| */ |
| public static final int STATE_ACTIVE = 4; |
| |
| /** |
| * The state of a {@code Call} when no further voice or other communication is being |
| * transmitted, the remote side has been or will inevitably be informed that the {@code Call} |
| * is no longer active, and the local data transport has or inevitably will release resources |
| * associated with this {@code Call}. |
| */ |
| public static final int STATE_DISCONNECTED = 7; |
| |
| /** |
| * The state of an outgoing {@code Call}, but waiting for user input before proceeding. |
| */ |
| public static final int STATE_PRE_DIAL_WAIT = 8; |
| |
| /** |
| * The initial state of an outgoing {@code Call}. |
| * Common transitions are to {@link #STATE_DIALING} state for a successful call or |
| * {@link #STATE_DISCONNECTED} if it failed. |
| */ |
| public static final int STATE_CONNECTING = 9; |
| |
| /** |
| * The state of a {@code Call} when the user has initiated a disconnection of the call, but the |
| * call has not yet been disconnected by the underlying {@code ConnectionService}. The next |
| * state of the call is (potentially) {@link #STATE_DISCONNECTED}. |
| */ |
| public static final int STATE_DISCONNECTING = 10; |
| |
| /** |
| * The key to retrieve the optional {@code PhoneAccount}s Telecom can bundle with its Call |
| * extras. Used to pass the phone accounts to display on the front end to the user in order to |
| * select phone accounts to (for example) place a call. |
| * |
| * @hide |
| */ |
| public static final String AVAILABLE_PHONE_ACCOUNTS = "selectPhoneAccountAccounts"; |
| |
| public static class Details { |
| private final Uri mHandle; |
| private final int mHandlePresentation; |
| private final String mCallerDisplayName; |
| private final int mCallerDisplayNamePresentation; |
| private final PhoneAccountHandle mAccountHandle; |
| private final int mCallCapabilities; |
| private final int mCallProperties; |
| private final DisconnectCause mDisconnectCause; |
| private final long mConnectTimeMillis; |
| private final GatewayInfo mGatewayInfo; |
| private final int mVideoState; |
| private final StatusHints mStatusHints; |
| private final Bundle mExtras; |
| |
| /** |
| * @return The handle (e.g., phone number) to which the {@code Call} is currently |
| * connected. |
| */ |
| public Uri getHandle() { |
| return mHandle; |
| } |
| |
| /** |
| * @return The presentation requirements for the handle. See |
| * {@link TelecomManager} for valid values. |
| */ |
| public int getHandlePresentation() { |
| return mHandlePresentation; |
| } |
| |
| /** |
| * @return The display name for the caller. |
| */ |
| public String 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 {@code PhoneAccountHandle} whereby the {@code Call} is currently being |
| * routed. |
| */ |
| public PhoneAccountHandle getAccountHandle() { |
| return mAccountHandle; |
| } |
| |
| /** |
| * @return A bitmask of the capabilities of the {@code Call}, as defined in |
| * {@link PhoneCapabilities}. |
| */ |
| public int getCallCapabilities() { |
| return mCallCapabilities; |
| } |
| |
| /** |
| * @return A bitmask of the properties of the {@code Call}, as defined in |
| * {@link CallProperties}. |
| */ |
| public int getCallProperties() { |
| return mCallProperties; |
| } |
| |
| /** |
| * @return For a {@link #STATE_DISCONNECTED} {@code Call}, the disconnect cause expressed |
| * by {@link android.telecom.DisconnectCause}. |
| */ |
| public DisconnectCause getDisconnectCause() { |
| return mDisconnectCause; |
| } |
| |
| /** |
| * @return The time the {@code Call} has been connected. This information is updated |
| * periodically, but user interfaces should not rely on this to display any "call time |
| * clock". |
| */ |
| public long getConnectTimeMillis() { |
| return mConnectTimeMillis; |
| } |
| |
| /** |
| * @return Information about any calling gateway the {@code Call} may be using. |
| */ |
| public GatewayInfo getGatewayInfo() { |
| return mGatewayInfo; |
| } |
| |
| /** |
| * @return The video state of the {@code Call}. |
| */ |
| public int getVideoState() { |
| return mVideoState; |
| } |
| |
| /** |
| * @return The current {@link android.telecom.StatusHints}, or {@code null} if none |
| * have been set. |
| */ |
| public StatusHints getStatusHints() { |
| return mStatusHints; |
| } |
| |
| /** |
| * @return A bundle extras to pass with the call |
| */ |
| public Bundle getExtras() { |
| return mExtras; |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o instanceof Details) { |
| Details d = (Details) o; |
| return |
| Objects.equals(mHandle, d.mHandle) && |
| Objects.equals(mHandlePresentation, d.mHandlePresentation) && |
| Objects.equals(mCallerDisplayName, d.mCallerDisplayName) && |
| Objects.equals(mCallerDisplayNamePresentation, |
| d.mCallerDisplayNamePresentation) && |
| Objects.equals(mAccountHandle, d.mAccountHandle) && |
| Objects.equals(mCallCapabilities, d.mCallCapabilities) && |
| Objects.equals(mCallProperties, d.mCallProperties) && |
| Objects.equals(mDisconnectCause, d.mDisconnectCause) && |
| Objects.equals(mConnectTimeMillis, d.mConnectTimeMillis) && |
| Objects.equals(mGatewayInfo, d.mGatewayInfo) && |
| Objects.equals(mVideoState, d.mVideoState) && |
| Objects.equals(mStatusHints, d.mStatusHints) && |
| Objects.equals(mExtras, d.mExtras); |
| } |
| return false; |
| } |
| |
| @Override |
| public int hashCode() { |
| return |
| Objects.hashCode(mHandle) + |
| Objects.hashCode(mHandlePresentation) + |
| Objects.hashCode(mCallerDisplayName) + |
| Objects.hashCode(mCallerDisplayNamePresentation) + |
| Objects.hashCode(mAccountHandle) + |
| Objects.hashCode(mCallCapabilities) + |
| Objects.hashCode(mCallProperties) + |
| Objects.hashCode(mDisconnectCause) + |
| Objects.hashCode(mConnectTimeMillis) + |
| Objects.hashCode(mGatewayInfo) + |
| Objects.hashCode(mVideoState) + |
| Objects.hashCode(mStatusHints) + |
| Objects.hashCode(mExtras); |
| } |
| |
| /** {@hide} */ |
| public Details( |
| Uri handle, |
| int handlePresentation, |
| String callerDisplayName, |
| int callerDisplayNamePresentation, |
| PhoneAccountHandle accountHandle, |
| int capabilities, |
| int properties, |
| DisconnectCause disconnectCause, |
| long connectTimeMillis, |
| GatewayInfo gatewayInfo, |
| int videoState, |
| StatusHints statusHints, |
| Bundle extras) { |
| mHandle = handle; |
| mHandlePresentation = handlePresentation; |
| mCallerDisplayName = callerDisplayName; |
| mCallerDisplayNamePresentation = callerDisplayNamePresentation; |
| mAccountHandle = accountHandle; |
| mCallCapabilities = capabilities; |
| mCallProperties = properties; |
| mDisconnectCause = disconnectCause; |
| mConnectTimeMillis = connectTimeMillis; |
| mGatewayInfo = gatewayInfo; |
| mVideoState = videoState; |
| mStatusHints = statusHints; |
| mExtras = extras; |
| } |
| } |
| |
| public static abstract class Listener { |
| /** |
| * Invoked when the state of this {@code Call} has changed. See {@link #getState()}. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param state The new state of the {@code Call}. |
| */ |
| public void onStateChanged(Call call, int state) {} |
| |
| /** |
| * Invoked when the parent of this {@code Call} has changed. See {@link #getParent()}. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param parent The new parent of the {@code Call}. |
| */ |
| public void onParentChanged(Call call, Call parent) {} |
| |
| /** |
| * Invoked when the children of this {@code Call} have changed. See {@link #getChildren()}. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param children The new children of the {@code Call}. |
| */ |
| public void onChildrenChanged(Call call, List<Call> children) {} |
| |
| /** |
| * Invoked when the details of this {@code Call} have changed. See {@link #getDetails()}. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param details A {@code Details} object describing the {@code Call}. |
| */ |
| public void onDetailsChanged(Call call, Details details) {} |
| |
| /** |
| * Invoked when the text messages that can be used as responses to the incoming |
| * {@code Call} are loaded from the relevant database. |
| * See {@link #getCannedTextResponses()}. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param cannedTextResponses The text messages useable as responses. |
| */ |
| public void onCannedTextResponsesLoaded(Call call, List<String> cannedTextResponses) {} |
| |
| /** |
| * Invoked when the post-dial sequence in the outgoing {@code Call} 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 #postDialContinue(boolean)} when the user makes the choice. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param remainingPostDialSequence The post-dial characters that remain to be sent. |
| */ |
| public void onPostDialWait(Call call, String remainingPostDialSequence) {} |
| |
| /** |
| * Invoked when the {@code Call.VideoCall} of the {@code Call} has changed. |
| * |
| * @param call The {@code Call} invoking this method. |
| * @param videoCall The {@code Call.VideoCall} associated with the {@code Call}. |
| * @hide |
| */ |
| public void onVideoCallChanged(Call call, InCallService.VideoCall videoCall) {} |
| |
| /** |
| * Invoked when the {@code Call} is destroyed. Clients should refrain from cleaning |
| * up their UI for the {@code Call} in response to state transitions. Specifically, |
| * clients should not assume that a {@link #onStateChanged(Call, int)} with a state of |
| * {@link #STATE_DISCONNECTED} is the final notification the {@code Call} will send. Rather, |
| * clients should wait for this method to be invoked. |
| * |
| * @param call The {@code Call} being destroyed. |
| */ |
| public void onCallDestroyed(Call call) {} |
| |
| /** |
| * Invoked upon changes to the set of {@code Call}s with which this {@code Call} can be |
| * conferenced. |
| * |
| * @param call The {@code Call} being updated. |
| * @param conferenceableCalls The {@code Call}s with which this {@code Call} can be |
| * conferenced. |
| */ |
| public void onConferenceableCallsChanged(Call call, List<Call> conferenceableCalls) {} |
| } |
| |
| private final Phone mPhone; |
| private final String mTelecomCallId; |
| private final InCallAdapter mInCallAdapter; |
| private final List<String> mChildrenIds = new ArrayList<>(); |
| private final List<Call> mChildren = new ArrayList<>(); |
| private final List<Call> mUnmodifiableChildren = Collections.unmodifiableList(mChildren); |
| private final List<Listener> mListeners = new CopyOnWriteArrayList<>(); |
| private final List<Call> mConferenceableCalls = new ArrayList<>(); |
| private final List<Call> mUnmodifiableConferenceableCalls = |
| Collections.unmodifiableList(mConferenceableCalls); |
| |
| private boolean mChildrenCached; |
| private String mParentId = null; |
| private int mState; |
| private List<String> mCannedTextResponses = null; |
| private String mRemainingPostDialSequence; |
| private InCallService.VideoCall mVideoCall; |
| private Details mDetails; |
| |
| /** |
| * Obtains the post-dial sequence remaining to be emitted by this {@code Call}, if any. |
| * |
| * @return The remaining post-dial sequence, or {@code null} if there is no post-dial sequence |
| * remaining or this {@code Call} is not in a post-dial state. |
| */ |
| public String getRemainingPostDialSequence() { |
| return mRemainingPostDialSequence; |
| } |
| |
| /** |
| * Instructs this {@link #STATE_RINGING} {@code Call} to answer. |
| * @param videoState The video state in which to answer the call. |
| */ |
| public void answer(int videoState) { |
| mInCallAdapter.answerCall(mTelecomCallId, videoState); |
| } |
| |
| /** |
| * Instructs this {@link #STATE_RINGING} {@code Call} to reject. |
| * |
| * @param rejectWithMessage Whether to reject with a text message. |
| * @param textMessage An optional text message with which to respond. |
| */ |
| public void reject(boolean rejectWithMessage, String textMessage) { |
| mInCallAdapter.rejectCall(mTelecomCallId, rejectWithMessage, textMessage); |
| } |
| |
| /** |
| * Instructs this {@code Call} to disconnect. |
| */ |
| public void disconnect() { |
| mInCallAdapter.disconnectCall(mTelecomCallId); |
| } |
| |
| /** |
| * Instructs this {@code Call} to go on hold. |
| */ |
| public void hold() { |
| mInCallAdapter.holdCall(mTelecomCallId); |
| } |
| |
| /** |
| * Instructs this {@link #STATE_HOLDING} call to release from hold. |
| */ |
| public void unhold() { |
| mInCallAdapter.unholdCall(mTelecomCallId); |
| } |
| |
| /** |
| * Instructs this {@code Call} 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) { |
| mInCallAdapter.playDtmfTone(mTelecomCallId, digit); |
| } |
| |
| /** |
| * Instructs this {@code Call} 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() { |
| mInCallAdapter.stopDtmfTone(mTelecomCallId); |
| } |
| |
| /** |
| * Instructs this {@code Call} to continue playing a post-dial DTMF string. |
| * |
| * A post-dial DTMF string is a string of digits entered after a phone number, when dialed, |
| * that 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 Call} 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 Call} will pause playing the tones and notify listeners via |
| * {@link Listener#onPostDialWait(Call, 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) { |
| mInCallAdapter.postDialContinue(mTelecomCallId, proceed); |
| } |
| |
| /** |
| * Notifies this {@code Call} that an account has been selected and to proceed with placing |
| * an outgoing call. Optionally sets this account as the default account. |
| */ |
| public void phoneAccountSelected(PhoneAccountHandle accountHandle, boolean setDefault) { |
| mInCallAdapter.phoneAccountSelected(mTelecomCallId, accountHandle, setDefault); |
| |
| } |
| |
| /** |
| * Instructs this {@code Call} to enter a conference. |
| * |
| * @param callToConferenceWith The other call with which to conference. |
| */ |
| public void conference(Call callToConferenceWith) { |
| if (callToConferenceWith != null) { |
| mInCallAdapter.conference(mTelecomCallId, callToConferenceWith.mTelecomCallId); |
| } |
| } |
| |
| /** |
| * Instructs this {@code Call} to split from any conference call with which it may be |
| * connected. |
| */ |
| public void splitFromConference() { |
| mInCallAdapter.splitFromConference(mTelecomCallId); |
| } |
| |
| /** |
| * Merges the calls within this conference. See {@link PhoneCapabilities#MERGE_CONFERENCE}. |
| */ |
| public void mergeConference() { |
| mInCallAdapter.mergeConference(mTelecomCallId); |
| } |
| |
| /** |
| * Swaps the calls within this conference. See {@link PhoneCapabilities#SWAP_CONFERENCE}. |
| */ |
| public void swapConference() { |
| mInCallAdapter.swapConference(mTelecomCallId); |
| } |
| |
| /** |
| * Obtains the parent of this {@code Call} in a conference, if any. |
| * |
| * @return The parent {@code Call}, or {@code null} if this {@code Call} is not a |
| * child of any conference {@code Call}s. |
| */ |
| public Call getParent() { |
| if (mParentId != null) { |
| return mPhone.internalGetCallByTelecomId(mParentId); |
| } |
| return null; |
| } |
| |
| /** |
| * Obtains the children of this conference {@code Call}, if any. |
| * |
| * @return The children of this {@code Call} if this {@code Call} is a conference, or an empty |
| * {@code List} otherwise. |
| */ |
| public List<Call> getChildren() { |
| if (!mChildrenCached) { |
| mChildrenCached = true; |
| mChildren.clear(); |
| |
| for(String id : mChildrenIds) { |
| Call call = mPhone.internalGetCallByTelecomId(id); |
| if (call == null) { |
| // At least one child was still not found, so do not save true for "cached" |
| mChildrenCached = false; |
| } else { |
| mChildren.add(call); |
| } |
| } |
| } |
| |
| return mUnmodifiableChildren; |
| } |
| |
| /** |
| * Returns the list of {@code Call}s with which this {@code Call} is allowed to conference. |
| * |
| * @return The list of conferenceable {@code Call}s. |
| */ |
| public List<Call> getConferenceableCalls() { |
| return mUnmodifiableConferenceableCalls; |
| } |
| |
| /** |
| * Obtains the state of this {@code Call}. |
| * |
| * @return A state value, chosen from the {@code STATE_*} constants. |
| */ |
| public int getState() { |
| return mState; |
| } |
| |
| /** |
| * Obtains a list of canned, pre-configured message responses to present to the user as |
| * ways of rejecting this {@code Call} using via a text message. |
| * |
| * @see #reject(boolean, String) |
| * |
| * @return A list of canned text message responses. |
| */ |
| public List<String> getCannedTextResponses() { |
| return mCannedTextResponses; |
| } |
| |
| /** |
| * Obtains an object that can be used to display video from this {@code Call}. |
| * |
| * @return An {@code Call.VideoCall}. |
| * @hide |
| */ |
| public InCallService.VideoCall getVideoCall() { |
| return mVideoCall; |
| } |
| |
| /** |
| * Obtains an object containing call details. |
| * |
| * @return A {@link Details} object. Depending on the state of the {@code Call}, the |
| * result may be {@code null}. |
| */ |
| public Details getDetails() { |
| return mDetails; |
| } |
| |
| /** |
| * Adds a listener to this {@code Call}. |
| * |
| * @param listener A {@code Listener}. |
| */ |
| public void addListener(Listener listener) { |
| mListeners.add(listener); |
| } |
| |
| /** |
| * Removes a listener from this {@code Call}. |
| * |
| * @param listener A {@code Listener}. |
| */ |
| public void removeListener(Listener listener) { |
| if (listener != null) { |
| mListeners.remove(listener); |
| } |
| } |
| |
| /** {@hide} */ |
| Call(Phone phone, String telecomCallId, InCallAdapter inCallAdapter) { |
| mPhone = phone; |
| mTelecomCallId = telecomCallId; |
| mInCallAdapter = inCallAdapter; |
| mState = STATE_NEW; |
| } |
| |
| /** {@hide} */ |
| final String internalGetCallId() { |
| return mTelecomCallId; |
| } |
| |
| /** {@hide} */ |
| final void internalUpdate(ParcelableCall parcelableCall, Map<String, Call> callIdMap) { |
| // First, we update the internal state as far as possible before firing any updates. |
| Details details = new Details( |
| parcelableCall.getHandle(), |
| parcelableCall.getHandlePresentation(), |
| parcelableCall.getCallerDisplayName(), |
| parcelableCall.getCallerDisplayNamePresentation(), |
| parcelableCall.getAccountHandle(), |
| parcelableCall.getCapabilities(), |
| parcelableCall.getProperties(), |
| parcelableCall.getDisconnectCause(), |
| parcelableCall.getConnectTimeMillis(), |
| parcelableCall.getGatewayInfo(), |
| parcelableCall.getVideoState(), |
| parcelableCall.getStatusHints(), |
| parcelableCall.getExtras()); |
| boolean detailsChanged = !Objects.equals(mDetails, details); |
| if (detailsChanged) { |
| mDetails = details; |
| } |
| |
| boolean cannedTextResponsesChanged = false; |
| if (mCannedTextResponses == null && parcelableCall.getCannedSmsResponses() != null |
| && !parcelableCall.getCannedSmsResponses().isEmpty()) { |
| mCannedTextResponses = |
| Collections.unmodifiableList(parcelableCall.getCannedSmsResponses()); |
| } |
| |
| boolean videoCallChanged = !Objects.equals(mVideoCall, parcelableCall.getVideoCall()); |
| if (videoCallChanged) { |
| mVideoCall = parcelableCall.getVideoCall(); |
| } |
| |
| int state = stateFromParcelableCallState(parcelableCall.getState()); |
| boolean stateChanged = mState != state; |
| if (stateChanged) { |
| mState = state; |
| } |
| |
| String parentId = parcelableCall.getParentCallId(); |
| boolean parentChanged = !Objects.equals(mParentId, parentId); |
| if (parentChanged) { |
| mParentId = parentId; |
| } |
| |
| List<String> childCallIds = parcelableCall.getChildCallIds(); |
| boolean childrenChanged = !Objects.equals(childCallIds, mChildrenIds); |
| if (childrenChanged) { |
| mChildrenIds.clear(); |
| mChildrenIds.addAll(parcelableCall.getChildCallIds()); |
| mChildrenCached = false; |
| } |
| |
| List<String> conferenceableCallIds = parcelableCall.getConferenceableCallIds(); |
| List<Call> conferenceableCalls = new ArrayList<Call>(conferenceableCallIds.size()); |
| for (String otherId : conferenceableCallIds) { |
| if (callIdMap.containsKey(otherId)) { |
| conferenceableCalls.add(callIdMap.get(otherId)); |
| } |
| } |
| |
| if (!Objects.equals(mConferenceableCalls, conferenceableCalls)) { |
| mConferenceableCalls.clear(); |
| mConferenceableCalls.addAll(conferenceableCalls); |
| fireConferenceableCallsChanged(); |
| } |
| |
| // Now we fire updates, ensuring that any client who listens to any of these notifications |
| // gets the most up-to-date state. |
| |
| if (stateChanged) { |
| fireStateChanged(mState); |
| } |
| if (detailsChanged) { |
| fireDetailsChanged(mDetails); |
| } |
| if (cannedTextResponsesChanged) { |
| fireCannedTextResponsesLoaded(mCannedTextResponses); |
| } |
| if (videoCallChanged) { |
| fireVideoCallChanged(mVideoCall); |
| } |
| if (parentChanged) { |
| fireParentChanged(getParent()); |
| } |
| if (childrenChanged) { |
| fireChildrenChanged(getChildren()); |
| } |
| |
| // If we have transitioned to DISCONNECTED, that means we need to notify clients and |
| // remove ourselves from the Phone. Note that we do this after completing all state updates |
| // so a client can cleanly transition all their UI to the state appropriate for a |
| // DISCONNECTED Call while still relying on the existence of that Call in the Phone's list. |
| if (mState == STATE_DISCONNECTED) { |
| fireCallDestroyed(); |
| mPhone.internalRemoveCall(this); |
| } |
| } |
| |
| /** {@hide} */ |
| final void internalSetPostDialWait(String remaining) { |
| mRemainingPostDialSequence = remaining; |
| firePostDialWait(mRemainingPostDialSequence); |
| } |
| |
| /** {@hide} */ |
| final void internalSetDisconnected() { |
| if (mState != Call.STATE_DISCONNECTED) { |
| mState = Call.STATE_DISCONNECTED; |
| fireStateChanged(mState); |
| fireCallDestroyed(); |
| mPhone.internalRemoveCall(this); |
| } |
| } |
| |
| private void fireStateChanged(int newState) { |
| for (Listener listener : mListeners) { |
| listener.onStateChanged(this, newState); |
| } |
| } |
| |
| private void fireParentChanged(Call newParent) { |
| for (Listener listener : mListeners) { |
| listener.onParentChanged(this, newParent); |
| } |
| } |
| |
| private void fireChildrenChanged(List<Call> children) { |
| for (Listener listener : mListeners) { |
| listener.onChildrenChanged(this, children); |
| } |
| } |
| |
| private void fireDetailsChanged(Details details) { |
| for (Listener listener : mListeners) { |
| listener.onDetailsChanged(this, details); |
| } |
| } |
| |
| private void fireCannedTextResponsesLoaded(List<String> cannedTextResponses) { |
| for (Listener listener : mListeners) { |
| listener.onCannedTextResponsesLoaded(this, cannedTextResponses); |
| } |
| } |
| |
| private void fireVideoCallChanged(InCallService.VideoCall videoCall) { |
| for (Listener listener : mListeners) { |
| listener.onVideoCallChanged(this, videoCall); |
| } |
| } |
| |
| private void firePostDialWait(String remainingPostDialSequence) { |
| for (Listener listener : mListeners) { |
| listener.onPostDialWait(this, remainingPostDialSequence); |
| } |
| } |
| |
| private void fireCallDestroyed() { |
| for (Listener listener : mListeners) { |
| listener.onCallDestroyed(this); |
| } |
| } |
| |
| private void fireConferenceableCallsChanged() { |
| for (Listener listener : mListeners) { |
| listener.onConferenceableCallsChanged(this, mUnmodifiableConferenceableCalls); |
| } |
| } |
| |
| private int stateFromParcelableCallState(int parcelableCallState) { |
| switch (parcelableCallState) { |
| case CallState.NEW: |
| return STATE_NEW; |
| case CallState.CONNECTING: |
| return STATE_CONNECTING; |
| case CallState.PRE_DIAL_WAIT: |
| return STATE_PRE_DIAL_WAIT; |
| case CallState.DIALING: |
| return STATE_DIALING; |
| case CallState.RINGING: |
| return STATE_RINGING; |
| case CallState.ACTIVE: |
| return STATE_ACTIVE; |
| case CallState.ON_HOLD: |
| return STATE_HOLDING; |
| case CallState.DISCONNECTED: |
| return STATE_DISCONNECTED; |
| case CallState.ABORTED: |
| return STATE_DISCONNECTED; |
| case CallState.DISCONNECTING: |
| return STATE_DISCONNECTING; |
| default: |
| Log.wtf(this, "Unrecognized CallState %s", parcelableCallState); |
| return STATE_NEW; |
| } |
| } |
| } |
