Java 当我打开片段时，如何在谷歌地图中只显示一次当前用户位置？

当我在Android Studio中打开片段时，如何在Google地图中只显示一次当前用户位置？ 我使用此代码，但相机会不断移动到用户当前位置。当用户移动地图时，它会自动移回当前位置

public class MapsFragment extends Fragment implements GoogleApiClient.ConnectionCallbacks,
        GoogleApiClient.OnConnectionFailedListener,
        LocationListener, OnMapReadyCallback {

private SharedPreferences sharedPref;

private GoogleMap gMap;

private GoogleApiClient mGoogleApiClient;
private LocationRequest mLocationRequest;

private Location locationData;


private static final long TIME_INTERVAL_GET_LOCATION = 1000 * 5; 
private final static int CONNECTION_FAILURE_RESOLUTION_REQUEST = 5000;

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sharedPref = PreferenceManager.getDefaultSharedPreferences(getContext());

        View rootView = inflater.inflate(R.layout.fragment_map, null);

        SupportMapFragment mapFragment = (SupportMapFragment) getChildFragmentManager().findFragmentById(R.id.map);

        mapFragment.getMapAsync(this);

        TedPermission.with(getActivity())
        .setPermissionListener(permissionlistener)
        .setDeniedMessage("If you reject permission,you can not use this service\n\nPlease turn on permissions at [Setting] > [Permission]")
        .setPermissions(Manifest.permission.ACCESS_FINE_LOCATION)
        .check();

        mGoogleApiClient = new GoogleApiClient.Builder(getActivity())
        .addConnectionCallbacks(this)
        .addOnConnectionFailedListener(this)
        .addApi(LocationServices.API)
        .build();

        return rootView;
        }


@Override
public void onResume() {
        super.onResume();


        }

        PermissionListener permissionlistener = new PermissionListener() {
@Override
public void onPermissionGranted() {

        mLocationRequest = LocationRequest.create()
        .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
        .setInterval(TIME_INTERVAL_GET_LOCATION)    
        .setFastestInterval(TIME_INTERVAL_GET_LOCATION); 


        if (!mGoogleApiClient.isConnected()) {
        mGoogleApiClient.connect();
        locationChecker(mGoogleApiClient, getActivity());
        }
        }

@Override
public void onPermissionDenied(ArrayList<String> deniedPermissions) {
        }
        };

@Override
public void onConnected(@Nullable Bundle bundle) {

        if (ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
        ActivityCompat.checkSelfPermission(getActivity(), Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {

        return;
        }
  

        FusedLocationProviderClient mFusedLocationClient = LocationServices.getFusedLocationProviderClient(getActivity());
        mFusedLocationClient.requestLocationUpdates(mLocationRequest, new LocationCallback() {
@Override
public void onLocationResult(LocationResult locationResult) {
        locationData = locationResult.getLastLocation();
        if (locationData != null) {

        LatLng myLocation = new LatLng(locationData.getLatitude(), locationData.getLongitude());

        gMap.clear();

        gMap.addMarker(new MarkerOptions().position(myLocation).title("You are here!").icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_BLUE)));

        CameraPosition cameraPosition = new CameraPosition.Builder().target(myLocation).zoom(14).build();
        gMap.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
   

        }

        }
        }, null);

        }

@Override
public void onConnectionSuspended(int i) {

        }

@Override
public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {

       //........
        

        }

public void locationChecker(GoogleApiClient mGoogleApiClient, final Activity activity) {
        LocationRequest locationRequest = LocationRequest.create();
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        locationRequest.setInterval(30 * 1000);
        locationRequest.setFastestInterval(5 * 1000);
        LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
        .addLocationRequest(locationRequest);
        builder.setAlwaysShow(true);
        PendingResult<LocationSettingsResult> result =
        LocationServices.SettingsApi.checkLocationSettings(mGoogleApiClient, builder.build());
        result.setResultCallback(new ResultCallback<LocationSettingsResult>() {
@Override
public void onResult(LocationSettingsResult result) {
final Status status = result.getStatus();
final LocationSettingsStates state = result.getLocationSettingsStates();
        switch (status.getStatusCode()) {
        case LocationSettingsStatusCodes.SUCCESS:
        
        break;
        case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
       
        try {
       
        status.startResolutionForResult(activity, 1000);

        } catch (IntentSender.SendIntentException e) {
        
        }
        break;
        case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
       
        break;
        }
        }

            });
        }

@Override
public void onLocationChanged(Location location) {
    {


        }
        }

    @Override
    public void onStatusChanged(String s, int i, Bundle bundle) {

    }

    @Override
    public void onProviderEnabled(String s) {

    }

    @Override
    public void onProviderDisabled(String s) {

    }

    @Override
public void onMapReady(GoogleMap googleMap) {
        gMap = googleMap;
        gMap.getUiSettings().setZoomControlsEnabled(false);
        gMap.setBuildingsEnabled(false);
        gMap.getUiSettings().setCompassEnabled(true);
        gMap.getUiSettings().setCompassEnabled(true);
        gMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
        gMap.setIndoorEnabled(false);
        gMap.getUiSettings().setRotateGesturesEnabled(true);



          
        }


}

