Merge "resolved conflicts for merge of 74fb97de to master" (2d72d000) · Commits · e / os / android_frameworks_base

Android.mk

+28 −1

Original line number	Diff line number	Diff line
		@@ -283,8 +283,9 @@ LOCAL_SRC_FILES += \
		telephony/java/com/android/internal/telephony/IPhoneStateListener.aidl \
		telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl \
		telephony/java/com/android/internal/telephony/ITelephony.aidl \
		telephony/java/com/android/internal/telephony/ISms.aidl \
		telephony/java/com/android/internal/telephony/ITelephonyListener.aidl \
		telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl \
		telephony/java/com/android/internal/telephony/ISms.aidl \
		telephony/java/com/android/internal/telephony/IWapPushManager.aidl \
		wifi/java/android/net/wifi/IWifiManager.aidl \
		wifi/java/android/net/wifi/p2p/IWifiP2pManager.aidl \
		@@ -632,6 +633,32 @@ $(full_target): $(framework_built) $(gen)
		$(INTERNAL_PLATFORM_API_FILE): $(full_target)
		$(call dist-for-goals,sdk,$(INTERNAL_PLATFORM_API_FILE))

		# ==== the private api stubs ===================================
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:=$(framework_docs_LOCAL_API_CHECK_SRC_FILES)
		LOCAL_INTERMEDIATE_SOURCES:=$(framework_docs_LOCAL_INTERMEDIATE_SOURCES)
		LOCAL_JAVA_LIBRARIES:=$(framework_docs_LOCAL_API_CHECK_JAVA_LIBRARIES)
		LOCAL_MODULE_CLASS:=$(framework_docs_LOCAL_MODULE_CLASS)
		LOCAL_DROIDDOC_SOURCE_PATH:=$(framework_docs_LOCAL_DROIDDOC_SOURCE_PATH)
		LOCAL_DROIDDOC_HTML_DIR:=$(framework_docs_LOCAL_DROIDDOC_HTML_DIR)
		LOCAL_ADDITIONAL_JAVA_DIR:=$(framework_docs_LOCAL_API_CHECK_ADDITIONAL_JAVA_DIR)
		LOCAL_ADDITIONAL_DEPENDENCIES:=$(framework_docs_LOCAL_ADDITIONAL_DEPENDENCIES)

		LOCAL_MODULE := private-api-stubs

		LOCAL_DROIDDOC_OPTIONS:=\
		$(framework_docs_LOCAL_DROIDDOC_OPTIONS) \
		-stubs $(TARGET_OUT_COMMON_INTERMEDIATES)/JAVA_LIBRARIES/android_private_stubs_current_intermediates/src \
		-showAnnotation android.annotation.PrivateApi \
		-nodocs

		LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:=build/tools/droiddoc/templates-sdk

		LOCAL_UNINSTALLABLE_MODULE := true

		include $(BUILD_DROIDDOC)

		# ==== check javadoc comments but don't generate docs ========
		include $(CLEAR_VARS)

core/java/android/annotation/PrivateApi.java

0 → 100644

+31 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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 android.annotation;

		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;

		/**
		* Indicates an API is exposed for use by bundled applications.
		* <p>
		* These APIs are not guaranteed to remain consistent release-to-release,
		* and are not for use by apps linking against the SDK.
		* @hide
		*/
		@Retention(RetentionPolicy.SOURCE)
		public @interface PrivateApi {
		}

telephony/java/android/telephony/CallStateListener.java

0 → 100644

+36 −0

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

		import android.annotation.PrivateApi;

		/** @hide */
		@PrivateApi
		public interface CallStateListener {
		/**
		* Notify of a new or updated call.
		* Any time the state of a call is updated, it will alert any listeners. This includes changes
		* of state such as when a call is put on hold or conferenced.
		*
		* @param callId a unique ideCntifier for a given call that can be used to track state changes
		* @param state the new state of the call.
		* {@see com.android.services.telephony.common.Call$State}
		* @param number the phone number of the call. For some states, this may be blank. However, it
		* will be populated for any initial state.
		*/
		public void onCallStateChanged(int callId, int state, String number);
		}

telephony/java/android/telephony/TelephonyManager.java

+506 −0

