ines-num-new">
            geocoderSearch = new GeocodeSearch(this);
126
            geocoderSearch.setOnGeocodeSearchListener(this);
127
            setUpMap();
126
            try {
127
                geocoderSearch = new GeocodeSearch(this);
128
                geocoderSearch.setOnGeocodeSearchListener(this);
129
                setUpMap();
130
            } catch (AMapException e) {
131
                e.printStackTrace();
132
            }
128 133
        }
129 134
    }
130 135
@ -267,23 +272,28 @@ public class RouteSelectPointActivity extends Activity implements View.OnClickLi
267 272
    public void activate(OnLocationChangedListener onLocationChangedListener) {
268 273
        mListener = onLocationChangedListener;
269 274
        if (mlocationClient == null) {
270
            mlocationClient = new AMapLocationClient(this);
271
            mLocationOption = new AMapLocationClientOption();
272
            //设置定位监听
273
            mlocationClient.setLocationListener(this);
274
            //设置为高精度定位模式
275
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
276
            //设置定位参数
277
            mlocationClient.setLocationOption(mLocationOption);
278
            // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
279
            // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
280
            // 在定位结束后,在合适的生命周期调用onDestroy()方法
281
            // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
282
            // 设置是否只定位一次,默认为false
283
            mLocationOption.setOnceLocation(true);
284
            //设置是否强制刷新WIFI,默认为强制刷新
285
            mLocationOption.setWifiActiveScan(false);
286
            mlocationClient.startLocation();
275
            try {
276
                mlocationClient = new AMapLocationClient(this);
277
                mLocationOption = new AMapLocationClientOption();
278
                //设置定位监听
279
                mlocationClient.setLocationListener(this);
280
                //设置为高精度定位模式
281
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
282
                //设置定位参数
283
                mlocationClient.setLocationOption(mLocationOption);
284
                // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
285
                // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
286
                // 在定位结束后,在合适的生命周期调用onDestroy()方法
287
                // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
288
                // 设置是否只定位一次,默认为false
289
                mLocationOption.setOnceLocation(true);
290
                //设置是否强制刷新WIFI,默认为强制刷新
291
                mLocationOption.setWifiActiveScan(false);
292
                mlocationClient.startLocation();
293
294
            } catch (Exception e) {
295
                e.printStackTrace();
296
            }
287 297
288 298
        }
289 299
    }

+ 9 - 3
app/src/main/java/com/electric/chargingpile/activity/SearchActivity.java

@ -42,6 +42,7 @@ import android.widget.Toast;
42 42

43 43
import com.amap.api.maps.AMapUtils;
44 44
import com.amap.api.maps.model.LatLng;
45
import com.amap.api.services.core.AMapException;
45 46
import com.amap.api.services.core.PoiItem;
46 47
import com.amap.api.services.core.SuggestionCity;
47 48
import com.amap.api.services.help.Inputtips;
@ -912,9 +913,14 @@ public class SearchActivity extends Activity implements OnClickListener, Inputti
912 913
        query.setPageSize(30);// 设置每页最多返回多少条poiitem
913 914
        query.setPageNum(currentPage);// 设置查第一页
914 915

915
        poiSearch = new PoiSearch(this, query);
916
        poiSearch.setOnPoiSearchListener(this);
917
        poiSearch.searchPOIAsyn();
916
        try {
917
            poiSearch = new PoiSearch(this, query);
918
            poiSearch.setOnPoiSearchListener(this);
919
            poiSearch.searchPOIAsyn();
920
        } catch (AMapException e) {
921
            e.printStackTrace();
922
        }
923

918 924
    }
919 925

