Android 如何设置随时间变化的随机位置标记

我正在开发一个应用程序，可以获取当前用户的位置，并在该位置添加一个标记。还有三个标记具有静态位置，还有一个名为“drawCircle”的函数，它围绕这些标记绘制圆圈，以测量这三个标记位置与用户当前位置之间的距离

类“Avatar”包含一个构造器，该构造器由三个标记（名称、经度和纬度）填充

如何随机设置三个标记的位置，以便它们在一段时间内发生变化

这是我的代码：

public class MapsActivity extends FragmentActivity implements
    OnMapReadyCallback,
    GoogleApiClient.ConnectionCallbacks,
    GoogleApiClient.OnConnectionFailedListener,
    LocationListener{

private GoogleMap mMap;
private GoogleMap firstMarker;
private GoogleMap secondMarker;
private GoogleMap thirdMarker;
private GoogleApiClient googleApiClient;
private LocationRequest locationRequest;
private Location mlocation;
private LocationManager locationManager;
private Marker currentUserLocationMarker;

Avatar[] character;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_maps);

    googleApiClient = new GoogleApiClient.Builder(this)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .addApi(LocationServices.API)
            .build();
    locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

    // 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);

    Avatar = new Avatar[3];
    Avatar[0] = new Avatar("firstMarker", 1000, 1000, 45.827159, 13.341452);
    Avatar[1] = new Avatar("secondMarker", 1000, 1000, 45.886060, 13.284799);
    Avatar[2] = new Avatar("thirdMarker", 1000, 1000, 45.825058, 13.345014);

}


@Override
public void onMapReady(GoogleMap googleMap) {
    mMap = googleMap;
    firstMarker = googleMap;
    secondMarker = googleMap;
    thirdMarker = googleMap;

    LatLng posFirstMarker = new LatLng(Avatar[0].Lat, Avatar[0].Long);
    LatLng posSecondMarker = new LatLng(Avatar[1].Lat, Avatar[1].Long);
    LatLng posThirdMarker = new LatLng(Avatar[2].Lat, Avatar[2].Long);

    BitmapDrawable dr = (BitmapDrawable) getResources().getDrawable(R.drawable.firstMarkerImg);
    Bitmap bitmapD = Bitmap.createScaledBitmap(dr.getBitmap(), 200, 200, false);
    BitmapDrawable bt = (BitmapDrawable) getResources().getDrawable(R.drawable.secondMarkerImg);
    Bitmap bitmapB = Bitmap.createScaledBitmap(bt.getBitmap(), 200, 200, false);
    BitmapDrawable sp = (BitmapDrawable) getResources().getDrawable(R.drawable.thirdMarkerImg);
    Bitmap bitmapS = Bitmap.createScaledBitmap(sp.getBitmap(), 125, 125, false);

    firstMarker.addMarker(new MarkerOptions().snippet("My Snippet").icon(BitmapDescriptorFactory.fromBitmap(bitmapB)).position(posFirstMarker).title("Pipistrello"));
    firstMarker.moveCamera(CameraUpdateFactory.newLatLng(posFirstMarker));
    secondMarker.addMarker(new MarkerOptions().snippet("My Snippet").icon(BitmapDescriptorFactory.fromBitmap(bitmapD)).position(posSecondMarker).title("Drago"));
    secondMarker.moveCamera(CameraUpdateFactory.newLatLng(posSecondMarker));
    thirdMarker.addMarker(new MarkerOptions().snippet("My Snippet").icon(BitmapDescriptorFactory.fromBitmap(bitmapS)).position(posThirdMarker).title("Serpe"));
    thirdMarker.moveCamera(CameraUpdateFactory.newLatLng(posThirdMarker));


    private GoogleMap Mymarker;
    @Override
    public void onMapReady (GoogleMap googleMap){
        Mymarker = googleMap;
        LatLng markerPosition = new LatLng(Lat, Long);
        BitmapDrawable dr = (BitmapDrawable) getResources().getDrawable(R.drawable.my_image);
        Bitmap bitmapD = Bitmap.createScaledBitmap(dr.getBitmap(), 200, 200, false);
        Mymarker.addMarker(new MarkerOptions().snippet("My Snippet").icon(BitmapDescriptorFactory.fromBitmap(bitmapD)).position(markerPosition).title("Marker"));
        Mymarker.moveCamera(CameraUpdateFactory.newLatLng(markerPosition));
    }


}

