/*
* Copyright (C) 2009 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.server.location;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.location.Criteria;
import android.location.ILocationProvider;
import android.location.Location;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.WorkSource;
import android.util.Log;
import com.android.internal.location.DummyLocationProvider;
/**
* A class for proxying location providers implemented as services.
*
* {@hide}
*/
public class LocationProviderProxy implements LocationProviderInterface {
private static final String TAG = "LocationProviderProxy";
private final Context mContext;
private final String mName;
private final Intent mIntent;
private final Handler mHandler;
private final Object mMutex = new Object(); // synchronizes access to non-final members
private Connection mServiceConnection = new Connection(); // never null
// cached values set by the location manager
private boolean mLocationTracking = false;
private boolean mEnabled = false;
private long mMinTime = -1;
private WorkSource mMinTimeSource = new WorkSource();
private int mNetworkState;
private NetworkInfo mNetworkInfo;
// constructor for proxying location providers implemented in a separate service
public LocationProviderProxy(Context context, String name, String serviceName,
Handler handler) {
mContext = context;
mName = name;
mIntent = new Intent(serviceName);
mHandler = handler;
mContext.bindService(mIntent, mServiceConnection,
Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND
| Context.BIND_ALLOW_OOM_MANAGEMENT);
}
/**
* When unbundled NetworkLocationService package is updated, we
* need to unbind from the old version and re-bind to the new one.
*/
public void reconnect() {
synchronized (mMutex) {
mContext.unbindService(mServiceConnection);
mServiceConnection = new Connection();
mContext.bindService(mIntent, mServiceConnection,
Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND
| Context.BIND_ALLOW_OOM_MANAGEMENT);
}
}
private class Connection implements ServiceConnection, Runnable {
private ILocationProvider mProvider;
// for caching requiresNetwork, requiresSatellite, etc.
private DummyLocationProvider mCachedAttributes; // synchronized by mMutex
public void onServiceConnected(ComponentName className, IBinder service) {
synchronized (this) {
mProvider = ILocationProvider.Stub.asInterface(service);
if (mProvider != null) {
mHandler.post(this);
}
}
}
public void onServiceDisconnected(ComponentName className) {
synchronized (this) {
mProvider = null;
}
}
public synchronized ILocationProvider getProvider() {
return mProvider;
}
public synchronized DummyLocationProvider getCachedAttributes() {
return mCachedAttributes;
}
public void run() {
synchronized (mMutex) {
if (mServiceConnection != this) {
// This ServiceConnection no longer the one we want to bind to.
return;
}
ILocationProvider provider = getProvider();
if (provider == null) {
return;
}
// resend previous values from the location manager if the service has restarted
try {
if (mEnabled) {
provider.enable();
}
if (mLocationTracking) {
provider.enableLocationTracking(true);
}
if (mMinTime >= 0) {
provider.setMinTime(mMinTime, mMinTimeSource);
}
if (mNetworkInfo != null) {
provider.updateNetworkState(mNetworkState, mNetworkInfo);
}
} catch (RemoteException e) {
}
// init cache of parameters
if (mCachedAttributes == null) {
try {
mCachedAttributes = new DummyLocationProvider(mName, null);
mCachedAttributes.setRequiresNetwork(provider.requiresNetwork());
mCachedAttributes.setRequiresSatellite(provider.requiresSatellite());
mCachedAttributes.setRequiresCell(provider.requiresCell());
mCachedAttributes.setHasMonetaryCost(provider.hasMonetaryCost());
mCachedAttributes.setSupportsAltitude(provider.supportsAltitude());
mCachedAttributes.setSupportsSpeed(provider.supportsSpeed());
mCachedAttributes.setSupportsBearing(provider.supportsBearing());
mCachedAttributes.setPowerRequirement(provider.getPowerRequirement());
mCachedAttributes.setAccuracy(provider.getAccuracy());
} catch (RemoteException e) {
mCachedAttributes = null;
}
}
}
}
};
public String getName() {
return mName;
}
private DummyLocationProvider getCachedAttributes() {
synchronized (mMutex) {
return mServiceConnection.getCachedAttributes();
}
}
public boolean requiresNetwork() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.requiresNetwork();
} else {
return false;
}
}
public boolean requiresSatellite() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.requiresSatellite();
} else {
return false;
}
}
public boolean requiresCell() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.requiresCell();
} else {
return false;
}
}
public boolean hasMonetaryCost() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.hasMonetaryCost();
} else {
return false;
}
}
public boolean supportsAltitude() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.supportsAltitude();
} else {
return false;
}
}
public boolean supportsSpeed() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.supportsSpeed();
} else {
return false;
}
}
public boolean supportsBearing() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.supportsBearing();
} else {
return false;
}
}
public int getPowerRequirement() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.getPowerRequirement();
} else {
return -1;
}
}
public int getAccuracy() {
DummyLocationProvider cachedAttributes = getCachedAttributes();
if (cachedAttributes != null) {
return cachedAttributes.getAccuracy();
} else {
return -1;
}
}
public boolean meetsCriteria(Criteria criteria) {
synchronized (mMutex) {
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
return provider.meetsCriteria(criteria);
} catch (RemoteException e) {
}
}
}
// default implementation if we lost connection to the provider
if ((criteria.getAccuracy() != Criteria.NO_REQUIREMENT) &&
(criteria.getAccuracy() < getAccuracy())) {
return false;
}
int criteriaPower = criteria.getPowerRequirement();
if ((criteriaPower != Criteria.NO_REQUIREMENT) &&
(criteriaPower < getPowerRequirement())) {
return false;
}
if (criteria.isAltitudeRequired() && !supportsAltitude()) {
return false;
}
if (criteria.isSpeedRequired() && !supportsSpeed()) {
return false;
}
if (criteria.isBearingRequired() && !supportsBearing()) {
return false;
}
return true;
}
public void enable() {
synchronized (mMutex) {
mEnabled = true;
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.enable();
} catch (RemoteException e) {
}
}
}
}
public void disable() {
synchronized (mMutex) {
mEnabled = false;
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.disable();
} catch (RemoteException e) {
}
}
}
}
public boolean isEnabled() {
synchronized (mMutex) {
return mEnabled;
}
}
public int getStatus(Bundle extras) {
ILocationProvider provider;
synchronized (mMutex) {
provider = mServiceConnection.getProvider();
}
if (provider != null) {
try {
return provider.getStatus(extras);
} catch (RemoteException e) {
}
}
return 0;
}
public long getStatusUpdateTime() {
ILocationProvider provider;
synchronized (mMutex) {
provider = mServiceConnection.getProvider();
}
if (provider != null) {
try {
return provider.getStatusUpdateTime();
} catch (RemoteException e) {
}
}
return 0;
}
public String getInternalState() {
ILocationProvider provider;
synchronized (mMutex) {
provider = mServiceConnection.getProvider();
}
if (provider != null) {
try {
return provider.getInternalState();
} catch (RemoteException e) {
Log.e(TAG, "getInternalState failed", e);
}
}
return null;
}
public boolean isLocationTracking() {
synchronized (mMutex) {
return mLocationTracking;
}
}
public void enableLocationTracking(boolean enable) {
synchronized (mMutex) {
mLocationTracking = enable;
if (!enable) {
mMinTime = -1;
mMinTimeSource.clear();
}
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.enableLocationTracking(enable);
} catch (RemoteException e) {
}
}
}
}
public boolean requestSingleShotFix() {
return false;
}
public long getMinTime() {
synchronized (mMutex) {
return mMinTime;
}
}
public void setMinTime(long minTime, WorkSource ws) {
synchronized (mMutex) {
mMinTime = minTime;
mMinTimeSource.set(ws);
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.setMinTime(minTime, ws);
} catch (RemoteException e) {
}
}
}
}
public void updateNetworkState(int state, NetworkInfo info) {
synchronized (mMutex) {
mNetworkState = state;
mNetworkInfo = info;
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.updateNetworkState(state, info);
} catch (RemoteException e) {
}
}
}
}
public void updateLocation(Location location) {
synchronized (mMutex) {
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.updateLocation(location);
} catch (RemoteException e) {
}
}
}
}
public boolean sendExtraCommand(String command, Bundle extras) {
synchronized (mMutex) {
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
return provider.sendExtraCommand(command, extras);
} catch (RemoteException e) {
}
}
}
return false;
}
public void addListener(int uid) {
synchronized (mMutex) {
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.addListener(uid);
} catch (RemoteException e) {
}
}
}
}
public void removeListener(int uid) {
synchronized (mMutex) {
ILocationProvider provider = mServiceConnection.getProvider();
if (provider != null) {
try {
provider.removeListener(uid);
} catch (RemoteException e) {
}
}
}
}
}