Call handover improvements (141ef580) · Commits · e / os / android_packages_services_Telecomm

src/com/android/server/telecom/Call.java

+38 −41

Original line number	Original line	Diff line number	Diff line
	@@ -456,20 +456,18 @@ public class Call implements CreateConnectionResponse, EventManager.Loggable {
	* When a call handover has been initiated via {@link #requestHandover(PhoneAccountHandle,		* When a call handover has been initiated via {@link #requestHandover(PhoneAccountHandle,
	* int, Bundle)}, contains the call which this call is being handed over to.		* int, Bundle)}, contains the call which this call is being handed over to.
	*/		*/
	private Call mHandoverToCall = null;		private Call mHandoverDestinationCall = null;

	/**		/**
	* When a call handover has been initiated via {@link #requestHandover(PhoneAccountHandle,		* When a call handover has been initiated via {@link #requestHandover(PhoneAccountHandle,
	* int, Bundle)}, contains the call which this call is being handed over from.		* int, Bundle)}, contains the call which this call is being handed over from.
	*/		*/
	private Call mHandoverFromCall = null;		private Call mHandoverSourceCall = null;

	/**		/**
	* When a call handover has been initiated via {@link #requestHandover(PhoneAccountHandle,		* Indicates the current state of this call if it is in the process of a handover.
	* int, Bundle)} and the handover has successfully succeeded, this field is set {@code true} to
	* indicate that the call was handed over from another call.
	*/		*/
	private boolean mIsHandoverSuccessful = false;		private int mHandoverState = HandoverState.HANDOVER_NONE;

	/**		/**
	* Persists the specified parameters and initializes the new instance.		* Persists the specified parameters and initializes the new instance.
	@@ -1091,57 +1089,56 @@ public class Call implements CreateConnectionResponse, EventManager.Loggable {
	setConnectionProperties(getConnectionProperties());		setConnectionProperties(getConnectionProperties());
	}		}

	/**		public void markFinishedHandoverStateAndCleanup(int handoverState) {
	* Marks a handover as failed.		if (mHandoverSourceCall != null) {
	*/		mHandoverSourceCall.setHandoverState(handoverState);
	public void markHandoverFailed() {		} else if (mHandoverDestinationCall != null) {
	markHandoverResult(false /* isComplete */);		mHandoverDestinationCall.setHandoverState(handoverState);
	}		}
			setHandoverState(handoverState);
	/**		maybeCleanupHandover();
	* Marks a handover as being successful.
	*/
	public void markHandoverSuccess() {
	markHandoverResult(true /* isComplete */);
	}		}

	private void markHandoverResult(boolean isHandoverSuccessful) {		public void maybeCleanupHandover() {
	if (mHandoverFromCall != null) {		if (mHandoverSourceCall != null) {
	mHandoverFromCall.mIsHandoverSuccessful = isHandoverSuccessful;		mHandoverSourceCall.setHandoverSourceCall(null);
	mHandoverFromCall.setHandoverFromCall(null);		mHandoverSourceCall.setHandoverDestinationCall(null);
	mHandoverFromCall.setHandoverToCall(null);		mHandoverSourceCall = null;
	mHandoverFromCall = null;		} else if (mHandoverDestinationCall != null) {
	} else if (mHandoverToCall != null) {		mHandoverDestinationCall.setHandoverSourceCall(null);
	mHandoverToCall.mIsHandoverSuccessful = isHandoverSuccessful;		mHandoverDestinationCall.setHandoverDestinationCall(null);
	mHandoverToCall.setHandoverFromCall(null);		mHandoverDestinationCall = null;
	mHandoverToCall.setHandoverToCall(null);
	mHandoverToCall = null;
	}		}
	mIsHandoverSuccessful = isHandoverSuccessful;
	}		}

	public boolean isHandoverInProgress() {		public boolean isHandoverInProgress() {
	return mHandoverFromCall != null \|\| mHandoverToCall != null;		return mHandoverSourceCall != null \|\| mHandoverDestinationCall != null;
			}

			public Call getHandoverDestinationCall() {
			return mHandoverDestinationCall;
	}		}

	public Call getHandoverToCall() {		public void setHandoverDestinationCall(Call call) {
	return mHandoverToCall;		mHandoverDestinationCall = call;
	}		}

	public void setHandoverToCall(Call call) {		public Call getHandoverSourceCall() {
	mHandoverToCall = call;		return mHandoverSourceCall;
	}		}

	public Call getHandoverFromCall() {		public void setHandoverSourceCall(Call call) {
	return mHandoverFromCall;		mHandoverSourceCall = call;
	}		}

	public void setHandoverFromCall(Call call) {		public void setHandoverState(int handoverState) {
	mHandoverFromCall = call;		Log.d(this, "setHandoverState: callId=%s, handoverState=%s", getId(),
			HandoverState.stateToString(handoverState));
			mHandoverState = handoverState;
	}		}

	public boolean isHandoverSuccessful() {		public int getHandoverState() {
	return mIsHandoverSuccessful;		return mHandoverState;
	}		}

	private void configureIsWorkCall() {		private void configureIsWorkCall() {

src/com/android/server/telecom/CallLogManager.java

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -153,7 +153,8 @@ public final class CallLogManager extends CallsManagerListenerBase {
	!isCallCanceled) &&		!isCallCanceled) &&
	!call.isExternalCall() &&		!call.isExternalCall() &&
	(!call.isSelfManaged() \|\|		(!call.isSelfManaged() \|\|
	call.isLoggedSelfManaged())) {		call.isLoggedSelfManaged() &&
			call.getHandoverState() != HandoverState.HANDOVER_FAILED)) {
	int type;		int type;
	if (!call.isIncoming()) {		if (!call.isIncoming()) {
	type = Calls.OUTGOING_TYPE;		type = Calls.OUTGOING_TYPE;

src/com/android/server/telecom/CallsManager.java

+117 −67

Original line number	Original line	Diff line number	Diff line
	@@ -884,7 +884,6 @@ public class CallsManager extends Call.ListenerBase
	getForegroundCall().getAnalytics().setCallIsInterrupted(true);		getForegroundCall().getAnalytics().setCallIsInterrupted(true);
	call.getAnalytics().setCallIsAdditional(true);		call.getAnalytics().setCallIsAdditional(true);
	}		}

	setIntentExtrasAndStartTime(call, extras);		setIntentExtrasAndStartTime(call, extras);
	// TODO: Move this to be a part of addCall()		// TODO: Move this to be a part of addCall()
	call.addListener(this);		call.addListener(this);
	@@ -912,8 +911,10 @@ public class CallsManager extends Call.ListenerBase

	if (isHandoverAllowed) {		if (isHandoverAllowed) {
	// Link the calls so we know we're handing over.		// Link the calls so we know we're handing over.
	fromCall.setHandoverToCall(call);		fromCall.setHandoverDestinationCall(call);
	call.setHandoverFromCall(fromCall);		call.setHandoverSourceCall(fromCall);
			call.setHandoverState(HandoverState.HANDOVER_TO_STARTED);
			fromCall.setHandoverState(HandoverState.HANDOVER_FROM_STARTED);
	Log.addEvent(fromCall, LogUtils.Events.START_HANDOVER,		Log.addEvent(fromCall, LogUtils.Events.START_HANDOVER,
	"handOverFrom=%s, handOverTo=%s", fromCall.getId(), call.getId());		"handOverFrom=%s, handOverTo=%s", fromCall.getId(), call.getId());
	Log.addEvent(call, LogUtils.Events.START_HANDOVER,		Log.addEvent(call, LogUtils.Events.START_HANDOVER,
	@@ -921,9 +922,9 @@ public class CallsManager extends Call.ListenerBase
	}		}
	} else {		} else {
	Log.w(this, "processIncomingCallIntent: To account doesn't support handover.");		Log.w(this, "processIncomingCallIntent: To account doesn't support handover.");
	isHandoverAllowed = false;
	}		}
	}		}

	if (!isHandoverAllowed \|\| (call.isSelfManaged() && !isIncomingCallPermitted(call,		if (!isHandoverAllowed \|\| (call.isSelfManaged() && !isIncomingCallPermitted(call,
	call.getTargetPhoneAccount()))) {		call.getTargetPhoneAccount()))) {
	notifyCreateConnectionFailed(phoneAccountHandle, call);		notifyCreateConnectionFailed(phoneAccountHandle, call);
	@@ -1721,8 +1722,7 @@ public class CallsManager extends Call.ListenerBase
	* Removes an existing disconnected call, and notifies the in-call app.		* Removes an existing disconnected call, and notifies the in-call app.
	*/		*/
	void markCallAsRemoved(Call call) {		void markCallAsRemoved(Call call) {
	call.markHandoverFailed();		call.maybeCleanupHandover();

	removeCall(call);		removeCall(call);
	Call foregroundCall = mCallAudioManager.getPossiblyHeldForegroundCall();		Call foregroundCall = mCallAudioManager.getPossiblyHeldForegroundCall();
	if (mLocallyDisconnectingCalls.contains(call)) {		if (mLocallyDisconnectingCalls.contains(call)) {
	@@ -2177,46 +2177,71 @@ public class CallsManager extends Call.ListenerBase

	Trace.beginSection("onCallStateChanged");		Trace.beginSection("onCallStateChanged");

	// If this call became active because it is being handed over from another Call, the		maybeHandleHandover(call, newState);
	// call which was being handed over from can be disconnected at this point.
	if (call.getHandoverFromCall() != null) {		// Only broadcast state change for calls that are being tracked.
			if (mCalls.contains(call)) {
			updateCanAddCall();
			for (CallsManagerListener listener : mListeners) {
			if (LogUtils.SYSTRACE_DEBUG) {
			Trace.beginSection(listener.getClass().toString() + " onCallStateChanged");
			}
			listener.onCallStateChanged(call, oldState, newState);
			if (LogUtils.SYSTRACE_DEBUG) {
			Trace.endSection();
			}
			}
			}
			Trace.endSection();
			}
			}

			/**
			* Identifies call state transitions for a call which trigger handover events.
			* - If this call has a handover to it which just started and this call goes active, treat
			* this as if the user accepted the handover.
			* - If this call has a handover to it which just started and this call is disconnected, treat
			* this as if the user rejected the handover.
			* - If this call has a handover from it which just started and this call is disconnected, do
			* nothing as the call prematurely disconnected before the user accepted the handover.
			* - If this call has a handover from it which was already accepted by the user and this call is
			* disconnected, mark the handover as complete.
			*
			* @param call A call whose state is changing.
			* @param newState The new state of the call.
			*/
			private void maybeHandleHandover(Call call, int newState) {
			if (call.getHandoverSourceCall() != null) {
			// We are handing over another call to this one.
			if (call.getHandoverState() == HandoverState.HANDOVER_TO_STARTED) {
			// A handover to this call has just been initiated.
	if (newState == CallState.ACTIVE) {		if (newState == CallState.ACTIVE) {
	Call handoverFrom = call.getHandoverFromCall();		// This call went active, so the user has accepted the handover.
	Log.addEvent(call, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",		Log.i(this, "setCallState: handover to accepted");
	handoverFrom.getId(), call.getId());		acceptHandoverTo(call);
	Log.addEvent(handoverFrom, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",
	handoverFrom.getId(), call.getId());
	handoverFrom.onConnectionEvent(
	android.telecom.Connection.EVENT_HANDOVER_COMPLETE, null);
	markCallAsDisconnected(handoverFrom,
	new DisconnectCause(DisconnectCause.LOCAL));
	call.markHandoverSuccess();
	markCallAsRemoved(handoverFrom);
	call.sendCallEvent(android.telecom.Call.EVENT_HANDOVER_COMPLETE, null);
	} else if (newState == CallState.DISCONNECTED) {		} else if (newState == CallState.DISCONNECTED) {
	Call handoverFrom = call.getHandoverFromCall();		// The call was disconnected, so the user has rejected the handover.
	Log.i(this, "Call %s failed to handover from %s.",		Log.i(this, "setCallState: handover to rejected");
	call.getId(), handoverFrom.getId());		rejectHandoverTo(call);
	Log.addEvent(handoverFrom, LogUtils.Events.HANDOVER_FAILED, "from=%s, to=%s",
	call.getId(), handoverFrom.getId());
	// Inform the "from" Call (ie the source call) that the handover from it has
	// failed; this allows the InCallService to be notified that a handover it
	// initiated failed.
	handoverFrom.onConnectionEvent(Connection.EVENT_HANDOVER_FAILED, null);
	// Inform the "to" ConnectionService that handover to it has failed. This
	// allows the ConnectionService the call was being handed over
	if (call.getConnectionService() != null) {
	// Only attempt if the call has a bound ConnectionService if handover failed
	// early on in the handover process, the CS will be unbound and we won't be
	// able to send the call event.
	call.sendCallEvent(android.telecom.Call.EVENT_HANDOVER_FAILED, null);
	}		}
	call.markHandoverFailed();
	}		}
	// If this call was disconnected because it was handed over TO another call, report the		// If this call was disconnected because it was handed over TO another call, report the
	// handover as complete.		// handover as complete.
	} else if (call.getHandoverToCall() != null && newState == CallState.DISCONNECTED) {		} else if (call.getHandoverDestinationCall() != null
	Call handoverTo = call.getHandoverToCall();		&& newState == CallState.DISCONNECTED) {
			int handoverState = call.getHandoverState();
			if (handoverState == HandoverState.HANDOVER_FROM_STARTED) {
			// Disconnect before handover was accepted.
			Log.i(this, "setCallState: disconnect before handover accepted");
			} else if (handoverState == HandoverState.HANDOVER_ACCEPTED) {
			Log.i(this, "setCallState: handover from complete");
			completeHandoverFrom(call);
			}
			}
			}

			private void completeHandoverFrom(Call call) {
			Call handoverTo = call.getHandoverDestinationCall();
	Log.addEvent(handoverTo, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",		Log.addEvent(handoverTo, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",
	call.getId(), handoverTo.getId());		call.getId(), handoverTo.getId());
	Log.addEvent(call, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",		Log.addEvent(call, LogUtils.Events.HANDOVER_COMPLETE, "from=%s, to=%s",
	@@ -2229,24 +2254,45 @@ public class CallsManager extends Call.ListenerBase
	// Inform the "to" ConnectionService that handover to it has completed.		// Inform the "to" ConnectionService that handover to it has completed.
	handoverTo.sendCallEvent(android.telecom.Call.EVENT_HANDOVER_COMPLETE, null);		handoverTo.sendCallEvent(android.telecom.Call.EVENT_HANDOVER_COMPLETE, null);
	answerCall(handoverTo, handoverTo.getVideoState());		answerCall(handoverTo, handoverTo.getVideoState());
	call.markHandoverSuccess();		call.markFinishedHandoverStateAndCleanup(HandoverState.HANDOVER_COMPLETE);
	}		}

	// Only broadcast state change for calls that are being tracked.		private void rejectHandoverTo(Call handoverTo) {
	if (mCalls.contains(call)) {		Call handoverFrom = handoverTo.getHandoverSourceCall();
	updateCanAddCall();		Log.i(this, "rejectHandoverTo: from=%s, to=%s", handoverFrom.getId(), handoverTo.getId());
	for (CallsManagerListener listener : mListeners) {		Log.addEvent(handoverFrom, LogUtils.Events.HANDOVER_FAILED, "from=%s, to=%s",
	if (LogUtils.SYSTRACE_DEBUG) {		handoverTo.getId(), handoverFrom.getId());
	Trace.beginSection(listener.getClass().toString() + " onCallStateChanged");		Log.addEvent(handoverTo, LogUtils.Events.HANDOVER_FAILED, "from=%s, to=%s",
	}		handoverTo.getId(), handoverFrom.getId());
	listener.onCallStateChanged(call, oldState, newState);
	if (LogUtils.SYSTRACE_DEBUG) {		// Inform the "from" Call (ie the source call) that the handover from it has
	Trace.endSection();		// failed; this allows the InCallService to be notified that a handover it
	}		// initiated failed.
	}		handoverFrom.onConnectionEvent(Connection.EVENT_HANDOVER_FAILED, null);
			// Inform the "to" ConnectionService that handover to it has failed. This
			// allows the ConnectionService the call was being handed over
			if (handoverTo.getConnectionService() != null) {
			// Only attempt if the call has a bound ConnectionService if handover failed
			// early on in the handover process, the CS will be unbound and we won't be
			// able to send the call event.
			handoverTo.sendCallEvent(android.telecom.Call.EVENT_HANDOVER_FAILED, null);
	}		}
	Trace.endSection();		handoverTo.markFinishedHandoverStateAndCleanup(HandoverState.HANDOVER_FAILED);
	}		}

			private void acceptHandoverTo(Call handoverTo) {
			Call handoverFrom = handoverTo.getHandoverSourceCall();
			Log.i(this, "acceptHandoverTo: from=%s, to=%s", handoverFrom.getId(), handoverTo.getId());
			handoverTo.setHandoverState(HandoverState.HANDOVER_ACCEPTED);
			handoverFrom.setHandoverState(HandoverState.HANDOVER_ACCEPTED);

			Log.addEvent(handoverTo, LogUtils.Events.ACCEPT_HANDOVER, "from=%s, to=%s",
			handoverFrom.getId(), handoverTo.getId());
			Log.addEvent(handoverFrom, LogUtils.Events.ACCEPT_HANDOVER, "from=%s, to=%s",
			handoverFrom.getId(), handoverTo.getId());

			// Disconnect the call we handed over from.
			disconnectCall(handoverFrom);
	}		}

	private void updateCanAddCall() {		private void updateCanAddCall() {
	@@ -2455,7 +2501,7 @@ public class CallsManager extends Call.ListenerBase
	public boolean shouldShowSystemIncomingCallUi(Call incomingCall) {		public boolean shouldShowSystemIncomingCallUi(Call incomingCall) {
	return incomingCall.isIncoming() && incomingCall.isSelfManaged() &&		return incomingCall.isIncoming() && incomingCall.isSelfManaged() &&
	hasCallsForOtherPhoneAccount(incomingCall.getTargetPhoneAccount()) &&		hasCallsForOtherPhoneAccount(incomingCall.getTargetPhoneAccount()) &&
	incomingCall.getHandoverFromCall() == null;		incomingCall.getHandoverSourceCall() == null;
	}		}

	private boolean makeRoomForOutgoingCall(Call call, boolean isEmergency) {		private boolean makeRoomForOutgoingCall(Call call, boolean isEmergency) {
	@@ -2785,7 +2831,7 @@ public class CallsManager extends Call.ListenerBase
	// Only permit outgoing calls if there is no ongoing emergency calls and all other calls		// Only permit outgoing calls if there is no ongoing emergency calls and all other calls
	// are associated with the current PhoneAccountHandle.		// are associated with the current PhoneAccountHandle.
	return !hasEmergencyCall() && (		return !hasEmergencyCall() && (
	excludeCall.getHandoverFromCall() != null \|\|		excludeCall.getHandoverSourceCall() != null \|\|
	(!hasMaximumSelfManagedCalls(excludeCall, phoneAccountHandle) &&		(!hasMaximumSelfManagedCalls(excludeCall, phoneAccountHandle) &&
	!hasCallsForOtherPhoneAccount(phoneAccountHandle) &&		!hasCallsForOtherPhoneAccount(phoneAccountHandle) &&
	!hasManagedCalls()));		!hasManagedCalls()));
	@@ -3046,6 +3092,8 @@ public class CallsManager extends Call.ListenerBase

	Bundle extras = new Bundle();		Bundle extras = new Bundle();
	extras.putBoolean(TelecomManager.EXTRA_IS_HANDOVER, true);		extras.putBoolean(TelecomManager.EXTRA_IS_HANDOVER, true);
			extras.putParcelable(TelecomManager.EXTRA_HANDOVER_FROM_PHONE_ACCOUNT,
			handoverFromCall.getTargetPhoneAccount());
	extras.putInt(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, videoState);		extras.putInt(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE, videoState);
	if (initiatingExtras != null) {		if (initiatingExtras != null) {
	extras.putAll(initiatingExtras);		extras.putAll(initiatingExtras);
	@@ -3056,8 +3104,10 @@ public class CallsManager extends Call.ListenerBase
	extras, getCurrentUserHandle(), null /* originalIntent */);		extras, getCurrentUserHandle(), null /* originalIntent */);
	Log.addEvent(handoverFromCall, LogUtils.Events.START_HANDOVER,		Log.addEvent(handoverFromCall, LogUtils.Events.START_HANDOVER,
	"handOverFrom=%s, handOverTo=%s", handoverFromCall.getId(), handoverToCall.getId());		"handOverFrom=%s, handOverTo=%s", handoverFromCall.getId(), handoverToCall.getId());
	handoverFromCall.setHandoverToCall(handoverToCall);		handoverFromCall.setHandoverDestinationCall(handoverToCall);
	handoverToCall.setHandoverFromCall(handoverFromCall);		handoverFromCall.setHandoverState(HandoverState.HANDOVER_FROM_STARTED);
			handoverToCall.setHandoverState(HandoverState.HANDOVER_TO_STARTED);
			handoverToCall.setHandoverSourceCall(handoverFromCall);
	handoverToCall.setNewOutgoingCallIntentBroadcastIsDone();		handoverToCall.setNewOutgoingCallIntentBroadcastIsDone();
	placeOutgoingCall(handoverToCall, handoverToCall.getHandle(), null /* gatewayInfo */,		placeOutgoingCall(handoverToCall, handoverToCall.getHandle(), null /* gatewayInfo */,
	false /* startwithSpeaker */,		false /* startwithSpeaker */,
	@@ -3109,8 +3159,8 @@ public class CallsManager extends Call.ListenerBase
	* @return {@code true} if a call in the process of handover exists, {@code false} otherwise.		* @return {@code true} if a call in the process of handover exists, {@code false} otherwise.
	*/		*/
	private boolean isHandoverInProgress() {		private boolean isHandoverInProgress() {
	return mCalls.stream().filter(c -> c.getHandoverFromCall() != null \|\|		return mCalls.stream().filter(c -> c.getHandoverSourceCall() != null \|\|
	c.getHandoverToCall() != null).count() > 0;		c.getHandoverDestinationCall() != null).count() > 0;
	}		}

	private void broadcastUnregisterIntent(PhoneAccountHandle accountHandle) {		private void broadcastUnregisterIntent(PhoneAccountHandle accountHandle) {

src/com/android/server/telecom/ConnectionServiceWrapper.java

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -930,8 +930,10 @@ public class ConnectionServiceWrapper extends ServiceBinder {

	// Call is incoming and added because we're handing over from another; tell CS		// Call is incoming and added because we're handing over from another; tell CS
	// that its expected to handover.		// that its expected to handover.
	if (call.isIncoming() && call.getHandoverFromCall() != null) {		if (call.isIncoming() && call.getHandoverSourceCall() != null) {
	extras.putBoolean(TelecomManager.EXTRA_IS_HANDOVER, true);		extras.putBoolean(TelecomManager.EXTRA_IS_HANDOVER, true);
			extras.putParcelable(TelecomManager.EXTRA_HANDOVER_FROM_PHONE_ACCOUNT,
			call.getHandoverSourceCall().getTargetPhoneAccount());
	}		}

	Log.addEvent(call, LogUtils.Events.START_CONNECTION,		Log.addEvent(call, LogUtils.Events.START_CONNECTION,

src/com/android/server/telecom/HandoverState.java

0 → 100644

+58 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2017 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.server.telecom;

			/**
			* Defines handover state constants for calls undergoing handover.
			*/
			public class HandoverState {
			private HandoverState() {
			// Can't instantiate.
			}

			public static final int HANDOVER_NONE = 1;
			public static final int HANDOVER_TO_STARTED = 2;
			public static final int HANDOVER_FROM_STARTED = 3;
			public static final int HANDOVER_ACCEPTED = 4;
			public static final int HANDOVER_COMPLETE = 5;
			public static final int HANDOVER_FAILED = 6;

			private static final String HANDOVER_NONE_STR = "NONE";
			private static final String HANDOVER_TO_STARTED_STR = "HANDOVER_TO_STARTED";
			private static final String HANDOVER_FROM_STARTED_STR = "HANDOVER_FROM_STARTED";
			private static final String HANDOVER_ACCEPTED_STR = "HANDOVER_ACCEPTED";
			private static final String HANDOVER_COMPLETE_STR = "HANDOVER_COMPLETE";
			private static final String HANDOVER_FAILED_STR = "HANDOVER_FAILED";

			public static String stateToString(int state) {
			switch (state) {
			case HANDOVER_NONE:
			return HANDOVER_NONE_STR;
			case HANDOVER_TO_STARTED:
			return HANDOVER_TO_STARTED_STR;
			case HANDOVER_FROM_STARTED:
			return HANDOVER_FROM_STARTED_STR;
			case HANDOVER_ACCEPTED:
			return HANDOVER_ACCEPTED_STR;
			case HANDOVER_COMPLETE:
			return HANDOVER_COMPLETE_STR;
			case HANDOVER_FAILED:
			return HANDOVER_FAILED_STR;
			}
			return "";
			}
			}