diff options
| -rw-r--r-- | cmds/telecom/Android.mk | 15 | ||||
| -rw-r--r-- | cmds/telecom/MODULE_LICENSE_APACHE2 | 0 | ||||
| -rw-r--r-- | cmds/telecom/NOTICE | 190 | ||||
| -rw-r--r-- | cmds/telecom/src/com/android/commands/telecom/Telecom.java | 134 | ||||
| -rwxr-xr-x | cmds/telecom/telecom | 6 | ||||
| -rw-r--r-- | telecomm/java/android/telecom/DefaultDialerManager.java | 17 | ||||
| -rw-r--r-- | telecomm/java/android/telecom/TelecomManager.java | 46 | ||||
| -rw-r--r-- | telecomm/java/com/android/internal/telecom/ITelecomService.aidl | 7 |
8 files changed, 364 insertions, 51 deletions
diff --git a/cmds/telecom/Android.mk b/cmds/telecom/Android.mk new file mode 100644 index 0000000..5f7bdf7 --- /dev/null +++ b/cmds/telecom/Android.mk @@ -0,0 +1,15 @@ +# Copyright 2015 The Android Open Source Project +# +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := $(call all-subdir-java-files) +LOCAL_MODULE := telecom +include $(BUILD_JAVA_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE := telecom +LOCAL_SRC_FILES := telecom +LOCAL_MODULE_CLASS := EXECUTABLES +LOCAL_MODULE_TAGS := optional +include $(BUILD_PREBUILT) diff --git a/cmds/telecom/MODULE_LICENSE_APACHE2 b/cmds/telecom/MODULE_LICENSE_APACHE2 new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/cmds/telecom/MODULE_LICENSE_APACHE2 diff --git a/cmds/telecom/NOTICE b/cmds/telecom/NOTICE new file mode 100644 index 0000000..8530865 --- /dev/null +++ b/cmds/telecom/NOTICE @@ -0,0 +1,190 @@ + + Copyright (c) 2015, 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. + + 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. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + diff --git a/cmds/telecom/src/com/android/commands/telecom/Telecom.java b/cmds/telecom/src/com/android/commands/telecom/Telecom.java new file mode 100644 index 0000000..250b002 --- /dev/null +++ b/cmds/telecom/src/com/android/commands/telecom/Telecom.java @@ -0,0 +1,134 @@ +/* + * 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.commands.telecom; + +import android.content.ComponentName; +import android.content.Context; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.telecom.PhoneAccountHandle; +import android.text.TextUtils; + +import com.android.internal.os.BaseCommand; +import com.android.internal.telecom.ITelecomService; + +import java.io.PrintStream; + +public final class Telecom extends BaseCommand { + + /** + * Command-line entry point. + * + * @param args The command-line arguments + */ + public static void main(String[] args) { + (new Telecom()).run(args); + } + + private static final String COMMAND_SET_PHONE_ACOUNT_ENABLED = "set-phone-account-enabled"; + private static final String COMMAND_SET_PHONE_ACOUNT_DISABLED = "set-phone-account-disabled"; + private static final String COMMAND_SET_DEFAULT_DIALER = "set-default-dialer"; + private static final String COMMAND_GET_DEFAULT_DIALER = "get-default-dialer"; + + private ComponentName mComponent; + private String mAccountId; + private ITelecomService mTelecomService; + + @Override + public void onShowUsage(PrintStream out) { + out.println( + "usage: telecom [subcommand] [options]\n" + + "usage: telecom set-phone-account-enabled <COMPONENT> <ID>\n" + + "usage: telecom set-phone-account-disabled <COMPONENT> <ID>\n" + + "usage: telecom set-default-dialer <PACKAGE>\n" + + "usage: telecom get-default-dialer <PACKAGE>\n" + + "\n" + + "telecom set-phone-account-enabled: Enables the given phone account, if it has \n" + + " already been registered with Telecom.\n" + + "\n" + + "telecom set-phone-account-disabled: Disables the given phone account, if it \n" + + " has already been registered with telecom.\n" + + "\n" + + "telecom set-default_dialer: Sets the default dialer to the given component. \n" + + "\n" + + "telecom get-default_dialer: Displays the current default dialer. \n" + ); + } + + @Override + public void onRun() throws Exception { + mTelecomService = ITelecomService.Stub.asInterface( + ServiceManager.getService(Context.TELECOM_SERVICE)); + if (mTelecomService == null) { + showError("Error: Could not access the Telecom Manager. Is the system running?"); + return; + } + + String command = nextArgRequired(); + switch (command) { + case COMMAND_SET_PHONE_ACOUNT_ENABLED: + runSetPhoneAccountEnabled(true); + break; + case COMMAND_SET_PHONE_ACOUNT_DISABLED: + runSetPhoneAccountEnabled(false); + break; + case COMMAND_SET_DEFAULT_DIALER: + runSetDefaultDialer(); + break; + case COMMAND_GET_DEFAULT_DIALER: + runGetDefaultDialer(); + break; + default: + throw new IllegalArgumentException ("unknown command '" + command + "'"); + } + } + + private void runSetPhoneAccountEnabled(boolean enabled) throws RemoteException { + final ComponentName component = parseComponentName(nextArgRequired()); + final String accountId = nextArgRequired(); + final PhoneAccountHandle handle = new PhoneAccountHandle(component, accountId); + final boolean success = mTelecomService.enablePhoneAccount(handle, enabled); + if (success) { + System.out.println("Success - " + handle + (enabled ? " enabled." : " disabled.")); + } else { + System.out.println("Error - is " + handle + " a valid PhoneAccount?"); + } + } + + private void runSetDefaultDialer() throws RemoteException { + final String packageName = nextArgRequired(); + final boolean success = mTelecomService.setDefaultDialer(packageName); + if (success) { + System.out.println("Success - " + packageName + " set as default dialer."); + } else { + System.out.println("Error - " + packageName + " is not an installed Dialer app, \n" + + " or is already the default dialer."); + } + } + + private void runGetDefaultDialer() throws RemoteException { + System.out.println(mTelecomService.getDefaultDialerPackage()); + } + + private ComponentName parseComponentName(String component) { + ComponentName cn = ComponentName.unflattenFromString(component); + if (cn == null) { + throw new IllegalArgumentException ("Invalid component " + component); + } + return cn; + } +}
\ No newline at end of file diff --git a/cmds/telecom/telecom b/cmds/telecom/telecom new file mode 100755 index 0000000..9efdcfd --- /dev/null +++ b/cmds/telecom/telecom @@ -0,0 +1,6 @@ +# Script to start "telecom" on the device +# +base=/system +export CLASSPATH=$base/framework/telecom.jar +exec app_process $base/bin com.android.commands.telecom.Telecom "$@" + diff --git a/telecomm/java/android/telecom/DefaultDialerManager.java b/telecomm/java/android/telecom/DefaultDialerManager.java index d3df151..3d49308 100644 --- a/telecomm/java/android/telecom/DefaultDialerManager.java +++ b/telecomm/java/android/telecom/DefaultDialerManager.java @@ -41,10 +41,13 @@ public class DefaultDialerManager { * The caller of this method needs to have permission to write to secure settings and * manage users on the device. * + * @return {@code true} if the default dialer application was successfully changed, + * {@code false} otherwise. + * * @hide * */ - public static void setDefaultDialerApplication(Context context, String packageName) { - setDefaultDialerApplication(context, packageName, ActivityManager.getCurrentUser()); + public static boolean setDefaultDialerApplication(Context context, String packageName) { + return setDefaultDialerApplication(context, packageName, ActivityManager.getCurrentUser()); } /** @@ -52,16 +55,20 @@ public class DefaultDialerManager { * The caller of this method needs to have permission to write to secure settings and * manage users on the device. * + * @return {@code true} if the default dialer application was successfully changed, + * {@code false} otherwise. + * * @hide * */ - public static void setDefaultDialerApplication(Context context, String packageName, int user) { + public static boolean setDefaultDialerApplication(Context context, String packageName, + int user) { // Get old package name String oldPackageName = Settings.Secure.getStringForUser(context.getContentResolver(), Settings.Secure.DIALER_DEFAULT_APPLICATION, user); if (packageName != null && oldPackageName != null && packageName.equals(oldPackageName)) { // No change - return; + return false; } // Only make the change if the new package belongs to a valid phone application @@ -71,7 +78,9 @@ public class DefaultDialerManager { // Update the secure setting. Settings.Secure.putStringForUser(context.getContentResolver(), Settings.Secure.DIALER_DEFAULT_APPLICATION, packageName, user); + return true; } + return false; } /** diff --git a/telecomm/java/android/telecom/TelecomManager.java b/telecomm/java/android/telecom/TelecomManager.java index 07176b3..3c8cc9a 100644 --- a/telecomm/java/android/telecom/TelecomManager.java +++ b/telecomm/java/android/telecom/TelecomManager.java @@ -124,33 +124,6 @@ public class TelecomManager { "android.telecom.action.CHANGE_DEFAULT_DIALER"; /** - * Privileged version of {@link #ACTION_CHANGE_DEFAULT_DIALER} that doesn't require - * confirmation from the user via the dialog. - * - * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} - * @hide - */ - public static final String ACTION_CHANGE_DEFAULT_DIALER_PRIVILEGED = - "android.telecom.action.CHANGE_DEFAULT_DIALER_PRIVILEGED"; - - /** - * Activity action: Opens the settings screen where a user can enable and disable which - * {@link PhoneAccount}s are allows to make and receive calls. Because a user must - * explicitly enable an account before the system will use it, an app may want to send the - * user to this setting after registering a {@link PhoneAccount}. - * <p> - * Input: get*Extra field {@link #EXTRA_PHONE_ACCOUNT_DESCRIPTION} contains a string-based - * reference to the {@link PhoneAccountHandle} you want to enable. get*Extra field - * {@link #EXTRA_ENABLE_PHONE_ACCOUNT_VALUE} contains a boolean value indicated whether - * the account should be enabled or disabled. - * <p> - * Requires permission: {@link android.Manifest.permission#MODIFY_PHONE_STATE} - * @hide - */ - public static final String ACTION_ENABLE_PHONE_ACCOUNT_SETTING = - "android.telecom.action.ENABLE_PHONE_ACCOUNT_SETTING"; - - /** * Extra value used to provide the package name for {@link #ACTION_CHANGE_DEFAULT_DIALER}. */ public static final String EXTRA_CHANGE_DEFAULT_DIALER_PACKAGE_NAME = @@ -186,25 +159,6 @@ public class TelecomManager { "android.telecom.extra.PHONE_ACCOUNT_HANDLE"; /** - * The extra used with {@link #ACTION_ENABLE_PHONE_ACCOUNT_SETTING} to specify a phone account - * as a string value. The value is of the form: "A;B" where A is the component name of the - * {@link PhoneAccount} (e.g., - * com.android.phone/com.android.services.telephony.TelephonyConnectionService) and B is the - * {@link PhoneAccount} ID. - * @hide - */ - public static final String EXTRA_PHONE_ACCOUNT_DESCRIPTION = - "android.telecom.extra.PHONE_ACCOUNT_DESCRIPTION"; - - /** - * Boolean extra used to specify a value for enabling and disabling a phone account. - * Used with {@link #ACTION_ENABLE_PHONE_ACCOUNT_SETTING}. - * @hide - */ - public static final String EXTRA_ENABLE_PHONE_ACCOUNT_VALUE = - "android.telecom.extra.ENABLE_PHONE_ACCOUNT_VALUE"; - - /** * Optional extra for {@link #ACTION_INCOMING_CALL} containing a {@link Bundle} which contains * metadata about the call. This {@link Bundle} will be returned to the * {@link ConnectionService}. diff --git a/telecomm/java/com/android/internal/telecom/ITelecomService.aidl b/telecomm/java/com/android/internal/telecom/ITelecomService.aidl index aa02021..ea6a74a 100644 --- a/telecomm/java/com/android/internal/telecom/ITelecomService.aidl +++ b/telecomm/java/com/android/internal/telecom/ITelecomService.aidl @@ -231,5 +231,10 @@ interface ITelecomService { /** * @see TelecomServiceImpl#enablePhoneAccount */ - void enablePhoneAccount(in PhoneAccountHandle accountHandle, boolean isEnabled); + boolean enablePhoneAccount(in PhoneAccountHandle accountHandle, boolean isEnabled); + + /** + * @see TelecomServiceImpl#setDefaultDialer + */ + boolean setDefaultDialer(in String packageName); } |