Javascript 如何修复谷歌地图上的标记并移动地图？

我已经在谷歌地图上显示了当前位置，但我想在选择“autoPlace city”时，在地图中央固定一个标记，然后在谷歌地图上显示这个位置

我的代码如下：

public class PostAdsFragmentFifth extends Fragment implements View.OnClickListener,  GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {

private static final String TAG = PostAdsFragmentFifth.class.getSimpleName();
private CustomTextView tvBackBtn;
PlaceAutocompleteFragment autocompleteFragment;
private GoogleMap mMap;
Address address;
protected GoogleApiClient mGoogleApiClient;
private Marker marker;
private SupportMapFragment mapFragment;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.activity_post_slide5, container, false);
    checkGpsEnabled();
    setGooglePlaces();
    mapFragment = (SupportMapFragment) this.getChildFragmentManager()
            .findFragmentById(R.id.map);
    tvBackBtn = (CustomTextView) getActivity().findViewById(R.id.tvBack);
    tvBackBtn.setVisibility(View.VISIBLE);
    tvBackBtn.setOnClickListener(this);
    return view;
}


@Override
public void onStart() {
    super.onStart();
    checkPermissions();

}

@Override
public void onDestroy() {
    super.onDestroy();
    if (mGoogleApiClient != null)
        mGoogleApiClient.disconnect();
}

@Override
public void onClick(View view) {
    switch (view.getId()) {
        case R.id.tvBack:
            MixPanelEvents.addMixPanelEvents(getActivity(), "Pet Address for Back");

            if (getUserVisibleHint())
                ((PostAdsActivity) getActivity()).gotoNext(4);
            break;

    }
}

private void setGooglePlaces() {
    autocompleteFragment = (PlaceAutocompleteFragment) getActivity().getFragmentManager().findFragmentById(R.id.place_autocomplete_fragment);
    autocompleteFragment.setHint(getResources().getString(R.string.address_hint_toast));

    AutocompleteFilter typeFilter = new AutocompleteFilter.Builder()
            .setTypeFilter(AutocompleteFilter.TYPE_FILTER_ADDRESS)
            .build();
    autocompleteFragment.setFilter(typeFilter);

    autocompleteFragment.setOnPlaceSelectedListener(new PlaceSelectionListener() {
        @Override
        public void onPlaceSelected(Place place) {

            address = new Address();
            address.setLatitude(place.getLatLng().latitude);
            address.setLongitude(place.getLatLng().longitude);
            address.setAddress(place.getAddress().toString());
            address.setLandmark(place.getName().toString());
            PostAdsActivity.postData.setAddress(address);

        }

        @Override
        public void onError(Status status) {
            // TODO: Handle the error.
            LogUtils.i(TAG, "An error occurred: " + status);
        }
    });
}


protected synchronized void buildGoogleApiClient() {
    mGoogleApiClient = new GoogleApiClient.Builder(getActivity())
            .addConnectionCallbacks(this)
            .addApi(LocationServices.API)
            .addApi(Places.GEO_DATA_API)
            .addApi(Places.PLACE_DETECTION_API)
            .build();
    mGoogleApiClient.connect();
}


@Override
public void onConnected(Bundle bundle) {
    Location mLastLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
    if (mLastLocation != null) {
        double lat = mLastLocation.getLatitude();
        double lng = mLastLocation.getLongitude();
        if (lat != 0 && lng != 0) {
            mMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(lat, lng), 16.0f));
            convertLocationToAddress(new LatLng(lat, lng));
            if (marker != null) {
                MarkerOptions markerOptions = new MarkerOptions().position(new LatLng(lat, lng));
                marker = mMap.addMarker(markerOptions);
            }
        }

    }
}

private void checkPermissions() {
    if (Build.VERSION.SDK_INT >= 23 && getActivity().checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
            && getActivity().checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ArrayList<String> permissons = new ArrayList<>();
        permissons.add(Manifest.permission.ACCESS_FINE_LOCATION);
        permissons.add(Manifest.permission.ACCESS_COARSE_LOCATION);
        String[] items = permissons.toArray(new String[permissons.size()]);
        requestPermissions(items, 4);
    } else {
        mapFragment.getMapAsync(new OnMapReadyCallback() {
            @Override
            public void onMapReady(GoogleMap googleMap) {
                mMap = googleMap;
                setUpMap();
                buildGoogleApiClient();
            }
        });
    }
}

