Java 使用多位置地理围栏

我用了这个密码

（）

（）

该代码通过单击创建geofence，并且只使用一个geofence

但我想在geofence启动时再做一个固定标记，然后再使用一个geofence

所以我修改了这段代码（mapsacativity.java）

package com.example.geofineering；
导入androidx.annotation.NonNull；
导入androidx.core.app.ActivityCompat；
导入androidx.core.content.ContextCompat；
导入androidx.fragment.app.FragmentActivity；
导入android.Manifest；
导入android.app.pendingent；
导入android.content.pm.PackageManager；
导入android.graphics.Color；
导入android.os.Build；
导入android.os.Bundle；
导入android.util.Log；
导入android.widget.Toast；
导入com.google.android.gms.location.geofense；
导入com.google.android.gms.location.GeofencingClient；
导入com.google.android.gms.location.GeofencingRequest；
导入com.google.android.gms.location.LocationServices；
导入com.google.android.gms.maps.CameraUpdateFactory；
导入com.google.android.gms.maps.GoogleMap；
导入com.google.android.gms.maps.OnMapReadyCallback；
导入com.google.android.gms.maps.SupportMapFragment；
导入com.google.android.gms.maps.model.CircleOptions；
导入com.google.android.gms.maps.model.LatLng；
导入com.google.android.gms.maps.model.MarkerOptions；
导入com.google.android.gms.tasks.OnFailureListener；
导入com.google.android.gms.tasks.OnSuccessListener；
导入java.util.ArrayList；
导入java.util.List；
公共类MapsActivity扩展了FragmentActivity在MapReadyCallback上的实现{
私有静态最终字符串TAG=“MapsActivity”；
私有谷歌地图；
私人Geofencing客户Geofencing客户；
私人GeofenceHelper GeofenceHelper；
专用浮式土工围栏_半径=20；
专用字符串geofrance\u ID=“SOME\u geofrance\u ID”；
私有内部精细位置访问请求代码=10001；
私有int后台\位置\访问\请求\代码=10002；
私人名单；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_映射）；
//获取SupportMapFragment，并在地图准备好使用时收到通知。
SupportMapFragment mapFragment=（SupportMapFragment）getSupportFragmentManager（）
.findFragmentById（R.id.map）；
getMapAsync（这个）；
geofencingClient=LocationServices.getGeofencingClient（this）；
geofenceHelper=新的geofenceHelper（此）；
}
/**
*一旦可用，就可以操纵贴图。
*当映射准备好使用时，将触发此回调。
*这是我们可以添加标记或线条、添加侦听器或移动摄影机的地方。在这种情况下，
*我们只是在澳大利亚悉尼附近加了一个标记。
*如果设备上未安装Google Play服务，系统将提示用户安装
*它位于SupportMapFragment内。此方法仅在用户
*已安装Google Play服务并返回应用程序。
*/
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
mMap=谷歌地图；
//将相机移到起点
LatLng LatLng_start=新LatLng（37.462749126.910311）；
mMap.moveCamera（CameraUpdateFactory.newLatLngZoom（latLng_start，16））；
latLng=新阵列列表（）；
latLng.add（新latLng（38.462349123.909955））；
latLng.add（新latLng（38.463194123.911317））；
latLng.add（新latLng（38.462720123.910768））；
latLng.add（新latLng（38.462743123.910317））；
用于（LatLng i：LatLng）{
添加标记（i）；
添加圆（i，土工围栏半径）；
添加土工栅栏（i，土工栅栏半径）；
}
//对于（int i=0；ipackage com.example.geofencing;

import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.FragmentActivity;

import android.Manifest;
import android.app.PendingIntent;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import com.google.android.gms.location.Geofence;
import com.google.android.gms.location.GeofencingClient;
import com.google.android.gms.location.GeofencingRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.CircleOptions;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;

import java.util.ArrayList;
import java.util.List;

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback {

    private static final String TAG = "MapsActivity";

    private GoogleMap mMap;
    private GeofencingClient geofencingClient;
    private GeofenceHelper geofenceHelper;

    private float GEOFENCE_RADIUS = 20;
    private String GEOFENCE_ID = "SOME_GEOFENCE_ID";

    private int FINE_LOCATION_ACCESS_REQUEST_CODE = 10001;
    private int BACKGROUND_LOCATION_ACCESS_REQUEST_CODE = 10002;

    private List<LatLng> latLng;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maps);
        // 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);

        geofencingClient = LocationServices.getGeofencingClient(this);
        geofenceHelper = new GeofenceHelper(this);
    }


    /**
     * Manipulates the map once available.
     * This callback is triggered when the map is ready to be used.
     * This is where we can add markers or lines, add listeners or move the camera. In this case,
     * we just add a marker near Sydney, Australia.
     * If Google Play services is not installed on the device, the user will be prompted to install
     * it inside the SupportMapFragment. This method will only be triggered once the user has
     * installed Google Play services and returned to the app.
     */
    @Override
    public void onMapReady(GoogleMap googleMap) {
        mMap = googleMap;
       
        //move the camera to the starting point
        LatLng latLng_start = new LatLng(37.462749, 126.910311);
        mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng_start, 16));

        latLng = new ArrayList<>();
        latLng.add(new LatLng(38.462349, 123.909955));
        latLng.add(new LatLng(38.463194, 123.911317));
        latLng.add(new LatLng(38.462720, 123.910768));
        latLng.add(new LatLng(38.462743, 123.910317));

        for (LatLng i : latLng) {
            addMarker(i);
            addCircle(i, GEOFENCE_RADIUS);
            addGeofence(i, GEOFENCE_RADIUS);
        }