920 926
    private void doPointNameSearchQuery() {

+ 16 - 11
app/src/main/java/com/electric/chargingpile/activity/SelectCityActivity.java

@ -293,7 +293,7 @@ public class SelectCityActivity extends Activity implements AMapLocationListener
293 293
        SQLiteDatabase recentVisitDb = cityOpenHelper.getWritableDatabase();
294 294
        Cursor cursor = recentVisitDb.rawQuery("select * from recentcity order by date desc limit 0, 3", null);
295 295
        while (cursor.moveToNext()) {
296
            String recentVisitCityName = cursor.getString(cursor.getColumnIndex("name"));
296
            @SuppressLint("Range") String recentVisitCityName = cursor.getString(cursor.getColumnIndex("name"));
297 297
            recentCityList.add(recentVisitCityName);
298 298
        }
299 299
        cursor.close();
@ -599,27 +599,32 @@ public class SelectCityActivity extends Activity implements AMapLocationListener
599 599
    private void setUpMap() {
600 600
//        //声明mLocationOption对象
601 601
//        AMapLocationClientOption mLocationOption = null;
602
        mlocationClient = new AMapLocationClient(this);
603
//初始化定位参数
604
        mLocationOption = new AMapLocationClientOption();
602
        try {
603
            mlocationClient = new AMapLocationClient(this);
604
            //初始化定位参数
605
            mLocationOption = new AMapLocationClientOption();
605 606
//设置定位监听
606
        mlocationClient.setLocationListener(this);
607
            mlocationClient.setLocationListener(this);
607 608
//设置定位模式为高精度模式,Battery_Saving为低功耗模式,Device_Sensors是仅设备模式
608
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
609
        mLocationOption.setOnceLocation(true);
610
        //设置是否强制刷新WIFI,默认为强制刷新
611
        mLocationOption.setWifiActiveScan(false);
609
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
610
            mLocationOption.setOnceLocation(true);
611
            //设置是否强制刷新WIFI,默认为强制刷新
612
            mLocationOption.setWifiActiveScan(false);
612 613
//设置定位间隔,单位毫秒,默认为2000ms
613 614
//        mLocationOption.setInterval(2000);
614 615
//设置定位参数
615
        mlocationClient.setLocationOption(mLocationOption);
616
            mlocationClient.setLocationOption(mLocationOption);
616 617
// 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
617 618
// 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
618 619
// 在定位结束后,在合适的生命周期调用onDestroy()方法
619 620
// 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
620 621
621 622
//启动定位
622
        mlocationClient.startLocation();
623
            mlocationClient.startLocation();
624
        } catch (Exception e) {
625
            e.printStackTrace();
626
        }
627
623 628
    }
624 629
625 630

+ 31 - 20
app/src/main/java/com/electric/chargingpile/activity/ShareMapActivity.java

@ -28,6 +28,7 @@ import com.amap.api.maps.model.BitmapDescriptorFactory;
28 28
import com.amap.api.maps.model.CameraPosition;
29 29
import com.amap.api.maps.model.LatLng;
30 30
import com.amap.api.maps.model.MyLocationStyle;
31
import com.amap.api.services.core.AMapException;
31 32
import com.amap.api.services.core.LatLonPoint;
32 33
import com.amap.api.services.geocoder.GeocodeResult;
33 34
import com.amap.api.services.geocoder.GeocodeSearch;
@ -112,9 +113,14 @@ public class ShareMapActivity extends Activity implements View.OnClickListener,
112 113
            //获得地图的最大和最小缩放级别
113 114
            maxZoomLevel = aMap.getMaxZoomLevel();
114 115
            minZoomLevel = aMap.getMinZoomLevel();
115
            geocoderSearch = new GeocodeSearch(this);
116
            geocoderSearch.setOnGeocodeSearchListener(this);
117
            setUpMap();
116
            try {
117
                geocoderSearch = new GeocodeSearch(this);
118
                geocoderSearch.setOnGeocodeSearchListener(this);
119
                setUpMap();
120
            } catch (AMapException e) {
121
                e.printStackTrace();
122
            }
123
118 124
        }
119 125
    }
