Androidframework LocationManager笔记

LocationManagerService.java extends ILocationManager.Stub


public LocationManagerService(Context context) {
super();
mContext = context;
mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
//利用PackageManager查询默认的LocationProvider
PackageManagerInternal packageManagerInternal = LocalServices.getService(
PackageManagerInternal.class);
packageManagerInternal.setLocationPackagesProvider(
new PackageManagerInternal.PackagesProvider() {
@Override
public String[] getPackages(int userId) {
return mContext.getResources().getStringArray(
com.android.internal.R.array.config_locationProviderPackageNames);
}
});
if (D) Log.d(TAG, "Constructed");


}


public void systemRunning() {
synchronized (mLock) {
mPackageManager = mContext.getPackageManager();

mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
//用于处理位置信息和包更新两种消息
mLocationHandler = new LocationWorkerHandler(BackgroundThread.get().getLooper());
//Android平台提供粗细两种精度的位置信息，其中粗精度的位置信息由LocationFudger根据
//细精度的位置信息进行一定的数字模糊处理后得到
mLocationFudger = new LocationFudger(mContext, mLocationHandler);
//系统有一个黑白名单用于禁用某些特定的LP，在黑白名单中，LP有其java对应的包名指定
mBlacklist = new LocationBlacklist(mContext, mLocationHandler);
mBlacklist.init();
//创建地理围栏对象
mGeofenceManager = new GeofenceManager(mContext, mBlacklist);
....
// 创建及加载系统中所有的LP
loadProvidersLocked();
//根据设置中的开关情况，开启或禁止某一个LP，在此函数中，各个LP中的enable/disable函数被调用
updateProvidersLocked();
}
//监听设置数据库的变化，字段LOCATION_PROVIDER_ALLOWED，当用户点击设置
//菜单按钮时，会改变该字段的值
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.LOCATION_PROVIDERS_ALLOWED), true,
new ContentObserver(mLocationHandler) {
@Override
public void onChange(boolean selfChange) {
synchronized (mLock) {
updateProvidersLocked();
}
}
}, UserHandle.USER_ALL);
mPackageMonitor.register(mContext, mLocationHandler.getLooper(), true);
....
}