@Override
public void onConnected(Bundle bundle) {
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        // TODO: Consider calling
        //    ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
        //                                          int[] grantResults)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.
        return;
    }
    startLocationUpdates();
    mlocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
    if (mlocation == null) {
        startLocationUpdates();
    }
    if (mlocation != null) {
        double latitude = mlocation.getLatitude();
        double longitude = mlocation.getLongitude();
    } else {
        Toast.makeText(this, "Location not Detected", Toast.LENGTH_SHORT).show();
    }
}

protected void startLocationUpdates() {
    // Create the location request
    locationRequest = LocationRequest.create()
            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
            .setInterval(1100)
            .setFastestInterval(1100);
    // Request location updates
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        // TODO: Consider calling
        //    ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
        //                                          int[] grantResults)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.
        return;
    }
    LocationServices.FusedLocationApi.requestLocationUpdates(googleApiClient,
            locationRequest, this);
    Log.d("reque", "--->>>>");
}

@Override
public void onConnectionSuspended(int i) {
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
}

@Override
public void onStart() {
    super.onStart();
    googleApiClient.connect();
}

@Override
public void onStop() {
    super.onStop();
    if (googleApiClient.isConnected()) {
        googleApiClient.disconnect();
    }
}

@Override
public void onLocationChanged(Location location) {
    mlocation = location;
    if (currentUserLocationMarker != null) {
        currentUserLocationMarker.remove();
    }
    LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
    MarkerOptions markerOptions = new MarkerOptions();
    markerOptions.position(latLng);
    markerOptions.title("Current Location");
    markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_ORANGE));
    currentUserLocationMarker = mMap.addMarker(markerOptions);

    drawCircle(new LatLng(location.getLatitude(), location.getLongitude()));
    Distance(new LatLng(location.getLatitude(), location.getLongitude()));

    mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
    //mMap.animateCamera(CameraUpdateFactory.zoomBy(13));

    if (googleApiClient != null) {
        LocationServices.FusedLocationApi.removeLocationUpdates(googleApiClient, this);
    }
}

private void drawCircle(LatLng point) {

    // Instantiating CircleOptions to draw a circle around the marker
    CircleOptions circleOptions = new CircleOptions();
    // Specifying the center of the circle
    circleOptions.center(point);
    // Radius of the circle
    circleOptions.radius(1000);
    // Border color of the circle
    circleOptions.strokeColor(Color.BLACK);
    // Fill color of the circle
    circleOptions.fillColor(0x30ff0000);
    // Border width of the circle
    circleOptions.strokeWidth(2);
    // Adding the circle to the GoogleMap
    mMap.addCircle(circleOptions);
}

private void Distance(LatLng distance) {

    float[] results = new float[1];

    for (int i = 0; i < 3; i++) {

        Location.distanceBetween(mlocation.getLatitude(), mlocation.getLongitude(),
                Avatar[i].Lat, Avatar[i].Long, results);
    }

}}