120 126
@ -399,24 +405,29 @@ public class ShareMapActivity extends Activity implements View.OnClickListener,
399 405
    public void activate(OnLocationChangedListener onLocationChangedListener) {
400 406
        mListener = onLocationChangedListener;
401 407
        if (mlocationClient == null) {
402
            mlocationClient = new AMapLocationClient(this);
403
            mLocationOption = new AMapLocationClientOption();
404
            //设置定位监听
405
            mlocationClient.setLocationListener(this);
406
            //设置为高精度定位模式
407
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
408
            //设置定位参数
409
            mlocationClient.setLocationOption(mLocationOption);
410
            // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
411
            // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
412
            // 在定位结束后,在合适的生命周期调用onDestroy()方法
413
            // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
414
            // 设置是否只定位一次,默认为false
415
            mLocationOption.setOnceLocation(true);
408
            try {
409
                mlocationClient = new AMapLocationClient(this);
410
                mLocationOption = new AMapLocationClientOption();
411
                //设置定位监听
412
                mlocationClient.setLocationListener(this);
413
                //设置为高精度定位模式
414
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
415
                //设置定位参数
416
                mlocationClient.setLocationOption(mLocationOption);
417
                // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
418
                // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
419
                // 在定位结束后,在合适的生命周期调用onDestroy()方法
420
                // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
421
                // 设置是否只定位一次,默认为false
422
                mLocationOption.setOnceLocation(true);
416 423
//            mLocationOption.setOnceLocationLatest(true);
417
            //设置是否强制刷新WIFI,默认为强制刷新
418
            mLocationOption.setWifiActiveScan(false);
419
            mlocationClient.startLocation();
424
                //设置是否强制刷新WIFI,默认为强制刷新
425
                mLocationOption.setWifiActiveScan(false);
426
                mlocationClient.startLocation();
427
            } catch (Exception e) {
428
                e.printStackTrace();
429
            }
430
420 431
421 432
        }
422 433
    }

+ 22 - 17
app/src/main/java/com/electric/chargingpile/activity/ShowBuildLocationActivity.java

@ -154,23 +154,28 @@ public class ShowBuildLocationActivity extends Activity implements AMap.OnCamera
154 154
    public void activate(OnLocationChangedListener onLocationChangedListener) {
155 155
        mListener = onLocationChangedListener;
156 156
        if (mlocationClient == null) {
157
            mlocationClient = new AMapLocationClient(this);
158
            mLocationOption = new AMapLocationClientOption();
159
            //设置定位监听
160
            mlocationClient.setLocationListener(this);
161
            //设置为高精度定位模式
162
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
163
            //设置定位参数
164
            mlocationClient.setLocationOption(mLocationOption);
165
            // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
166
            // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
167
            // 在定位结束后,在合适的生命周期调用onDestroy()方法
168
            // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
169
            // 设置是否只定位一次,默认为false
170
            mLocationOption.setOnceLocation(true);
171
            //设置是否强制刷新WIFI,默认为强制刷新
172
            mLocationOption.setWifiActiveScan(false);
173
            mlocationClient.startLocation();
157
            try {
158
                mlocationClient = new AMapLocationClient(this);
159
                mLocationOption = new AMapLocationClientOption();
160
                //设置定位监听
161
                mlocationClient.setLocationListener(this);
162
                //设置为高精度定位模式
163
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
164
                //设置定位参数
165
                mlocationClient.setLocationOption(mLocationOption);
166
                // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
167
                // 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
168
                // 在定位结束后,在合适的生命周期调用onDestroy()方法
169
                // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
170
                // 设置是否只定位一次,默认为false
171
                mLocationOption.setOnceLocation(true);
172
                //设置是否强制刷新WIFI,默认为强制刷新
173
                mLocationOption.setWifiActiveScan(false);
174
                mlocationClient.startLocation();
175
            } catch (Exception e) {
176
                e.printStackTrace();
177
            }
178
174 179
        }
175 180
    }
176 181

+ 18 - 9
app/src/main/java/com/electric/chargingpile/activity/SimpleNaviActivity.java