//        for (int i = 0; i < markerLocation.length; i++) {
//            LatLng latLng = new LatLng(markerLocation[i][0], markerLocation[i][1]);
//            addMarker(latLng);
//            addCircle(latLng, GEOFENCE_RADIUS);
//            addGeofence(latLng, GEOFENCE_RADIUS);
//        }
        enableUserLocation();
    }

    private void enableUserLocation() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            mMap.setMyLocationEnabled(true);
        } else {
            //Ask for permission
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
                //We need to show user a dialog for displaying why the permission is needed and then ask for the permission...
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, FINE_LOCATION_ACCESS_REQUEST_CODE);
            } else {
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, FINE_LOCATION_ACCESS_REQUEST_CODE);
            }
        }
    }

    private void addMarker(LatLng latLng) {
        MarkerOptions markerOptions = new MarkerOptions().position(latLng);
        mMap.addMarker(markerOptions);
    }

    private void addCircle(LatLng latLng, float radius) {
        CircleOptions circleOptions = new CircleOptions();
        circleOptions.center(latLng);
        circleOptions.radius(radius);
        circleOptions.strokeColor(Color.argb(255, 255, 0, 0));
        circleOptions.fillColor(Color.argb(64, 255, 0, 0));
        circleOptions.strokeWidth(4);
        mMap.addCircle(circleOptions);
    }

    private void addGeofence(LatLng latLng, float radius) {

        Geofence geofence = geofenceHelper.getGeofence(GEOFENCE_ID, latLng, radius, Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_DWELL | Geofence.GEOFENCE_TRANSITION_EXIT);
        GeofencingRequest geofencingRequest = geofenceHelper.getGeofencingRequest(geofence);
        PendingIntent pendingIntent = geofenceHelper.getPendingIntent();

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_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;
        }
        geofencingClient.addGeofences(geofencingRequest, pendingIntent)
                .addOnSuccessListener(new OnSuccessListener<Void>() {
                    @Override
                    public void onSuccess(Void aVoid) {
                        Log.d(TAG, "onSuccess: Geofence Added...");
                    }
                })
                .addOnFailureListener(new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        String errorMessage = geofenceHelper.getErrorString(e);
                        Log.d(TAG, "onFailure: " + errorMessage);
                    }
                });
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == FINE_LOCATION_ACCESS_REQUEST_CODE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                //We have the permission
                mMap.setMyLocationEnabled(true);
            } else {
                //We do not have the permission..

            }
        }

        if (requestCode == BACKGROUND_LOCATION_ACCESS_REQUEST_CODE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                //We have the permission
                Toast.makeText(this, "You can add geofences...", Toast.LENGTH_SHORT).show();
            } else {
                //We do not have the permission..
                Toast.makeText(this, "Background location access is neccessary for geofences to trigger...", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

private GeofencingRequest getGeofencingRequest() {
    ArrayList<Geofence> geofenceList = new ArrayList<>();
    
    // Iterate through your LatLng(s) to build the Geofence list
    for(LatLng coordinate: latLngList){

        // Set up each Geofence with your corresponding values
        geofenceList.add(new Geofence.Builder()
                .setRequestId("My Geofence ID") // A string to identify this geofence
                .setCircularRegion(coordinate.latitude, coordinate.longitude, Constants.GEOFENCE_LARGE_RADIUS_IN_METERS)
                .setExpirationDuration(Constants.GEOFENCE_EXPIRATION_IN_MILLISECONDS)
                .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER)
                .build()
        );
    }
    
    GeofencingRequest.Builder builder = new GeofencingRequest.Builder();

    // The INITIAL_TRIGGER_ENTER flag indicates that geofencing service should trigger a
    // GEOFENCE_TRANSITION_ENTER notification when the geofence is added and if the device
    // is already inside that geofence.
    builder.setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER);

    // Add the geofences to be monitored by geofencing service using the list we created.
    builder.addGeofences(geofenceList);

    return builder.build();
}

private void addGeofences() {
    PendingIntent pendingIntent = geofenceHelper.getPendingIntent();

    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_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;
    }
    
    // Pass the request built with the getGeofencingRequest() function to the Geofencing Client
    geofencingClient.addGeofences(getGeofencingRequest(), pendingIntent)
            .addOnSuccessListener(new OnSuccessListener<Void>() {
                @Override
                public void onSuccess(Void aVoid) {
                    Log.d(TAG, "onSuccess: Geofence Added...");
                }
            })
            .addOnFailureListener(new OnFailureListener() {
                @Override
                public void onFailure(@NonNull Exception e) {
                    String errorMessage = geofenceHelper.getErrorString(e);
                    Log.d(TAG, "onFailure: " + errorMessage);
                }
            });
}

latLngList = new ArrayList<>();
latLngList.add(new LatLng(38.462349, 123.909955));
latLngList.add(new LatLng(38.463194, 123.911317));
latLngList.add(new LatLng(38.462720, 123.910768));
latLngList.add(new LatLng(38.462743, 123.910317));

addGeofences(); // Add all of your geofences to the client