Added a private apis jar that includes explicitly supported APIs that are not useful for 3rd party developers.
The first set of these APIs is for telephony:
Added some APIs to ITelephony and created a first party framework for them
toggleHold()
merge()
mute(boolean mute)
playDtmfTone(char digit, boolean timedShortCode)
stopDtmfTone()
swap()
addListener(ITelephonyListener listener)
removeListener(ITelephonyListener listener)
Bug: 13302451
Change-Id: Iefec5688c26a1b4fe77f5643eba6e1690a057ee6
diff --git a/Android.mk b/Android.mk
index b0a27e4..bcfc240 100644
--- a/Android.mk
+++ b/Android.mk
@@ -264,8 +264,9 @@
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 \
@@ -755,6 +756,32 @@
$(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)
diff --git a/core/java/android/annotation/PrivateApi.java b/core/java/android/annotation/PrivateApi.java
new file mode 100644
index 0000000..985eafe
--- /dev/null
+++ b/core/java/android/annotation/PrivateApi.java
@@ -0,0 +1,31 @@
+/*
+ * 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 {
+}
diff --git a/telephony/java/android/telephony/CallStateListener.java b/telephony/java/android/telephony/CallStateListener.java
new file mode 100644
index 0000000..e2ffbfa
--- /dev/null
+++ b/telephony/java/android/telephony/CallStateListener.java
@@ -0,0 +1,36 @@
+/*
+ * 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);
+}
diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java
index 8f17e72..3ab7000f 100644
--- a/telephony/java/android/telephony/TelephonyManager.java
+++ b/telephony/java/android/telephony/TelephonyManager.java
@@ -16,17 +16,22 @@
package android.telephony;
+import android.annotation.PrivateApi;
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.telephony.Rlog;
+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;
@@ -34,6 +39,7 @@
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;
@@ -60,8 +66,41 @@
private static final String TAG = "TelephonyManager";
private static ITelephonyRegistry sRegistry;
+
+ private final HashMap<CallStateListener,Listener> mListeners
+ = new HashMap<CallStateListener,Listener>();
private final Context mContext;
+ 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 */
public TelephonyManager(Context context) {
Context appContext = context.getApplicationContext();
@@ -1439,4 +1478,397 @@
return mContext.getResources().getString(
com.android.internal.R.string.config_mms_user_agent_profile_url);
}
+
+ /** @hide */
+ @PrivateApi
+ public void dial(String number) {
+ try {
+ getITelephony().dial(number);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#dial", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void call(String callingPackage, String number) {
+ try {
+ getITelephony().call(callingPackage, number);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#call", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean showCallScreen() {
+ try {
+ return getITelephony().showCallScreen();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#showCallScreen", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean showCallScreenWithDialpad(boolean showDialpad) {
+ try {
+ return getITelephony().showCallScreenWithDialpad(showDialpad);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#showCallScreenWithDialpad", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean endCall() {
+ try {
+ return getITelephony().endCall();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#endCall", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void answerRingingCall() {
+ try {
+ getITelephony().answerRingingCall();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#answerRingingCall", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void toggleHold() {
+ try {
+ getITelephony().toggleHold();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#toggleHold", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void merge() {
+ try {
+ getITelephony().merge();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#merge", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void swap() {
+ try {
+ getITelephony().swap();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#swap", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void mute(boolean mute) {
+ try {
+ getITelephony().mute(mute);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#mute", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void silenceRinger() {
+ try {
+ getITelephony().silenceRinger();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#silenceRinger", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isOffhook() {
+ try {
+ return getITelephony().isOffhook();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isOffhook", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isRinging() {
+ try {
+ return getITelephony().isRinging();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isRinging", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isIdle() {
+ try {
+ return getITelephony().isIdle();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isIdle", e);
+ }
+ return true;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isRadioOn() {
+ try {
+ return getITelephony().isRadioOn();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isRadioOn", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isSimPinEnabled() {
+ try {
+ return getITelephony().isSimPinEnabled();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isSimPinEnabled", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void cancelMissedCallsNotification() {
+ try {
+ getITelephony().cancelMissedCallsNotification();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#cancelMissedCallsNotification", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean supplyPin(String pin) {
+ try {
+ return getITelephony().supplyPin(pin);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#supplyPin", e);
+ }
+ 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", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public int[] supplyPinReportResult(String pin) {
+ try {
+ return getITelephony().supplyPinReportResult(pin);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#supplyPinReportResult", e);
+ }
+ 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#]", e);
+ }
+ 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", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void toggleRadioOnOff() {
+ try {
+ getITelephony().toggleRadioOnOff();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#toggleRadioOnOff", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean setRadio(boolean turnOn) {
+ try {
+ return getITelephony().setRadio(turnOn);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#setRadio", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean setRadioPower(boolean turnOn) {
+ try {
+ return getITelephony().setRadioPower(turnOn);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#setRadioPower", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void updateServiceLocation() {
+ try {
+ getITelephony().updateServiceLocation();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#updateServiceLocation", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public int enableApnType(String type) {
+ try {
+ return getITelephony().enableApnType(type);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#enableApnType", e);
+ }
+ 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", e);
+ }
+ return PhoneConstants.APN_REQUEST_FAILED;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean enableDataConnectivity() {
+ try {
+ return getITelephony().enableDataConnectivity();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#enableDataConnectivity", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean disableDataConnectivity() {
+ try {
+ return getITelephony().disableDataConnectivity();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#disableDataConnectivity", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean isDataConnectivityPossible() {
+ try {
+ return getITelephony().isDataConnectivityPossible();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#isDataConnectivityPossible", e);
+ }
+ return false;
+ }
+
+ /** @hide */
+ @PrivateApi
+ public boolean needsOtaServiceProvisioning() {
+ try {
+ return getITelephony().needsOtaServiceProvisioning();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#needsOtaServiceProvisioning", e);
+ }
+ 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", e);
+ }
+ }
+
+ /** @hide */
+ @PrivateApi
+ public void stopDtmfTone() {
+ try {
+ getITelephony().stopDtmfTone();
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error calling ITelephony#stopDtmfTone", e);
+ }
+ }
+
+ /** @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", e);
+ }
+ }
+
+ /** @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", e);
+ }
+ }
}
diff --git a/telephony/java/com/android/internal/telephony/ITelephony.aidl b/telephony/java/com/android/internal/telephony/ITelephony.aidl
index 7bd2c84..9c73059 100644
--- a/telephony/java/com/android/internal/telephony/ITelephony.aidl
+++ b/telephony/java/com/android/internal/telephony/ITelephony.aidl
@@ -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
@@ -324,5 +327,48 @@
* Sets minimum time in milli-seconds between onCellInfoChanged
*/
void setCellInfoListRate(int rateInMillis);
+
+ /**
+ * 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);
}
diff --git a/telephony/java/com/android/internal/telephony/ITelephonyListener.aidl b/telephony/java/com/android/internal/telephony/ITelephonyListener.aidl
new file mode 100644
index 0000000..c226217
--- /dev/null
+++ b/telephony/java/com/android/internal/telephony/ITelephonyListener.aidl
@@ -0,0 +1,27 @@
+/*
+ * 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 com.android.internal.telephony;
+
+/**
+ * Interface used to register a listener that gets more detailed call state information than
+ * {@link android.telephony.PhoneStateListener}
+ *
+ * {@hide}
+ */
+oneway interface ITelephonyListener {
+ void onUpdate(int callId, int state, String number);
+}