@ -8,6 +8,7 @@ import android.util.Log;
8 8
import android.view.Window;
9 9
import android.view.WindowManager;
10 10
11
import com.amap.api.maps.AMapException;
11 12
import com.amap.api.maps.model.BitmapDescriptor;
12 13
import com.amap.api.maps.model.BitmapDescriptorFactory;
13 14
import com.amap.api.navi.AMapNaviViewOptions;
@ -24,7 +25,7 @@ import com.amap.api.navi.model.AMapLaneInfo;
24 25
import com.amap.api.navi.model.AMapModelCross;
25 26
import com.amap.api.navi.model.AMapNaviCameraInfo;
26 27
import com.amap.api.navi.model.AMapNaviCross;
27
import com.amap.api.navi.model.AMapNaviInfo;
28
28 29
import com.amap.api.navi.model.AMapNaviLocation;
29 30
import com.amap.api.navi.model.AMapNaviPath;
30 31
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
@ -33,7 +34,7 @@ import com.amap.api.navi.model.AMapServiceAreaInfo;
33 34
import com.amap.api.navi.model.AimLessModeCongestionInfo;
34 35
import com.amap.api.navi.model.AimLessModeStat;
35 36
import com.amap.api.navi.model.NaviInfo;
36
import com.autonavi.tbt.TrafficFacilityInfo;
37
37 38
import com.electric.chargingpile.R;
38 39
39 40
import java.util.List;
@ -73,7 +74,11 @@ public class SimpleNaviActivity extends Activity implements AMapNaviListener, AM
73 74
        options.setAfterRouteAutoGray(true);
74 75
        mAMapNaviView.setViewOptions(options);
75 76
76
        mAMapNavi = AMapNavi.getInstance(getApplicationContext());
77
        try {
78
            mAMapNavi = AMapNavi.getInstance(getApplicationContext());
79
        } catch (AMapException e) {
80
            e.printStackTrace();
81
        }
77 82
        mAMapNavi.addAMapNaviListener(this);
78 83
        mAMapNavi.setEmulatorNaviSpeed(60);
79 84
        mAMapNavi.setUseInnerVoice(true);
@ -189,9 +194,6 @@ public class SimpleNaviActivity extends Activity implements AMapNaviListener, AM
189 194
    public void onGpsOpenStatus(boolean b) {
190 195
    }
191 196
192
    @Override
193
    public void onNaviInfoUpdated(AMapNaviInfo aMapNaviInfo) {
194
    }
195 197
196 198
    @Override
197 199
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
@ -215,9 +217,6 @@ public class SimpleNaviActivity extends Activity implements AMapNaviListener, AM
215 217
        }
216 218
    }
217 219
218
    @Override
219
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
220
    }
221 220
222 221
    @Override
223 222
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
@ -302,6 +301,11 @@ public class SimpleNaviActivity extends Activity implements AMapNaviListener, AM
302 301
    }
303 302
304 303
    @Override
304
    public void onGpsSignalWeak(boolean b) {
305
306
    }
307
308
    @Override
305 309
    public void onNaviSetting() {
306 310
    }
307 311
@ -346,4 +350,9 @@ public class SimpleNaviActivity extends Activity implements AMapNaviListener, AM
346 350
    @Override
347 351
    public void onNaviViewShowMode(int i) {
348 352
    }
353
354
    @Override
355
    public void onPointerCaptureChanged(boolean hasCapture) {
356
357
    }
349 358
}

+ 15 - 10
app/src/main/java/com/electric/chargingpile/activity/SwitchCityActivity.java

