IMS call merge call-back changes.
[android/platform/frameworks/opt/net/ims.git] / src / java / com / android / ims / internal / ImsCallSession.java
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
17 package com.android.ims.internal;
18
19 import android.os.RemoteException;
20
21 import com.android.ims.ImsCallProfile;
22 import com.android.ims.ImsConferenceState;
23 import com.android.ims.ImsReasonInfo;
24 import com.android.ims.ImsStreamMediaProfile;
25
26 /**
27  * Provides the call initiation/termination, and media exchange between two IMS endpoints.
28  * It directly communicates with IMS service which implements the IMS protocol behavior.
29  *
30  * @hide
31  */
32 public class ImsCallSession {
33     private static final String TAG = "ImsCallSession";
34
35     /**
36      * Defines IMS call session state.
37      */
38     public static class State {
39         public static final int IDLE = 0;
40         public static final int INITIATED = 1;
41         public static final int NEGOTIATING = 2;
42         public static final int ESTABLISHING = 3;
43         public static final int ESTABLISHED = 4;
44
45         public static final int RENEGOTIATING = 5;
46         public static final int REESTABLISHING = 6;
47
48         public static final int TERMINATING = 7;
49         public static final int TERMINATED = 8;
50
51         public static final int INVALID = (-1);
52
53         /**
54          * Converts the state to string.
55          */
56         public static String toString(int state) {
57             switch (state) {
58                 case IDLE:
59                     return "IDLE";
60                 case INITIATED:
61                     return "INITIATED";
62                 case NEGOTIATING:
63                     return "NEGOTIATING";
64                 case ESTABLISHING:
65                     return "ESTABLISHING";
66                 case ESTABLISHED:
67                     return "ESTABLISHED";
68                 case RENEGOTIATING:
69                     return "RENEGOTIATING";
70                 case REESTABLISHING:
71                     return "REESTABLISHING";
72                 case TERMINATING:
73                     return "TERMINATING";
74                 case TERMINATED:
75                     return "TERMINATED";
76                 default:
77                     return "UNKNOWN";
78             }
79         }
80
81         private State() {
82         }
83     }
84
85     /**
86      * Listener for events relating to an IMS session, such as when a session is being
87      * recieved ("on ringing") or a call is outgoing ("on calling").
88      * <p>Many of these events are also received by {@link ImsCall.Listener}.</p>
89      */
90     public static class Listener {
91         /**
92          * Called when a request is sent out to initiate a new session
93          * and 1xx response is received from the network.
94          *
95          * @param session the session object that carries out the IMS session
96          */
97         public void callSessionProgressing(ImsCallSession session,
98                 ImsStreamMediaProfile profile) {
99             // no-op
100         }
101
102         /**
103          * Called when the session is established.
104          *
105          * @param session the session object that carries out the IMS session
106          */
107         public void callSessionStarted(ImsCallSession session,
108                 ImsCallProfile profile) {
109             // no-op
110         }
111
112         /**
113          * Called when the session establishment is failed.
114          *
115          * @param session the session object that carries out the IMS session
116          * @param reasonInfo detailed reason of the session establishment failure
117          */
118         public void callSessionStartFailed(ImsCallSession session,
119                 ImsReasonInfo reasonInfo) {
120         }
121
122         /**
123          * Called when the session is terminated.
124          *
125          * @param session the session object that carries out the IMS session
126          * @param reasonInfo detailed reason of the session termination
127          */
128         public void callSessionTerminated(ImsCallSession session,
129                 ImsReasonInfo reasonInfo) {
130         }
131
132         /**
133          * Called when the session is in hold.
134          *
135          * @param session the session object that carries out the IMS session
136          */
137         public void callSessionHeld(ImsCallSession session,
138                 ImsCallProfile profile) {
139         }
140
141         /**
142          * Called when the session hold is failed.
143          *
144          * @param session the session object that carries out the IMS session
145          * @param reasonInfo detailed reason of the session hold failure
146          */
147         public void callSessionHoldFailed(ImsCallSession session,
148                 ImsReasonInfo reasonInfo) {
149         }
150
151         /**
152          * Called when the session hold is received from the remote user.
153          *
154          * @param session the session object that carries out the IMS session
155          */
156         public void callSessionHoldReceived(ImsCallSession session,
157                 ImsCallProfile profile) {
158         }
159
160         /**
161          * Called when the session resume is done.
162          *
163          * @param session the session object that carries out the IMS session
164          */
165         public void callSessionResumed(ImsCallSession session,
166                 ImsCallProfile profile) {
167         }
168
169         /**
170          * Called when the session resume is failed.
171          *
172          * @param session the session object that carries out the IMS session
173          * @param reasonInfo detailed reason of the session resume failure
174          */
175         public void callSessionResumeFailed(ImsCallSession session,
176                 ImsReasonInfo reasonInfo) {
177         }
178
179         /**
180          * Called when the session resume is received from the remote user.
181          *
182          * @param session the session object that carries out the IMS session
183          */
184         public void callSessionResumeReceived(ImsCallSession session,
185                 ImsCallProfile profile) {
186         }
187
188         /**
189          * Called when the session merge has been started.  At this point, the {@code newSession}
190          * represents the session which has been initiated to the IMS conference server for the
191          * new merged conference.
192          *
193          * @param session the session object that carries out the IMS session
194          * @param newSession the session object that is merged with an active & hold session
195          */
196         public void callSessionMergeStarted(ImsCallSession session,
197                 ImsCallSession newSession, ImsCallProfile profile) {
198         }
199
200         /**
201          * Called when the session merge is successful and the merged session is active.
202          *
203          * @param session the session object that carries out the IMS session
204          */
205         public void callSessionMergeComplete(ImsCallSession session) {
206         }
207
208         /**
209          * Called when the session merge has failed.
210          *
211          * @param session the session object that carries out the IMS session
212          * @param reasonInfo detailed reason of the call merge failure
213          */
214         public void callSessionMergeFailed(ImsCallSession session,
215                 ImsReasonInfo reasonInfo) {
216         }
217
218         /**
219          * Called when the session is updated (except for hold/unhold).
220          *
221          * @param call the call object that carries out the IMS call
222          */
223         public void callSessionUpdated(ImsCallSession session,
224                 ImsCallProfile profile) {
225         }
226
227         /**
228          * Called when the session update is failed.
229          *
230          * @param session the session object that carries out the IMS session
231          * @param reasonInfo detailed reason of the session update failure
232          */
233         public void callSessionUpdateFailed(ImsCallSession session,
234                 ImsReasonInfo reasonInfo) {
235         }
236
237         /**
238          * Called when the session update is received from the remote user.
239          *
240          * @param session the session object that carries out the IMS session
241          */
242         public void callSessionUpdateReceived(ImsCallSession session,
243                 ImsCallProfile profile) {
244             // no-op
245         }
246
247         /**
248          * Called when the session is extended to the conference session.
249          *
250          * @param session the session object that carries out the IMS session
251          * @param newSession the session object that is extended to the conference
252          *      from the active session
253          */
254         public void callSessionConferenceExtended(ImsCallSession session,
255                 ImsCallSession newSession, ImsCallProfile profile) {
256         }
257
258         /**
259          * Called when the conference extension is failed.
260          *
261          * @param session the session object that carries out the IMS session
262          * @param reasonInfo detailed reason of the conference extension failure
263          */
264         public void callSessionConferenceExtendFailed(ImsCallSession session,
265                 ImsReasonInfo reasonInfo) {
266         }
267
268         /**
269          * Called when the conference extension is received from the remote user.
270          *
271          * @param session the session object that carries out the IMS session
272          */
273         public void callSessionConferenceExtendReceived(ImsCallSession session,
274                 ImsCallSession newSession, ImsCallProfile profile) {
275             // no-op
276         }
277
278         /**
279          * Called when the invitation request of the participants is delivered to the conference
280          * server.
281          *
282          * @param session the session object that carries out the IMS session
283          */
284         public void callSessionInviteParticipantsRequestDelivered(ImsCallSession session) {
285             // no-op
286         }
287
288         /**
289          * Called when the invitation request of the participants is failed.
290          *
291          * @param session the session object that carries out the IMS session
292          * @param reasonInfo detailed reason of the conference invitation failure
293          */
294         public void callSessionInviteParticipantsRequestFailed(ImsCallSession session,
295                 ImsReasonInfo reasonInfo) {
296             // no-op
297         }
298
299         /**
300          * Called when the removal request of the participants is delivered to the conference
301          * server.
302          *
303          * @param session the session object that carries out the IMS session
304          */
305         public void callSessionRemoveParticipantsRequestDelivered(ImsCallSession session) {
306             // no-op
307         }
308
309         /**
310          * Called when the removal request of the participants is failed.
311          *
312          * @param session the session object that carries out the IMS session
313          * @param reasonInfo detailed reason of the conference removal failure
314          */
315         public void callSessionRemoveParticipantsRequestFailed(ImsCallSession session,
316                 ImsReasonInfo reasonInfo) {
317             // no-op
318         }
319
320         /**
321          * Called when the conference state is updated.
322          *
323          * @param session the session object that carries out the IMS session
324          */
325         public void callSessionConferenceStateUpdated(ImsCallSession session,
326                 ImsConferenceState state) {
327             // no-op
328         }
329
330         /**
331          * Called when the USSD message is received from the network.
332          *
333          * @param mode mode of the USSD message (REQUEST / NOTIFY)
334          * @param ussdMessage USSD message
335          */
336         public void callSessionUssdMessageReceived(ImsCallSession session,
337                 int mode, String ussdMessage) {
338             // no-op
339         }
340
341         /**
342          * Called when session access technology changes
343          *
344          * @param session IMS session object
345          * @param srcAccessTech original access technology
346          * @param targetAccessTech new access technology
347          * @param reasonInfo
348          */
349         public void callSessionHandover(ImsCallSession session,
350                                  int srcAccessTech, int targetAccessTech,
351                                  ImsReasonInfo reasonInfo) {
352             // no-op
353         }
354
355         /**
356          * Called when session access technology change fails
357          *
358          * @param session IMS session object
359          * @param srcAccessTech original access technology
360          * @param targetAccessTech new access technology
361          * @param reasonInfo handover failure reason
362          */
363         public void callSessionHandoverFailed(ImsCallSession session,
364                                        int srcAccessTech, int targetAccessTech,
365                                        ImsReasonInfo reasonInfo) {
366             // no-op
367         }
368     }
369
370     private final IImsCallSession miSession;
371     private boolean mClosed = false;
372     private Listener mListener;
373
374     public ImsCallSession(IImsCallSession iSession) {
375         miSession = iSession;
376
377         if (iSession != null) {
378             try {
379                 iSession.setListener(new IImsCallSessionListenerProxy());
380             } catch (RemoteException e) {
381             }
382         } else {
383             mClosed = true;
384         }
385     }
386
387     public ImsCallSession(IImsCallSession iSession, Listener listener) {
388         this(iSession);
389         setListener(listener);
390     }
391
392     /**
393      * Closes this object. This object is not usable after being closed.
394      */
395     public synchronized void close() {
396         if (mClosed) {
397             return;
398         }
399
400         try {
401             miSession.close();
402             mClosed = true;
403         } catch (RemoteException e) {
404         }
405     }
406
407     /**
408      * Gets the call ID of the session.
409      *
410      * @return the call ID
411      */
412     public String getCallId() {
413         if (mClosed) {
414             return null;
415         }
416
417         try {
418             return miSession.getCallId();
419         } catch (RemoteException e) {
420             return null;
421         }
422     }
423
424     /**
425      * Gets the call profile that this session is associated with
426      *
427      * @return the call profile that this session is associated with
428      */
429     public ImsCallProfile getCallProfile() {
430         if (mClosed) {
431             return null;
432         }
433
434         try {
435             return miSession.getCallProfile();
436         } catch (RemoteException e) {
437             return null;
438         }
439     }
440
441     /**
442      * Gets the local call profile that this session is associated with
443      *
444      * @return the local call profile that this session is associated with
445      */
446     public ImsCallProfile getLocalCallProfile() {
447         if (mClosed) {
448             return null;
449         }
450
451         try {
452             return miSession.getLocalCallProfile();
453         } catch (RemoteException e) {
454             return null;
455         }
456     }
457
458     /**
459      * Gets the video call provider for the session.
460      *
461      * @return The video call provider.
462      */
463     public IImsVideoCallProvider getVideoCallProvider() {
464         if (mClosed) {
465             return null;
466         }
467
468         try {
469             return miSession.getVideoCallProvider();
470         } catch (RemoteException e) {
471             return null;
472         }
473     }
474
475     /**
476      * Gets the value associated with the specified property of this session.
477      *
478      * @return the string value associated with the specified property
479      */
480     public String getProperty(String name) {
481         if (mClosed) {
482             return null;
483         }
484
485         try {
486             return miSession.getProperty(name);
487         } catch (RemoteException e) {
488             return null;
489         }
490     }
491
492     /**
493      * Gets the session state.
494      * The value returned must be one of the states in {@link State}.
495      *
496      * @return the session state
497      */
498     public int getState() {
499         if (mClosed) {
500             return State.INVALID;
501         }
502
503         try {
504             return miSession.getState();
505         } catch (RemoteException e) {
506             return State.INVALID;
507         }
508     }
509
510     /**
511      * Gets the native IMS call session.
512      * @hide
513      */
514     public IImsCallSession getSession() {
515         return miSession;
516     }
517
518     /**
519      * Checks if the session is in call.
520      *
521      * @return true if the session is in call
522      */
523     public boolean isInCall() {
524         if (mClosed) {
525             return false;
526         }
527
528         try {
529             return miSession.isInCall();
530         } catch (RemoteException e) {
531             return false;
532         }
533     }
534
535     /**
536      * Sets the listener to listen to the session events. A {@link ImsCallSession}
537      * can only hold one listener at a time. Subsequent calls to this method
538      * override the previous listener.
539      *
540      * @param listener to listen to the session events of this object
541      */
542     public void setListener(Listener listener) {
543         mListener = listener;
544     }
545
546     /**
547      * Mutes or unmutes the mic for the active call.
548      *
549      * @param muted true if the call is muted, false otherwise
550      */
551     public void setMute(boolean muted) {
552         if (mClosed) {
553             return;
554         }
555
556         try {
557             miSession.setMute(muted);
558         } catch (RemoteException e) {
559         }
560     }
561
562     /**
563      * Initiates an IMS call with the specified target and call profile.
564      * The session listener is called back upon defined session events.
565      * The method is only valid to call when the session state is in
566      * {@link ImsCallSession#State#IDLE}.
567      *
568      * @param callee dialed string to make the call to
569      * @param profile call profile to make the call with the specified service type,
570      *      call type and media information
571      * @see Listener#callSessionStarted, Listener#callSessionStartFailed
572      */
573     public void start(String callee, ImsCallProfile profile) {
574         if (mClosed) {
575             return;
576         }
577
578         try {
579             miSession.start(callee, profile);
580         } catch (RemoteException e) {
581         }
582     }
583
584     /**
585      * Initiates an IMS conference call with the specified target and call profile.
586      * The session listener is called back upon defined session events.
587      * The method is only valid to call when the session state is in
588      * {@link ImsCallSession#State#IDLE}.
589      *
590      * @param participants participant list to initiate an IMS conference call
591      * @param profile call profile to make the call with the specified service type,
592      *      call type and media information
593      * @see Listener#callSessionStarted, Listener#callSessionStartFailed
594      */
595     public void start(String[] participants, ImsCallProfile profile) {
596         if (mClosed) {
597             return;
598         }
599
600         try {
601             miSession.startConference(participants, profile);
602         } catch (RemoteException e) {
603         }
604     }
605
606     /**
607      * Accepts an incoming call or session update.
608      *
609      * @param callType call type specified in {@link ImsCallProfile} to be answered
610      * @param profile stream media profile {@link ImsStreamMediaProfile} to be answered
611      * @see Listener#callSessionStarted
612      */
613     public void accept(int callType, ImsStreamMediaProfile profile) {
614         if (mClosed) {
615             return;
616         }
617
618         try {
619             miSession.accept(callType, profile);
620         } catch (RemoteException e) {
621         }
622     }
623
624     /**
625      * Rejects an incoming call or session update.
626      *
627      * @param reason reason code to reject an incoming call
628      * @see Listener#callSessionStartFailed
629      */
630     public void reject(int reason) {
631         if (mClosed) {
632             return;
633         }
634
635         try {
636             miSession.reject(reason);
637         } catch (RemoteException e) {
638         }
639     }
640
641     /**
642      * Terminates a call.
643      *
644      * @see Listener#callSessionTerminated
645      */
646     public void terminate(int reason) {
647         if (mClosed) {
648             return;
649         }
650
651         try {
652             miSession.terminate(reason);
653         } catch (RemoteException e) {
654         }
655     }
656
657     /**
658      * Puts a call on hold. When it succeeds, {@link Listener#callSessionHeld} is called.
659      *
660      * @param profile stream media profile {@link ImsStreamMediaProfile} to hold the call
661      * @see Listener#callSessionHeld, Listener#callSessionHoldFailed
662      */
663     public void hold(ImsStreamMediaProfile profile) {
664         if (mClosed) {
665             return;
666         }
667
668         try {
669             miSession.hold(profile);
670         } catch (RemoteException e) {
671         }
672     }
673
674     /**
675      * Continues a call that's on hold. When it succeeds,
676      * {@link Listener#callSessionResumed} is called.
677      *
678      * @param profile stream media profile {@link ImsStreamMediaProfile} to resume the call
679      * @see Listener#callSessionResumed, Listener#callSessionResumeFailed
680      */
681     public void resume(ImsStreamMediaProfile profile) {
682         if (mClosed) {
683             return;
684         }
685
686         try {
687             miSession.resume(profile);
688         } catch (RemoteException e) {
689         }
690     }
691
692     /**
693      * Merges the active & hold call. When it succeeds,
694      * {@link Listener#callSessionMergeStarted} is called.
695      *
696      * @see Listener#callSessionMergeStarted , Listener#callSessionMergeFailed
697      */
698     public void merge() {
699         if (mClosed) {
700             return;
701         }
702
703         try {
704             miSession.merge();
705         } catch (RemoteException e) {
706         }
707     }
708
709     /**
710      * Updates the current call's properties (ex. call mode change: video upgrade / downgrade).
711      *
712      * @param callType call type specified in {@link ImsCallProfile} to be updated
713      * @param profile stream media profile {@link ImsStreamMediaProfile} to be updated
714      * @see Listener#callSessionUpdated, Listener#callSessionUpdateFailed
715      */
716     public void update(int callType, ImsStreamMediaProfile profile) {
717         if (mClosed) {
718             return;
719         }
720
721         try {
722             miSession.update(callType, profile);
723         } catch (RemoteException e) {
724         }
725     }
726
727     /**
728      * Extends this call to the conference call with the specified recipients.
729      *
730      * @participants participant list to be invited to the conference call after extending the call
731      * @see Listener#sessionConferenceExtened, Listener#sessionConferenceExtendFailed
732      */
733     public void extendToConference(String[] participants) {
734         if (mClosed) {
735             return;
736         }
737
738         try {
739             miSession.extendToConference(participants);
740         } catch (RemoteException e) {
741         }
742     }
743
744     /**
745      * Requests the conference server to invite an additional participants to the conference.
746      *
747      * @participants participant list to be invited to the conference call
748      * @see Listener#sessionInviteParticipantsRequestDelivered,
749      *      Listener#sessionInviteParticipantsRequestFailed
750      */
751     public void inviteParticipants(String[] participants) {
752         if (mClosed) {
753             return;
754         }
755
756         try {
757             miSession.inviteParticipants(participants);
758         } catch (RemoteException e) {
759         }
760     }
761
762     /**
763      * Requests the conference server to remove the specified participants from the conference.
764      *
765      * @param participants participant list to be removed from the conference call
766      * @see Listener#sessionRemoveParticipantsRequestDelivered,
767      *      Listener#sessionRemoveParticipantsRequestFailed
768      */
769     public void removeParticipants(String[] participants) {
770         if (mClosed) {
771             return;
772         }
773
774         try {
775             miSession.removeParticipants(participants);
776         } catch (RemoteException e) {
777         }
778     }
779
780
781     /**
782      * Sends a DTMF code. According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833</a>,
783      * event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15,
784      * and event flash to 16. Currently, event flash is not supported.
785      *
786      * @param c the DTMF to send. '0' ~ '9', 'A' ~ 'D', '*', '#' are valid inputs.
787      */
788     public void sendDtmf(char c) {
789         if (mClosed) {
790             return;
791         }
792
793         try {
794             miSession.sendDtmf(c, null);
795         } catch (RemoteException e) {
796         }
797     }
798
799     /**
800      * Sends an USSD message.
801      *
802      * @param ussdMessage USSD message to send
803      */
804     public void sendUssd(String ussdMessage) {
805         if (mClosed) {
806             return;
807         }
808
809         try {
810             miSession.sendUssd(ussdMessage);
811         } catch (RemoteException e) {
812         }
813     }
814
815     /**
816      * Determines if the session is multiparty.
817      *
818      * @return {@code True} if the session is multiparty.
819      */
820     public boolean isMultiparty() {
821         if (mClosed) {
822             return false;
823         }
824
825         try {
826             return miSession.isMultiparty();
827         } catch (RemoteException e) {
828             return false;
829         }
830     }
831
832     /**
833      * A listener type for receiving notification on IMS call session events.
834      * When an event is generated for an {@link IImsCallSession},
835      * the application is notified by having one of the methods called on
836      * the {@link IImsCallSessionListener}.
837      */
838     private class IImsCallSessionListenerProxy extends IImsCallSessionListener.Stub {
839         /**
840          * Notifies the result of the basic session operation (setup / terminate).
841          */
842         @Override
843         public void callSessionProgressing(IImsCallSession session,
844                 ImsStreamMediaProfile profile) {
845             if (mListener != null) {
846                 mListener.callSessionProgressing(ImsCallSession.this, profile);
847             }
848         }
849
850         @Override
851         public void callSessionStarted(IImsCallSession session,
852                 ImsCallProfile profile) {
853             if (mListener != null) {
854                 mListener.callSessionStarted(ImsCallSession.this, profile);
855             }
856         }
857
858         @Override
859         public void callSessionStartFailed(IImsCallSession session,
860                 ImsReasonInfo reasonInfo) {
861             if (mListener != null) {
862                 mListener.callSessionStartFailed(ImsCallSession.this, reasonInfo);
863             }
864         }
865
866         @Override
867         public void callSessionTerminated(IImsCallSession session,
868                 ImsReasonInfo reasonInfo) {
869             if (mListener != null) {
870                 mListener.callSessionTerminated(ImsCallSession.this, reasonInfo);
871             }
872         }
873
874         /**
875          * Notifies the result of the call hold/resume operation.
876          */
877         @Override
878         public void callSessionHeld(IImsCallSession session,
879                 ImsCallProfile profile) {
880             if (mListener != null) {
881                 mListener.callSessionHeld(ImsCallSession.this, profile);
882             }
883         }
884
885         @Override
886         public void callSessionHoldFailed(IImsCallSession session,
887                 ImsReasonInfo reasonInfo) {
888             if (mListener != null) {
889                 mListener.callSessionHoldFailed(ImsCallSession.this, reasonInfo);
890             }
891         }
892
893         @Override
894         public void callSessionHoldReceived(IImsCallSession session,
895                 ImsCallProfile profile) {
896             if (mListener != null) {
897                 mListener.callSessionHoldReceived(ImsCallSession.this, profile);
898             }
899         }
900
901         @Override
902         public void callSessionResumed(IImsCallSession session,
903                 ImsCallProfile profile) {
904             if (mListener != null) {
905                 mListener.callSessionResumed(ImsCallSession.this, profile);
906             }
907         }
908
909         @Override
910         public void callSessionResumeFailed(IImsCallSession session,
911                 ImsReasonInfo reasonInfo) {
912             if (mListener != null) {
913                 mListener.callSessionResumeFailed(ImsCallSession.this, reasonInfo);
914             }
915         }
916
917         @Override
918         public void callSessionResumeReceived(IImsCallSession session,
919                 ImsCallProfile profile) {
920             if (mListener != null) {
921                 mListener.callSessionResumeReceived(ImsCallSession.this, profile);
922             }
923         }
924
925         /**
926          * Notifies the start of a call merge operation.
927          *
928          * @param session The call session.
929          * @param newSession The merged call session.
930          * @param profile The call profile.
931          */
932         @Override
933         public void callSessionMergeStarted(IImsCallSession session,
934                 IImsCallSession newSession, ImsCallProfile profile) {
935             if (mListener != null) {
936                 mListener.callSessionMergeStarted(ImsCallSession.this,
937                         new ImsCallSession(newSession), profile);
938             }
939         }
940
941         /**
942          * Notifies the successful completion of a call merge operation.
943          *
944          * @param session The call session.
945          */
946         @Override
947         public void callSessionMergeComplete(IImsCallSession session) {
948             if (mListener != null) {
949                 mListener.callSessionMergeComplete(ImsCallSession.this);
950             }
951         }
952
953         /**
954          * Notifies of a failure to perform a call merge operation.
955          *
956          * @param session The call session.
957          * @param reasonInfo The merge failure reason.
958          */
959         @Override
960         public void callSessionMergeFailed(IImsCallSession session,
961                 ImsReasonInfo reasonInfo) {
962             if (mListener != null) {
963                 mListener.callSessionMergeFailed(ImsCallSession.this, reasonInfo);
964             }
965         }
966
967         /**
968          * Notifies the result of call upgrade / downgrade or any other call updates.
969          */
970         @Override
971         public void callSessionUpdated(IImsCallSession session,
972                 ImsCallProfile profile) {
973             if (mListener != null) {
974                 mListener.callSessionUpdated(ImsCallSession.this, profile);
975             }
976         }
977
978         @Override
979         public void callSessionUpdateFailed(IImsCallSession session,
980                 ImsReasonInfo reasonInfo) {
981             if (mListener != null) {
982                 mListener.callSessionUpdateFailed(ImsCallSession.this, reasonInfo);
983             }
984         }
985
986         @Override
987         public void callSessionUpdateReceived(IImsCallSession session,
988                 ImsCallProfile profile) {
989             if (mListener != null) {
990                 mListener.callSessionUpdateReceived(ImsCallSession.this, profile);
991             }
992         }
993
994         /**
995          * Notifies the result of conference extension.
996          */
997         @Override
998         public void callSessionConferenceExtended(IImsCallSession session,
999                 IImsCallSession newSession, ImsCallProfile profile) {
1000             if (mListener != null) {
1001                 mListener.callSessionConferenceExtended(ImsCallSession.this,
1002                         new ImsCallSession(newSession), profile);
1003             }
1004         }
1005
1006         @Override
1007         public void callSessionConferenceExtendFailed(IImsCallSession session,
1008                 ImsReasonInfo reasonInfo) {
1009             if (mListener != null) {
1010                 mListener.callSessionConferenceExtendFailed(ImsCallSession.this, reasonInfo);
1011             }
1012         }
1013
1014         @Override
1015         public void callSessionConferenceExtendReceived(IImsCallSession session,
1016                 IImsCallSession newSession, ImsCallProfile profile) {
1017             if (mListener != null) {
1018                 mListener.callSessionConferenceExtendReceived(ImsCallSession.this,
1019                         new ImsCallSession(newSession), profile);
1020             }
1021         }
1022
1023         /**
1024          * Notifies the result of the participant invitation / removal to/from
1025          * the conference session.
1026          */
1027         @Override
1028         public void callSessionInviteParticipantsRequestDelivered(IImsCallSession session) {
1029             if (mListener != null) {
1030                 mListener.callSessionInviteParticipantsRequestDelivered(ImsCallSession.this);
1031             }
1032         }
1033
1034         @Override
1035         public void callSessionInviteParticipantsRequestFailed(IImsCallSession session,
1036                 ImsReasonInfo reasonInfo) {
1037             if (mListener != null) {
1038                 mListener.callSessionInviteParticipantsRequestFailed(ImsCallSession.this,
1039                         reasonInfo);
1040             }
1041         }
1042
1043         @Override
1044         public void callSessionRemoveParticipantsRequestDelivered(IImsCallSession session) {
1045             if (mListener != null) {
1046                 mListener.callSessionRemoveParticipantsRequestDelivered(ImsCallSession.this);
1047             }
1048         }
1049
1050         @Override
1051         public void callSessionRemoveParticipantsRequestFailed(IImsCallSession session,
1052                 ImsReasonInfo reasonInfo) {
1053             if (mListener != null) {
1054                 mListener.callSessionRemoveParticipantsRequestFailed(ImsCallSession.this,
1055                         reasonInfo);
1056             }
1057         }
1058
1059         /**
1060          * Notifies the changes of the conference info. in the conference session.
1061          */
1062         @Override
1063         public void callSessionConferenceStateUpdated(IImsCallSession session,
1064                 ImsConferenceState state) {
1065             if (mListener != null) {
1066                 mListener.callSessionConferenceStateUpdated(ImsCallSession.this, state);
1067             }
1068         }
1069
1070         /**
1071          * Notifies the incoming USSD message.
1072          */
1073         @Override
1074         public void callSessionUssdMessageReceived(IImsCallSession session,
1075                 int mode, String ussdMessage) {
1076             if (mListener != null) {
1077                 mListener.callSessionUssdMessageReceived(ImsCallSession.this, mode, ussdMessage);
1078             }
1079         }
1080
1081         /**
1082          * Notifies of handover information for this call
1083          */
1084         @Override
1085         public void callSessionHandover(IImsCallSession session,
1086                                  int srcAccessTech, int targetAccessTech,
1087                                  ImsReasonInfo reasonInfo) {
1088             if (mListener != null) {
1089                 mListener.callSessionHandover(ImsCallSession.this, srcAccessTech,
1090                         targetAccessTech, reasonInfo);
1091             }
1092         }
1093
1094         @Override
1095         public void callSessionHandoverFailed(IImsCallSession session,
1096                                        int srcAccessTech, int targetAccessTech,
1097                                        ImsReasonInfo reasonInfo) {
1098             if (mListener != null) {
1099                 mListener.callSessionHandoverFailed(ImsCallSession.this, srcAccessTech,
1100                         targetAccessTech, reasonInfo);
1101             }
1102         }
1103
1104         /**
1105          * Notifies the TTY mode received from remote party.
1106          */
1107         @Override
1108         public void callSessionTtyModeReceived(IImsCallSession session,
1109                 int mode) {
1110             if (mListener != null) {
1111                 //TODO: UI specific implementation.
1112                 //Vendor UI can listen to this callback to take action on received TTY mode.
1113             }
1114         }
1115     }
1116 }