公共类映射活动扩展了FragmentActivity实现
四月一日，
GoogleAppClient.ConnectionCallbacks，
GoogleAppClient.OnConnectionFailedListener，
位置侦听器{
私有谷歌地图；
私人谷歌地图；
私有谷歌地图；
私人谷歌地图第三市场；
私人GoogleapClient GoogleapClient；
私人位置请求位置请求；
私人位置；
私人场所经理场所经理；
私有标记currentUserLocationMarker；
化身[]角色；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_映射）；
GoogleapClient=新的GoogleapClient.Builder（此）
.addConnectionCallbacks（此）
.addOnConnectionFailedListener（此）
.addApi（LocationServices.API）
.build（）；
locationManager=（locationManager）getSystemService（Context.LOCATION\u服务）；
//获取SupportMapFragment，并在地图准备好使用时收到通知。
SupportMapFragment mapFragment=（SupportMapFragment）getSupportFragmentManager（）
.findFragmentById（R.id.map）；
getMapAsync（这个）；
阿凡达=新的阿凡达[3]；
阿凡达[0]=新的阿凡达（“firstMarker”，10001000，45.827159，13.341452）；
阿凡达[1]=新的阿凡达（“第二标记”，1000,1000,45.886060,13.284799）；
阿凡达[2]=新的阿凡达（“第三个标记者”，10001000，45.825058，13.345014）；
}
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
mMap=谷歌地图；
firstMarker=谷歌地图；
secondMarker=谷歌地图；
thirdMarker=谷歌地图；
LatLng posFirstMarker=new LatLng（化身[0]。Lat，化身[0]。长）；
LatLng posSecondMarker=新LatLng（化身[1]。Lat，化身[1]。长）；
LatLng posThirdMarker=新LatLng（化身[2]。Lat，化身[2]。长）；
BitmapDrawable dr=（BitmapDrawable）getResources（）.getDrawable（R.drawable.firstMarkerImg）；
位图bitmapD=Bitmap.createScaledBitmap（dr.getBitmap（），200，200，false）；
BitmapDrawable bt=（BitmapDrawable）getResources（）.getDrawable（R.drawable.secondMarkerImg）；
位图bitmapB=Bitmap.createScaledBitmap（bt.getBitmap（），200，200，false）；
BitmapDrawable sp=（BitmapDrawable）getResources（）.getDrawable（R.drawable.thirdMarkerImg）；
位图位图=位图.createScaledBitmap（sp.getBitmap（），125，false）；
firstMarker.addMarker（新MarkerOptions（）.snippet（“我的代码片段”）.icon（BitmapDescriptorFactory.fromBitmap（bitmapB））.position（posFirstMarker.title（“Pipistrello”）；
firstMarker.moveCamera（CameraUpdateFactory.newLatLng（posFirstMarker））；
secondMarker.addMarker（新MarkerOptions（）.snippet（“我的代码片段”）.icon（BitmapDescriptorFactory.fromBitmap（bitmapD））.posSecondMarker.title（“Drago”）；
第二个Marker.moveCamera（CameraUpdateFactory.newLatLng（PossencodeMarker））；
thirdMarker.addMarker（新MarkerOptions（）.snippet（“我的代码片段”）.icon（BitmapDescriptorFactory.fromBitmap（位图））.position（posThirdMarker.title（“Serpe”）；
第三个市场。移动相机（CameraUpdateFactory.newLatLng（后第三个市场））；
私有谷歌地图Mymarker；
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
Mymarker=谷歌地图；
板条标记位置=新板条（板条，长）；
BitmapDrawable dr=（BitmapDrawable）getResources（）.getDrawable（R.drawable.my_image）；
位图bitmapD=Bitmap.createScaledBitmap（dr.getBitmap（），200，200，false）；
Mymarker.addMarker（新MarkerOptions（）.snippet（“我的代码片段”）.icon（BitmapDescriptorFactory.fromBitmap（bitmapD））.position（markerPosition）.title（“标记”）；
Mymarker.moveCamera（CameraUpdateFactory.newLatLng（markerPosition））；
}
}
@凌驾
未连接的公共空间（捆绑包）{
if（ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予和&ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u LOCATION）！=PackageManager.permission\u已授予）{
考虑到呼叫
//ActivityCompat#请求权限
//在此处请求缺少的权限，然后覆盖
//public void onRequestPermissionsResult（int-requestCode，字符串[]权限，
//int[]格兰特结果）
//处理用户授予权限的情况。请参阅文档
//对于ActivityCompat，请请求权限以获取更多详细信息。
返回；
}
startLocationUpdates（）；
mlocation=LocationServices.FusedLocationApi.getLastLocation（GoogleAppClient）；
if（mlocation==null）{
startLocationUpdates（）；
}
如果（mlocation！=null）{
双纬度=mlocation.getLatitude（）；
double longitude=mlocation.getLongitude（）；
}否则{
Toast.makeText（此“未检测到位置”，Toast.LENGTH_SHORT）.show（）；
}
}
受保护的void startLocationUpdates（）{
//创建位置请求
locationRequest=locationRequest.create（）
.setPriority（定位请求。优先级高精度）
.setInterval（1100）
.SetFastTestInterval（1100）；
//请求位置更新
if（ActivityCompat.checkSelfPermission（this，Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予&&ActivityComp
new LatLng(parseCoordRandom(arrayList.get(i).getLatitude()), parseCoordRandom(arrayList.get(i).getLongitude()))

public static double parseCoordRandom(@NonNull String s_coord)
    return tryParseStringToDouble(s_coord, 0.0) +getMarkerOffset();
}

public static double tryParseStringToDouble(@NonNull String s, double defaultValue) {
    try {
        return Double.parseDouble(s);
    } catch (NumberFormatException e) {
        return defaultValue;
    }
}

public static double getMarkerOffset(){
    //add tiny random offset to keep markers from dropping on top of themselves
    double offset =Math.random()/4000;
    boolean isEven = ((int)(offset *400000)) %2 ==0;
    if (isEven) return  offset;
    else        return -offset;
}