private void loadProvidersLocked() {
//创建passiveProvider，该LP始终是enable的，它自己不能更新位置信息，
//而是靠其他的LP来触发
//PassiveProvider的位置更新是由LMS接收其他LP的位置更新通知后，主动调用LocationProvider的、
//updateLocation函数来完成
PassiveProvider passiveProvider = new PassiveProvider(this);
addProviderLocked(passiveProvider);
//mEnabledProviders用于保存被启用的LP
mEnabledProviders.add(passiveProvider.getName());
mPassiveProvider = passiveProvider;
//mEnabledProviders用于保存所有被启用的LP
if (GpsLocationProvider.isSupported()) {
//GpsLocationProvider使用GPS定位是最准确的定位方式
//GPSLocationProvider有LMS创建并加载，运行在LMS所在的system_process中，属于系统提供的LP服务
GpsLocationProvider gpsProvider = new GpsLocationProvider(mContext, this,
mLocationHandler.getLooper());
mGpsStatusProvider = gpsProvider.getGpsStatusProvider();
mNetInitiatedListener = gpsProvider.getNetInitiatedListener();
//保存GpsLocationProvider
addProviderLocked(gpsProvider);
//GpsLocationProvider真实的位置提供者，将其保存在mRealProviders中
mRealProviders.put(LocationManager.GPS_PROVIDER, gpsProvider);
mGpsMeasurementsProvider = gpsProvider.getGpsMeasurementsProvider();
mGpsNavigationMessageProvider = gpsProvider.getGpsNavigationMessageProvider();
mGpsGeofenceProxy = gpsProvider.getGpsGeofenceProxy();
}


//
Resources resources = mContext.getResources();
ArrayList providerPackageNames = new ArrayList();
//config_locationProviderPackageNames存储了第三方LP的java包名，Android原生代码中该值为
//“com.android.location.fused”，FusedLP对应的源码路径为framework/base/packages/FusedLocation
String[] pkgs = resources.getStringArray(
com.android.internal.R.array.config_locationProviderPackageNames);
if (pkgs != null) providerPackageNames.addAll(Arrays.asList(pkgs));
//加载应用程序使用的LP服务时，LMS将检查它们的签名信息及版本信息
ensureFallbackFusedProviderPresentLocked(providerPackageNames);


//加载networkLP，创建以网络方式进行定位的LP
//使用网络实现定位服务的代理，网络定位依赖于手机信号的基站或者WiFi接入点作为定位的基础
LocationProviderProxy networkProvider = LocationProviderProxy.createAndBind(
mContext,
LocationManager.NETWORK_PROVIDER,
NETWORK_LOCATION_SERVICE_ACTION,
com.android.internal.R.bool.config_enableNetworkLocationOverlay,
com.android.internal.R.string.config_networkLocationProviderPackageName,
com.android.internal.R.array.config_locationProviderPackageNames,
mLocationHandler);
if (networkProvider != null) {
mRealProviders.put(LocationManager.NETWORK_PROVIDER, networkProvider);
//应用程序实现的LP保存在mProxyProviders
mProxyProviders.add(networkProvider);
addProviderLocked(networkProvider);
} else {
Slog.w(TAG,  "no network location provider found");
}
//加载FusedLP
//属于系统提供的应用程序，其内部将使用其他的LP
LocationProviderProxy fusedLocationProvider = LocationProviderProxy.createAndBind(
mContext,
LocationManager.FUSED_PROVIDER,
FUSED_LOCATION_SERVICE_ACTION,
com.android.internal.R.bool.config_enableFusedLocationOverlay,
com.android.internal.R.string.config_fusedLocationProviderPackageName,
com.android.internal.R.array.config_locationProviderPackageNames,
mLocationHandler);
if (fusedLocationProvider != null) {
addProviderLocked(fusedLocationProvider);
mProxyProviders.add(fusedLocationProvider);
//FusedLP默认处于启动状态
mEnabledProviders.add(fusedLocationProvider.getName());
mRealProviders.put(LocationManager.FUSED_PROVIDER, fusedLocationProvider);
} else {
Slog.e(TAG, "no fused location provider found",
new IllegalStateException("Location service needs a fused location provider"));
}


//mGeocodeProvider由第三方应用程序提供，一般与NetWorkLP位于同一个应用程序中
mGeocodeProvider = GeocoderProxy.createAndBind(mContext,
com.android.internal.R.bool.config_enableGeocoderOverlay,
com.android.internal.R.string.config_geocoderProviderPackageName,
com.android.internal.R.array.config_locationProviderPackageNames,
mLocationHandler);
if (mGeocodeProvider == null) {
Slog.e(TAG,  "no geocoder provider found");
}
.....
}




LocationProviderProxy.java
public static LocationProviderProxy createAndBind(
Context context, String name, String action,
int overlaySwitchResId, int defaultServicePackageNameResId,
int initialPackageNamesResId, Handler handler) {
LocationProviderProxy proxy = new LocationProviderProxy(context, name, action,
overlaySwitchResId, defaultServicePackageNameResId, initialPackageNamesResId,
handler);
if (proxy.bind()) {
return proxy;
} else {
return null;
}
}


private LocationProviderProxy(Context context, String name, String action,
int overlaySwitchResId, int defaultServicePackageNameResId,
int initialPackageNamesResId, Handler handler) {
mContext = context;
mName = name;
//用于连接和监视应用程序实现的LP服务
mServiceWatcher = new ServiceWatcher(mContext, TAG + "-" + name, action, overlaySwitchResId,
defaultServicePackageNameResId, initialPackageNamesResId,
mNewServiceWork, handler);
}


