如何在Android应用中实现类似Snap Map的好友实时位置追踪？

嘿，很高兴看到你已经搞定了自身位置的获取！要实现类似Snap Map的好友位置追踪，核心是把每个用户的位置实时同步到后端服务，然后监听其他好友的位置更新。既然你已经用了Firebase Auth，那Firebase Realtime Database就是绝佳的选择——它能轻松实现实时数据同步。我来给你一步步讲解并修改你的代码：

1. 先完成Firebase Realtime Database的基础配置 #

首先你需要在Firebase控制台完成数据库的基础配置：

• 打开Firebase控制台，找到你的项目，进入「Realtime Database」页面创建数据库
• 开发阶段可以暂时设置规则为开放（上线后一定要改成仅授权用户可访问）：

  {
    "rules": {
      ".read": true,
      ".write": true
    }
  }
  

• 在你的app级build.gradle里添加数据库依赖（用最新版本即可）：

  implementation 'com.google.firebase:firebase-database:20.3.0'
  

2. 修改代码，添加位置同步和好友监听功能 #

我会基于你的现有代码，添加上传自身位置、监听好友位置的完整逻辑：

完整修改后的MapsActivity代码 #

import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import java.util.HashMap;

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback, LocationListener { 
    private FirebaseAuth mAuth;
    final static int PERMISSION_ALL = 1;
    final static String[] PERMISSIONS = {Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION}; 
    private GoogleMap mMap; 
    MarkerOptions mo; 
    Marker myMarker; 
    private LocationManager locationManager;
    // 新增：Firebase数据库引用
    private DatabaseReference mDatabase;
    // 新增：存储好友的标记，key是好友UID，value是对应的Marker
    private HashMap<String, Marker> friendMarkers = new HashMap<>();
    // 示例好友UID列表（实际项目中应该从好友系统获取）
    private String[] friendUids = {"好友1的UID", "好友2的UID"};

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.activity_maps); 
        mAuth = FirebaseAuth.getInstance(); 
        // 初始化Firebase数据库引用
        mDatabase = FirebaseDatabase.getInstance().getReference();

        // Obtain the SupportMapFragment and get notified when the map is ready to be used. 
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager() 
                .findFragmentById(R.id.map); 
        mapFragment.getMapAsync(this); 
        locationManager = (LocationManager) getSystemService(LOCATION_SERVICE); 
        mo = new MarkerOptions().position(new LatLng(0, 0)).title("My Current Location"); 

        if (Build.VERSION.SDK_INT >= 27 && !isPermissionGranted()) { 
            requestPermissions(PERMISSIONS, PERMISSION_ALL); 
        } else requestLocation(); 

        if (!isLocationEnabled()) showAlert(1); 

        // 启动监听好友位置
        startListeningToFriendsLocation();
    } 

    @Override 
    public void onMapReady(GoogleMap googleMap) { 
        mMap = googleMap; 
        myMarker = mMap.addMarker(mo); 
    } 

    // Called when the location has changed. 
    @Override 
    public void onLocationChanged(Location location) { 
        LatLng myCoordinates = new LatLng(location.getLatitude(), location.getLongitude()); 
        myMarker.setPosition(myCoordinates); 
        mMap.moveCamera(CameraUpdateFactory.newLatLng(myCoordinates));

        // 新增：上传自身位置到Firebase数据库
        String currentUid = mAuth.getCurrentUser().getUid();
        mDatabase.child("user_locations").child(currentUid).setValue(new UserLocation(location.getLatitude(), location.getLongitude()));
    } 

    // 新增：用于存储位置的实体类（Firebase需要空构造函数）
    public static class UserLocation {
        public double lat;
        public double lng;

        public UserLocation() {}

        public UserLocation(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
    }

    // 新增：监听所有好友的位置变化
    private void startListeningToFriendsLocation() {
        for (String friendUid : friendUids) {
            mDatabase.child("user_locations").child(friendUid).addValueEventListener(new ValueEventListener() {
                @Override
                public void onDataChange(DataSnapshot dataSnapshot) {
                    UserLocation friendLocation = dataSnapshot.getValue(UserLocation.class);
                    if (friendLocation != null) {
                        LatLng friendLatLng = new LatLng(friendLocation.lat, friendLocation.lng);
                        // 检查是否已有该好友的标记，有就更新位置，没有就添加新标记
                        if (friendMarkers.containsKey(friendUid)) {
                            friendMarkers.get(friendUid).setPosition(friendLatLng);
                        } else {
                            MarkerOptions friendMo = new MarkerOptions()
                                    .position(friendLatLng)
                                    .title("Friend: " + friendUid); // 实际可以显示好友昵称
                            Marker friendMarker = mMap.addMarker(friendMo);
                            friendMarkers.put(friendUid, friendMarker);
                        }
                    }
                }

                @Override
                public void onCancelled(DatabaseError databaseError) {
                    // 可以在这里添加错误日志或提示
                }
            });
        }
    }

    // 以下是你原有代码，保持不变
    @Override 
    public void onStatusChanged(String provider, int status, Bundle extras) { } 

    @Override 
    public void onProviderEnabled(String provider) { } 

    @Override 
    public void onProviderDisabled(String provider) { } 

    private void requestLocation() { 
        Criteria criteria = new Criteria(); 
        criteria.setAccuracy(Criteria.ACCURACY_FINE); 
        criteria.setPowerRequirement(Criteria.POWER_HIGH); 
        String provider = locationManager.getBestProvider(criteria, true); 
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { 
            return; 
        } 
        locationManager.requestLocationUpdates(provider, 10000, 10, this); 
    } 

    private boolean isLocationEnabled() { 
        return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER); 
    } 

    private boolean isPermissionGranted() { 
        if (checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED || checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) { 
            Log.v("mylog","Permission is granted"); 
            return true; 
        }else{ 
            Log.v("mylog","Permission not granted"); 
            return false; 
        } 
    } 

    private void showAlert(final int status) { 
        String message, title, btnText; 
        if (status == 1) { 
            message = "Your Locations Settings is set to 'Off'.\\nPlease Enable Location to " + "use this app"; 
            title = "Enable Location"; 
            btnText = "Location Settings"; 
        } else { 
            message = "Please allow this app to access location!"; 
            title = "Permission access"; 
            btnText = "Grant"; 
        } 
        final AlertDialog.Builder dialog = new AlertDialog.Builder(this); 
        dialog.setCancelable(false); 
        dialog.setTitle(title) 
                .setMessage(message) 
                .setPositiveButton(btnText, new DialogInterface.OnClickListener() { 
                    @Override 
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) { 
                        if (status == 1) { 
                            Intent myIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS); 
                            startActivity(myIntent); 
                        } else requestPermissions(PERMISSIONS, PERMISSION_ALL); 
                    } 
                }) 
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() { 
                    @Override 
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) { 
                        finish(); 
                    } 
                }); 
        dialog.show(); 
    } 
}

关键功能说明 #

• 上传自身位置：在onLocationChanged方法里，把当前用户的经纬度存储到Firebase的user_locations/{UID}节点下，实现实时同步
• 监听好友位置：startListeningToFriendsLocation方法会为每个好友的位置节点添加实时监听，当好友位置更新时自动更新地图上的标记
• 标记管理：用HashMap存储好友的Marker，避免重复创建，提升地图性能

后续优化建议 #

• 替换示例的friendUids列表：实际项目中应该实现好友系统，比如从Firebase Auth的用户列表或专门的好友节点获取好友UID
• 优化数据库权限：上线前一定要修改Firebase规则，只允许授权用户访问自己和好友的位置数据，保障隐私安全
• 添加个性化标记：比如用不同颜色的图标区分好友，显示好友昵称而非UID
• 调整位置更新频率：可以根据需求修改requestLocationUpdates的时间间隔和距离阈值，平衡实时性和电量消耗

内容的提问来源于stack exchange，提问作者niya panchal