Android Google Maps API OnLocationChanged只调用一次 [英] Android Google Maps API OnLocationChanged only called once
本文介绍了Android Google Maps API OnLocationChanged只调用一次的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我试图在我的位置发生变化时更新相机。但是，onLocationChanged只能调用一次。当我在模拟器中发送新位置后，不会调用onLocationChanged。
我现在一直在尝试几个小时，似乎无法修复它。 / p>
public class RouteActivity扩展FragmentActivity实现OnMapReadyCallback，
GoogleApiClient.ConnectionCallbacks，
GoogleApiClient.OnConnectionFailedListener，
LocationListener {
私有GoogleMap mMap;
ArrayList< LatLng> MarkerPoints;
GoogleApiClient mGoogleApiClient;
位置mLastLocation;
标记mCurrLocationMarker;
LocationRequest mLocationRequest;
@Override
protected void onCreate（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）;
setContentView（R.layout.route）;
if（android.os.Build.VERSION.SDK_INT> = Build.VERSION_CODES.M）{
checkLocationPermission（）;
}
//初始化
MarkerPoints = new ArrayList< LatLng>（）;
//获取SupportMapFragment并在地图准备好使用时得到通知。
SupportMapFragment mapFragment =（SupportMapFragment）getSupportFragmentManager（）
.findFragmentById（R.id.map）;
mapFragment.getMapAsync（this）;
}
/ **
*操作一次可用的地图。
*当地图准备好使用时，会触发此回调。
*这是我们可以添加标记或线条，添加听众或移动相机的位置。在这种情况下，
*我们只在澳大利亚悉尼附近添加一个标记。
*如果设备上未安装Google Play服务，系统会提示用户在SupportMapFragment中安装
* it。只有当用户安装了
* Google Play服务并返回到应用时，才会触发此方法。
* /
@Override
public void onMapReady（GoogleMap googleMap）{
mMap = googleMap;
//初始化Google Play服务
if（android.os.Build.VERSION.SDK_INT> = Build.VERSION_CODES.M）{
if（ContextCompat.checkSelfPermission（this ，
Manifest.permission.ACCESS_FINE_LOCATION）
== PackageManager.PERMISSION_GRANTED）{
buildGoogleApiClient（）;
mMap.setMyLocationEnabled（true）;
}
}
else {
buildGoogleApiClient（）;
mMap.setMyLocationEnabled（true）;
}
//设置地图的onclick事件监听器
mMap.setOnMapClickListener（new GoogleMap.OnMapClickListener（）{
$ b $ @Override
public void onMapClick（LatLng point）{
//已经有两个位置
if（MarkerPoints.size（）> 1）{
MarkerPoints.clear（）;
mMap.clear（）;
}
//将新项添加到ArrayList
MarkerPoints.add（point）;
//创建MarkerOptions
MarkerOptions options = new MarkerOptions（）;
//设置标记的位置
options.position（point）;
/ **
*对于起始位置，标记的颜色为绿色，结束位置为
*，标记的颜色为红色。 size（）== 1）{
options.icon（BitmapDescriptorFactory.defaultMarker（BitmapDescriptorFactory.HUE_GREEN））;
} else if（MarkerPoints.size（）== 2）{
options.icon（BitmapDescriptorFactory.defaultMarker（BitmapDescriptorFactory.HUE_RED））;
}
//将新标记添加到Google地图Android API V2
mMap.addMarker（options）;
//检查是否捕获到开始和结束位置
if（MarkerPoints.size（）> = 2）{
LatLng origin = MarkerPoints.get（0）;
LatLng dest = MarkerPoints.get（1）;
//获取URL到Google路线API
String url = getUrl（origin，dest）;
Log.d（onMapClick，url.toString（））;
FetchUrl FetchUrl = new FetchUrl（）;
//开始从Google Directions API下载json数据
FetchUrl.execute（url）;
//移动地图相机
mMap.moveCamera（CameraUpdateFactory.newLatLng（origin））;
mMap.animateCamera（CameraUpdateFactory.zoomTo（11））;
}
}
}）;
private String getUrl（LatLng origin，LatLng dest）{
//路由的起源
String str_origin =origin =+ origin.latitude +，+ origin.longitude;
//路线
的目的地String str_dest =destination =+ dest.latitude +，+ dest.longitude;
//启用传感器
String sensor =sensor = false;
//将参数构建到Web服务
字符串参数= str_origin +& + str_dest +& +传感器;
//输出格式
字符串输出=json;
//将网址构建到Web服务
String url =https://maps.googleapis.com/maps/api/directions/+ output +？ +参数;
return url;
$ b $ ** b $ b *从url下载json数据的方法
* /
private String downloadUrl（String strUrl）throws IOException {
String data =;
InputStream iStream = null;
HttpURLConnection urlConnection = null;
尝试{
URL url = new URL（strUrl）;
//创建一个http连接与url进行通信
urlConnection =（HttpURLConnection）url.openConnection（）;
//连接到url
urlConnection.connect（）;
//从url读取数据
iStream = urlConnection.getInputStream（）;
BufferedReader br = new BufferedReader（new InputStreamReader（iStream））;
StringBuffer sb = new StringBuffer（）;
String line =; （（line = br.readLine（））！= null）{
sb.append（line）;
while
}
data = sb.toString（）;
Log.d（downloadUrl，data.toString（））;
br.close（）;
} catch（Exception e）{
Log.d（Exception，e.toString（））;
} finally {
iStream.close（）;
urlConnection.disconnect（）;
}
返回数据;
}
//从url中获取数据传递
private class FetchUrl extends AsyncTask< String，Void，String> {
@Override
保护字符串doInBackground（String ... url）{
//用于存储来自Web服务的数据
String data = ;
尝试{
//从Web服务获取数据
data = downloadUrl（url [0]）;
Log.d（后台任务数据，data.toString（））;
} catch（Exception e）{
Log.d（Background Task，e.toString（））;
}
返回数据;
}
@Override
protected void onPostExecute（String result）{
super.onPostExecute（result）;
ParserTask parserTask = new ParserTask（）;
//调用解析JSON数据的线程
parserTask.execute（result）;
$ b $ ** b $ b *以JSON格式解析Google Places的类
* /
私人类ParserTask扩展AsyncTask< String，Integer，List< List< HashMap< String，String>>>> {
//解析非ui线程中的数据
@Override
protected List< List< HashMap< String，String>>> doInBackground（String ... jsonData）{
JSONObject jObject;
List< List< HashMap< String，String>>> routes = null;
尝试{
jObject = new JSONObject（jsonData [0]）;
Log.d（ParserTask，jsonData [0] .toString（））;
DataParser parser = new DataParser（）;
Log.d（ParserTask，parser.toString（））;
//开始解析数据
routes = parser.parse（jObject）;
Log.d（ParserTask，执行路线）;
Log.d（ParserTask，routes.toString（））;
catch（Exception e）{
Log.d（ParserTask，e.toString（））;
e.printStackTrace（）;
}
返回路线;
}
//在解析过程之后在UI线程中执行
@Override
protected void onPostExecute（List< List< HashMap< String，String>> >结果）{
ArrayList< LatLng>点;
PolylineOptions lineOptions = null;
//遍历所有路由
for（int i = 0; i< result.size（）; i ++）{
points = new ArrayList< LatLng>（ ）;
lineOptions = new PolylineOptions（）;
//获取第i条路线
List< HashMap< String，String>> path = result.get（i）;
//获取第i条路由中的所有点
for（int j = 0; j
double lat = Double.parseDouble（point.get（lat））;
double lng = Double.parseDouble（point.get（lng））;
LatLng position = new LatLng（lat，lng）;
points.add（position）;
}
//将路线中的所有点添加到LineOptions
lineOptions.addAll（points）;
lineOptions.width（10）;
lineOptions.color（Color.BLUE）;
Log.d（onPostExecute，onPostExecute lineoptions decoding）;
//在Google Map中为第i条路线绘制多段线
if（lineOptions！= null）{
mMap.addPolyline （lineOptions）;
}
else {
Log.d（onPostExecute，没有折线画出来）;
$ b protected synchronized void buildGoogleApiClient（）{
mGoogleApiClient = new GoogleApiClient.Builder（this）
.addConnectionCallbacks（这个）
.addOnConnectionFailedListener（this）
.addApi（LocationServices.API）
.build（）;
mGoogleApiClient.connect（）;
}
@Override
public void onConnected（Bundle bundle）{
Log.i（LOCATION，Connected！）;
mLocationRequest = new LocationRequest（）;
mLocationRequest.setInterval（1000）;
mLocationRequest.setFastestInterval（1000）;
mLocationRequest.setPriority（LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY）;
if（ContextCompat.checkSelfPermission（this，
Manifest.permission.ACCESS_FINE_LOCATION）
== PackageManager.PERMISSION_GRANTED）{
LocationServices.FusedLocationApi.requestLocationUpdates（mGoogleApiClient，mLocationRequest，this）;
Log.i（LOCATION，请求位置更新正在运行）;
} else {
Log.e（LOCATION，请求位置更新没有运行!!! - 没有获得许可）;
@Override
public void onConnectionSuspended（int i）{
Log.i（LOCATION，Connection suspended！） ;
@Override
public void onLocationChanged（Location location）{
Log.i（LOCATION，Location changed）;
mLastLocation = location;
if（mCurrLocationMarker！= null）{
mCurrLocationMarker.remove（）;
}
//放置当前位置标记
LatLng latLng = new LatLng（location.getLatitude（），location.getLongitude（））;
//移动地图相机
mMap.moveCamera（CameraUpdateFactory.newLatLng（latLng））;
mMap.animateCamera（CameraUpdateFactory.zoomTo（11））;
//停止位置更新
if（mGoogleApiClient！= null）{
LocationServices.FusedLocationApi.removeLocationUpdates（mGoogleApiClient，this）;
$ b @Override
public void onConnectionFailed（ConnectionResult connectionResult）{
Log.i（LOCATION，Connection失败）;
}
public static final int MY_PERMISSIONS_REQUEST_LOCATION = 99;
public boolean checkLocationPermission（）{
if（ContextCompat.checkSelfPermission（this，
Manifest.permission.ACCESS_FINE_LOCATION）
！= PackageManager.PERMISSION_GRANTED）{
//询问用户是否需要解释
if（ActivityCompat.shouldShowRequestPermissionRationale（this，
Manifest.permission.ACCESS_FINE_LOCATION））{
//向用户显示解释*异步* - 不要阻止
//此线程正在等待用户的响应！在用户
//看到解释后，再次尝试请求权限。
//一旦显示解释提示用户
ActivityCompat.requestPermissions（this，
new String [] {Manifest.permission.ACCESS_FINE_LOCATION}，
MY_PERMISSIONS_REQUEST_LOCATION） ;
}其他{
//无需解释，我们可以申请许可。
ActivityCompat.requestPermissions（this，
new String [] {Manifest.permission.ACCESS_FINE_LOCATION}，
MY_PERMISSIONS_REQUEST_LOCATION）;
}
返回false;
} else {
return true;
}
}
@Override
public void onRequestPermissionsResult（int requestCode，
String permissions []，int [] grantResults）{
switch（requestCode）{
case MY_PERMISSIONS_REQUEST_LOCATION：{
//如果请求被取消，结果数组为空。
if（grantResults.length> 0
&&& amp; grantResults [0] == PackageManager.PERMISSION_GRANTED）{
//授予权限。做你需要做的
//联系人相关的任务。
if（ContextCompat.checkSelfPermission（this，
Manifest.permission.ACCESS_FINE_LOCATION）
== PackageManager.PERMISSION_GRANTED）{
if（mGoogleApiClient == null）{
buildGoogleApiClient（）;
}
mMap.setMyLocationEnabled（true）;
}
}其他{
// Permission denied，禁用取决于此权限的功能。
Toast.makeText（this，permission denied，Toast.LENGTH_LONG）.show（）;
}
return;
}
//其他'case'行来检查此应用可能请求的其他权限。
//您可以根据您的要求在此添加其他案例陈述。
}}
调试输出：
解决方案
我认为您需要使用位置管理器。 here 有一个很好的教程。
网站上说的是，您需要添加以下内容：
LocationManager locationManager =（ LocationManager）getSystemService（Context.LOCATION_SERVICE）;
locationManager.requestLocationUpdates（LocationManager.GPS_PROVIDER，
2000，
10，this）;
第一个参数是您正在使用的提供商（本例中为GPS提供商）。第二个参数（2000）是每次更新之间的最小时间（以毫秒为单位）。第三个参数（10）是最小距离。最后一个参数是你的LocationListener（this）。
如果你想要实现 onProviderDisabled 用户关闭了GPS。
I'm trying to update my camera whenever my location changes. However, onLocationChanged is only called once. When I send a new location afterwards in my emulator, onLocationChanged is not called.
I've been trying for hours now and I can't seem to fix it.
public class RouteActivity extends FragmentActivity implements OnMapReadyCallback,
GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener,
LocationListener {
private GoogleMap mMap;
ArrayList<LatLng> MarkerPoints;
GoogleApiClient mGoogleApiClient;
Location mLastLocation;
Marker mCurrLocationMarker;
LocationRequest mLocationRequest;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.route);
if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
checkLocationPermission();
}
// Initializing
MarkerPoints = new ArrayList<LatLng>();
// 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);
}
/**
* 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;
//Initialize Google Play Services
if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
buildGoogleApiClient();
mMap.setMyLocationEnabled(true);
}
}
else {
buildGoogleApiClient();
mMap.setMyLocationEnabled(true);
}
// Setting onclick event listener for the map
mMap.setOnMapClickListener(new GoogleMap.OnMapClickListener() {
@Override
public void onMapClick(LatLng point) {
// Already two locations
if (MarkerPoints.size() > 1) {
MarkerPoints.clear();
mMap.clear();
}
// Adding new item to the ArrayList
MarkerPoints.add(point);
// Creating MarkerOptions
MarkerOptions options = new MarkerOptions();
// Setting the position of the marker
options.position(point);
/**
* For the start location, the color of marker is GREEN and
* for the end location, the color of marker is RED.
*/
if (MarkerPoints.size() == 1) {
options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN));
} else if (MarkerPoints.size() == 2) {
options.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED));
}
// Add new marker to the Google Map Android API V2
mMap.addMarker(options);
// Checks, whether start and end locations are captured
if (MarkerPoints.size() >= 2) {
LatLng origin = MarkerPoints.get(0);
LatLng dest = MarkerPoints.get(1);
// Getting URL to the Google Directions API
String url = getUrl(origin, dest);
Log.d("onMapClick", url.toString());
FetchUrl FetchUrl = new FetchUrl();
// Start downloading json data from Google Directions API
FetchUrl.execute(url);
//move map camera
mMap.moveCamera(CameraUpdateFactory.newLatLng(origin));
mMap.animateCamera(CameraUpdateFactory.zoomTo(11));
}
}
});
}
private String getUrl(LatLng origin, LatLng dest) {
// Origin of route
String str_origin = "origin=" + origin.latitude + "," + origin.longitude;
// Destination of route
String str_dest = "destination=" + dest.latitude + "," + dest.longitude;
// Sensor enabled
String sensor = "sensor=false";
// Building the parameters to the web service
String parameters = str_origin + "&" + str_dest + "&" + sensor;
// Output format
String output = "json";
// Building the url to the web service
String url = "https://maps.googleapis.com/maps/api/directions/" + output + "?" + parameters;
return url;
}
/**
* A method to download json data from url
*/
private String downloadUrl(String strUrl) throws IOException {
String data = "";
InputStream iStream = null;
HttpURLConnection urlConnection = null;
try {
URL url = new URL(strUrl);
// Creating an http connection to communicate with url
urlConnection = (HttpURLConnection) url.openConnection();
// Connecting to url
urlConnection.connect();
// Reading data from url
iStream = urlConnection.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(iStream));
StringBuffer sb = new StringBuffer();
String line = "";
while ((line = br.readLine()) != null) {
sb.append(line);
}
data = sb.toString();
Log.d("downloadUrl", data.toString());
br.close();
} catch (Exception e) {
Log.d("Exception", e.toString());
} finally {
iStream.close();
urlConnection.disconnect();
}
return data;
}
// Fetches data from url passed
private class FetchUrl extends AsyncTask<String, Void, String> {
@Override
protected String doInBackground(String... url) {
// For storing data from web service
String data = "";
try {
// Fetching the data from web service
data = downloadUrl(url[0]);
Log.d("Background Task data", data.toString());
} catch (Exception e) {
Log.d("Background Task", e.toString());
}
return data;
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
ParserTask parserTask = new ParserTask();
// Invokes the thread for parsing the JSON data
parserTask.execute(result);
}
}
/**
* A class to parse the Google Places in JSON format
*/
private class ParserTask extends AsyncTask<String, Integer, List<List<HashMap<String, String>>>> {
// Parsing the data in non-ui thread
@Override
protected List<List<HashMap<String, String>>> doInBackground(String... jsonData) {
JSONObject jObject;
List<List<HashMap<String, String>>> routes = null;
try {
jObject = new JSONObject(jsonData[0]);
Log.d("ParserTask",jsonData[0].toString());
DataParser parser = new DataParser();
Log.d("ParserTask", parser.toString());
// Starts parsing data
routes = parser.parse(jObject);
Log.d("ParserTask","Executing routes");
Log.d("ParserTask",routes.toString());
} catch (Exception e) {
Log.d("ParserTask",e.toString());
e.printStackTrace();
}
return routes;
}
// Executes in UI thread, after the parsing process
@Override
protected void onPostExecute(List<List<HashMap<String, String>>> result) {
ArrayList<LatLng> points;
PolylineOptions lineOptions = null;
// Traversing through all the routes
for (int i = 0; i < result.size(); i++) {
points = new ArrayList<LatLng>();
lineOptions = new PolylineOptions();
// Fetching i-th route
List<HashMap<String, String>> path = result.get(i);
// Fetching all the points in i-th route
for (int j = 0; j < path.size(); j++) {
HashMap<String, String> point = path.get(j);
double lat = Double.parseDouble(point.get("lat"));
double lng = Double.parseDouble(point.get("lng"));
LatLng position = new LatLng(lat, lng);
points.add(position);
}
// Adding all the points in the route to LineOptions
lineOptions.addAll(points);
lineOptions.width(10);
lineOptions.color(Color.BLUE);
Log.d("onPostExecute","onPostExecute lineoptions decoded");
}
// Drawing polyline in the Google Map for the i-th route
if(lineOptions != null) {
mMap.addPolyline(lineOptions);
}
else {
Log.d("onPostExecute","without Polylines drawn");
}
}
}
protected synchronized void buildGoogleApiClient() {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
mGoogleApiClient.connect();
}
@Override
public void onConnected(Bundle bundle) {
Log.i("LOCATION", "Connected!");
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(1000);
mLocationRequest.setFastestInterval(1000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
Log.i("LOCATION", "Request location updates are running");
} else {
Log.e("LOCATION", "Request location updates are NOT running!!! - No permissions gained");
}
}
@Override
public void onConnectionSuspended(int i) {
Log.i("LOCATION", "Connection suspended!");
}
@Override
public void onLocationChanged(Location location) {
Log.i("LOCATION", "Location changed");
mLastLocation = location;
if (mCurrLocationMarker != null) {
mCurrLocationMarker.remove();
}
//Place current location marker
LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude());
//move map camera
mMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
mMap.animateCamera(CameraUpdateFactory.zoomTo(11));
//stop location updates
if (mGoogleApiClient != null) {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
}
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.i("LOCATION", "Connection failed");
}
public static final int MY_PERMISSIONS_REQUEST_LOCATION = 99;
public boolean checkLocationPermission(){
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED) {
// Asking user if explanation is needed
if (ActivityCompat.shouldShowRequestPermissionRationale(this,
Manifest.permission.ACCESS_FINE_LOCATION)) {
// Show an explanation to the user *asynchronously* -- don't block
// this thread waiting for the user's response! After the user
// sees the explanation, try again to request the permission.
//Prompt the user once explanation has been shown
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
MY_PERMISSIONS_REQUEST_LOCATION);
} else {
// No explanation needed, we can request the permission.
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
MY_PERMISSIONS_REQUEST_LOCATION);
}
return false;
} else {
return true;
}
}
@Override
public void onRequestPermissionsResult(int requestCode,
String permissions[], int[] grantResults) {
switch (requestCode) {
case MY_PERMISSIONS_REQUEST_LOCATION: {
// If request is cancelled, the result arrays are empty.
if (grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// permission was granted. Do the
// contacts-related task you need to do.
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION)
== PackageManager.PERMISSION_GRANTED) {
if (mGoogleApiClient == null) {
buildGoogleApiClient();
}
mMap.setMyLocationEnabled(true);
}
} else {
// Permission denied, Disable the functionality that depends on this permission.
Toast.makeText(this, "permission denied", Toast.LENGTH_LONG).show();
}
return;
}
// other 'case' lines to check for other permissions this app might request.
// You can add here other case statements according to your requirement.
}
}}
Debug output:
解决方案
I think you need to use the Location Manager. There is a good tutorial here.
What is say's on the website is that you need to add the following:
LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationManager.requestLocationUpdates( LocationManager.GPS_PROVIDER,
2000,
10, this);
the first parameters is the provider you are using (in this case the GPS Provider). The second parameter (2000) is the minimum time in milliseconds between each update. The third parameter (10) is the minimum distance. The last parameters is your LocationListener (this).
It is also a good idea to implement onProviderDisabled in case the user has his GPS turned off.
这篇关于Android Google Maps API OnLocationChanged只调用一次的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