@ -1310,27 +1310,32 @@ public class SwitchCityActivity extends Activity implements OnScrollListener, AM
1310 1310
    private void setUpMap() {
1311 1311
//        //声明mLocationOption对象
1312 1312
//        AMapLocationClientOption mLocationOption = null;
1313
        mlocationClient = new AMapLocationClient(this);
1314
//初始化定位参数
1315
        mLocationOption = new AMapLocationClientOption();
1313
        try {
1314
            mlocationClient = new AMapLocationClient(this);
1315
            //初始化定位参数
1316
            mLocationOption = new AMapLocationClientOption();
1316 1317
//设置定位监听
1317
        mlocationClient.setLocationListener(this);
1318
            mlocationClient.setLocationListener(this);
1318 1319
//设置定位模式为高精度模式,Battery_Saving为低功耗模式,Device_Sensors是仅设备模式
1319
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
1320
        mLocationOption.setOnceLocation(true);
1321
        //设置是否强制刷新WIFI,默认为强制刷新
1322
        mLocationOption.setWifiActiveScan(false);
1320
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
1321
            mLocationOption.setOnceLocation(true);
1322
            //设置是否强制刷新WIFI,默认为强制刷新
1323
            mLocationOption.setWifiActiveScan(false);
1323 1324
//设置定位间隔,单位毫秒,默认为2000ms
1324 1325
//        mLocationOption.setInterval(2000);
1325 1326
//设置定位参数
1326
        mlocationClient.setLocationOption(mLocationOption);
1327
            mlocationClient.setLocationOption(mLocationOption);
1327 1328
// 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
1328 1329
// 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
1329 1330
// 在定位结束后,在合适的生命周期调用onDestroy()方法
1330 1331
// 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
1331 1332
1332 1333
//启动定位
1333
        mlocationClient.startLocation();
1334
            mlocationClient.startLocation();
1335
        } catch (Exception e) {
1336
            e.printStackTrace();
1337
        }
1338
1334 1339
    }
1335 1340
1336 1341
    @Override

+ 16 - 10
app/src/main/java/com/electric/chargingpile/activity/UserCenterActivity.java

@ -34,6 +34,7 @@ import android.widget.ToggleButton;
34 34
35 35
import androidx.annotation.NonNull;
36 36
37
import com.amap.api.services.core.AMapException;
37 38
import com.amap.api.services.weather.LocalDayWeatherForecast;
38 39
import com.amap.api.services.weather.LocalWeatherForecast;
39 40
import com.amap.api.services.weather.LocalWeatherForecastResult;
@ -293,16 +294,21 @@ public class UserCenterActivity extends Activity implements View.OnClickListener
293 294
        loadDialog = new LoadingDialog(this);
294 295
        loadDialog.setCanceledOnTouchOutside(false);
295 296
        mquery = new WeatherSearchQuery(MainMapActivity.location_city, WeatherSearchQuery.WEATHER_TYPE_FORECAST);
296
        mweathersearch = new WeatherSearch(this);
297
        mweathersearch.setOnWeatherSearchListener(this);
298
        mweathersearch.setQuery(mquery);
299
        mweathersearch.searchWeatherAsyn(); //异步搜索
300
301
        mquery1 = new WeatherSearchQuery(MainMapActivity.location_city, WeatherSearchQuery.WEATHER_TYPE_LIVE);
302
        mweathersearch1 = new WeatherSearch(this);
303
        mweathersearch1.setOnWeatherSearchListener(this);
304
        mweathersearch1.setQuery(mquery1);
305
        mweathersearch1.searchWeatherAsyn(); //异步搜索
297
        try {
298
            mweathersearch = new WeatherSearch(this);
299
            mweathersearch.setOnWeatherSearchListener(this);
300
            mweathersearch.setQuery(mquery);
301
            mweathersearch.searchWeatherAsyn(); //异步搜索
302
303
            mquery1 = new WeatherSearchQuery(MainMapActivity.location_city, WeatherSearchQuery.WEATHER_TYPE_LIVE);
304
            mweathersearch1 = new WeatherSearch(this);
305
            mweathersearch1.setOnWeatherSearchListener(this);
306
            mweathersearch1.setQuery(mquery1);
307
            mweathersearch1.searchWeatherAsyn(); //异步搜索
308
        } catch (AMapException e) {
309
            e.printStackTrace();
310
        }
311
306 312
        sv = (ObservableScrollView) findViewById(R.id.sv);
307 313
        sv.setScrollViewListener(this);
308 314
        iv_qiandao = (ImageView) findViewById(R.id.iv_qiandao);

+ 15 - 10
app/src/main/java/com/electric/chargingpile/adapter/CityListAdapter.java

