blob: 1c070748400dcfd03b8a0e3ee7db48adc7f19941 [file] [log] [blame]
/*
* 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.app.ActivityManager;
import android.app.role.RoleManager;
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.net.Uri;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Process;
import android.os.UserHandle;
import android.text.TextUtils;
import android.util.Slog;
import com.android.internal.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Consumer;
/**
* 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 for the current user.
* 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 boolean setDefaultDialerApplication(Context context, String packageName) {
return setDefaultDialerApplication(context, packageName, ActivityManager.getCurrentUser());
}
/**
* Sets the specified package name as the default dialer application for the specified user.
* 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 boolean setDefaultDialerApplication(Context context, String packageName,
int user) {
final long identity = Binder.clearCallingIdentity();
try {
CompletableFuture<Void> future = new CompletableFuture<>();
Consumer<Boolean> callback = successful -> {
if (successful) {
future.complete(null);
} else {
future.completeExceptionally(new RuntimeException());
}
};
context.getSystemService(RoleManager.class).addRoleHolderAsUser(
RoleManager.ROLE_DIALER, packageName, 0, UserHandle.of(user),
AsyncTask.THREAD_POOL_EXECUTOR, callback);
future.get(5, TimeUnit.SECONDS);
return true;
} catch (InterruptedException | ExecutionException | TimeoutException e) {
Slog.e(TAG, "Failed to set default dialer to " + packageName + " for user " + user, e);
return false;
} finally {
Binder.restoreCallingIdentity(identity);
}
}
/**
* Returns the installed dialer application for the current user 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
*
* The caller of this method needs to have permission to manage users on the device.
*
* @hide
* */
public static String getDefaultDialerApplication(Context context) {
return getDefaultDialerApplication(context, context.getUserId());
}
/**
* Returns the installed dialer application for the specified user 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
*
* The caller of this method needs to have permission to manage users on the device.
*
* @hide
* */
public static String getDefaultDialerApplication(Context context, int user) {
final long identity = Binder.clearCallingIdentity();
try {
return CollectionUtils.firstOrNull(context.getSystemService(RoleManager.class)
.getRoleHoldersAsUser(RoleManager.ROLE_DIALER, UserHandle.of(user)));
} finally {
Binder.restoreCallingIdentity(identity);
}
}
/**
* 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, int userId) {
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.queryIntentActivitiesAsUser(intent, 0, userId);
List<String> packageNames = new ArrayList<>();
for (ResolveInfo resolveInfo : resolveInfoList) {
final ActivityInfo activityInfo = resolveInfo.activityInfo;
if (activityInfo != null
&& !packageNames.contains(activityInfo.packageName)
// ignore cross profile intent handler
&& resolveInfo.targetUserId == UserHandle.USER_CURRENT) {
packageNames.add(activityInfo.packageName);
}
}
final Intent dialIntentWithTelScheme = new Intent(Intent.ACTION_DIAL);
dialIntentWithTelScheme.setData(Uri.fromParts(PhoneAccount.SCHEME_TEL, "", null));
return filterByIntent(context, packageNames, dialIntentWithTelScheme, userId);
}
public static List<String> getInstalledDialerApplications(Context context) {
return getInstalledDialerApplications(context, Process.myUserHandle().getIdentifier());
}
/**
* 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());
}
/**
* Filter a given list of package names for those packages that contain an activity that has
* an intent filter for a given intent.
*
* @param context A valid context
* @param packageNames List of package names to filter.
* @param userId The UserId
* @return The filtered list.
*/
private static List<String> filterByIntent(Context context, List<String> packageNames,
Intent intent, int userId) {
if (packageNames == null || packageNames.isEmpty()) {
return new ArrayList<>();
}
final List<String> result = new ArrayList<>();
final List<ResolveInfo> resolveInfoList = context.getPackageManager()
.queryIntentActivitiesAsUser(intent, 0, userId);
final int length = resolveInfoList.size();
for (int i = 0; i < length; i++) {
final ActivityInfo info = resolveInfoList.get(i).activityInfo;
if (info != null && packageNames.contains(info.packageName)
&& !result.contains(info.packageName)) {
result.add(info.packageName);
}
}
return result;
}
private static TelecomManager getTelecomManager(Context context) {
return (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE);
}
}