Original line number	Diff line number	Diff line
		@@ -20,12 +20,16 @@ import android.annotation.SdkConstant;
		import android.annotation.SdkConstant.SdkConstantType;
		import android.content.Context;
		import android.os.Bundle;
		import android.os.Handler;
		import android.os.Message;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.os.SystemProperties;
		import android.util.Log;

		import com.android.internal.telephony.IPhoneSubInfo;
		import com.android.internal.telephony.ITelephony;
		import com.android.internal.telephony.ITelephonyListener;
		import com.android.internal.telephony.ITelephonyRegistry;
		import com.android.internal.telephony.PhoneConstants;
		import com.android.internal.telephony.RILConstants;
		@@ -33,6 +37,7 @@ import com.android.internal.telephony.TelephonyProperties;

		import java.io.FileInputStream;
		import java.io.IOException;
		import java.util.HashMap;
		import java.util.List;
		import java.util.regex.Matcher;
		import java.util.regex.Pattern;
		@@ -82,6 +87,38 @@ public class TelephonyManager {
		}

		private static TelephonyManager sInstance = new TelephonyManager();
		private HashMap<CallStateListener, Listener> mListeners
		= new HashMap<CallStateListener, Listener>();

		private static class Listener extends ITelephonyListener.Stub {
		final CallStateListener mListener;
		private static final int WHAT = 1;

		private Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
		mListener.onCallStateChanged(msg.arg1, msg.arg2, (String) msg.obj);
		}
		};

		Listener(CallStateListener listener) {
		mListener = listener;
		}

		@Override
		public void onUpdate(final int callId, final int state, final String number) {
		if (mHandler != null) {
		mHandler.sendMessage(mHandler.obtainMessage(WHAT, callId, state, number));
		}
		}

		void clearQueue() {
		mHandler.removeMessages(WHAT);

		// Don't accept more incoming binder calls either.
		mHandler = null;
		}
		}

		/** @hide
		/* @deprecated - use getSystemService as described above */
		@@ -1878,4 +1915,473 @@ public class TelephonyManager {
		}
		return false;
		}

		/**
		* Expose the rest of ITelephony to @PrivateApi
		*/

		/**
		* @hide
		* @PrivateApi
		*/
		public void dial(String number) {
		try {
		getITelephony().dial(number);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#dial");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void call(String callingPackage, String number) {
		try {
		getITelephony().call(callingPackage, number);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#call");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean showCallScreen() {
		try {
		return getITelephony().showCallScreen();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#showCallScreen");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean showCallScreenWithDialpad(boolean showDialpad) {
		try {
		return getITelephony().showCallScreenWithDialpad(showDialpad);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#showCallScreenWithDialpad");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean endCall() {
		try {
		return getITelephony().endCall();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#endCall");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void answerRingingCall() {
		try {
		getITelephony().answerRingingCall();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#answerRingingCall");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void toggleHold() {
		try {
		getITelephony().toggleHold();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#toggleHold");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void merge() {
		try {
		getITelephony().merge();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#merge");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void swap() {
		try {
		getITelephony().swap();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#swap");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void mute(boolean mute) {
		try {
		getITelephony().mute(mute);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#mute");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void silenceRinger() {
		try {
		getITelephony().silenceRinger();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#silenceRinger");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isOffhook() {
		try {
		return getITelephony().isOffhook();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isOffhook");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isRinging() {
		try {
		return getITelephony().isRinging();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isRinging");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isIdle() {
		try {
		return getITelephony().isIdle();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isIdle");
		}
		return true;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isRadioOn() {
		try {
		return getITelephony().isRadioOn();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isRadioOn");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isSimPinEnabled() {
		try {
		return getITelephony().isSimPinEnabled();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isSimPinEnabled");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void cancelMissedCallsNotification() {
		try {
		getITelephony().cancelMissedCallsNotification();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#cancelMissedCallsNotification");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean supplyPin(String pin) {
		try {
		return getITelephony().supplyPin(pin);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#supplyPin");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean supplyPuk(String puk, String pin) {
		try {
		return getITelephony().supplyPuk(puk, pin);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#supplyPuk");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public int[] supplyPinReportResult(String pin) {
		try {
		return getITelephony().supplyPinReportResult(pin);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#supplyPinReportResult");
		}
		return new int[0];
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public int[] supplyPukReportResult(String puk, String pin) {
		try {
		return getITelephony().supplyPukReportResult(puk, pin);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#]");
		}
		return new int[0];
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean handlePinMmi(String dialString) {
		try {
		return getITelephony().handlePinMmi(dialString);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#handlePinMmi");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void toggleRadioOnOff() {
		try {
		getITelephony().toggleRadioOnOff();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#toggleRadioOnOff");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean setRadio(boolean turnOn) {
		try {
		return getITelephony().setRadio(turnOn);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#setRadio");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean setRadioPower(boolean turnOn) {
		try {
		return getITelephony().setRadioPower(turnOn);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#setRadioPower");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void updateServiceLocation() {
		try {
		getITelephony().updateServiceLocation();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#updateServiceLocation");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public int enableApnType(String type) {
		try {
		return getITelephony().enableApnType(type);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#enableApnType");
		}
		return PhoneConstants.APN_REQUEST_FAILED;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public int disableApnType(String type) {
		try {
		return getITelephony().disableApnType(type);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#disableApnType");
		}
		return PhoneConstants.APN_REQUEST_FAILED;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean enableDataConnectivity() {
		try {
		return getITelephony().enableDataConnectivity();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#enableDataConnectivity");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean disableDataConnectivity() {
		try {
		return getITelephony().disableDataConnectivity();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#disableDataConnectivity");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean isDataConnectivityPossible() {
		try {
		return getITelephony().isDataConnectivityPossible();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#isDataConnectivityPossible");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public boolean needsOtaServiceProvisioning() {
		try {
		return getITelephony().needsOtaServiceProvisioning();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#needsOtaServiceProvisioning");
		}
		return false;
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void playDtmfTone(char digit, boolean timedShortCode) {
		try {
		getITelephony().playDtmfTone(digit, timedShortCode);
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#playDtmfTone");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void stopDtmfTone() {
		try {
		getITelephony().stopDtmfTone();
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#stopDtmfTone");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void addCallStateListener(CallStateListener listener) {
		try {
		if (listener == null) {
		throw new RuntimeException("Listener can't be null");
		}
		if (!mListeners.containsKey(listener)) {
		final Listener l = new Listener(listener);
		mListeners.put(listener, l);
		getITelephony().addListener(l);
		}
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#addListener");
		}
		}

		/**
		* @hide
		* @PrivateApi
		*/
		public void removeCallStateListener(CallStateListener listener) {
		try {
		final Listener l = mListeners.remove(listener);
		if (l != null) {
		// Make sure that no callbacks that are already in flight come.
		l.clearQueue();
		getITelephony().removeListener(l);
		}
		} catch (RemoteException e) {
		Log.e(TAG, "Error calling ITelephony#removeListener");
		}
		}
		}

telephony/java/com/android/internal/telephony/ITelephony.aidl

+48 −2

Original line number	Diff line number	Diff line
		@@ -17,9 +17,12 @@
		package com.android.internal.telephony;

		import android.os.Bundle;
		import java.util.List;
		import android.telephony.NeighboringCellInfo;
		import android.telephony.CellInfo;
		import android.telephony.NeighboringCellInfo;

		import com.android.internal.telephony.ITelephonyListener;

		import java.util.List;

		/**
		* Interface used to interact with the phone. Mostly this is used by the
		@@ -420,4 +423,47 @@ interface ITelephony {
		* @return true on success; false on any failure.
		*/
		boolean setPreferredNetworkType(int networkType);

		/**
		* Put a call on hold.
		*/
		void toggleHold();

		/**
		* Merge foreground and background calls.
		*/
		void merge();

		/**
		* Swap foreground and background calls.
		*/
		void swap();

		/**
		* Mute the phone.
		*/
		void mute(boolean mute);

		/**
		* Start playing DTMF tone for the specified digit.
		*
		* @param digit the digit that corresponds with the desired tone.
		* @param timedShortcode whether the specified digit should be played as a timed short code.
		*/
		void playDtmfTone(char digit, boolean timedShortCode);

		/**
		* Stop playing DTMF tones.
		*/
		void stopDtmfTone();

		/**
		* Register a callback.
		*/
		void addListener(ITelephonyListener listener);

		/**
		* Unregister a callback.
		*/
		void removeListener(ITelephonyListener listener);
		}