Android 从位置坐标获取地址并将其添加到textview

这是获取当前位置的代码，我想在文本视图中添加当前位置的地址。如何同时添加地址和显示当前位置。我无法获得如何添加显示当前位置地址的文本视图

public class MapActivity extends AppCompatActivity implements OnMapReadyCallback {
    @Override
    public void onMapReady(GoogleMap googleMap) {
        Toast.makeText(this, "Map is Ready", Toast.LENGTH_SHORT).show();
        Log.d(TAG, "onMapReady: map is ready");
        mMap = googleMap;

        if (mLocationPermissionsGranted) {
            getDeviceLocation();

            if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                    != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this,
                    Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            mMap.setMyLocationEnabled(true);
            mMap.getUiSettings().setMyLocationButtonEnabled(false);

        }
    }
    private static final String TAG = "MapActivity";

    private static final String FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    private static final String COURSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
    private static final int LOCATION_PERMISSION_REQUEST_CODE = 1234;
    private static final float DEFAULT_ZOOM = 15f;

    //vars
    private Boolean mLocationPermissionsGranted = false;
    private GoogleMap mMap;
    private FusedLocationProviderClient mFusedLocationProviderClient;

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

        getLocationPermission();
    }

    private void getDeviceLocation(){
        Log.d(TAG, "getDeviceLocation: getting the devices current location");

        mFusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);

        try{
            if(mLocationPermissionsGranted){

                final Task location = mFusedLocationProviderClient.getLastLocation();
                location.addOnCompleteListener(new OnCompleteListener() {
                    @Override
                    public void onComplete(@NonNull Task task) {
                        if(task.isSuccessful()){
                            Log.d(TAG, "onComplete: found location!");
                            Location currentLocation = (Location) task.getResult();

                            moveCamera(new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude()),
                                    DEFAULT_ZOOM);

                        }else{
                            Log.d(TAG, "onComplete: current location is null");
                            Toast.makeText(MapActivity.this, "unable to get current location", Toast.LENGTH_SHORT).show();
                        }
                    }
                });
            }
        }catch (SecurityException e){
            Log.e(TAG, "getDeviceLocation: SecurityException: " + e.getMessage() );
        }
    }

    private void moveCamera(LatLng latLng, float zoom){
        Log.d(TAG, "moveCamera: moving the camera to: lat: " + latLng.latitude + ", lng: " + latLng.longitude );
        mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng, zoom));
    }

    private void initMap(){
        Log.d(TAG, "initMap: initializing map");
        SupportMapFragment mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);

        mapFragment.getMapAsync(MapActivity.this);
    }

    private void getLocationPermission(){
        Log.d(TAG, "getLocationPermission: getting location permissions");
        String[] permissions = {Manifest.permission.ACCESS_FINE_LOCATION,
        Manifest.permission.ACCESS_COARSE_LOCATION};
        if(ContextCompat.checkSelfPermission(this.getApplicationContext(),
                FINE_LOCATION) == PackageManager.PERMISSION_GRANTED){
            if(ContextCompat.checkSelfPermission(this.getApplicationContext(),
                    COURSE_LOCATION) == PackageManager.PERMISSION_GRANTED){
                mLocationPermissionsGranted = true;
                initMap();
            }else{
                ActivityCompat.requestPermissions(this,
                        permissions,
                        LOCATION_PERMISSION_REQUEST_CODE);
            }
        }else{
            ActivityCompat.requestPermissions(this,
                    permissions,
                    LOCATION_PERMISSION_REQUEST_CODE);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        Log.d(TAG, "onRequestPermissionsResult: called.");
        mLocationPermissionsGranted = false;

        switch(requestCode){
            case LOCATION_PERMISSION_REQUEST_CODE:{
                if(grantResults.length > 0){
                    for(int i = 0; i < grantResults.length; i++){
                        if(grantResults[i] != PackageManager.PERMISSION_GRANTED){
                            mLocationPermissionsGranted = false;
                            Log.d(TAG, "onRequestPermissionsResult: permission failed");
                            return;
                        }
                    }
                    Log.d(TAG, "onRequestPermissionsResult: permission granted");
                    mLocationPermissionsGranted = true;
                    //initialize our map
                    initMap();
                }
            }
        }
    } 
}