private boolean bind () {
return mServiceWatcher.start();
}


ServiceWatcher.java
public boolean start() {
synchronized (mLock) {
//检查应用程序的目标签名，查找应用程序实现的service，绑定service
if (!bindBestPackageLocked(mServicePackageName)) return false;
}
//监听用户的切换
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
mContext.registerReceiverAsUser(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intent.ACTION_USER_SWITCHED.equals(action)) {
switchUser();
}
}
}, UserHandle.ALL, intentFilter, null, mHandler);
//监听应用程序安装，卸载，更新等广播事件
if (mServicePackageName == null) {
mPackageMonitor.register(mContext, null, UserHandle.ALL, true);
}


return true;
}




private boolean bindBestPackageLocked(String justCheckThisPackage) {
Intent intent = new Intent(mAction);
if (justCheckThisPackage != null) {
intent.setPackage(justCheckThisPackage);
}
//返回指定Action的ResolveInfo
List rInfos = mPm.queryIntentServicesAsUser(intent,
PackageManager.GET_META_DATA, UserHandle.USER_OWNER);
int bestVersion = Integer.MIN_VALUE;
String bestPackage = null;
boolean bestIsMultiuser = false;
if (rInfos != null) {
//检查应用程序的签名
for (ResolveInfo rInfo : rInfos) {
//查找应用程序实现的service
String packageName = rInfo.serviceInfo.packageName;
try {
PackageInfo pInfo;
pInfo = mPm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
if (!isSignatureMatch(pInfo.signatures)) {
...
}
} catch (NameNotFoundException e) {
...
}
.....
if (version > mVersion) {
bestVersion = version;
bestPackage = packageName;
bestIsMultiuser = isMultiuser;
}
}
....
}...
if (bestPackage != null) {
//绑定LP服务，LocationProviderProxy可与应用程序中的LP交互
bindToPackageLocked(bestPackage, bestVersion, bestIsMultiuser);
return true;
}
return false;
}




private void bindToPackageLocked(String packageName, int version, boolean isMultiuser) {
unbindLocked();
Intent intent = new Intent(mAction);
intent.setPackage(packageName);
mPackageName = packageName;
mVersion = version;
mIsMultiuser = isMultiuser;
//bindServiceAsUser函数绑定了第三方应用程序的服务
mContext.bindServiceAsUser(intent, this, Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND
| Context.BIND_NOT_VISIBLE, mIsMultiuser ? UserHandle.OWNER : UserHandle.CURRENT);
}


//绑定成功后，会调用onServiceConnected()函数
public void onServiceConnected(ComponentName name, IBinder binder) {
synchronized (mLock) {
String packageName = name.getPackageName();
if (packageName.equals(mPackageName)) {
....
mBinder = binder;
if (mHandler !=null && mNewServiceWork != null) {
mHandler.post(mNewServiceWork);
}
}....
}
}


mNewServiceWork是一个Runnable对象
LocationProviderProxy.java
private Runnable mNewServiceWork = new Runnable() {
public void run() {
if (D) Log.d(TAG, "applying state to connected service");


boolean enabled;
ProviderProperties properties = null;
ProviderRequest request;
WorkSource source;
ILocationProvider service;
synchronized (mLock) {
enabled = mEnabled;
request = mRequest;
source = mWorksource;
service = getService();
}


if (service == null) return;


try {
// load properties from provider
properties = service.getProperties();
if (properties == null) {
Log.e(TAG, mServiceWatcher.getBestPackageName() +
" has invalid locatino provider properties");
}


// apply current state to new service
if (enabled) {
service.enable();
if (request != null) {
service.setRequest(request, source);
}
}
} catch (RemoteException e) {
Log.w(TAG, e);
} catch (Exception e) {
// never let remote service crash system server
Log.e(TAG, "Exception from " + mServiceWatcher.getBestPackageName(), e);
}


synchronized (mLock) {
mProperties = properties;
}
}
};


}