@ -289,27 +289,32 @@ public class CityListAdapter extends BaseAdapter implements AMapLocationListener
289 289
    private void setUpMap() {
290 290
//        //声明mLocationOption对象
291 291
//        AMapLocationClientOption mLocationOption = null;
292
        mlocationClient = new AMapLocationClient(mActivity);
293
//初始化定位参数
294
        mLocationOption = new AMapLocationClientOption();
292
        try {
293
            mlocationClient = new AMapLocationClient(mActivity);
294
            //初始化定位参数
295
            mLocationOption = new AMapLocationClientOption();
295 296
//设置定位监听
296
        mlocationClient.setLocationListener(this);
297
            mlocationClient.setLocationListener(this);
297 298
//设置定位模式为高精度模式,Battery_Saving为低功耗模式,Device_Sensors是仅设备模式
298
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
299
        mLocationOption.setOnceLocation(true);
300
        //设置是否强制刷新WIFI,默认为强制刷新
301
        mLocationOption.setWifiActiveScan(false);
299
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
300
            mLocationOption.setOnceLocation(true);
301
            //设置是否强制刷新WIFI,默认为强制刷新
302
            mLocationOption.setWifiActiveScan(false);
302 303
//设置定位间隔,单位毫秒,默认为2000ms
303 304
//        mLocationOption.setInterval(2000);
304 305
//设置定位参数
305
        mlocationClient.setLocationOption(mLocationOption);
306
            mlocationClient.setLocationOption(mLocationOption);
306 307
// 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
307 308
// 注意设置合适的定位时间的间隔(最小间隔支持为2000ms),并且在合适时间调用stopLocation()方法来取消定位请求
308 309
// 在定位结束后,在合适的生命周期调用onDestroy()方法
309 310
// 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
310 311
311 312
//启动定位
312
        mlocationClient.startLocation();
313
            mlocationClient.startLocation();
314
315
        } catch (Exception e) {
316
            e.printStackTrace();
317
        }
313 318
    }
314 319
315 320

+ 39 - 35
app/src/main/java/com/electric/chargingpile/adapter/ZhuangStatusadapter.java