公共类MapActivity扩展了AppCompatActivity在MapReadyCallback上的实现{
@凌驾
4月1日公开作废（谷歌地图谷歌地图）{
Toast.makeText（这是“地图准备就绪”，Toast.LENGTH_SHORT）.show（）；
Log.d（标记“onMapReady:map is ready”）；
mMap=谷歌地图；
如果（mLocationPermissionsGranted）{
getDeviceLocation（）；
if（ActivityCompat.checkSelfPermission（这是Manifest.permission.ACCESS\u FINE\u位置）
！=PackageManager.PERMISSION\u已授予和&ActivityCompat.checkSelfPermission（此，
Manifest.permission.ACCESS\u\u位置）！=PackageManager.permission\u已授予）{
返回；
}
mMap.setMyLocationEnabled（真）；
mMap.getUiSettings（）.setMyLocationButtonEnabled（false）；
}
}
私有静态最终字符串TAG=“MapActivity”；
私有静态最终字符串FINE\u LOCATION=Manifest.permission.ACCESS\u FINE\u LOCATION；
私有静态最终字符串COURSE\u LOCATION=Manifest.permission.ACCESS\u rough\u LOCATION；
私有静态最终整数位置\权限\请求\代码=1234；
私有静态最终浮动默认值_缩放=15f；
//瓦尔斯
私有布尔值mLocationPermissionsGranted=false；
私有谷歌地图；
私有FusedLocationProviderClient mFusedLocationProviderClient；
@凌驾
创建时受保护的void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_map）；
getLocationPermission（）；
}
私有void getDeviceLocation（）{
Log.d（标签，“getDeviceLocation:获取设备当前位置”）；
mFusedLocationProviderClient=LocationServices.getFusedLocationProviderClient（此）；
试一试{
如果（mLocationPermissionsGranted）{
最终任务位置=mFusedLocationProviderClient.getLastLocation（）；
location.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
Log.d（标记“onComplete:foundlocation！”）；
Location currentLocation=（Location）task.getResult（）；
移动摄像头（新车床（currentLocation.getLatitude（），currentLocation.getLatitude（）），
默认值（放大）；
}否则{
Log.d（标记“onComplete:当前位置为空”）；
Toast.makeText（MapActivity.this，“无法获取当前位置”，Toast.LENGTH_SHORT.show（）；
}
}
});
}
}捕获（安全异常e）{
Log.e（标记“getDeviceLocation:SecurityException:”+e.getMessage（））；
}
}
专用移动摄影机（锁定、浮动变焦）{
Log.d（标签，“移动摄像机：将摄像机移动到：lat:+latLng.lation+”，lng:+latLng.longitude）；
mMap.moveCamera（CameraUpdateFactory.newLatLngZoom（latLng，zoom））；
}
私有void initMap（）{
d（标记“initMap:initializedmap”）；
SupportMapFragment mapFragment=（SupportMapFragment）getSupportFragmentManager（）.findFragmentById（R.id.map）；
getMapAsync（MapActivity.this）；
}
私有void getLocationPermission（）{
Log.d（标记“getLocationPermission:获取位置权限”）；
字符串[]权限={Manifest.permission.ACCESS\u FINE\u位置，
Manifest.permission.ACCESS\u\u LOCATION}；
if（ContextCompat.checkSelfPermission）（this.getApplicationContext（），
精细位置）==PackageManager.PERMISSION（已授予权限）{
if（ContextCompat.checkSelfPermission）（this.getApplicationContext（），
课程位置）==软件包管理员权限（已授予）{
mLocationPermissionsGranted=真；
initMap（）；
}否则{
ActivityCompat.requestPermissions（此，
权限，
位置（许可、请求、代码）；
}
}否则{
ActivityCompat.requestPermissions（此，
权限，
位置（许可、请求、代码）；
}
}
@凌驾
public void onRequestPermissionsResult（int-requestCode，@NonNull-String[]permissions，@NonNull-int[]grantResults）{
d（标记“onRequestPermissionsResult:called”）；
mLocationPermissionsGranted=错误；
开关（请求代码）{
案例位置\权限\请求\代码：{
如果（grantResults.length>0）{
对于（int i=0；i

---

任何帮助都将不胜感激

您可能应该看看Android框架位置API中的类

基本上，您必须遵循三个步骤：

创建地理编码器

覆盖乐趣