Revert "Revert "Move SIP telephony related codes to framework."" (ccd0b695) · Commits · e / os / android_frameworks_base

telephony/java/com/android/internal/telephony/SipPhoneNotifier.java

0 → 100644

+236 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.internal.telephony;

		import android.os.Bundle;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.telephony.TelephonyManager;
		import android.util.Log;

		import com.android.internal.telephony.ITelephonyRegistry;

		/**
		* Temporary. Will be removed after integrating with CallManager.
		* 100% copy from DefaultPhoneNotifier. Cannot access its package level
		* constructor; thus the copy.
		* @hide
		*/
		public class SipPhoneNotifier implements PhoneNotifier {

		static final String LOG_TAG = "GSM";
		private static final boolean DBG = true;
		private ITelephonyRegistry mRegistry;

		public SipPhoneNotifier() {
		mRegistry = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService(
		"telephony.registry"));
		}

		public void notifyPhoneState(Phone sender) {
		Call ringingCall = sender.getRingingCall();
		String incomingNumber = "";
		if (ringingCall != null && ringingCall.getEarliestConnection() != null){
		incomingNumber = ringingCall.getEarliestConnection().getAddress();
		}
		try {
		mRegistry.notifyCallState(convertCallState(sender.getState()), incomingNumber);
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyServiceState(Phone sender) {
		try {
		mRegistry.notifyServiceState(sender.getServiceState());
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifySignalStrength(Phone sender) {
		try {
		mRegistry.notifySignalStrength(sender.getSignalStrength());
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyMessageWaitingChanged(Phone sender) {
		try {
		mRegistry.notifyMessageWaitingChanged(sender.getMessageWaitingIndicator());
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyCallForwardingChanged(Phone sender) {
		try {
		mRegistry.notifyCallForwardingChanged(sender.getCallForwardingIndicator());
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyDataActivity(Phone sender) {
		try {
		mRegistry.notifyDataActivity(convertDataActivityState(sender.getDataActivityState()));
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyDataConnection(Phone sender, String reason) {
		TelephonyManager telephony = TelephonyManager.getDefault();
		try {
		mRegistry.notifyDataConnection(
		convertDataState(sender.getDataConnectionState()),
		sender.isDataConnectivityPossible(), reason,
		sender.getActiveApn(),
		sender.getActiveApnTypes(),
		sender.getInterfaceName(null),
		((telephony!=null) ? telephony.getNetworkType() :
		TelephonyManager.NETWORK_TYPE_UNKNOWN));
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyDataConnectionFailed(Phone sender, String reason) {
		try {
		mRegistry.notifyDataConnectionFailed(reason);
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		public void notifyCellLocation(Phone sender) {
		Bundle data = new Bundle();
		sender.getCellLocation().fillInNotifierBundle(data);
		try {
		mRegistry.notifyCellLocation(data);
		} catch (RemoteException ex) {
		// system process is dead
		}
		}

		private void log(String s) {
		Log.d(LOG_TAG, "[PhoneNotifier] " + s);
		}

		/**
		* Convert the {@link State} enum into the TelephonyManager.CALL_STATE_* constants
		* for the public API.
		*/
		public static int convertCallState(Phone.State state) {
		switch (state) {
		case RINGING:
		return TelephonyManager.CALL_STATE_RINGING;
		case OFFHOOK:
		return TelephonyManager.CALL_STATE_OFFHOOK;
		default:
		return TelephonyManager.CALL_STATE_IDLE;
		}
		}

		/**
		* Convert the TelephonyManager.CALL_STATE_* constants into the {@link State} enum
		* for the public API.
		*/
		public static Phone.State convertCallState(int state) {
		switch (state) {
		case TelephonyManager.CALL_STATE_RINGING:
		return Phone.State.RINGING;
		case TelephonyManager.CALL_STATE_OFFHOOK:
		return Phone.State.OFFHOOK;
		default:
		return Phone.State.IDLE;
		}
		}

		/**
		* Convert the {@link DataState} enum into the TelephonyManager.DATA_* constants
		* for the public API.
		*/
		public static int convertDataState(Phone.DataState state) {
		switch (state) {
		case CONNECTING:
		return TelephonyManager.DATA_CONNECTING;
		case CONNECTED:
		return TelephonyManager.DATA_CONNECTED;
		case SUSPENDED:
		return TelephonyManager.DATA_SUSPENDED;
		default:
		return TelephonyManager.DATA_DISCONNECTED;
		}
		}

		/**
		* Convert the TelephonyManager.DATA_* constants into {@link DataState} enum
		* for the public API.
		*/
		public static Phone.DataState convertDataState(int state) {
		switch (state) {
		case TelephonyManager.DATA_CONNECTING:
		return Phone.DataState.CONNECTING;
		case TelephonyManager.DATA_CONNECTED:
		return Phone.DataState.CONNECTED;
		case TelephonyManager.DATA_SUSPENDED:
		return Phone.DataState.SUSPENDED;
		default:
		return Phone.DataState.DISCONNECTED;
		}
		}

		/**
		* Convert the {@link DataState} enum into the TelephonyManager.DATA_* constants
		* for the public API.
		*/
		public static int convertDataActivityState(Phone.DataActivityState state) {
		switch (state) {
		case DATAIN:
		return TelephonyManager.DATA_ACTIVITY_IN;
		case DATAOUT:
		return TelephonyManager.DATA_ACTIVITY_OUT;
		case DATAINANDOUT:
		return TelephonyManager.DATA_ACTIVITY_INOUT;
		case DORMANT:
		return TelephonyManager.DATA_ACTIVITY_DORMANT;
		default:
		return TelephonyManager.DATA_ACTIVITY_NONE;
		}
		}

		/**
		* Convert the TelephonyManager.DATA_* constants into the {@link DataState} enum
		* for the public API.
		*/
		public static Phone.DataActivityState convertDataActivityState(int state) {
		switch (state) {
		case TelephonyManager.DATA_ACTIVITY_IN:
		return Phone.DataActivityState.DATAIN;
		case TelephonyManager.DATA_ACTIVITY_OUT:
		return Phone.DataActivityState.DATAOUT;
		case TelephonyManager.DATA_ACTIVITY_INOUT:
		return Phone.DataActivityState.DATAINANDOUT;
		case TelephonyManager.DATA_ACTIVITY_DORMANT:
		return Phone.DataActivityState.DORMANT;
		default:
		return Phone.DataActivityState.NONE;
		}
		}
		}

telephony/java/com/android/internal/telephony/sip/CallFailCause.java

0 → 100644

+50 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.internal.telephony.sip;

		/**
		* Call fail causes from TS 24.008 .
		* These are mostly the cause codes we need to distinguish for the UI.
		* See 22.001 Annex F.4 for mapping of cause codes to local tones.
		*
		* {@hide}
		*
		*/
		public interface CallFailCause {
		static final int NORMAL_CLEARING = 16;
		// Busy Tone
		static final int USER_BUSY = 17;

		// No Tone
		static final int NUMBER_CHANGED = 22;
		static final int STATUS_ENQUIRY = 30;
		static final int NORMAL_UNSPECIFIED = 31;

		// Congestion Tone
		static final int NO_CIRCUIT_AVAIL = 34;
		static final int TEMPORARY_FAILURE = 41;
		static final int SWITCHING_CONGESTION = 42;
		static final int CHANNEL_NOT_AVAIL = 44;
		static final int QOS_NOT_AVAIL = 49;
		static final int BEARER_NOT_AVAIL = 58;

		// others
		static final int ACM_LIMIT_EXCEEDED = 68;
		static final int CALL_BARRED = 240;
		static final int FDN_BLOCKED = 241;
		static final int ERROR_UNSPECIFIED = 0xffff;
		}

telephony/java/com/android/internal/telephony/sip/CallProxy.java

0 → 100644

+114 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.internal.telephony.sip;

		import com.android.internal.telephony.*;
		import java.util.List;

		// TODO: remove this class after integrating with CallManager
		class CallProxy extends Call {
		private Call mTarget;

		void setTarget(Call target) {
		mTarget = target;
		}

		@Override
		public List<Connection> getConnections() {
		return mTarget.getConnections();
		}

		@Override
		public Phone getPhone() {
		return mTarget.getPhone();
		}

		@Override
		public boolean isMultiparty() {
		return mTarget.isMultiparty();
		}

		@Override
		public void hangup() throws CallStateException {
		mTarget.hangup();
		}

		@Override
		public boolean hasConnection(Connection c) {
		return mTarget.hasConnection(c);
		}

		@Override
		public boolean hasConnections() {
		return mTarget.hasConnections();
		}

		@Override
		public State getState() {
		return mTarget.getState();
		}

		@Override
		public boolean isIdle() {
		return mTarget.isIdle();
		}

		@Override
		public Connection getEarliestConnection() {
		return mTarget.getEarliestConnection();
		}

		@Override
		public long getEarliestCreateTime() {
		return mTarget.getEarliestCreateTime();
		}

		@Override
		public long getEarliestConnectTime() {
		return mTarget.getEarliestConnectTime();
		}

		@Override
		public boolean isDialingOrAlerting() {
		return mTarget.isDialingOrAlerting();
		}

		@Override
		public boolean isRinging() {
		return mTarget.isRinging();
		}

		@Override
		public Connection getLatestConnection() {
		return mTarget.getLatestConnection();
		}

		@Override
		public boolean isGeneric() {
		return mTarget.isGeneric();
		}

		@Override
		public void setGeneric(boolean generic) {
		mTarget.setGeneric(generic);
		}

		@Override
		public void hangupIfAlive() {
		mTarget.hangupIfAlive();
		}
		}

telephony/java/com/android/internal/telephony/sip/SipCallBase.java

0 → 100644

+103 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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.internal.telephony.sip;

		import com.android.internal.telephony.Call;
		import com.android.internal.telephony.CallStateException;
		import com.android.internal.telephony.Connection;
		import com.android.internal.telephony.DriverCall;
		import com.android.internal.telephony.Phone;

		import android.net.sip.SipManager;
		import java.util.ArrayList;
		import java.util.Iterator;
		import java.util.List;
		import javax.sip.SipException;

		abstract class SipCallBase extends Call {
		private static final int MAX_CONNECTIONS_PER_CALL = 5;

		protected List<Connection> connections = new ArrayList<Connection>();

		protected abstract void setState(State newState);

		public void dispose() {
		}

		public List<Connection> getConnections() {
		// FIXME should return Collections.unmodifiableList();
		return connections;
		}

		public boolean isMultiparty() {
		return connections.size() > 1;
		}

		public String toString() {
		return state.toString();
		}

		/**
		* Called by SipConnection when it has disconnected
		*/
		void connectionDisconnected(Connection conn) {
		if (state != State.DISCONNECTED) {
		/* If only disconnected connections remain, we are disconnected*/

		boolean hasOnlyDisconnectedConnections = true;

		for (int i = 0, s = connections.size() ; i < s; i ++) {
		if (connections.get(i).getState()
		!= State.DISCONNECTED
		) {
		hasOnlyDisconnectedConnections = false;
		break;
		}
		}

		if (hasOnlyDisconnectedConnections) {
		state = State.DISCONNECTED;
		}
		}
		}


		/package/ void detach(Connection conn) {
		connections.remove(conn);

		if (connections.size() == 0) {
		state = State.IDLE;
		}
		}

		/**
		* @return true if there's no space in this call for additional
		* connections to be added via "conference"
		*/
		/package/ boolean isFull() {
		return connections.size() == MAX_CONNECTIONS_PER_CALL;
		}

		void clearDisconnected() {
		for (Iterator<Connection> it = connections.iterator(); it.hasNext(); ) {
		Connection c = it.next();
		if (c.getState() == State.DISCONNECTED) it.remove();
		}

		if (connections.isEmpty()) setState(State.IDLE);
		}
		}

telephony/java/com/android/internal/telephony/sip/SipCommandInterface.java

0 → 100644

+373 −0

File added.

Preview size limit exceeded, changes collapsed.