1/*
2 * Copyright (c) 2013 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 com.android.ims;
18
19import android.os.Bundle;
20import android.os.Parcel;
21import android.os.Parcelable;
22import android.telecom.VideoProfile;
23
24import com.android.internal.telephony.PhoneConstants;
25
26/**
27 * Parcelable object to handle IMS call profile.
28 * It is created from GSMA IR.92/IR.94, 3GPP TS 24.229/TS 26.114/TS26.111.
29 * It provides the service and call type, the additional information related to the call.
30 *
31 * @hide
32 */
33public class ImsCallProfile implements Parcelable {
34    private static final String TAG = "ImsCallProfile";
35
36    /**
37     * Service types
38     */
39    /**
40     * It is for a special case. It helps that the application can make a call
41     * without IMS connection (not registered).
42     * In the moment of the call initiation, the device try to connect to the IMS network
43     * and initiates the call.
44     */
45    public static final int SERVICE_TYPE_NONE = 0;
46    /**
47     * It is a default type and can be selected when the device is connected to the IMS network.
48     */
49    public static final int SERVICE_TYPE_NORMAL = 1;
50    /**
51     * It is for an emergency call.
52     */
53    public static final int SERVICE_TYPE_EMERGENCY = 2;
54
55    /**
56     * Call types
57     */
58    /**
59     * IMSPhone to support IR.92 & IR.94 (voice + video upgrade/downgrade)
60     */
61    public static final int CALL_TYPE_VOICE_N_VIDEO = 1;
62    /**
63     * IR.92 (Voice only)
64     */
65    public static final int CALL_TYPE_VOICE = 2;
66    /**
67     * VT to support IR.92 & IR.94 (voice + video upgrade/downgrade)
68     */
69    public static final int CALL_TYPE_VIDEO_N_VOICE = 3;
70    /**
71     * Video Telephony (audio / video two way)
72     */
73    public static final int CALL_TYPE_VT = 4;
74    /**
75     * Video Telephony (audio two way / video TX one way)
76     */
77    public static final int CALL_TYPE_VT_TX = 5;
78    /**
79     * Video Telephony (audio two way / video RX one way)
80     */
81    public static final int CALL_TYPE_VT_RX = 6;
82    /**
83     * Video Telephony (audio two way / video inactive)
84     */
85    public static final int CALL_TYPE_VT_NODIR = 7;
86    /**
87     * VideoShare (video two way)
88     */
89    public static final int CALL_TYPE_VS = 8;
90    /**
91     * VideoShare (video TX one way)
92     */
93    public static final int CALL_TYPE_VS_TX = 9;
94    /**
95     * VideoShare (video RX one way)
96     */
97    public static final int CALL_TYPE_VS_RX = 10;
98
99    /**
100     * Extra properties for IMS call.
101     */
102    /**
103     * Boolean extra properties - "true" / "false"
104     *  conference : Indicates if the session is for the conference call or not.
105     *  e_call : Indicates if the session is for the emergency call or not.
106     *  vms : Indicates if the session is connected to the voice mail system or not.
107     *  call_mode_changeable : Indicates if the session is able to upgrade/downgrade
108     *      the video during voice call.
109     *  conference_avail : Indicates if the session can be extended to the conference.
110     */
111    public static final String EXTRA_CONFERENCE = "conference";
112    public static final String EXTRA_E_CALL = "e_call";
113    public static final String EXTRA_VMS = "vms";
114    public static final String EXTRA_CALL_MODE_CHANGEABLE = "call_mode_changeable";
115    public static final String EXTRA_CONFERENCE_AVAIL = "conference_avail";
116
117    // Extra string for internal use only. OEMs should not use
118    // this for packing extras.
119    public static final String EXTRA_OEM_EXTRAS = "OemCallExtras";
120
121    /**
122     * Integer extra properties
123     *  oir : Rule for originating identity (number) presentation, MO/MT.
124     *      {@link ImsCallProfile#OIR_DEFAULT}
125     *      {@link ImsCallProfile#OIR_PRESENTATION_RESTRICTED}
126     *      {@link ImsCallProfile#OIR_PRESENTATION_NOT_RESTRICTED}
127     *  cnap : Rule for calling name presentation
128     *      {@link ImsCallProfile#OIR_DEFAULT}
129     *      {@link ImsCallProfile#OIR_PRESENTATION_RESTRICTED}
130     *      {@link ImsCallProfile#OIR_PRESENTATION_NOT_RESTRICTED}
131     *  dialstring : To identify the Ims call type, MO
132     *      {@link ImsCallProfile#DIALSTRING_NORMAL_CALL}
133     *      {@link ImsCallProfile#DIALSTRING_SS_CONF}
134     *      {@link ImsCallProfile#DIALSTRING_USSD}
135     */
136    public static final String EXTRA_OIR = "oir";
137    public static final String EXTRA_CNAP = "cnap";
138    public static final String EXTRA_DIALSTRING = "dialstring";
139
140    /**
141     * Values for EXTRA_OIR / EXTRA_CNAP
142     */
143    public static final int OIR_DEFAULT = 0;    // "user subscription default value"
144    public static final int OIR_PRESENTATION_RESTRICTED = 1;
145    public static final int OIR_PRESENTATION_NOT_RESTRICTED = 2;
146
147    /**
148     * Values for EXTRA_DIALSTRING
149     */
150    // default (normal call)
151    public static final int DIALSTRING_NORMAL = 0;
152    // Call for SIP-based user configuration
153    public static final int DIALSTRING_SS_CONF = 1;
154    // Call for USSD message
155    public static final int DIALSTRING_USSD = 2;
156
157    /**
158     * Values for causes that restrict call types
159     */
160    // Default cause not restricted at peer and HD is supported
161    public static final int CALL_RESTRICT_CAUSE_NONE = 0;
162    // Service not supported by RAT at peer
163    public static final int CALL_RESTRICT_CAUSE_RAT = 1;
164    // Service Disabled at peer
165    public static final int CALL_RESTRICT_CAUSE_DISABLED = 2;
166    // HD is not supported
167    public static final int CALL_RESTRICT_CAUSE_HD = 3;
168
169    /**
170     * String extra properties
171     *  oi : Originating identity (number), MT only
172     *  cna : Calling name
173     *  ussd : For network-initiated USSD, MT only
174     *  remote_uri : Connected user identity (it can be used for the conference)
175     */
176    public static final String EXTRA_OI = "oi";
177    public static final String EXTRA_CNA = "cna";
178    public static final String EXTRA_USSD = "ussd";
179    public static final String EXTRA_REMOTE_URI = "remote_uri";
180
181    public int mServiceType;
182    public int mCallType;
183    public int mRestrictCause = CALL_RESTRICT_CAUSE_NONE;
184    public Bundle mCallExtras;
185    public ImsStreamMediaProfile mMediaProfile;
186
187    public ImsCallProfile(Parcel in) {
188        readFromParcel(in);
189    }
190
191    public ImsCallProfile() {
192        mServiceType = SERVICE_TYPE_NORMAL;
193        mCallType = CALL_TYPE_VOICE_N_VIDEO;
194        mCallExtras = new Bundle();
195        mMediaProfile = new ImsStreamMediaProfile();
196    }
197
198    public ImsCallProfile(int serviceType, int callType) {
199        mServiceType = serviceType;
200        mCallType = callType;
201        mCallExtras = new Bundle();
202        mMediaProfile = new ImsStreamMediaProfile();
203    }
204
205    public String getCallExtra(String name) {
206        return getCallExtra(name, "");
207    }
208
209    public String getCallExtra(String name, String defaultValue) {
210        if (mCallExtras == null) {
211            return defaultValue;
212        }
213
214        return mCallExtras.getString(name, defaultValue);
215    }
216
217    public boolean getCallExtraBoolean(String name) {
218        return getCallExtraBoolean(name, false);
219    }
220
221    public boolean getCallExtraBoolean(String name, boolean defaultValue) {
222        if (mCallExtras == null) {
223            return defaultValue;
224        }
225
226        return mCallExtras.getBoolean(name, defaultValue);
227    }
228
229    public int getCallExtraInt(String name) {
230        return getCallExtraInt(name, -1);
231    }
232
233    public int getCallExtraInt(String name, int defaultValue) {
234        if (mCallExtras == null) {
235            return defaultValue;
236        }
237
238        return mCallExtras.getInt(name, defaultValue);
239    }
240
241    public void setCallExtra(String name, String value) {
242        if (mCallExtras != null) {
243            mCallExtras.putString(name, value);
244        }
245    }
246
247    public void setCallExtraBoolean(String name, boolean value) {
248        if (mCallExtras != null) {
249            mCallExtras.putBoolean(name, value);
250        }
251    }
252
253    public void setCallExtraInt(String name, int value) {
254        if (mCallExtras != null) {
255            mCallExtras.putInt(name, value);
256        }
257    }
258
259    public void updateCallType(ImsCallProfile profile) {
260        mCallType = profile.mCallType;
261    }
262
263    public void updateCallExtras(ImsCallProfile profile) {
264        mCallExtras.clear();
265        mCallExtras = (Bundle) profile.mCallExtras.clone();
266    }
267
268    @Override
269    public String toString() {
270        return "{ serviceType=" + mServiceType +
271                ", callType=" + mCallType +
272                ", restrictCause=" + mRestrictCause +
273                ", callExtras=" + mCallExtras.toString() +
274                ", mediaProfile=" + mMediaProfile.toString() + " }";
275    }
276
277    @Override
278    public int describeContents() {
279        return 0;
280    }
281
282    @Override
283    public void writeToParcel(Parcel out, int flags) {
284        out.writeInt(mServiceType);
285        out.writeInt(mCallType);
286        out.writeParcelable(mCallExtras, 0);
287        out.writeParcelable(mMediaProfile, 0);
288    }
289
290    private void readFromParcel(Parcel in) {
291        mServiceType = in.readInt();
292        mCallType = in.readInt();
293        mCallExtras = in.readParcelable(null);
294        mMediaProfile = in.readParcelable(null);
295    }
296
297    public static final Creator<ImsCallProfile> CREATOR = new Creator<ImsCallProfile>() {
298        @Override
299        public ImsCallProfile createFromParcel(Parcel in) {
300            return new ImsCallProfile(in);
301        }
302
303        @Override
304        public ImsCallProfile[] newArray(int size) {
305            return new ImsCallProfile[size];
306        }
307    };
308
309    /**
310     * Converts from the call types defined in {@link com.android.ims.ImsCallProfile} to the
311     * video state values defined in {@link VideoProfile}.
312     *
313     * @param callType The call type.
314     * @return The video state.
315     */
316    public static int getVideoStateFromCallType(int callType) {
317        switch (callType) {
318            case CALL_TYPE_VT_NODIR:
319                return VideoProfile.VideoState.PAUSED |
320                        VideoProfile.VideoState.BIDIRECTIONAL;
321            case CALL_TYPE_VT_TX:
322                return VideoProfile.VideoState.TX_ENABLED;
323            case CALL_TYPE_VT_RX:
324                return VideoProfile.VideoState.RX_ENABLED;
325            case CALL_TYPE_VT:
326                return VideoProfile.VideoState.BIDIRECTIONAL;
327            case CALL_TYPE_VOICE:
328                return VideoProfile.VideoState.AUDIO_ONLY;
329            default:
330                return VideoProfile.VideoState.AUDIO_ONLY;
331        }
332    }
333
334    /**
335     * Converts from the video state values defined in {@link VideoProfile}
336     * to the call types defined in {@link ImsCallProfile}.
337     *
338     * @param videoState The video state.
339     * @return The call type.
340     */
341    public static int getCallTypeFromVideoState(int videoState) {
342        boolean videoTx = isVideoStateSet(videoState, VideoProfile.VideoState.TX_ENABLED);
343        boolean videoRx = isVideoStateSet(videoState, VideoProfile.VideoState.RX_ENABLED);
344        boolean isPaused = isVideoStateSet(videoState, VideoProfile.VideoState.PAUSED);
345        if (isPaused) {
346            return ImsCallProfile.CALL_TYPE_VT_NODIR;
347        } else if (videoTx && !videoRx) {
348            return ImsCallProfile.CALL_TYPE_VT_TX;
349        } else if (!videoTx && videoRx) {
350            return ImsCallProfile.CALL_TYPE_VT_RX;
351        } else if (videoTx && videoRx) {
352            return ImsCallProfile.CALL_TYPE_VT;
353        }
354        return ImsCallProfile.CALL_TYPE_VOICE;
355    }
356
357    /**
358     * Translate presentation value to OIR value
359     * @param presentation
360     * @return OIR valuse
361     */
362    public static int presentationToOIR(int presentation) {
363        switch (presentation) {
364            case PhoneConstants.PRESENTATION_RESTRICTED:
365                return ImsCallProfile.OIR_PRESENTATION_RESTRICTED;
366            case PhoneConstants.PRESENTATION_ALLOWED:
367                return ImsCallProfile.OIR_PRESENTATION_NOT_RESTRICTED;
368            default:
369                return ImsCallProfile.OIR_DEFAULT;
370        }
371    }
372
373    /**
374     * Translate OIR value to presentation value
375     * @param oir value
376     * @return presentation value
377     */
378    public static int OIRToPresentation(int oir) {
379        switch(oir) {
380            case ImsCallProfile.OIR_PRESENTATION_RESTRICTED:
381                return PhoneConstants.PRESENTATION_RESTRICTED;
382            case ImsCallProfile.OIR_PRESENTATION_NOT_RESTRICTED:
383                return PhoneConstants.PRESENTATION_ALLOWED;
384            default:
385                return PhoneConstants.PRESENTATION_UNKNOWN;
386        }
387    }
388
389    /**
390     * Determines if a video state is set in a video state bit-mask.
391     *
392     * @param videoState The video state bit mask.
393     * @param videoStateToCheck The particular video state to check.
394     * @return True if the video state is set in the bit-mask.
395     */
396    private static boolean isVideoStateSet(int videoState, int videoStateToCheck) {
397        return (videoState & videoStateToCheck) == videoStateToCheck;
398    }
399}
400