1/*
2 * Copyright 2014, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.telecom;
18
19import android.net.Uri;
20import android.os.Bundle;
21import android.os.Parcel;
22import android.os.Parcelable;
23
24import com.android.internal.telecom.IVideoProvider;
25
26import java.util.ArrayList;
27import java.util.List;
28
29/**
30 * Information about a connection that is used between Telecom and the ConnectionService.
31 * This is used to send initial Connection information to Telecom when the connection is
32 * first created.
33 * @hide
34 */
35public final class ParcelableConnection implements Parcelable {
36    private final PhoneAccountHandle mPhoneAccount;
37    private final int mState;
38    private final int mConnectionCapabilities;
39    private final int mConnectionProperties;
40    private final Uri mAddress;
41    private final int mAddressPresentation;
42    private final String mCallerDisplayName;
43    private final int mCallerDisplayNamePresentation;
44    private final IVideoProvider mVideoProvider;
45    private final int mVideoState;
46    private final boolean mRingbackRequested;
47    private final boolean mIsVoipAudioMode;
48    private final long mConnectTimeMillis;
49    private final StatusHints mStatusHints;
50    private final DisconnectCause mDisconnectCause;
51    private final List<String> mConferenceableConnectionIds;
52    private final Bundle mExtras;
53
54    /** @hide */
55    public ParcelableConnection(
56            PhoneAccountHandle phoneAccount,
57            int state,
58            int capabilities,
59            int properties,
60            Uri address,
61            int addressPresentation,
62            String callerDisplayName,
63            int callerDisplayNamePresentation,
64            IVideoProvider videoProvider,
65            int videoState,
66            boolean ringbackRequested,
67            boolean isVoipAudioMode,
68            long connectTimeMillis,
69            StatusHints statusHints,
70            DisconnectCause disconnectCause,
71            List<String> conferenceableConnectionIds,
72            Bundle extras) {
73        mPhoneAccount = phoneAccount;
74        mState = state;
75        mConnectionCapabilities = capabilities;
76        mConnectionProperties = properties;
77        mAddress = address;
78        mAddressPresentation = addressPresentation;
79        mCallerDisplayName = callerDisplayName;
80        mCallerDisplayNamePresentation = callerDisplayNamePresentation;
81        mVideoProvider = videoProvider;
82        mVideoState = videoState;
83        mRingbackRequested = ringbackRequested;
84        mIsVoipAudioMode = isVoipAudioMode;
85        mConnectTimeMillis = connectTimeMillis;
86        mStatusHints = statusHints;
87        mDisconnectCause = disconnectCause;
88        mConferenceableConnectionIds = conferenceableConnectionIds;
89        mExtras = extras;
90    }
91
92    public PhoneAccountHandle getPhoneAccount() {
93        return mPhoneAccount;
94    }
95
96    public int getState() {
97        return mState;
98    }
99
100    /**
101     * Returns the current connection capabilities bit-mask.  Connection capabilities are defined as
102     * {@code CAPABILITY_*} constants in {@link Connection}.
103     *
104     * @return Bit-mask containing capabilities of the connection.
105     */
106    public int getConnectionCapabilities() {
107        return mConnectionCapabilities;
108    }
109
110    /**
111     * Returns the current connection properties bit-mask.  Connection properties are defined as
112     * {@code PROPERTY_*} constants in {@link Connection}.
113     *
114     * @return Bit-mask containing properties of the connection.
115     */
116    public int getConnectionProperties() {
117        return mConnectionProperties;
118    }
119
120    public Uri getHandle() {
121        return mAddress;
122    }
123
124    public int getHandlePresentation() {
125        return mAddressPresentation;
126    }
127
128    public String getCallerDisplayName() {
129        return mCallerDisplayName;
130    }
131
132    public int getCallerDisplayNamePresentation() {
133        return mCallerDisplayNamePresentation;
134    }
135
136    public IVideoProvider getVideoProvider() {
137        return mVideoProvider;
138    }
139
140    public int getVideoState() {
141        return mVideoState;
142    }
143
144    public boolean isRingbackRequested() {
145        return mRingbackRequested;
146    }
147
148    public boolean getIsVoipAudioMode() {
149        return mIsVoipAudioMode;
150    }
151
152    public long getConnectTimeMillis() {
153        return mConnectTimeMillis;
154    }
155
156    public final StatusHints getStatusHints() {
157        return mStatusHints;
158    }
159
160    public final DisconnectCause getDisconnectCause() {
161        return mDisconnectCause;
162    }
163
164    public final List<String> getConferenceableConnectionIds() {
165        return mConferenceableConnectionIds;
166    }
167
168    public final Bundle getExtras() {
169        return mExtras;
170    }
171
172    @Override
173    public String toString() {
174        return new StringBuilder()
175                .append("ParcelableConnection [act:")
176                .append(mPhoneAccount)
177                .append("], state:")
178                .append(mState)
179                .append(", capabilities:")
180                .append(Connection.capabilitiesToString(mConnectionCapabilities))
181                .append(", properties:")
182                .append(Connection.propertiesToString(mConnectionProperties))
183                .append(", extras:")
184                .append(mExtras)
185                .toString();
186    }
187
188    public static final Parcelable.Creator<ParcelableConnection> CREATOR =
189            new Parcelable.Creator<ParcelableConnection> () {
190        @Override
191        public ParcelableConnection createFromParcel(Parcel source) {
192            ClassLoader classLoader = ParcelableConnection.class.getClassLoader();
193
194            PhoneAccountHandle phoneAccount = source.readParcelable(classLoader);
195            int state = source.readInt();
196            int capabilities = source.readInt();
197            Uri address = source.readParcelable(classLoader);
198            int addressPresentation = source.readInt();
199            String callerDisplayName = source.readString();
200            int callerDisplayNamePresentation = source.readInt();
201            IVideoProvider videoCallProvider =
202                    IVideoProvider.Stub.asInterface(source.readStrongBinder());
203            int videoState = source.readInt();
204            boolean ringbackRequested = source.readByte() == 1;
205            boolean audioModeIsVoip = source.readByte() == 1;
206            long connectTimeMillis = source.readLong();
207            StatusHints statusHints = source.readParcelable(classLoader);
208            DisconnectCause disconnectCause = source.readParcelable(classLoader);
209            List<String> conferenceableConnectionIds = new ArrayList<>();
210            source.readStringList(conferenceableConnectionIds);
211            Bundle extras = Bundle.setDefusable(source.readBundle(classLoader), true);
212            int properties = source.readInt();
213
214            return new ParcelableConnection(
215                    phoneAccount,
216                    state,
217                    capabilities,
218                    properties,
219                    address,
220                    addressPresentation,
221                    callerDisplayName,
222                    callerDisplayNamePresentation,
223                    videoCallProvider,
224                    videoState,
225                    ringbackRequested,
226                    audioModeIsVoip,
227                    connectTimeMillis,
228                    statusHints,
229                    disconnectCause,
230                    conferenceableConnectionIds,
231                    extras);
232        }
233
234        @Override
235        public ParcelableConnection[] newArray(int size) {
236            return new ParcelableConnection[size];
237        }
238    };
239
240    /** {@inheritDoc} */
241    @Override
242    public int describeContents() {
243        return 0;
244    }
245
246    /** Writes ParcelableConnection object into a Parcel. */
247    @Override
248    public void writeToParcel(Parcel destination, int flags) {
249        destination.writeParcelable(mPhoneAccount, 0);
250        destination.writeInt(mState);
251        destination.writeInt(mConnectionCapabilities);
252        destination.writeParcelable(mAddress, 0);
253        destination.writeInt(mAddressPresentation);
254        destination.writeString(mCallerDisplayName);
255        destination.writeInt(mCallerDisplayNamePresentation);
256        destination.writeStrongBinder(
257                mVideoProvider != null ? mVideoProvider.asBinder() : null);
258        destination.writeInt(mVideoState);
259        destination.writeByte((byte) (mRingbackRequested ? 1 : 0));
260        destination.writeByte((byte) (mIsVoipAudioMode ? 1 : 0));
261        destination.writeLong(mConnectTimeMillis);
262        destination.writeParcelable(mStatusHints, 0);
263        destination.writeParcelable(mDisconnectCause, 0);
264        destination.writeStringList(mConferenceableConnectionIds);
265        destination.writeBundle(mExtras);
266        destination.writeInt(mConnectionProperties);
267    }
268}
269