公共类MapsFragment扩展片段实现GoogleAppClient.ConnectionCallbacks，
GoogleAppClient.OnConnectionFailedListener，
LocationListener，OnMapReadyCallback{
私人SharedReferences SharedRef；
私有谷歌地图；
私人GoogleapClient MGoogleapClient；
私人位置请求mLocationRequest；
私有位置数据；
私有静态最终长时间间隔获取位置=1000*5；
专用最终静态int连接\u故障\u解决\u请求=5000；
@可空
@凌驾
创建视图时的公共视图（LayoutFlater充气机、@Nullable ViewGroup容器、@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
sharedPref=PreferenceManager.getDefaultSharedPreferences（getContext（））；
视图根视图=充气机。充气（R.layout.fragment\u map，null）；
SupportMapFragment mapFragment=（SupportMapFragment）getChildFragmentManager（）.findFragmentById（R.id.map）；
getMapAsync（这个）；
TedPermission.with（getActivity（））
.setPermissionListener（permissionlistener）
.setDeniedMessage（“如果拒绝权限，则无法使用此服务\n\n请在[Setting]>[permission]打开权限”）
.setPermissions（Manifest.permission.ACCESS\u FINE\u位置）
.检查（）；
mgoogleapclient=新的Googleapclient.Builder（getActivity（））
.addConnectionCallbacks（此）
.addOnConnectionFailedListener（此）
.addApi（LocationServices.API）
.build（）；
返回rootView；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
}
PermissionListener PermissionListener=新PermissionListener（）{
@凌驾
已授予许可的公共无效（）{
mLocationRequest=LocationRequest.create（）
.setPriority（定位请求。优先级高精度）
.setInterval（时间间隔获取位置）
.SetFastTestInterval（时间间隔获取位置）；
如果（！mgoogleapClient.isConnected（））{
mGoogleApiClient.connect（）；
locationChecker（mgoogleapClient，getActivity（））；
}
}
@凌驾
public void onPermissionDenied（ArrayList deniedPermissions）{
}
};
@凌驾
未连接的公共无效（@Nullable Bundle）{
if（ActivityCompat.checkSelfPermission（getActivity（），Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予&&
ActivityCompat.checkSelfPermission（getActivity（），Manifest.permission.ACCESS\u\u位置）！=PackageManager.permission\u已授予）{
返回；
}
FusedLocationProviderClient mFusedLocationClient=LocationServices.getFusedLocationProviderClient（getActivity（））；
mFusedLocationClient.RequestLocationUpdate（mlLocationRequest，new LocationCallback（））{
@凌驾
public void onLocationResult（LocationResult LocationResult）{
locationData=locationResult.getLastLocation（）；
if（locationData！=null）{
LatLng myLocation=新LatLng（locationData.getLatitude（），locationData.getLength（））；
gMap.clear（）；
gMap.addMarker（新的MarkerOptions（）.position（myLocation）.title（“你在这里！”）.icon（BitmapDescriptorFactory.defaultMarker（BitmapDescriptorFactory.HUE_BLUE））；
CameraPosition CameraPosition=新建CameraPosition.Builder（）.target（myLocation.zoom）（14.build（）；
gMap.animateCamera（CameraUpdateFactory.newCameraPosition（cameraPosition））；
}
}
}，空）；
}
@凌驾
公共空间连接暂停（int i）{
}
@凌驾
public void onconnection失败（@NonNull ConnectionResult ConnectionResult）{
//........
}
公共无效位置检查器（GoogleapClient MGoogleapClient，最终活动）{
LocationRequest LocationRequest=LocationRequest.create（）；
locationRequest.setPriority（locationRequest.PRIORITY\u高精度）；
位置请求设置间隔（30*1000）；
locationRequest.SetFastTestInterval（5*1000）；
LocationSettingsRequest.Builder=新建LocationSettingsRequest.Builder（）
.addLocationRequest（locationRequest）；
builder.setAlwaysShow（true）；
Pendingreult结果=
LocationServices.SettingsApi.checkLocationSettings（mgoogleapClient，builder.build（））；
result.setResultCallback（新的ResultCallback（）{
@凌驾
公共void onResult（位置设置结果）{
最终状态状态=result.getStatus（）；
最终位置SettingsStates状态=结果。getLocationSettingsStates（）；
开关（status.getStatusCode（））{
案例位置设置StatusCodes.SUCCESS：
打破
案例位置设置StatusCodes.RESOLUTION_要求：
试一试{
状态。开始解决结果（活动，1000）；
}catch（IntentSender.sendtintentexe）{
}
打破
案例位置设置StatusCodes.SETTINGS\u CHANGE\u不可用：
打破
}
}
});
}
@凌驾
已更改位置上的公共无效（位置）{
{
}
}
@凌驾
状态已更改的公共void（字符串s、int i、Bundle）{
}
@凌驾
已提供已启用的公共void（字符串s）{
}
@凌驾
公共无效onProviderDisabled（字符串s）{
}
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
gMap=谷歌地图；
gMap.getUiSettings（）.setZoomControlsEnabled（false）；
gMap.SetBuildingEnabled（假）；
gMap.getUiSettings（）.setCompassEnabled（true）；
gMap.getUiSettings（）.s
yourGoogleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(position, 8));