1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
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);
}
}
|
