能否在多个Activity间共享FusedLocationProviderClient？如何实现？

能否共享FusedLocationProviderClient？ #

完全可以。FusedLocationProviderClient本身就是为跨组件复用设计的实例，重复创建不仅会引发定位初始化延迟，还会浪费系统资源。

实现方案：用单例类封装定位逻辑 #

最稳妥的方式是把定位相关逻辑（包括FusedLocationProviderClient实例、LocationRequest、LocationCallback）封装在单例类中，让所有Activity共享这个单例的定位服务，避免在每个Activity的onCreate里重复初始化，消除多次请求定位更新带来的延迟。

示例实现代码 #

public class LocationManager {
    private static LocationManager INSTANCE;
    private final FusedLocationProviderClient locationProviderClient;
    private LocationRequest locationRequest;
    private LocationCallback locationCallback;
    private List<LocationUpdateListener> listeners = new ArrayList<>();

    // 私有构造方法，禁止外部实例化
    private LocationManager(Context context) {
        locationProviderClient = LocationServices.getFusedLocationProviderClient(context.getApplicationContext());
        initLocationRequest();
        initLocationCallback();
    }

    // 获取单例实例
    public static synchronized LocationManager getInstance(Context context) {
        if (INSTANCE == null) {
            INSTANCE = new LocationManager(context);
        }
        return INSTANCE;
    }

    // 初始化LocationRequest
    private void initLocationRequest() {
        locationRequest = LocationRequest.create();
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        locationRequest.setInterval(500);
    }

    // 统一处理定位结果，分发给所有注册的监听器
    private void initLocationCallback() {
        locationCallback = new LocationCallback() {
            @Override
            public void onLocationResult(LocationResult locationResult) {
                if (locationResult == null) {
                    return;
                }
                for (Location location : locationResult.getLocations()) {
                    if (location != null) {
                        // 通知所有注册的监听器
                        for (LocationUpdateListener listener : listeners) {
                            listener.onLocationUpdated(location);
                        }
                    }
                }
            }
        };
    }

    // 注册定位更新监听器（Activity调用此方法接收定位数据）
    public void registerListener(LocationUpdateListener listener) {
        if (!listeners.contains(listener)) {
            listeners.add(listener);
            // 仅当第一个监听器注册时，才启动定位更新
            if (listeners.size() == 1) {
                startLocationUpdates();
            }
        }
    }

    // 取消注册监听器（Activity在onDestroy/onStop时调用，避免内存泄漏）
    public void unregisterListener(LocationUpdateListener listener) {
        listeners.remove(listener);
        // 无监听器时停止定位更新，节省资源
        if (listeners.isEmpty()) {
            stopLocationUpdates();
        }
    }

    // 启动定位更新请求
    private void startLocationUpdates() {
        try {
            locationProviderClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper());
        } catch (SecurityException e) {
            // 处理权限异常（如用户未授予定位权限）
            e.printStackTrace();
        }
    }

    // 停止定位更新
    private void stopLocationUpdates() {
        locationProviderClient.removeLocationUpdates(locationCallback);
    }

    // 定义监听器接口，Activity实现此接口接收定位数据
    public interface LocationUpdateListener {
        void onLocationUpdated(Location location);
    }
}

Activity中的使用方式 #

1. 让Activity实现LocationManager.LocationUpdateListener接口：

public class MainActivity extends AppCompatActivity implements LocationManager.LocationUpdateListener {
    private LocationManager locationManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        locationManager = LocationManager.getInstance(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // 注册监听器，开始接收定位更新
        locationManager.registerListener(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 取消注册监听器，避免内存泄漏
        locationManager.unregisterListener(this);
    }

    @Override
    public void onLocationUpdated(Location location) {
        // 在这里处理定位数据（如更新UI）
        // Do some stuff with the location
    }
}

额外优化建议 #

• 权限处理：确保请求定位前已获取ACCESS_FINE_LOCATION或ACCESS_COARSE_LOCATION权限，避免因权限问题导致定位失败。
• 首次定位延迟优化：可在应用启动时（如Application的onCreate方法）提前初始化LocationManager，或调用getLastLocation()获取最近的缓存定位结果，先展示缓存数据再等待实时更新，提升用户体验。示例代码如下：

// 在LocationManager中添加获取最后定位的方法
public void getLastLocation(LocationResultCallback callback) {
    try {
        locationProviderClient.getLastLocation()
                .addOnSuccessListener(location -> {
                    if (location != null) {
                        callback.onResult(location);
                    }
                })
                .addOnFailureListener(e -> callback.onError(e));
    } catch (SecurityException e) {
        callback.onError(e);
    }
}

// 对应的回调接口
public interface LocationResultCallback {
    void onResult(Location location);
    void onError(Exception e);
}

内容的提问来源于stack exchange，提问作者Henrik Berg