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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
* Copyright (C) 2016 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.contacts.common.location;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationManager;
import android.preference.PreferenceManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import com.android.dialer.util.PermissionsUtil;
import java.util.Locale;
/**
* This class is used to detect the country where the user is. It is a simplified version of the
* country detector service in the framework. The sources of country location are queried in the
* following order of reliability:
*
* <ul>
* <li>Mobile network
* <li>Location manager
* <li>SIM's country
* <li>User's default locale
* </ul>
*
* As far as possible this class tries to replicate the behavior of the system's country detector
* service: 1) Order in priority of sources of country location 2) Mobile network information
* provided by CDMA phones is ignored 3) Location information is updated every 12 hours (instead of
* 24 hours in the system) 4) Location updates only uses the {@link
* LocationManager#PASSIVE_PROVIDER} to avoid active use of the GPS 5) If a location is successfully
* obtained and geocoded, we never fall back to use of the SIM's country (for the system, the
* fallback never happens without a reboot) 6) Location is not used if the device does not implement
* a {@link android.location.Geocoder}
*/
public class CountryDetector {
public static final String KEY_PREFERENCE_TIME_UPDATED = "preference_time_updated";
public static final String KEY_PREFERENCE_CURRENT_COUNTRY = "preference_current_country";
private static final String TAG = "CountryDetector";
// Wait 12 hours between updates
private static final long TIME_BETWEEN_UPDATES_MS = 1000L * 60 * 60 * 12;
// Minimum distance before an update is triggered, in meters. We don't need this to be too
// exact because all we care about is what country the user is in.
private static final long DISTANCE_BETWEEN_UPDATES_METERS = 5000;
private static CountryDetector sInstance;
private final TelephonyManager mTelephonyManager;
private final LocationManager mLocationManager;
private final LocaleProvider mLocaleProvider;
// Used as a default country code when all the sources of country data have failed in the
// exceedingly rare event that the device does not have a default locale set for some reason.
private static final String DEFAULT_COUNTRY_ISO = "US";
private final Context mContext;
private CountryDetector(Context context) {
this(
context,
(TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE),
(LocationManager) context.getSystemService(Context.LOCATION_SERVICE),
new LocaleProvider());
}
private CountryDetector(
Context context,
TelephonyManager telephonyManager,
LocationManager locationManager,
LocaleProvider localeProvider) {
mTelephonyManager = telephonyManager;
mLocationManager = locationManager;
mLocaleProvider = localeProvider;
mContext = context;
registerForLocationUpdates(context, mLocationManager);
}
public static void registerForLocationUpdates(Context context, LocationManager locationManager) {
if (!PermissionsUtil.hasLocationPermissions(context)) {
Log.w(TAG, "No location permissions, not registering for location updates.");
return;
}
if (!Geocoder.isPresent()) {
// Certain devices do not have an implementation of a geocoder - in that case there is
// no point trying to get location updates because we cannot retrieve the country based
// on the location anyway.
return;
}
final Intent activeIntent = new Intent(context, LocationChangedReceiver.class);
final PendingIntent pendingIntent =
PendingIntent.getBroadcast(context, 0, activeIntent, PendingIntent.FLAG_UPDATE_CURRENT);
locationManager.requestLocationUpdates(
LocationManager.PASSIVE_PROVIDER,
TIME_BETWEEN_UPDATES_MS,
DISTANCE_BETWEEN_UPDATES_METERS,
pendingIntent);
}
/**
* Returns the instance of the country detector. {@link #initialize(Context)} must have been
* called previously.
*
* @return the initialized country detector.
*/
public static synchronized CountryDetector getInstance(Context context) {
if (sInstance == null) {
sInstance = new CountryDetector(context.getApplicationContext());
}
return sInstance;
}
/** Factory method for {@link CountryDetector} that allows the caller to provide mock objects. */
public CountryDetector getInstanceForTest(
Context context,
TelephonyManager telephonyManager,
LocationManager locationManager,
LocaleProvider localeProvider,
Geocoder geocoder) {
return new CountryDetector(context, telephonyManager, locationManager, localeProvider);
}
public String getCurrentCountryIso() {
String result = null;
if (isNetworkCountryCodeAvailable()) {
result = getNetworkBasedCountryIso();
}
if (TextUtils.isEmpty(result)) {
result = getLocationBasedCountryIso();
}
if (TextUtils.isEmpty(result)) {
result = getSimBasedCountryIso();
}
if (TextUtils.isEmpty(result)) {
result = getLocaleBasedCountryIso();
}
if (TextUtils.isEmpty(result)) {
result = DEFAULT_COUNTRY_ISO;
}
return result.toUpperCase(Locale.US);
}
/** @return the country code of the current telephony network the user is connected to. */
private String getNetworkBasedCountryIso() {
return mTelephonyManager.getNetworkCountryIso();
}
/** @return the geocoded country code detected by the {@link LocationManager}. */
private String getLocationBasedCountryIso() {
if (!Geocoder.isPresent() || !PermissionsUtil.hasLocationPermissions(mContext)) {
return null;
}
final SharedPreferences sharedPreferences =
PreferenceManager.getDefaultSharedPreferences(mContext);
return sharedPreferences.getString(KEY_PREFERENCE_CURRENT_COUNTRY, null);
}
/** @return the country code of the SIM card currently inserted in the device. */
private String getSimBasedCountryIso() {
return mTelephonyManager.getSimCountryIso();
}
/** @return the country code of the user's currently selected locale. */
private String getLocaleBasedCountryIso() {
Locale defaultLocale = mLocaleProvider.getDefaultLocale();
if (defaultLocale != null) {
return defaultLocale.getCountry();
}
return null;
}
private boolean isNetworkCountryCodeAvailable() {
// On CDMA TelephonyManager.getNetworkCountryIso() just returns the SIM's country code.
// In this case, we want to ignore the value returned and fallback to location instead.
return mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_GSM;
}
/**
* Class that can be used to return the user's default locale. This is in its own class so that it
* can be mocked out.
*/
public static class LocaleProvider {
public Locale getDefaultLocale() {
return Locale.getDefault();
}
}
public static class LocationChangedReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, Intent intent) {
if (!intent.hasExtra(LocationManager.KEY_LOCATION_CHANGED)) {
return;
}
final Location location =
(Location) intent.getExtras().get(LocationManager.KEY_LOCATION_CHANGED);
UpdateCountryService.updateCountry(context, location);
}
}
}
|