private void setUpMap() {
    if (Utility.isAppInstalled(getActivity(), "com.google.android.apps.maps")) {
        mMap.setMyLocationEnabled(true);

        mMap.setOnMarkerClickListener(new GoogleMap.OnMarkerClickListener() {
            @Override
            public boolean onMarkerClick(Marker marker) {

                LatLng currentLocation = marker.getPosition();
                convertLocationToAddress(currentLocation);
                return false;
            }
        });
        mMap.setOnMarkerDragListener(new GoogleMap.OnMarkerDragListener() {

            @Override
            public void onMarkerDragStart(Marker marker) {

            }

            @Override
            public void onMarkerDragEnd(Marker marker) {
                LatLng currentLocation = marker.getPosition();
                convertLocationToAddress(currentLocation);
            }

            @Override
            public void onMarkerDrag(Marker marker) {
            }
        });

        mMap.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() {
            @Override
            public void onMapLoaded() {

                LogUtils.e("TAG", mMap.getCameraPosition().target.toString());
                convertLocationToAddress(mMap.getCameraPosition().target);
                marker = mMap.addMarker(new MarkerOptions()
                        .position(new LatLng(mMap.getCameraPosition().target.latitude, mMap.getCameraPosition().target.longitude))
                        .title("Marker")
                        .draggable(true)
                        .snippet("Location")
                        .icon(BitmapDescriptorFactory
                                .defaultMarker(BitmapDescriptorFactory.HUE_RED)));
            }
        });


    }
}


@Override
public void onConnectionSuspended(int i) {

}

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

}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == 4) {
        for (int a = 0; a < permissions.length; a++) {
            if (grantResults[a] != PackageManager.PERMISSION_GRANTED) {
                continue;
            }
            switch (permissions[a]) {
                case Manifest.permission.ACCESS_FINE_LOCATION:
                    mapFragment.getMapAsync(new OnMapReadyCallback() {
                        @Override
                        public void onMapReady(GoogleMap googleMap) {
                            mMap = googleMap;
                            setUpMap();
                            buildGoogleApiClient();
                        }
                    });
                    break;
                case Manifest.permission.ACCESS_COARSE_LOCATION:
                    mapFragment.getMapAsync(new OnMapReadyCallback() {
                        @Override
                        public void onMapReady(GoogleMap googleMap) {
                            mMap = googleMap;
                            setUpMap();
                            buildGoogleApiClient();
                        }
                    });
                    break;

            }
        }
    }
}

private void convertLocationToAddress(LatLng latLong) {
    try {

        Geocoder geocoder;
        List<android.location.Address> addresses;
        geocoder = new Geocoder(getActivity(), Locale.getDefault());
        addresses = geocoder.getFromLocation(latLong.latitude, latLong.longitude, 1);

        LogUtils.d("Address", addresses.toString());
        /*address.setAddress(addresses.get(0).getAddressLine(0));
        if (addresses.get(0).getLocality() != null) {
            address.setCity(addresses.get(0).getLocality());
        } else {
            address.setCity("");
        }
        if (addresses.get(0).getAdminArea() != null) {
            address.setState(addresses.get(0).getAdminArea());
        } else {
            address.setState("");
        }
        address.setLatitude(latLong.latitude);
        address.setLongitude(latLong.longitude);
        if (addresses.get(0).getPostalCode() != null) {
            // address.setPinCode(addresses.get(0).getPostalCode());
        }*/


    } catch (Exception e) {
        e.printStackTrace();
    }
}
private void checkGpsEnabled() {
    LocationManager locationManager = (LocationManager) getActivity().getSystemService(Context.LOCATION_SERVICE);
    boolean gps_enabled = false;
    boolean network_enabled = false;
    try {
        gps_enabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        network_enabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
        if (!gps_enabled && !network_enabled) {
            AlertDialog.Builder dialog = new AlertDialog.Builder(getActivity());
            dialog.setTitle(getResources().getString(R.string.location_gps_alretDialog_tittle));
            dialog.setMessage(getResources().getString(R.string.location_gps_alretDialog_msg));
            dialog.setPositiveButton(this.getResources().getString(R.string.yes), new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                    MixPanelEvents.addMixPanelEvents(getActivity(), getResources().getString(R.string.location_gps_alretDialog_tittle));
                    Intent myIntent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                    startActivityForResult(myIntent, 1);
                }
            });
            dialog.setNegativeButton(this.getString(R.string.no), new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                    paramDialogInterface.dismiss();
                }
            });
            dialog.show();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}
}

