diff options
Diffstat (limited to 'telecomm/java/android/telecom/ParcelableCall.java')
| -rw-r--r-- | telecomm/java/android/telecom/ParcelableCall.java | 330 |
1 files changed, 330 insertions, 0 deletions
diff --git a/telecomm/java/android/telecom/ParcelableCall.java b/telecomm/java/android/telecom/ParcelableCall.java new file mode 100644 index 0000000..c5c3d11 --- /dev/null +++ b/telecomm/java/android/telecom/ParcelableCall.java @@ -0,0 +1,330 @@ +/* + * Copyright 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.net.Uri; +import android.os.Bundle; +import android.os.Parcel; +import android.os.Parcelable; +import android.os.RemoteException; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import com.android.internal.telecom.IVideoProvider; + +/** + * Information about a call that is used between InCallService and Telecom. + * @hide + */ +public final class ParcelableCall implements Parcelable { + private final String mId; + private final int mState; + private final DisconnectCause mDisconnectCause; + private final List<String> mCannedSmsResponses; + private final int mCapabilities; + private final int mProperties; + private final long mConnectTimeMillis; + private final Uri mHandle; + private final int mHandlePresentation; + private final String mCallerDisplayName; + private final int mCallerDisplayNamePresentation; + private final GatewayInfo mGatewayInfo; + private final PhoneAccountHandle mAccountHandle; + private final IVideoProvider mVideoCallProvider; + private InCallService.VideoCall mVideoCall; + private final String mParentCallId; + private final List<String> mChildCallIds; + private final StatusHints mStatusHints; + private final int mVideoState; + private final List<String> mConferenceableCallIds; + private final Bundle mExtras; + + public ParcelableCall( + String id, + int state, + DisconnectCause disconnectCause, + List<String> cannedSmsResponses, + int capabilities, + int properties, + long connectTimeMillis, + Uri handle, + int handlePresentation, + String callerDisplayName, + int callerDisplayNamePresentation, + GatewayInfo gatewayInfo, + PhoneAccountHandle accountHandle, + IVideoProvider videoCallProvider, + String parentCallId, + List<String> childCallIds, + StatusHints statusHints, + int videoState, + List<String> conferenceableCallIds, + Bundle extras) { + mId = id; + mState = state; + mDisconnectCause = disconnectCause; + mCannedSmsResponses = cannedSmsResponses; + mCapabilities = capabilities; + mProperties = properties; + mConnectTimeMillis = connectTimeMillis; + mHandle = handle; + mHandlePresentation = handlePresentation; + mCallerDisplayName = callerDisplayName; + mCallerDisplayNamePresentation = callerDisplayNamePresentation; + mGatewayInfo = gatewayInfo; + mAccountHandle = accountHandle; + mVideoCallProvider = videoCallProvider; + mParentCallId = parentCallId; + mChildCallIds = childCallIds; + mStatusHints = statusHints; + mVideoState = videoState; + mConferenceableCallIds = Collections.unmodifiableList(conferenceableCallIds); + mExtras = extras; + } + + /** The unique ID of the call. */ + public String getId() { + return mId; + } + + /** The current state of the call. */ + public int getState() { + return mState; + } + + /** + * Reason for disconnection, as described by {@link android.telecomm.DisconnectCause}. Valid + * when call state is {@link CallState#DISCONNECTED}. + */ + public DisconnectCause getDisconnectCause() { + return mDisconnectCause; + } + + /** + * The set of possible text message responses when this call is incoming. + */ + public List<String> getCannedSmsResponses() { + return mCannedSmsResponses; + } + + // Bit mask of actions a call supports, values are defined in {@link CallCapabilities}. + public int getCapabilities() { + return mCapabilities; + } + + /** Bitmask of properties of the call. */ + public int getProperties() { return mProperties; } + + /** The time that the call switched to the active state. */ + public long getConnectTimeMillis() { + return mConnectTimeMillis; + } + + /** The endpoint to which the call is connected. */ + public Uri getHandle() { + return mHandle; + } + + /** + * The presentation requirements for the handle. See {@link TelecomManager} for valid values. + */ + public int getHandlePresentation() { + return mHandlePresentation; + } + + /** The endpoint to which the call is connected. */ + public String getCallerDisplayName() { + return mCallerDisplayName; + } + + /** + * The presentation requirements for the caller display name. + * See {@link TelecomManager} for valid values. + */ + public int getCallerDisplayNamePresentation() { + return mCallerDisplayNamePresentation; + } + + /** Gateway information for the call. */ + public GatewayInfo getGatewayInfo() { + return mGatewayInfo; + } + + /** PhoneAccountHandle information for the call. */ + public PhoneAccountHandle getAccountHandle() { + return mAccountHandle; + } + + /** + * Returns an object for remotely communicating through the video call provider's binder. + * @return The video call. + */ + public InCallService.VideoCall getVideoCall() { + if (mVideoCall == null && mVideoCallProvider != null) { + try { + mVideoCall = new VideoCallImpl(mVideoCallProvider); + } catch (RemoteException ignored) { + // Ignore RemoteException. + } + } + + return mVideoCall; + } + + /** + * The conference call to which this call is conferenced. Null if not conferenced. + */ + public String getParentCallId() { + return mParentCallId; + } + + /** + * The child call-IDs if this call is a conference call. Returns an empty list if this is not + * a conference call or if the conference call contains no children. + */ + public List<String> getChildCallIds() { + return mChildCallIds; + } + + public List<String> getConferenceableCallIds() { + return mConferenceableCallIds; + } + + /** + * The status label and icon. + * + * @return Status hints. + */ + public StatusHints getStatusHints() { + return mStatusHints; + } + + /** + * The video state. + * @return The video state of the call. + */ + public int getVideoState() { + return mVideoState; + } + + /** + * Any extras to pass with the call + * + * @return a bundle of extras + */ + public Bundle getExtras() { + return mExtras; + } + + /** Responsible for creating ParcelableCall objects for deserialized Parcels. */ + public static final Parcelable.Creator<ParcelableCall> CREATOR = + new Parcelable.Creator<ParcelableCall> () { + @Override + public ParcelableCall createFromParcel(Parcel source) { + ClassLoader classLoader = ParcelableCall.class.getClassLoader(); + String id = source.readString(); + int state = source.readInt(); + DisconnectCause disconnectCause = source.readParcelable(classLoader); + List<String> cannedSmsResponses = new ArrayList<>(); + source.readList(cannedSmsResponses, classLoader); + int capabilities = source.readInt(); + int properties = source.readInt(); + long connectTimeMillis = source.readLong(); + Uri handle = source.readParcelable(classLoader); + int handlePresentation = source.readInt(); + String callerDisplayName = source.readString(); + int callerDisplayNamePresentation = source.readInt(); + GatewayInfo gatewayInfo = source.readParcelable(classLoader); + PhoneAccountHandle accountHandle = source.readParcelable(classLoader); + IVideoProvider videoCallProvider = + IVideoProvider.Stub.asInterface(source.readStrongBinder()); + String parentCallId = source.readString(); + List<String> childCallIds = new ArrayList<>(); + source.readList(childCallIds, classLoader); + StatusHints statusHints = source.readParcelable(classLoader); + int videoState = source.readInt(); + List<String> conferenceableCallIds = new ArrayList<>(); + source.readList(conferenceableCallIds, classLoader); + Bundle extras = source.readParcelable(classLoader); + return new ParcelableCall( + id, + state, + disconnectCause, + cannedSmsResponses, + capabilities, + properties, + connectTimeMillis, + handle, + handlePresentation, + callerDisplayName, + callerDisplayNamePresentation, + gatewayInfo, + accountHandle, + videoCallProvider, + parentCallId, + childCallIds, + statusHints, + videoState, + conferenceableCallIds, + extras); + } + + @Override + public ParcelableCall[] newArray(int size) { + return new ParcelableCall[size]; + } + }; + + /** {@inheritDoc} */ + @Override + public int describeContents() { + return 0; + } + + /** Writes ParcelableCall object into a Parcel. */ + @Override + public void writeToParcel(Parcel destination, int flags) { + destination.writeString(mId); + destination.writeInt(mState); + destination.writeParcelable(mDisconnectCause, 0); + destination.writeList(mCannedSmsResponses); + destination.writeInt(mCapabilities); + destination.writeInt(mProperties); + destination.writeLong(mConnectTimeMillis); + destination.writeParcelable(mHandle, 0); + destination.writeInt(mHandlePresentation); + destination.writeString(mCallerDisplayName); + destination.writeInt(mCallerDisplayNamePresentation); + destination.writeParcelable(mGatewayInfo, 0); + destination.writeParcelable(mAccountHandle, 0); + destination.writeStrongBinder( + mVideoCallProvider != null ? mVideoCallProvider.asBinder() : null); + destination.writeString(mParentCallId); + destination.writeList(mChildCallIds); + destination.writeParcelable(mStatusHints, 0); + destination.writeInt(mVideoState); + destination.writeList(mConferenceableCallIds); + destination.writeParcelable(mExtras, 0); + } + + @Override + public String toString() { + return String.format("[%s, parent:%s, children:%s]", mId, mParentCallId, mChildCallIds); + } +} |