@ -242,43 +242,47 @@ public class ZhuangStatusadapter extends BaseAdapter {
242 242
        final AMapLocationClient mlocationClient;
243 243
        //声明mLocationOption对象
244 244
        AMapLocationClientOption mLocationOption = null;
245
        mlocationClient = new AMapLocationClient(activity);
246
        //初始化定位参数
247
        mLocationOption = new AMapLocationClientOption();
248
        //设置定位监听
249
        mlocationClient.setLocationListener(new AMapLocationListener() {
250
            @Override
251
            public void onLocationChanged(AMapLocation amapLocation) {
252
                if (amapLocation != null) {
253
                    if (amapLocation.getErrorCode() == 0) {
254
                        //定位成功回调信息,设置相关消息
255
                        amapLocation.getLocationType();//获取当前定位结果来源,如网络定位结果,详见定位类型表
256
                        amapLocation.getLatitude();//获取纬度
257
                        amapLocation.getLongitude();//获取
258
                        amapLocation.getAccuracy();//获取精度信息
259
                        LogUtils.e(amapLocation.getLatitude() + "--" + amapLocation.getLongitude());
260
                        mlocationClient.stopLocation();
261
                        sendControlParkingDownLock(amapLocation, zhuangStatus);
262
                    } else {
263
                        //显示错误信息ErrCode是错误码,errInfo是错误信息,详见错误码表。
264
                        Log.e("AmapError", "location Error, ErrCode:"
265
                                + amapLocation.getErrorCode() + ", errInfo:"
266
                                + amapLocation.getErrorInfo());
245
        try {
246
            mlocationClient = new AMapLocationClient(activity);
247
            //初始化定位参数
248
            mLocationOption = new AMapLocationClientOption();
249
            //设置定位监听
250
            mlocationClient.setLocationListener(new AMapLocationListener() {
251
                @Override
252
                public void onLocationChanged(AMapLocation amapLocation) {
253
                    if (amapLocation != null) {
254
                        if (amapLocation.getErrorCode() == 0) {
255
                            //定位成功回调信息,设置相关消息
256
                            amapLocation.getLocationType();//获取当前定位结果来源,如网络定位结果,详见定位类型表
257
                            amapLocation.getLatitude();//获取
258
                            amapLocation.getLongitude();//获取经度
259
                            amapLocation.getAccuracy();//获取精度信息
260
                            LogUtils.e(amapLocation.getLatitude() + "--" + amapLocation.getLongitude());
261
                            mlocationClient.stopLocation();
262
                            sendControlParkingDownLock(amapLocation, zhuangStatus);
263
                        } else {
264
                            //显示错误信息ErrCode是错误码,errInfo是错误信息,详见错误码表。
265
                            Log.e("AmapError", "location Error, ErrCode:"
266
                                    + amapLocation.getErrorCode() + ", errInfo:"
267
                                    + amapLocation.getErrorInfo());
268
                        }
267 269
                    }
268 270
                }
269
            }
270
        });
271
        //设置定位模式为高精度模式,Battery_Saving为低功耗模式,Device_Sensors是仅设备模式
272
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
273
        //设置定位间隔,单位毫秒,默认为2000ms//        mLocationOption.setInterval(2000);
274
        //设置定位参数
275
        mlocationClient.setLocationOption(mLocationOption);
276
        // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
277
        // 注意设置合适的定位时间的间隔(最小间隔支持为1000ms),并且在合适时间调用stopLocation()方法来取消定位请求
278
        // 在定位结束后,在合适的生命周期调用onDestroy()方法
279
        // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
280
        //启动定位
281
        mlocationClient.startLocation();
271
            });
272
            //设置定位模式为高精度模式,Battery_Saving为低功耗模式,Device_Sensors是仅设备模式
273
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
274
            //设置定位间隔,单位毫秒,默认为2000ms//        mLocationOption.setInterval(2000);
275
            //设置定位参数
276
            mlocationClient.setLocationOption(mLocationOption);
277
            // 此方法为每隔固定时间会发起一次定位请求,为了减少电量消耗或网络流量消耗,
278
            // 注意设置合适的定位时间的间隔(最小间隔支持为1000ms),并且在合适时间调用stopLocation()方法来取消定位请求
279
            // 在定位结束后,在合适的生命周期调用onDestroy()方法
280
            // 在单次定位情况下,定位无论成功与否,都无需调用stopLocation()方法移除请求,定位sdk内部会移除
281
            //启动定位
282
            mlocationClient.startLocation();
283
        } catch (Exception e) {
284
            e.printStackTrace();
285
        }
282 286
    }
283 287
284 288
    private void sendControlParkingDownLock(AMapLocation amapLocation, ZhuangStatus zhuangStatus) {

+ 6 - 0
app/src/main/java/com/electric/chargingpile/application/MainApplication.java

@ -13,6 +13,7 @@ import android.util.Log;
13 13
import androidx.multidex.MultiDexApplication;
14 14

15 15
import com.alibaba.fastjson.JSONException;
16
import com.amap.api.location.AMapLocationClient;
16 17
import com.amap.api.maps.model.LatLng;
17 18
import com.blankj.utilcode.util.LogUtils;
18 19
import com.blankj.utilcode.util.Utils;
@ -199,6 +200,9 @@ public class MainApplication extends MultiDexApplication {
199 200
        userCarIntentMode = ProfileManager.getInstance().getCarIntentModel(getApplicationContext());
200 201
        loginRemind();
201 202
        setFestival();
203
        if (ProfileManager.getInstance().getPrivacyAgreement(this)) {
204
            MainApplication.initSDK();
205
        }
202 206
    }
203 207

204 208
    public void initJPush() {
@ -392,6 +396,8 @@ public class MainApplication extends MultiDexApplication {
392 396
    }
393 397

394 398
    public static void initSDK() {
399
        AMapLocationClient.updatePrivacyShow(context,true,true);
400
        AMapLocationClient.updatePrivacyAgree(context,true);
395 401
        MobSDK.init(MainApplication.context);
396 402
        MobSDK.submitPolicyGrantResult(true,null);
397 403
        CrashReport.initCrashReport(MainApplication.context, "900010422", BuildConfig.DEBUG);

+ 7 - 9
app/src/main/java/com/electric/chargingpile/util/TTSController.java

@ -10,7 +10,7 @@ import com.amap.api.navi.model.AMapLaneInfo;
10 10
import com.amap.api.navi.model.AMapModelCross;
11 11
import com.amap.api.navi.model.AMapNaviCameraInfo;
12 12
import com.amap.api.navi.model.AMapNaviCross;
13
import com.amap.api.navi.model.AMapNaviInfo;
13
14 14
import com.amap.api.navi.model.AMapNaviLocation;
15 15
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
16 16
import com.amap.api.navi.model.AMapNaviTrafficFacilityInfo;
@ -18,7 +18,7 @@ import com.amap.api.navi.model.AMapServiceAreaInfo;
18 18
import com.amap.api.navi.model.AimLessModeCongestionInfo;
19 19
import com.amap.api.navi.model.AimLessModeStat;
20 20
import com.amap.api.navi.model.NaviInfo;
21
import com.autonavi.tbt.TrafficFacilityInfo;
21
22 22
import com.blankj.utilcode.util.LogUtils;
23 23
import com.electric.chargingpile.R;
24 24
import com.iflytek.cloud.speech.SpeechConstant;
@ -279,11 +279,7 @@ public class TTSController implements SynthesizerListener, AMapNaviListener, AMa
279 279
280 280
    }
281 281
282
    @Override
283
    public void onNaviInfoUpdated(AMapNaviInfo arg0) {
284
        // TODO Auto-generated method stub
285 282
286
    }
287 283
288 284
    @Override
289 285
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
@ -307,10 +303,7 @@ public class TTSController implements SynthesizerListener, AMapNaviListener, AMa
307 303
308 304
    }
309 305
310
    @Override
311
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
312 306
313
    }
314 307
315 308
    @Override
316 309
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
@ -401,6 +394,11 @@ public class TTSController implements SynthesizerListener, AMapNaviListener, AMa
401 394
    }
402 395
403 396
    @Override
397
    public void onGpsSignalWeak(boolean b) {
398
399
    }
400
401
    @Override
404 402
    public void onNaviSetting() {
405 403
    }
406 404

BIN
app/src/main/jniLibs/arm64-v8a/libAMapSDK_MAP_v6_9_2.so


BIN
app/src/main/jniLibs/arm64-v8a/libAMapSDK_NAVI_v6_9_0.so


BIN
app/src/main/jniLibs/arm64-v8a/libAMapSDK_NAVI_v8_1_0.so


BIN
app/src/main/jniLibs/arm64-v8a/libneonui_shared.so


BIN
app/src/main/jniLibs/arm64-v8a/libneonuijni_public.so


BIN
app/src/main/jniLibs/armeabi-v7a/libAMapSDK_MAP_v6_9_2.so


BIN
app/src/main/jniLibs/armeabi-v7a/libAMapSDK_NAVI_v6_9_0.so


BIN
app/src/main/jniLibs/armeabi-v7a/libAMapSDK_NAVI_v8_1_0.so


BIN
app/src/main/jniLibs/armeabi-v7a/libneonui_shared.so


BIN
app/src/main/jniLibs/armeabi-v7a/libneonuijni_public.so


BIN
app/src/main/jniLibs/armeabi/libAMapSDK_MAP_v6_9_2.so


BIN
app/src/main/jniLibs/armeabi/libAMapSDK_NAVI_v6_9_0.so


BIN
app/src/main/jniLibs/armeabi/libAMapSDK_NAVI_v8_1_0.so


BIN
app/src/main/jniLibs/armeabi/libneonui_shared.so


BIN
app/src/main/jniLibs/armeabi/libneonuijni_public.so


dudu/cdzApp - Gogs: Go Git Service

2 Revīzijas (b54a935e284f8dc0c5bdbf9c36bdeb534b901ff5)

Autors SHA1 Ziņojums Datums
  1145873331@qq.com e1cf244fe0 remove Useless dependence 6 gadi atpakaļ
  dxh 06bd894653 init 6 gadi atpakaļ