公共类PostadFragmentFifth扩展片段实现View.OnClickListener、GoogleAppClient.ConnectionCallbacks、GoogleAppClient.OnConnectionFailedListener{
私有静态最终字符串标记=PostadFragmentFifth.class.getSimpleName（）；
私有CustomTextView tvBackBtn；
位置自动完成碎片自动完成碎片；
私有谷歌地图；
地址；
受保护的GoogleapClient MGoogleapClient；
专用标记；
私有支持mapFragment mapFragment；
@凌驾
创建视图上的公共视图（布局、充气机、视图组容器、，
Bundle savedInstanceState）{
视图=充气机。充气（R.layout.activity\u post\u slide5，容器，假）；
checkGpsEnabled（）；
setGooglePlaces（）；
mapFragment=（SupportMapFragment）this.getChildFragmentManager（）
.findFragmentById（R.id.map）；
tvBackBtn=（CustomTextView）getActivity（）.findViewById（R.id.tvBack）；
tvBackBtn.setVisibility（View.VISIBLE）；
tvBackBtn.setOnClickListener（此）；
返回视图；
}
@凌驾
public void onStart（）{
super.onStart（）；
检查权限（）；
}
@凌驾
公共空间{
super.ondestory（）；
if（mGoogleApiClient！=null）
mGoogleApiClient.disconnect（）；
}
@凌驾
公共void onClick（视图）{
开关（view.getId（））{
案例R.id.tvBack：
addMixPanelEvents（getActivity（），“背面的宠物地址”）；
if（getUserVisibleHint（））
（（PostadActivity）getActivity（））.GotonNext（4）；
打破
}
}
私有无效设置GooglePlaces（）{
autocompleteFragment=（PlaceAutocompleteFragment）getActivity（）.getFragmentManager（）.findFragmentById（R.id.place\u autocomplete\u fragment）；
setHint（getResources（）.getString（R.string.address_hint_toast））；
AutoCompleteTFilter typeFilter=新的AutoCompleteTFilter.Builder（）
.setTypeFilter（自动完成过滤器.TYPE\u FILTER\u地址）
.build（）；
设置过滤器（类型过滤器）；
autocompleteFragment.setOnPlaceSelectedListener（新的PlaceSelectionListener（）{
@凌驾
已选定地点上的公共作废（地点）{
地址=新地址（）；
address.setLatitude（place.getLatLng（）.latitude）；
address.setLongitude（place.getLatLng（）.longitude）；
address.setAddress（place.getAddress（）.toString（））；
address.setLandmark（place.getName（）.toString（））；
PostadActivity.postData.setAddress（地址）；
}
@凌驾
公共作废申报人（状态）{
//TODO:处理错误。
LogUtils.i（标记“发生错误：+状态”）；
}
});
}
受保护的同步无效BuildGoogleAppClient（）{
mgoogleapclient=新的Googleapclient.Builder（getActivity（））
.addConnectionCallbacks（此）
.addApi（LocationServices.API）
.addApi（Places.GEO_数据_API）
.addApi（Places.PLACE\u DETECTION\u API）
.build（）；
mGoogleApiClient.connect（）；
}
@凌驾
未连接的公共空间（捆绑包）{
Location mLastLocation=LocationServices.FusedLocationApi.getLastLocation（mgoogleapClient）；
如果（mLastLocation！=null）{
双lat=mLastLocation.getLatitude（）；
double lng=mLastLocation.getLongitude（）；
如果（纬度=0和液化天然气=0）{
mMap.animateCamera（CameraUpdateFactory.newLatLngZoom（新LatLng（lat，lng），16.0f））；
转换地址（新LatLng（lat，lng））；
如果（标记！=null）{
MarkerOptions MarkerOptions=新MarkerOptions（）.位置（新车床（车床，lng））；
marker=mMap.addMarker（markerOptions）；
}
}
}
}
私有void checkPermissions（）{
如果（Build.VERSION.SDK\u INT>=23&&getActivity（）.checkSelfPermission（Manifest.permission.ACCESS\u FINE\u LOCATION）！=PackageManager.permission\u已授予
&&getActivity（）.checkSelfPermission（Manifest.permission.ACCESS\u\u LOCATION）！=PackageManager.permission\u provided）{
ArrayList permissons=新的ArrayList（）；
permissons.add（Manifest.permission.ACCESS\u FINE\u位置）；
permissons.add（Manifest.permission.ACCESS\u\u位置）；
String[]items=permissons.toArray（新字符串[permissons.size（）]）；
请求权限（项目4）；
}否则{
getMapAsync（新的OnMapReadyCallback（）{
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
mMap=谷歌地图；
setUpMap（）；
buildGoogleAppClient（）；
}
});
}
}
私有void setUpMap（）{
if（Utility.isAppInstalled（getActivity（），“com.google.android.apps.maps”））{
mMap.setMyLocationEnabled（真）；
setOnMarkerClickListener（新的GoogleMap.OnMarkerClickListener（）{
@凌驾
公共布尔onMarkerClick（标记）{
LatLng currentLocation=marker.getPosition（）；
convertLocationToAddress（当前位置）；
返回false；
}
});
mMap.setOnMarkerDragListener（新的GoogleMap.OnMarkerDragListener（）{
@凌驾
MarkerDragStart上的公共空白（标记）{
}
@凌驾
MarkerDragend上的公共空白（标记）{
LatLng currentLocation=marker.getPosition（）；
convertLocationToAddress（当前位置）；
}
@凌驾
MarkerDrag上的公共空白（标记）{
}
});
setOnMapLoadedCallback（新的GoogleMap.OnMapLoadedCallback（）{
@凌驾
公众的
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:id="@+id/map_container"
   android:layout_width="match_parent"
   android:layout_height="match_parent">

  <fragment xmlns:tools="http://schemas.android.com/tools"
      android:id="@+id/map"
      android:name="com.google.android.gms.maps.SupportMapFragment"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      tools:context="com.example.mapstest.MapsActivity" />

  <FrameLayout
      android:id="@+id/pin_view"
      android:layout_gravity="center"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:background="@drawable/pin"/>

</FrameLayout>

public void moveCamera(double lat, double lng) {
    CameraPosition cameraPos = new CameraPosition.Builder()
            .target(new LatLng(lat, lng))
            .zoom(10).bearing(0).tilt(0).build();
    mapView.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPos), null);
}