1 files changed, 157 insertions, 0 deletions
diff --git a/telecomm/java/android/telecom/DefaultDialerManager.java b/telecomm/java/android/telecom/DefaultDialerManager.java
new file mode 100644
index 0000000..b5d566a
--- /dev/null
+++ b/telecomm/java/android/telecom/DefaultDialerManager.java
@@ -0,0 +1,157 @@
+/*
+ * 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. 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.telecom;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.provider.Settings;
+import android.text.TextUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class for managing the default dialer application that will receive incoming calls, and be
+ * allowed to make emergency outgoing calls.
+ *
+ * @hide
+ */
+public class DefaultDialerManager {
+    private static final String TAG = "DefaultDialerManager";
+
+    /**
+     * Sets the specified package name as the default dialer application. The caller of this method
+     * needs to have permission to write to secure settings.
+     *
+     * @hide
+     * */
+    public static void setDefaultDialerApplication(Context context, String packageName) {
+        // Get old package name
+        String oldPackageName = Settings.Secure.getString(context.getContentResolver(),
+                Settings.Secure.DIALER_DEFAULT_APPLICATION);
+
+        if (packageName != null && oldPackageName != null && packageName.equals(oldPackageName)) {
+            // No change
+            return;
+        }
+
+        // Only make the change if the new package belongs to a valid phone application
+        List<String> packageNames = getInstalledDialerApplications(context);
+
+        if (packageNames.contains(packageName)) {
+            // Update the secure setting.
+            Settings.Secure.putString(context.getContentResolver(),
+                    Settings.Secure.DIALER_DEFAULT_APPLICATION, packageName);
+        }
+    }
+
+    /**
+     * Returns the installed dialer application that will be used to receive incoming calls, and is
+     * allowed to make emergency calls.
+     *
+     * The application will be returned in order of preference:
+     * 1) User selected phone application (if still installed)
+     * 2) Pre-installed system dialer (if not disabled)
+     * 3) Null
+     *
+     * @hide
+     * */
+    public static String getDefaultDialerApplication(Context context) {
+        String defaultPackageName = Settings.Secure.getString(context.getContentResolver(),
+                Settings.Secure.DIALER_DEFAULT_APPLICATION);
+
+
+        final List<String> packageNames = getInstalledDialerApplications(context);
+
+        // Verify that the default dialer has not been disabled or uninstalled.
+        if (packageNames.contains(defaultPackageName)) {
+            return defaultPackageName;
+        }
+
+        // No user-set dialer found, fallback to system dialer
+        String systemDialerPackageName = getTelecomManager(context).getSystemDialerPackage();
+
+        if (TextUtils.isEmpty(systemDialerPackageName)) {
+            // No system dialer configured at build time
+            return null;
+        }
+
+        if (packageNames.contains(systemDialerPackageName)) {
+            return systemDialerPackageName;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns a list of installed and available dialer applications.
+     *
+     * In order to appear in the list, a dialer application must implement an intent-filter with
+     * the DIAL intent for the following schemes:
+     *
+     * 1) Empty scheme
+     * 2) tel Uri scheme
+     *
+     * @hide
+     **/
+    public static List<String> getInstalledDialerApplications(Context context) {
+        PackageManager packageManager = context.getPackageManager();
+
+        // Get the list of apps registered for the DIAL intent with empty scheme
+        Intent intent = new Intent(Intent.ACTION_DIAL);
+        List<ResolveInfo> resolveInfoList = packageManager.queryIntentActivities(intent, 0);
+
+        List<String> packageNames = new ArrayList<>();
+
+        for (ResolveInfo resolveInfo : resolveInfoList) {
+            final ActivityInfo activityInfo = resolveInfo.activityInfo;
+            if (activityInfo == null) {
+                continue;
+            }
+            packageNames.add(activityInfo.packageName);
+        }
+
+        // TODO: Filter for apps that don't handle DIAL intent with tel scheme
+        return packageNames;
+    }
+
+    /**
+     * Determines if the package name belongs to the user-selected default dialer or the preloaded
+     * system dialer, and thus should be allowed to perform certain privileged operations.
+     *
+     * @param context A valid context.
+     * @param packageName of the package to check for.
+     *
+     * @return {@code true} if the provided package name corresponds to the user-selected default
+     *         dialer or the preloaded system dialer, {@code false} otherwise.
+     *
+     * @hide
+     */
+    public static boolean isDefaultOrSystemDialer(Context context, String packageName) {
+        if (TextUtils.isEmpty(packageName)) {
+            return false;
+        }
+        final TelecomManager tm = getTelecomManager(context);
+        return packageName.equals(tm.getDefaultDialerPackage())
+                || packageName.equals(tm.getSystemDialerPackage());
+    }
+
+    private static TelecomManager getTelecomManager(Context context) {
+        return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
+    }
+}