ImsCallProfile.java revision 99eb21d172348936cb42202f295ae6478272a39f 
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    public static final int OIR_PRESENTATION_UNKNOWN = 3;
147    public static final int OIR_PRESENTATION_PAYPHONE = 4;
148
149    /**
150     * Values for EXTRA_DIALSTRING
151     */
152    // default (normal call)
153    public static final int DIALSTRING_NORMAL = 0;
154    // Call for SIP-based user configuration
155    public static final int DIALSTRING_SS_CONF = 1;
156    // Call for USSD message
157    public static final int DIALSTRING_USSD = 2;
158
159    /**
160     * Values for causes that restrict call types
161     */
162    // Default cause not restricted at peer and HD is supported
163    public static final int CALL_RESTRICT_CAUSE_NONE = 0;
164    // Service not supported by RAT at peer
165    public static final int CALL_RESTRICT_CAUSE_RAT = 1;
166    // Service Disabled at peer
167    public static final int CALL_RESTRICT_CAUSE_DISABLED = 2;
168    // HD is not supported
169    public static final int CALL_RESTRICT_CAUSE_HD = 3;
170
171    /**
172     * String extra properties
173     *  oi : Originating identity (number), MT only
174     *  cna : Calling name
175     *  ussd : For network-initiated USSD, MT only
176     *  remote_uri : Connected user identity (it can be used for the conference)
177     *  ChildNum: Child number info.
178     *  Codec: Codec info.
179     *  DisplayText: Display text for the call.
180     *  AdditionalCallInfo: Additional call info.
181     *  CallPull: Boolean value specifying if the call is a pulled call.
182     */
183    public static final String EXTRA_OI = "oi";
184    public static final String EXTRA_CNA = "cna";
185    public static final String EXTRA_USSD = "ussd";
186    public static final String EXTRA_REMOTE_URI = "remote_uri";
187    public static final String EXTRA_CHILD_NUMBER = "ChildNum";
188    public static final String EXTRA_CODEC = "Codec";
189    public static final String EXTRA_DISPLAY_TEXT = "DisplayText";
190    public static final String EXTRA_ADDITIONAL_CALL_INFO = "AdditionalCallInfo";
191    public static final String EXTRA_IS_CALL_PULL = "CallPull";
192
193    /**
194     * Extra key which the RIL can use to indicate the radio technology used for a call.
195     * Valid values are:
196     * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE},
197     * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_IWLAN}, and the other defined
198     * {@code RIL_RADIO_TECHNOLOGY_*} constants.
199     * Note: Despite the fact the {@link android.telephony.ServiceState} values are integer
200     * constants, the values passed for the {@link #EXTRA_CALL_RAT_TYPE} should be strings (e.g.
201     * "14" vs (int) 14).
202     * Note: This is used by {@link com.android.internal.telephony.imsphone.ImsPhoneConnection#
203     *      updateWifiStateFromExtras(Bundle)} to determine whether to set the
204     * {@link android.telecom.Connection#CAPABILITY_WIFI} capability on a connection.
205     */
206    public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
207
208    public int mServiceType;
209    public int mCallType;
210    public int mRestrictCause = CALL_RESTRICT_CAUSE_NONE;
211    public Bundle mCallExtras;
212    public ImsStreamMediaProfile mMediaProfile;
213
214    public ImsCallProfile(Parcel in) {
215        readFromParcel(in);
216    }
217
218    public ImsCallProfile() {
219        mServiceType = SERVICE_TYPE_NORMAL;
220        mCallType = CALL_TYPE_VOICE_N_VIDEO;
221        mCallExtras = new Bundle();
222        mMediaProfile = new ImsStreamMediaProfile();
223    }
224
225    public ImsCallProfile(int serviceType, int callType) {
226        mServiceType = serviceType;
227        mCallType = callType;
228        mCallExtras = new Bundle();
229        mMediaProfile = new ImsStreamMediaProfile();
230    }
231
232    public String getCallExtra(String name) {
233        return getCallExtra(name, "");
234    }
235
236    public String getCallExtra(String name, String defaultValue) {
237        if (mCallExtras == null) {
238            return defaultValue;
239        }
240
241        return mCallExtras.getString(name, defaultValue);
242    }
243
244    public boolean getCallExtraBoolean(String name) {
245        return getCallExtraBoolean(name, false);
246    }
247
248    public boolean getCallExtraBoolean(String name, boolean defaultValue) {
249        if (mCallExtras == null) {
250            return defaultValue;
251        }
252
253        return mCallExtras.getBoolean(name, defaultValue);
254    }
255
256    public int getCallExtraInt(String name) {
257        return getCallExtraInt(name, -1);
258    }
259
260    public int getCallExtraInt(String name, int defaultValue) {
261        if (mCallExtras == null) {
262            return defaultValue;
263        }
264
265        return mCallExtras.getInt(name, defaultValue);
266    }
267
268    public void setCallExtra(String name, String value) {
269        if (mCallExtras != null) {
270            mCallExtras.putString(name, value);
271        }
272    }
273
274    public void setCallExtraBoolean(String name, boolean value) {
275        if (mCallExtras != null) {
276            mCallExtras.putBoolean(name, value);
277        }
278    }
279
280    public void setCallExtraInt(String name, int value) {
281        if (mCallExtras != null) {
282            mCallExtras.putInt(name, value);
283        }
284    }
285
286    public void updateCallType(ImsCallProfile profile) {
287        mCallType = profile.mCallType;
288    }
289
290    public void updateCallExtras(ImsCallProfile profile) {
291        mCallExtras.clear();
292        mCallExtras = (Bundle) profile.mCallExtras.clone();
293    }
294
295    @Override
296    public String toString() {
297        return "{ serviceType=" + mServiceType +
298                ", callType=" + mCallType +
299                ", restrictCause=" + mRestrictCause +
300                ", mediaProfile=" + mMediaProfile.toString() + " }";
301    }
302
303    @Override
304    public int describeContents() {
305        return 0;
306    }
307
308    @Override
309    public void writeToParcel(Parcel out, int flags) {
310        out.writeInt(mServiceType);
311        out.writeInt(mCallType);
312        out.writeParcelable(mCallExtras, 0);
313        out.writeParcelable(mMediaProfile, 0);
314    }
315
316    private void readFromParcel(Parcel in) {
317        mServiceType = in.readInt();
318        mCallType = in.readInt();
319        mCallExtras = in.readParcelable(null);
320        mMediaProfile = in.readParcelable(null);
321    }
322
323    public static final Creator<ImsCallProfile> CREATOR = new Creator<ImsCallProfile>() {
324        @Override
325        public ImsCallProfile createFromParcel(Parcel in) {
326            return new ImsCallProfile(in);
327        }
328
329        @Override
330        public ImsCallProfile[] newArray(int size) {
331            return new ImsCallProfile[size];
332        }
333    };
334
335    /**
336     * Converts from the call types defined in {@link com.android.ims.ImsCallProfile} to the
337     * video state values defined in {@link VideoProfile}.
338     *
339     * @param callType The call type.
340     * @return The video state.
341     */
342    public static int getVideoStateFromImsCallProfile(ImsCallProfile callProfile) {
343        int videostate = VideoProfile.STATE_AUDIO_ONLY;
344        switch (callProfile.mCallType) {
345            case CALL_TYPE_VT_TX:
346                videostate = VideoProfile.STATE_TX_ENABLED;
347                break;
348            case CALL_TYPE_VT_RX:
349                videostate = VideoProfile.STATE_RX_ENABLED;
350                break;
351            case CALL_TYPE_VT:
352                videostate = VideoProfile.STATE_BIDIRECTIONAL;
353                break;
354            case CALL_TYPE_VOICE:
355                videostate = VideoProfile.STATE_AUDIO_ONLY;
356                break;
357            default:
358                videostate = VideoProfile.STATE_AUDIO_ONLY;
359                break;
360        }
361        if (callProfile.isVideoPaused() && !VideoProfile.isAudioOnly(videostate)) {
362            videostate |= VideoProfile.STATE_PAUSED;
363        } else {
364            videostate &= ~VideoProfile.STATE_PAUSED;
365        }
366        return videostate;
367    }
368
369    /**
370     * Converts from the video state values defined in {@link VideoProfile}
371     * to the call types defined in {@link ImsCallProfile}.
372     *
373     * @param videoState The video state.
374     * @return The call type.
375     */
376    public static int getCallTypeFromVideoState(int videoState) {
377        boolean videoTx = isVideoStateSet(videoState, VideoProfile.STATE_TX_ENABLED);
378        boolean videoRx = isVideoStateSet(videoState, VideoProfile.STATE_RX_ENABLED);
379        boolean isPaused = isVideoStateSet(videoState, VideoProfile.STATE_PAUSED);
380        if (isPaused) {
381            return ImsCallProfile.CALL_TYPE_VT_NODIR;
382        } else if (videoTx && !videoRx) {
383            return ImsCallProfile.CALL_TYPE_VT_TX;
384        } else if (!videoTx && videoRx) {
385            return ImsCallProfile.CALL_TYPE_VT_RX;
386        } else if (videoTx && videoRx) {
387            return ImsCallProfile.CALL_TYPE_VT;
388        }
389        return ImsCallProfile.CALL_TYPE_VOICE;
390    }
391
392    /**
393     * Translate presentation value to OIR value
394     * @param presentation
395     * @return OIR valuse
396     */
397    public static int presentationToOIR(int presentation) {
398        switch (presentation) {
399            case PhoneConstants.PRESENTATION_RESTRICTED:
400                return ImsCallProfile.OIR_PRESENTATION_RESTRICTED;
401            case PhoneConstants.PRESENTATION_ALLOWED:
402                return ImsCallProfile.OIR_PRESENTATION_NOT_RESTRICTED;
403            case PhoneConstants.PRESENTATION_PAYPHONE:
404                return ImsCallProfile.OIR_PRESENTATION_PAYPHONE;
405            case PhoneConstants.PRESENTATION_UNKNOWN:
406                return ImsCallProfile.OIR_PRESENTATION_UNKNOWN;
407            default:
408                return ImsCallProfile.OIR_DEFAULT;
409        }
410    }
411
412    /**
413     * Translate OIR value to presentation value
414     * @param oir value
415     * @return presentation value
416     */
417    public static int OIRToPresentation(int oir) {
418        switch(oir) {
419            case ImsCallProfile.OIR_PRESENTATION_RESTRICTED:
420                return PhoneConstants.PRESENTATION_RESTRICTED;
421            case ImsCallProfile.OIR_PRESENTATION_NOT_RESTRICTED:
422                return PhoneConstants.PRESENTATION_ALLOWED;
423            case ImsCallProfile.OIR_PRESENTATION_PAYPHONE:
424                return PhoneConstants.PRESENTATION_PAYPHONE;
425            case ImsCallProfile.OIR_PRESENTATION_UNKNOWN:
426                return PhoneConstants.PRESENTATION_UNKNOWN;
427            default:
428                return PhoneConstants.PRESENTATION_UNKNOWN;
429        }
430    }
431
432    /**
433     * Checks if video call is paused
434     * @return true if call is video paused
435     */
436    public boolean isVideoPaused() {
437        return mMediaProfile.mVideoDirection == ImsStreamMediaProfile.DIRECTION_INACTIVE;
438    }
439
440    /**
441     * Determines if a video state is set in a video state bit-mask.
442     *
443     * @param videoState The video state bit mask.
444     * @param videoStateToCheck The particular video state to check.
445     * @return True if the video state is set in the bit-mask.
446     */
447    private static boolean isVideoStateSet(int videoState, int videoStateToCheck) {
448        return (videoState & videoStateToCheck) == videoStateToCheck;
449    }
450}
451