/*
* Copyright (c) 2013 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 com.android.ims.internal;
import android.os.Message;
import android.os.RemoteException;
import com.android.ims.ImsCallProfile;
import com.android.ims.ImsConferenceState;
import com.android.ims.ImsReasonInfo;
import com.android.ims.ImsStreamMediaProfile;
/**
* Provides the call initiation/termination, and media exchange between two IMS endpoints.
* It directly communicates with IMS service which implements the IMS protocol behavior.
*
* @hide
*/
public class ImsCallSession {
private static final String TAG = "ImsCallSession";
/**
* Defines IMS call session state.
*/
public static class State {
public static final int IDLE = 0;
public static final int INITIATED = 1;
public static final int NEGOTIATING = 2;
public static final int ESTABLISHING = 3;
public static final int ESTABLISHED = 4;
public static final int RENEGOTIATING = 5;
public static final int REESTABLISHING = 6;
public static final int TERMINATING = 7;
public static final int TERMINATED = 8;
public static final int INVALID = (-1);
/**
* Converts the state to string.
*/
public static String toString(int state) {
switch (state) {
case IDLE:
return "IDLE";
case INITIATED:
return "INITIATED";
case NEGOTIATING:
return "NEGOTIATING";
case ESTABLISHING:
return "ESTABLISHING";
case ESTABLISHED:
return "ESTABLISHED";
case RENEGOTIATING:
return "RENEGOTIATING";
case REESTABLISHING:
return "REESTABLISHING";
case TERMINATING:
return "TERMINATING";
case TERMINATED:
return "TERMINATED";
default:
return "UNKNOWN";
}
}
private State() {
}
}
/**
* Listener for events relating to an IMS session, such as when a session is being
* recieved ("on ringing") or a call is outgoing ("on calling").
* <p>Many of these events are also received by {@link ImsCall.Listener}.</p>
*/
public static class Listener {
/**
* Called when a request is sent out to initiate a new session
* and 1xx response is received from the network.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionProgressing(ImsCallSession session,
ImsStreamMediaProfile profile) {
// no-op
}
/**
* Called when the session is established.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionStarted(ImsCallSession session,
ImsCallProfile profile) {
// no-op
}
/**
* Called when the session establishment is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the session establishment failure
*/
public void callSessionStartFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session is terminated.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the session termination
*/
public void callSessionTerminated(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session is in hold.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionHeld(ImsCallSession session,
ImsCallProfile profile) {
}
/**
* Called when the session hold is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the session hold failure
*/
public void callSessionHoldFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session hold is received from the remote user.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionHoldReceived(ImsCallSession session,
ImsCallProfile profile) {
}
/**
* Called when the session resume is done.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionResumed(ImsCallSession session,
ImsCallProfile profile) {
}
/**
* Called when the session resume is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the session resume failure
*/
public void callSessionResumeFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session resume is received from the remote user.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionResumeReceived(ImsCallSession session,
ImsCallProfile profile) {
}
/**
* Called when the session merge has been started. At this point, the {@code newSession}
* represents the session which has been initiated to the IMS conference server for the
* new merged conference.
*
* @param session the session object that carries out the IMS session
* @param newSession the session object that is merged with an active & hold session
*/
public void callSessionMergeStarted(ImsCallSession session,
ImsCallSession newSession, ImsCallProfile profile) {
}
/**
* Called when the session merge is successful and the merged session is active.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionMergeComplete(ImsCallSession session) {
}
/**
* Called when the session merge has failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the call merge failure
*/
public void callSessionMergeFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session is updated (except for hold/unhold).
*
* @param call the call object that carries out the IMS call
*/
public void callSessionUpdated(ImsCallSession session,
ImsCallProfile profile) {
}
/**
* Called when the session update is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the session update failure
*/
public void callSessionUpdateFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the session update is received from the remote user.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionUpdateReceived(ImsCallSession session,
ImsCallProfile profile) {
// no-op
}
/**
* Called when the session is extended to the conference session.
*
* @param session the session object that carries out the IMS session
* @param newSession the session object that is extended to the conference
* from the active session
*/
public void callSessionConferenceExtended(ImsCallSession session,
ImsCallSession newSession, ImsCallProfile profile) {
}
/**
* Called when the conference extension is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the conference extension failure
*/
public void callSessionConferenceExtendFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
}
/**
* Called when the conference extension is received from the remote user.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionConferenceExtendReceived(ImsCallSession session,
ImsCallSession newSession, ImsCallProfile profile) {
// no-op
}
/**
* Called when the invitation request of the participants is delivered to the conference
* server.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionInviteParticipantsRequestDelivered(ImsCallSession session) {
// no-op
}
/**
* Called when the invitation request of the participants is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the conference invitation failure
*/
public void callSessionInviteParticipantsRequestFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
// no-op
}
/**
* Called when the removal request of the participants is delivered to the conference
* server.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionRemoveParticipantsRequestDelivered(ImsCallSession session) {
// no-op
}
/**
* Called when the removal request of the participants is failed.
*
* @param session the session object that carries out the IMS session
* @param reasonInfo detailed reason of the conference removal failure
*/
public void callSessionRemoveParticipantsRequestFailed(ImsCallSession session,
ImsReasonInfo reasonInfo) {
// no-op
}
/**
* Called when the conference state is updated.
*
* @param session the session object that carries out the IMS session
*/
public void callSessionConferenceStateUpdated(ImsCallSession session,
ImsConferenceState state) {
// no-op
}
/**
* Called when the USSD message is received from the network.
*
* @param mode mode of the USSD message (REQUEST / NOTIFY)
* @param ussdMessage USSD message
*/
public void callSessionUssdMessageReceived(ImsCallSession session,
int mode, String ussdMessage) {
// no-op
}
/**
* Called when session access technology changes
*
* @param session IMS session object
* @param srcAccessTech original access technology
* @param targetAccessTech new access technology
* @param reasonInfo
*/
public void callSessionHandover(ImsCallSession session,
int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
// no-op
}
/**
* Called when session access technology change fails
*
* @param session IMS session object
* @param srcAccessTech original access technology
* @param targetAccessTech new access technology
* @param reasonInfo handover failure reason
*/
public void callSessionHandoverFailed(ImsCallSession session,
int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
// no-op
}
/**
* Called when TTY mode of remote party changed
*
* @param session IMS session object
* @param mode TTY mode of remote party
*/
public void callSessionTtyModeReceived(ImsCallSession session,
int mode) {
// no-op
}
}
private final IImsCallSession miSession;
private boolean mClosed = false;
private Listener mListener;
public ImsCallSession(IImsCallSession iSession) {
miSession = iSession;
if (iSession != null) {
try {
iSession.setListener(new IImsCallSessionListenerProxy());
} catch (RemoteException e) {
}
} else {
mClosed = true;
}
}
public ImsCallSession(IImsCallSession iSession, Listener listener) {
this(iSession);
setListener(listener);
}
/**
* Closes this object. This object is not usable after being closed.
*/
public synchronized void close() {
if (mClosed) {
return;
}
try {
miSession.close();
mClosed = true;
} catch (RemoteException e) {
}
}
/**
* Gets the call ID of the session.
*
* @return the call ID
*/
public String getCallId() {
if (mClosed) {
return null;
}
try {
return miSession.getCallId();
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the call profile that this session is associated with
*
* @return the call profile that this session is associated with
*/
public ImsCallProfile getCallProfile() {
if (mClosed) {
return null;
}
try {
return miSession.getCallProfile();
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the local call profile that this session is associated with
*
* @return the local call profile that this session is associated with
*/
public ImsCallProfile getLocalCallProfile() {
if (mClosed) {
return null;
}
try {
return miSession.getLocalCallProfile();
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the remote call profile that this session is associated with
*
* @return the remote call profile that this session is associated with
*/
public ImsCallProfile getRemoteCallProfile() {
if (mClosed) {
return null;
}
try {
return miSession.getRemoteCallProfile();
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the video call provider for the session.
*
* @return The video call provider.
*/
public IImsVideoCallProvider getVideoCallProvider() {
if (mClosed) {
return null;
}
try {
return miSession.getVideoCallProvider();
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the value associated with the specified property of this session.
*
* @return the string value associated with the specified property
*/
public String getProperty(String name) {
if (mClosed) {
return null;
}
try {
return miSession.getProperty(name);
} catch (RemoteException e) {
return null;
}
}
/**
* Gets the session state.
* The value returned must be one of the states in {@link State}.
*
* @return the session state
*/
public int getState() {
if (mClosed) {
return State.INVALID;
}
try {
return miSession.getState();
} catch (RemoteException e) {
return State.INVALID;
}
}
/**
* Determines if the {@link ImsCallSession} is currently alive (e.g. not in a terminated or
* closed state).
*
* @return {@code True} if the session is alive.
*/
public boolean isAlive() {
if (mClosed) {
return false;
}
int state = getState();
switch (state) {
case State.IDLE:
case State.INITIATED:
case State.NEGOTIATING:
case State.ESTABLISHING:
case State.ESTABLISHED:
case State.RENEGOTIATING:
case State.REESTABLISHING:
return true;
default:
return false;
}
}
/**
* Gets the native IMS call session.
* @hide
*/
public IImsCallSession getSession() {
return miSession;
}
/**
* Checks if the session is in call.
*
* @return true if the session is in call
*/
public boolean isInCall() {
if (mClosed) {
return false;
}
try {
return miSession.isInCall();
} catch (RemoteException e) {
return false;
}
}
/**
* Sets the listener to listen to the session events. A {@link ImsCallSession}
* can only hold one listener at a time. Subsequent calls to this method
* override the previous listener.
*
* @param listener to listen to the session events of this object
*/
public void setListener(Listener listener) {
mListener = listener;
}
/**
* Mutes or unmutes the mic for the active call.
*
* @param muted true if the call is muted, false otherwise
*/
public void setMute(boolean muted) {
if (mClosed) {
return;
}
try {
miSession.setMute(muted);
} catch (RemoteException e) {
}
}
/**
* Initiates an IMS call with the specified target and call profile.
* The session listener is called back upon defined session events.
* The method is only valid to call when the session state is in
* {@link ImsCallSession#State#IDLE}.
*
* @param callee dialed string to make the call to
* @param profile call profile to make the call with the specified service type,
* call type and media information
* @see Listener#callSessionStarted, Listener#callSessionStartFailed
*/
public void start(String callee, ImsCallProfile profile) {
if (mClosed) {
return;
}
try {
miSession.start(callee, profile);
} catch (RemoteException e) {
}
}
/**
* Initiates an IMS conference call with the specified target and call profile.
* The session listener is called back upon defined session events.
* The method is only valid to call when the session state is in
* {@link ImsCallSession#State#IDLE}.
*
* @param participants participant list to initiate an IMS conference call
* @param profile call profile to make the call with the specified service type,
* call type and media information
* @see Listener#callSessionStarted, Listener#callSessionStartFailed
*/
public void start(String[] participants, ImsCallProfile profile) {
if (mClosed) {
return;
}
try {
miSession.startConference(participants, profile);
} catch (RemoteException e) {
}
}
/**
* Accepts an incoming call or session update.
*
* @param callType call type specified in {@link ImsCallProfile} to be answered
* @param profile stream media profile {@link ImsStreamMediaProfile} to be answered
* @see Listener#callSessionStarted
*/
public void accept(int callType, ImsStreamMediaProfile profile) {
if (mClosed) {
return;
}
try {
miSession.accept(callType, profile);
} catch (RemoteException e) {
}
}
/**
* Rejects an incoming call or session update.
*
* @param reason reason code to reject an incoming call
* @see Listener#callSessionStartFailed
*/
public void reject(int reason) {
if (mClosed) {
return;
}
try {
miSession.reject(reason);
} catch (RemoteException e) {
}
}
/**
* Terminates a call.
*
* @see Listener#callSessionTerminated
*/
public void terminate(int reason) {
if (mClosed) {
return;
}
try {
miSession.terminate(reason);
} catch (RemoteException e) {
}
}
/**
* Puts a call on hold. When it succeeds, {@link Listener#callSessionHeld} is called.
*
* @param profile stream media profile {@link ImsStreamMediaProfile} to hold the call
* @see Listener#callSessionHeld, Listener#callSessionHoldFailed
*/
public void hold(ImsStreamMediaProfile profile) {
if (mClosed) {
return;
}
try {
miSession.hold(profile);
} catch (RemoteException e) {
}
}
/**
* Continues a call that's on hold. When it succeeds,
* {@link Listener#callSessionResumed} is called.
*
* @param profile stream media profile {@link ImsStreamMediaProfile} to resume the call
* @see Listener#callSessionResumed, Listener#callSessionResumeFailed
*/
public void resume(ImsStreamMediaProfile profile) {
if (mClosed) {
return;
}
try {
miSession.resume(profile);
} catch (RemoteException e) {
}
}
/**
* Merges the active & hold call. When it succeeds,
* {@link Listener#callSessionMergeStarted} is called.
*
* @see Listener#callSessionMergeStarted , Listener#callSessionMergeFailed
*/
public void merge() {
if (mClosed) {
return;
}
try {
miSession.merge();
} catch (RemoteException e) {
}
}
/**
* Updates the current call's properties (ex. call mode change: video upgrade / downgrade).
*
* @param callType call type specified in {@link ImsCallProfile} to be updated
* @param profile stream media profile {@link ImsStreamMediaProfile} to be updated
* @see Listener#callSessionUpdated, Listener#callSessionUpdateFailed
*/
public void update(int callType, ImsStreamMediaProfile profile) {
if (mClosed) {
return;
}
try {
miSession.update(callType, profile);
} catch (RemoteException e) {
}
}
/**
* Extends this call to the conference call with the specified recipients.
*
* @participants participant list to be invited to the conference call after extending the call
* @see Listener#sessionConferenceExtened, Listener#sessionConferenceExtendFailed
*/
public void extendToConference(String[] participants) {
if (mClosed) {
return;
}
try {
miSession.extendToConference(participants);
} catch (RemoteException e) {
}
}
/**
* Requests the conference server to invite an additional participants to the conference.
*
* @participants participant list to be invited to the conference call
* @see Listener#sessionInviteParticipantsRequestDelivered,
* Listener#sessionInviteParticipantsRequestFailed
*/
public void inviteParticipants(String[] participants) {
if (mClosed) {
return;
}
try {
miSession.inviteParticipants(participants);
} catch (RemoteException e) {
}
}
/**
* Requests the conference server to remove the specified participants from the conference.
*
* @param participants participant list to be removed from the conference call
* @see Listener#sessionRemoveParticipantsRequestDelivered,
* Listener#sessionRemoveParticipantsRequestFailed
*/
public void removeParticipants(String[] participants) {
if (mClosed) {
return;
}
try {
miSession.removeParticipants(participants);
} catch (RemoteException e) {
}
}
/**
* Sends a DTMF code. According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833</a>,
* event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15,
* and event flash to 16. Currently, event flash is not supported.
*
* @param c the DTMF to send. '0' ~ '9', 'A' ~ 'D', '*', '#' are valid inputs.
*/
public void sendDtmf(char c, Message result) {
if (mClosed) {
return;
}
try {
miSession.sendDtmf(c, result);
} catch (RemoteException e) {
}
}
/**
* Starts a DTMF code. According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833</a>,
* event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15,
* and event flash to 16. Currently, event flash is not supported.
*
* @param c the DTMF to send. '0' ~ '9', 'A' ~ 'D', '*', '#' are valid inputs.
*/
public void startDtmf(char c) {
if (mClosed) {
return;
}
try {
miSession.startDtmf(c);
} catch (RemoteException e) {
}
}
/**
* Stops a DTMF code.
*/
public void stopDtmf() {
if (mClosed) {
return;
}
try {
miSession.stopDtmf();
} catch (RemoteException e) {
}
}
/**
* Sends an USSD message.
*
* @param ussdMessage USSD message to send
*/
public void sendUssd(String ussdMessage) {
if (mClosed) {
return;
}
try {
miSession.sendUssd(ussdMessage);
} catch (RemoteException e) {
}
}
/**
* Determines if the session is multiparty.
*
* @return {@code True} if the session is multiparty.
*/
public boolean isMultiparty() {
if (mClosed) {
return false;
}
try {
return miSession.isMultiparty();
} catch (RemoteException e) {
return false;
}
}
/**
* A listener type for receiving notification on IMS call session events.
* When an event is generated for an {@link IImsCallSession},
* the application is notified by having one of the methods called on
* the {@link IImsCallSessionListener}.
*/
private class IImsCallSessionListenerProxy extends IImsCallSessionListener.Stub {
/**
* Notifies the result of the basic session operation (setup / terminate).
*/
@Override
public void callSessionProgressing(IImsCallSession session,
ImsStreamMediaProfile profile) {
if (mListener != null) {
mListener.callSessionProgressing(ImsCallSession.this, profile);
}
}
@Override
public void callSessionStarted(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionStarted(ImsCallSession.this, profile);
}
}
@Override
public void callSessionStartFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionStartFailed(ImsCallSession.this, reasonInfo);
}
}
@Override
public void callSessionTerminated(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionTerminated(ImsCallSession.this, reasonInfo);
}
}
/**
* Notifies the result of the call hold/resume operation.
*/
@Override
public void callSessionHeld(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionHeld(ImsCallSession.this, profile);
}
}
@Override
public void callSessionHoldFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionHoldFailed(ImsCallSession.this, reasonInfo);
}
}
@Override
public void callSessionHoldReceived(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionHoldReceived(ImsCallSession.this, profile);
}
}
@Override
public void callSessionResumed(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionResumed(ImsCallSession.this, profile);
}
}
@Override
public void callSessionResumeFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionResumeFailed(ImsCallSession.this, reasonInfo);
}
}
@Override
public void callSessionResumeReceived(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionResumeReceived(ImsCallSession.this, profile);
}
}
/**
* Notifies the start of a call merge operation.
*
* @param session The call session.
* @param newSession The merged call session.
* @param profile The call profile.
*/
@Override
public void callSessionMergeStarted(IImsCallSession session,
IImsCallSession newSession, ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionMergeStarted(ImsCallSession.this,
new ImsCallSession(newSession), profile);
}
}
/**
* Notifies the successful completion of a call merge operation.
*
* @param session The call session.
*/
@Override
public void callSessionMergeComplete(IImsCallSession session) {
if (mListener != null) {
mListener.callSessionMergeComplete(ImsCallSession.this);
}
}
/**
* Notifies of a failure to perform a call merge operation.
*
* @param session The call session.
* @param reasonInfo The merge failure reason.
*/
@Override
public void callSessionMergeFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionMergeFailed(ImsCallSession.this, reasonInfo);
}
}
/**
* Notifies the result of call upgrade / downgrade or any other call updates.
*/
@Override
public void callSessionUpdated(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionUpdated(ImsCallSession.this, profile);
}
}
@Override
public void callSessionUpdateFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionUpdateFailed(ImsCallSession.this, reasonInfo);
}
}
@Override
public void callSessionUpdateReceived(IImsCallSession session,
ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionUpdateReceived(ImsCallSession.this, profile);
}
}
/**
* Notifies the result of conference extension.
*/
@Override
public void callSessionConferenceExtended(IImsCallSession session,
IImsCallSession newSession, ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionConferenceExtended(ImsCallSession.this,
new ImsCallSession(newSession), profile);
}
}
@Override
public void callSessionConferenceExtendFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionConferenceExtendFailed(ImsCallSession.this, reasonInfo);
}
}
@Override
public void callSessionConferenceExtendReceived(IImsCallSession session,
IImsCallSession newSession, ImsCallProfile profile) {
if (mListener != null) {
mListener.callSessionConferenceExtendReceived(ImsCallSession.this,
new ImsCallSession(newSession), profile);
}
}
/**
* Notifies the result of the participant invitation / removal to/from
* the conference session.
*/
@Override
public void callSessionInviteParticipantsRequestDelivered(IImsCallSession session) {
if (mListener != null) {
mListener.callSessionInviteParticipantsRequestDelivered(ImsCallSession.this);
}
}
@Override
public void callSessionInviteParticipantsRequestFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionInviteParticipantsRequestFailed(ImsCallSession.this,
reasonInfo);
}
}
@Override
public void callSessionRemoveParticipantsRequestDelivered(IImsCallSession session) {
if (mListener != null) {
mListener.callSessionRemoveParticipantsRequestDelivered(ImsCallSession.this);
}
}
@Override
public void callSessionRemoveParticipantsRequestFailed(IImsCallSession session,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionRemoveParticipantsRequestFailed(ImsCallSession.this,
reasonInfo);
}
}
/**
* Notifies the changes of the conference info. in the conference session.
*/
@Override
public void callSessionConferenceStateUpdated(IImsCallSession session,
ImsConferenceState state) {
if (mListener != null) {
mListener.callSessionConferenceStateUpdated(ImsCallSession.this, state);
}
}
/**
* Notifies the incoming USSD message.
*/
@Override
public void callSessionUssdMessageReceived(IImsCallSession session,
int mode, String ussdMessage) {
if (mListener != null) {
mListener.callSessionUssdMessageReceived(ImsCallSession.this, mode, ussdMessage);
}
}
/**
* Notifies of handover information for this call
*/
@Override
public void callSessionHandover(IImsCallSession session,
int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionHandover(ImsCallSession.this, srcAccessTech,
targetAccessTech, reasonInfo);
}
}
@Override
public void callSessionHandoverFailed(IImsCallSession session,
int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
mListener.callSessionHandoverFailed(ImsCallSession.this, srcAccessTech,
targetAccessTech, reasonInfo);
}
}
/**
* Notifies the TTY mode received from remote party.
*/
@Override
public void callSessionTtyModeReceived(IImsCallSession session,
int mode) {
if (mListener != null) {
mListener.callSessionTtyModeReceived(ImsCallSession.this, mode);
}
}
}
/**
* Provides a string representation of the {@link ImsCallSession}. Primarily intended for
* use in log statements.
*
* @return String representation of session.
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("[ImsCallSession objId:");
sb.append(System.identityHashCode(this));
sb.append(" state:");
sb.append(State.toString(getState()));
sb.append(" callId:");
sb.append(getCallId());
sb.append("]");
return sb.toString();
}
}
|
