31
31 
import com.blankj.utilcode.util.LogUtils;
32 
import com.blankj.utilcode.util.LogUtils;
32 
import com.electric.chargingpile.R;
33 
import com.electric.chargingpile.R;
33
34
60 
//        mTtsManager.init();
61 
//        mTtsManager.init();
61 
//        mTtsManager.startSpeaking();
62 
//        mTtsManager.startSpeaking();
62 
//
63 
//
63 
        mAMapNavi = AMapNavi.getInstance(getApplicationContext());
64 
        try {
65 
            mAMapNavi = AMapNavi.getInstance(getApplicationContext());
66 
        } catch (AMapException e) {
67 
            e.printStackTrace();
68 
        }
64 
        mAMapNavi.addAMapNaviListener(this);
69 
        mAMapNavi.addAMapNaviListener(this);
65
70
66 
//        mAMapNavi.addAMapNaviListener(mTtsManager);
71 
//        mAMapNavi.addAMapNaviListener(mTtsManager);
210
215
211 
    }
216 
    }
212
217
213 
    @Override
214 
    public void onNaviInfoUpdated(AMapNaviInfo aMapNaviInfo) {
215
218
216 
    }
217
219
218 
    @Override
220 
    @Override
219 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
221 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
241
243
242 
    }
244 
    }
243
245
244 
    @Override
245 
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
246
247 
    }
248
246
249 
    @Override
247 
    @Override
250 
    public void showCross(AMapNaviCross aMapNaviCross) {
248 
    public void showCross(AMapNaviCross aMapNaviCross) {
333 
    }
331 
    }
334
332
335 
    @Override
333 
    @Override
334 
    public void onGpsSignalWeak(boolean b) {
335
336 
    }
337
338 
    @Override
336 
    public void onNaviSetting() {
339 
    public void onNaviSetting() {
337
340
338 
    }
341 
    }
387
390
388 
    }
391 
    }
389
392
393 
    @Override
394 
    public void onPointerCaptureChanged(boolean hasCapture) {
395
396 
    }
390 
}
397 
}

+ 31 - 20
app/src/main/java/com/electric/chargingpile/activity/BuildMapActivity.java
Просмотреть файл

22 
import com.amap.api.maps.model.CameraPosition;
 22 
import com.amap.api.maps.model.CameraPosition;
23 
import com.amap.api.maps.model.LatLng;
 23 
import com.amap.api.maps.model.LatLng;
24 
import com.amap.api.maps.model.MyLocationStyle;
 24 
import com.amap.api.maps.model.MyLocationStyle;
25 
import com.amap.api.services.core.AMapException;
25 
import com.amap.api.services.core.LatLonPoint;
 26 
import com.amap.api.services.core.LatLonPoint;
26 
import com.amap.api.services.geocoder.GeocodeResult;
 27 
import com.amap.api.services.geocoder.GeocodeResult;
27 
import com.amap.api.services.geocoder.GeocodeSearch;
 28 
import com.amap.api.services.geocoder.GeocodeSearch;
95 
            //获得地图的最大和最小缩放级别
 96 
            //获得地图的最大和最小缩放级别
96 
            maxZoomLevel = aMap.getMaxZoomLevel();
 97 
            maxZoomLevel = aMap.getMaxZoomLevel();
97 
            minZoomLevel = aMap.getMinZoomLevel();
 98 
            minZoomLevel = aMap.getMinZoomLevel();
98 
            geocoderSearch = new GeocodeSearch(this);
99 
            geocoderSearch.setOnGeocodeSearchListener(this);
100 
            setUpMap();
99 
            try {
100 
                geocoderSearch = new GeocodeSearch(this);
101 
                geocoderSearch.setOnGeocodeSearchListener(this);
102 
                setUpMap();
103 
            } catch (AMapException e) {
104 
                e.printStackTrace();
105 
            }
106
101 
        }
 107 
        }
102 
    }
 108 
    }
103
109
342 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 348 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
343 
        mListener = onLocationChangedListener;
 349 
        mListener = onLocationChangedListener;
344 
        if (mlocationClient == null) {
 350 
        if (mlocationClient == null) {
345 
            mlocationClient = new AMapLocationClient(this);
346 
            mLocationOption = new AMapLocationClientOption();
347 
            //设置定位监听
348 
            mlocationClient.setLocationListener(this);
349 
            //设置为高精度定位模式
350 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
351 
            //设置定位参数
352 
            mlocationClient.setLocationOption(mLocationOption);
353 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
354 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
355 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
356 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
357 
            // 设置是否只定位一次,默认为false
358 
            mLocationOption.setOnceLocation(true);
359 
            //设置是否强制刷新WIFI，默认为强制刷新
360 
            mLocationOption.setWifiActiveScan(false);
361 
            mlocationClient.startLocation();
351 
            try {
352 
                mlocationClient = new AMapLocationClient(this);
353 
                mLocationOption = new AMapLocationClientOption();
354 
                //设置定位监听
355 
                mlocationClient.setLocationListener(this);
356 
                //设置为高精度定位模式
357 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
358 
                //设置定位参数
359 
                mlocationClient.setLocationOption(mLocationOption);
360 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
361 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
362 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
363 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
364 
                // 设置是否只定位一次,默认为false
365 
                mLocationOption.setOnceLocation(true);
366 
                //设置是否强制刷新WIFI，默认为强制刷新
367 
                mLocationOption.setWifiActiveScan(false);
368 
                mlocationClient.startLocation();
369
370 
            } catch (Exception e) {
371 
                e.printStackTrace();
372 
            }
362
373
363 
        }
 374 
        }
364 
    }
 375 
    }

+ 22 - 17
app/src/main/java/com/electric/chargingpile/activity/ClaimMapActivity.java
Просмотреть файл

1607 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 1607 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
1608 
        mListener = onLocationChangedListener;
 1608 
        mListener = onLocationChangedListener;
1609 
        if (mlocationClient == null) {
 1609 
        if (mlocationClient == null) {
1610 
            mlocationClient = new AMapLocationClient(this);
1611 
            mLocationOption = new AMapLocationClientOption();
1612 
            //设置定位监听
1613 
            mlocationClient.setLocationListener(this);
1614 
            //设置为高精度定位模式
1615 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
1616 
            //设置定位参数
1617 
            mlocationClient.setLocationOption(mLocationOption);
1618 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
1619 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
1620 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
1621 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
1622 
            // 设置是否只定位一次,默认为false
1623 
            mLocationOption.setOnceLocation(true);
1624 
            //设置是否强制刷新WIFI，默认为强制刷新
1625 
            mLocationOption.setWifiActiveScan(false);
1626 
            mlocationClient.startLocation();
1610 
            try {
1611 
                mlocationClient = new AMapLocationClient(this);
1612 
                mLocationOption = new AMapLocationClientOption();
1613 
                //设置定位监听
1614 
                mlocationClient.setLocationListener(this);
1615 
                //设置为高精度定位模式
1616 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
1617 
                //设置定位参数
1618 
                mlocationClient.setLocationOption(mLocationOption);
1619 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
1620 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
1621 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
1622 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
1623 
                // 设置是否只定位一次,默认为false
1624 
                mLocationOption.setOnceLocation(true);
1625 
                //设置是否强制刷新WIFI，默认为强制刷新
1626 
                mLocationOption.setWifiActiveScan(false);
1627 
                mlocationClient.startLocation();
1628 
            } catch (Exception e) {
1629 
                e.printStackTrace();
1630 
            }
1631
1627
1632
1628 
        }
 1633 
        }
1629 
    }
 1634 
    }

+ 29 - 20
app/src/main/java/com/electric/chargingpile/activity/ClaimSurveyTwoActivity.java
Просмотреть файл

62 
import com.amap.api.maps.model.Marker;
 62 
import com.amap.api.maps.model.Marker;
63 
import com.amap.api.maps.model.MarkerOptions;
 63 
import com.amap.api.maps.model.MarkerOptions;
64 
import com.amap.api.maps.model.MyLocationStyle;
 64 
import com.amap.api.maps.model.MyLocationStyle;
65 
import com.amap.api.services.core.AMapException;
65 
import com.amap.api.services.core.LatLonPoint;
 66 
import com.amap.api.services.core.LatLonPoint;
66 
import com.amap.api.services.geocoder.GeocodeResult;
 67 
import com.amap.api.services.geocoder.GeocodeResult;
67 
import com.amap.api.services.geocoder.GeocodeSearch;
 68 
import com.amap.api.services.geocoder.GeocodeSearch;
2201 
            //获得地图的最大和最小缩放级别
 2202 
            //获得地图的最大和最小缩放级别
2202 
            maxZoomLevel = aMap.getMaxZoomLevel();
 2203 
            maxZoomLevel = aMap.getMaxZoomLevel();
2203 
            minZoomLevel = aMap.getMinZoomLevel();
 2204 
            minZoomLevel = aMap.getMinZoomLevel();
2204 
            geocoderSearch = new GeocodeSearch(this);
2205 
            geocoderSearch.setOnGeocodeSearchListener(this);
2206 
            setUpMap();
2205 
            try {
2206 
                geocoderSearch = new GeocodeSearch(this);
2207 
                geocoderSearch.setOnGeocodeSearchListener(this);
2208 
                setUpMap();
2209 
            } catch (AMapException e) {
2210 
                e.printStackTrace();
2211 
            }
2207 
        }
 2212 
        }
2208 
    }
 2213 
    }
2209
2214
2234 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 2239 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
2235 
        mListener = onLocationChangedListener;
 2240 
        mListener = onLocationChangedListener;
2236 
        if (mlocationClient == null) {
 2241 
        if (mlocationClient == null) {
2237 
            mlocationClient = new AMapLocationClient(this);
2238 
            mLocationOption = new AMapLocationClientOption();
2239 
            //设置定位监听
2240 
            mlocationClient.setLocationListener(this);
2241 
            //设置为高精度定位模式
2242 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
2243 
            //设置定位参数
2244 
            mlocationClient.setLocationOption(mLocationOption);
2245 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
2246 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
2247 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
2248 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
2249 
            // 设置是否只定位一次,默认为false
2250 
            mLocationOption.setOnceLocation(true);
2251 
            //设置是否强制刷新WIFI，默认为强制刷新
2252 
            mLocationOption.setWifiActiveScan(false);
2253 
            mlocationClient.startLocation();
2242 
            try {
2243 
                mlocationClient = new AMapLocationClient(this);
2244 
                mLocationOption = new AMapLocationClientOption();
2245 
                //设置定位监听
2246 
                mlocationClient.setLocationListener(this);
2247 
                //设置为高精度定位模式
2248 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
2249 
                //设置定位参数
2250 
                mlocationClient.setLocationOption(mLocationOption);
2251 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
2252 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
2253 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
2254 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
2255 
                // 设置是否只定位一次,默认为false
2256 
                mLocationOption.setOnceLocation(true);
2257 
                //设置是否强制刷新WIFI，默认为强制刷新
2258 
                mLocationOption.setWifiActiveScan(false);
2259 
                mlocationClient.startLocation();
2260 
            } catch (Exception e) {
2261 
                e.printStackTrace();
2262 
            }
2254 
        }
 2263 
        }
2255 
    }
 2264 
    }
2256
2265

+ 43 - 40
app/src/main/java/com/electric/chargingpile/activity/MainMapActivity.java
Просмотреть файл

1401
1401
1402 
        changeButton();
 1402 
        changeButton();
1403
1403
1404 
        if (hasLocationPermission() && center == null) {
1404 
        if (hasLocationPermission() && center == null && mlocationClient!=null) {
1405 
            mlocationClient.startLocation();
 1405 
            mlocationClient.startLocation();
1406 
        }
 1406 
        }
1407 
    }
 1407 
    }
1504 
    public void activate(OnLocationChangedListener listener) {
 1504 
    public void activate(OnLocationChangedListener listener) {
1505 
        mListener = listener;
 1505 
        mListener = listener;
1506 
        if (mlocationClient == null) {
 1506 
        if (mlocationClient == null) {
1507 
            mlocationClient = new AMapLocationClient(this);
1507 
            try {
1508 
                mlocationClient = new AMapLocationClient(this);
1508
1509
1509 
            mLocationOption = new AMapLocationClientOption();
1510 
            //设置定位监听
1511 
            mlocationClient.setLocationListener(this);
1512 
            //设置为高精度定位模式
1513 
            mLocationOption.setLocationMode(AMapLocationMode.Battery_Saving);
1510 
                mLocationOption = new AMapLocationClientOption();
1511 
                //设置定位监听
1512 
                mlocationClient.setLocationListener(this);
1513 
                //设置为高精度定位模式
1514 
                mLocationOption.setLocationMode(AMapLocationMode.Battery_Saving);
1514 
//            mLocationOption.setGpsFirst(true);
 1515 
//            mLocationOption.setGpsFirst(true);
1515 
//            mLocationOption.setOnceLocation(true);
 1516 
//            mLocationOption.setOnceLocation(true);
1516 
            mLocationOption.setInterval(1500);
1517 
                mLocationOption.setInterval(1500);
1517
1518
1518 
            //设置是否强制刷新WIFI，默认为强制刷新
1519 
                //设置是否强制刷新WIFI，默认为强制刷新
1519 
//            mLocationOption.setWifiActiveScan(true);
 1520 
//            mLocationOption.setWifiActiveScan(true);
1520 
            //设置定位参数
1521 
            mlocationClient.setLocationOption(mLocationOption);
1522 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
1523 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
1524 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
1525 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
1526 
            // 设置是否只定位一次,默认为false
1527 
            mLocationOption.setOnceLocation(false);
1528 
            //设置是否强制刷新WIFI，默认为强制刷新
1529 
            //mLocationOption.setWifiActiveScan(false);
1530 
            mLocationOption.setWifiScan(true);
1531
1532 
            if (ProfileManager.getInstance().getStartedRequestLocationPermission(MainMapActivity.this)) {
1533 
                if (hasLocationPermission()) {
1534 
                    requestLocationPermission();
1535 
                }
1536 
            } else { // 首次启动
1521 
                //设置定位参数
1522 
                mlocationClient.setLocationOption(mLocationOption);
1523 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
1524 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
1525 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
1526 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
1527 
                // 设置是否只定位一次,默认为false
1528 
                mLocationOption.setOnceLocation(false);
1529 
                //设置是否强制刷新WIFI，默认为强制刷新
1530 
                //mLocationOption.setWifiActiveScan(false);
1531 
                mLocationOption.setWifiScan(true);
1532 
                if (ProfileManager.getInstance().getStartedRequestLocationPermission(MainMapActivity.this)) {
1533 
                    if (hasLocationPermission()) {
1534 
                        requestLocationPermission();
1535 
                    }
1536 
                } else { // 首次启动
1537
1537
1538 
                ProfileManager.getInstance().setStartedRequestLocationPermission(MainMapActivity.this, true);
1539 
                new LocationPermissionsDialog(context)
1540 
                        .builder()
1541 
                        .setMsg("需要确定您所在的城市，首页才能显示您所在的城市的站点信息，请您授权定位")
1542 
                        .setLeftButton("取消",v -> {
1538 
                    ProfileManager.getInstance().setStartedRequestLocationPermission(MainMapActivity.this, true);
1539 
                    new LocationPermissionsDialog(context)
1540 
                            .builder()
1541 
                            .setMsg("需要确定您所在的城市，首页才能显示您所在的城市的站点信息，请您授权定位")
1542 
                            .setLeftButton("取消",v -> {
1543
1543
1544 
                        })
1545 
                        .setRightButton("确定",v->{
1544 
                            })
1545 
                            .setRightButton("确定",v->{
1546 
                                EasyPermissions.requestPermissions(
 1546 
                                EasyPermissions.requestPermissions(
1547 
                                        this,
 1547 
                                        this,
1548 
                                        "为了定位您的位置，推荐充电桩，充电桩位置路线导航需要开启位置权限，是否前往开启?",
 1548 
                                        "为了定位您的位置，推荐充电桩，充电桩位置路线导航需要开启位置权限，是否前往开启?",
1549 
                                        RC_Location_FIRST_PERM,
 1549 
                                        RC_Location_FIRST_PERM,
1550 
                                        Manifest.permission.ACCESS_FINE_LOCATION,
 1550 
                                        Manifest.permission.ACCESS_FINE_LOCATION,
1551 
                                        Manifest.permission.ACCESS_COARSE_LOCATION
 1551 
                                        Manifest.permission.ACCESS_COARSE_LOCATION
1552 
                                        );
1552 
                                );
1553
1553
1554 
                        }).show();
1554 
                            }).show();
1555
1555
1556 
            }
1556 
                }
1557
1557
1558 
            if (hasLocationPermission()) {
1559 
                Log.e(TAG, "onResume: hyc 4" );
1560 
                requestLocationPermission();
1561 
            }
1558 
                if (hasLocationPermission()) {
1559 
                    Log.e(TAG, "onResume: hyc 4" );
1560 
                    requestLocationPermission();
1561 
                }
1562
1562
1563 
            } catch (Exception e) {
1564 
                e.printStackTrace();
1565 
            }
1563 
        }
 1566 
        }
1564 
    }
 1567 
    }
1565
1568

+ 31 - 26
app/src/main/java/com/electric/chargingpile/activity/NewSelectCityActivity.java
Просмотреть файл

397 
    }
 397 
    }
398
398
399 
    private void initLocation() {
 399 
    private void initLocation() {
400 
        mlocationClient = new AMapLocationClient(this);
401 
        //初始化定位参数
402 
        mLocationOption = new AMapLocationClientOption();
403 
        //设置定位监听
404 
        mlocationClient.setLocationListener(this);
405 
        //设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
406 
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
407 
        mLocationOption.setOnceLocation(true);
408 
        //设置是否强制刷新WIFI，默认为强制刷新
409 
        mLocationOption.setWifiActiveScan(false);
410 
        //设置定位间隔,单位毫秒,默认为2000ms
411 
        // mLocationOption.setInterval(2000);
412 
        // 设置定位参数
413 
        mlocationClient.setLocationOption(mLocationOption);
414 
        // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
415 
        // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
416 
        // 在定位结束后，在合适的生命周期调用onDestroy()方法
417 
        // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
418 
        //启动定位
419
420 
        if (hasLocationPermission()) {
421 
            requestLocationPermission();
422 
        } else {
423 
            mTvLocation.setText("定位失败");
424 
            if (!ProfileManager.getInstance().getFirstRequestLocationPermission(NewSelectCityActivity.this)) {
425 
                ProfileManager.getInstance().setFirstRequestLocationPermission(NewSelectCityActivity.this, true);
400 
        try {
401 
            mlocationClient = new AMapLocationClient(this);
402 
            //初始化定位参数
403 
            mLocationOption = new AMapLocationClientOption();
404 
            //设置定位监听
405 
            mlocationClient.setLocationListener(this);
406 
            //设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
407 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
408 
            mLocationOption.setOnceLocation(true);
409 
            //设置是否强制刷新WIFI，默认为强制刷新
410 
            mLocationOption.setWifiActiveScan(false);
411 
            //设置定位间隔,单位毫秒,默认为2000ms
412 
            // mLocationOption.setInterval(2000);
413 
            // 设置定位参数
414 
            mlocationClient.setLocationOption(mLocationOption);
415 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
416 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
417 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
418 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
419 
            //启动定位
420
421 
            if (hasLocationPermission()) {
426 
                requestLocationPermission();
 422 
                requestLocationPermission();
423 
            } else {
424 
                mTvLocation.setText("定位失败");
425 
                if (!ProfileManager.getInstance().getFirstRequestLocationPermission(NewSelectCityActivity.this)) {
426 
                    ProfileManager.getInstance().setFirstRequestLocationPermission(NewSelectCityActivity.this, true);
427 
                    requestLocationPermission();
428 
                }
427 
            }
 429 
            }
430 
        } catch (Exception e) {
431 
            e.printStackTrace();
428 
        }
 432 
        }
433
429 
    }
 434 
    }
430
435
431 
    private void insertData(CityRecord cityRecord) {
 436 
    private void insertData(CityRecord cityRecord) {

+ 19 - 14
app/src/main/java/com/electric/chargingpile/activity/OfflineMapActivity.java
Просмотреть файл

238 
        mAllOfflineMapList = (ExpandableListView) provinceContainer
 238 
        mAllOfflineMapList = (ExpandableListView) provinceContainer
239 
                .findViewById(R.id.province_download_list);
 239 
                .findViewById(R.id.province_download_list);
240
240
241 
        amapManager = new OfflineMapManager(this, this);
242
243 
        initProvinceListAndCityMap();
244
245 
        // adapter = new OfflineListAdapter(provinceList, cityMap, amapManager,
246 
        // OfflineMapActivity.this);
247 
        adapter = new OfflineListAdapter(provinceList, amapManager,
248 
                OfflineMapActivity.this);
249 
        // 为列表绑定数据源
250 
        mAllOfflineMapList.setAdapter(adapter);
251 
        // adapter实现了扩展列表的展开与合并监听
252 
        mAllOfflineMapList.setOnGroupCollapseListener(adapter);
253 
        mAllOfflineMapList.setOnGroupExpandListener(adapter);
254 
        mAllOfflineMapList.setGroupIndicator(null);
241 
        try {
242 
            amapManager = new OfflineMapManager(this, this);
243
244 
            initProvinceListAndCityMap();
245
246 
            // adapter = new OfflineListAdapter(provinceList, cityMap, amapManager,
247 
            // OfflineMapActivity.this);
248 
            adapter = new OfflineListAdapter(provinceList, amapManager,
249 
                    OfflineMapActivity.this);
250 
            // 为列表绑定数据源
251 
            mAllOfflineMapList.setAdapter(adapter);
252 
            // adapter实现了扩展列表的展开与合并监听
253 
            mAllOfflineMapList.setOnGroupCollapseListener(adapter);
254 
            mAllOfflineMapList.setOnGroupExpandListener(adapter);
255 
            mAllOfflineMapList.setGroupIndicator(null);
256 
        } catch (Exception e) {
257 
            e.printStackTrace();
258 
        }
259
255 
    }
 260 
    }
256
261
257 
    /**
 262 
    /**

+ 40 - 35
app/src/main/java/com/electric/chargingpile/activity/PileDetailsActivity.java
Просмотреть файл

348 
        final AMapLocationClient mlocationClient;
 348 
        final AMapLocationClient mlocationClient;
349 
        //声明mLocationOption对象
 349 
        //声明mLocationOption对象
350 
        AMapLocationClientOption mLocationOption = null;
 350 
        AMapLocationClientOption mLocationOption = null;
351 
        mlocationClient = new AMapLocationClient(this);
352 
        //初始化定位参数
353 
        mLocationOption = new AMapLocationClientOption();
354 
        //设置定位监听
355 
        mlocationClient.setLocationListener(new AMapLocationListener() {
356 
            @Override
357 
            public void onLocationChanged(AMapLocation amapLocation) {
358 
                if (amapLocation != null) {
359 
                    if (amapLocation.getErrorCode() == 0) {
360 
                        //定位成功回调信息，设置相关消息
361 
                        amapLocation.getLocationType();//获取当前定位结果来源，如网络定位结果，详见定位类型表
362 
                        amapLocation.getLatitude();//获取纬度
363 
                        amapLocation.getLongitude();//获取经度
364 
                        amapLocation.getAccuracy();//获取精度信息
365 
                        LogUtils.e(amapLocation.getLatitude() + "--" + amapLocation.getLongitude());
366 
                        mlocationClient.stopLocation();
367 
                        sendControlParkingDownLock(amapLocation, pileData);
368 
                    } else {
369 
                        //显示错误信息ErrCode是错误码，errInfo是错误信息，详见错误码表。
370 
                        Log.e("AmapError", "location Error, ErrCode:"
371 
                                + amapLocation.getErrorCode() + ", errInfo:"
372 
                                + amapLocation.getErrorInfo());
351 
        try {
352 
            mlocationClient = new AMapLocationClient(this);
353 
            //初始化定位参数
354 
            mLocationOption = new AMapLocationClientOption();
355 
            //设置定位监听
356 
            mlocationClient.setLocationListener(new AMapLocationListener() {
357 
                @Override
358 
                public void onLocationChanged(AMapLocation amapLocation) {
359 
                    if (amapLocation != null) {
360 
                        if (amapLocation.getErrorCode() == 0) {
361 
                            //定位成功回调信息，设置相关消息
362 
                            amapLocation.getLocationType();//获取当前定位结果来源，如网络定位结果，详见定位类型表
363 
                            amapLocation.getLatitude();//获取纬度
364 
                            amapLocation.getLongitude();//获取经度
365 
                            amapLocation.getAccuracy();//获取精度信息
366 
                            LogUtils.e(amapLocation.getLatitude() + "--" + amapLocation.getLongitude());
367 
                            mlocationClient.stopLocation();
368 
                            sendControlParkingDownLock(amapLocation, pileData);
369 
                        } else {
370 
                            //显示错误信息ErrCode是错误码，errInfo是错误信息，详见错误码表。
371 
                            Log.e("AmapError", "location Error, ErrCode:"
372 
                                    + amapLocation.getErrorCode() + ", errInfo:"
373 
                                    + amapLocation.getErrorInfo());
374 
                        }
373 
                    }
 375 
                    }
374 
                }
 376 
                }
375 
            }
376 
        });
377 
        //设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
378 
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
379 
        //设置定位间隔,单位毫秒,默认为2000ms//        mLocationOption.setInterval(2000);
380 
        //设置定位参数
381 
        mlocationClient.setLocationOption(mLocationOption);
382 
        // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
383 
        // 注意设置合适的定位时间的间隔（最小间隔支持为1000ms），并且在合适时间调用stopLocation()方法来取消定位请求
384 
        // 在定位结束后，在合适的生命周期调用onDestroy()方法
385 
        // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
386 
        //启动定位
387 
        mlocationClient.startLocation();
377 
            });
378 
            //设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
379 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
380 
            //设置定位间隔,单位毫秒,默认为2000ms//        mLocationOption.setInterval(2000);
381 
            //设置定位参数
382 
            mlocationClient.setLocationOption(mLocationOption);
383 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
384 
            // 注意设置合适的定位时间的间隔（最小间隔支持为1000ms），并且在合适时间调用stopLocation()方法来取消定位请求
385 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
386 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
387 
            //启动定位
388 
            mlocationClient.startLocation();
389 
        } catch (Exception e) {
390 
            e.printStackTrace();
391 
        }
392
388 
    }
 393 
    }
389
394
390 
    private void sendControlParkingDownLock(AMapLocation amapLocation, PileData pileData) {
 395 
    private void sendControlParkingDownLock(AMapLocation amapLocation, PileData pileData) {

+ 0 - 1
app/src/main/java/com/electric/chargingpile/activity/PrivacyAgreementActivity.java
Просмотреть файл

37 
        setContentView(R.layout.activity_privacy_agreement);
 37 
        setContentView(R.layout.activity_privacy_agreement);
38 
        BarColorUtil.initStatusBarColor(PrivacyAgreementActivity.this);
 38 
        BarColorUtil.initStatusBarColor(PrivacyAgreementActivity.this);
39 
        if (ProfileManager.getInstance().getPrivacyAgreement(this)) {
 39 
        if (ProfileManager.getInstance().getPrivacyAgreement(this)) {
40 
            MainApplication.initSDK();
41 
            Log.e("TAG_HYC", "onCreate:  getPrivacyAgreement" );
 40 
            Log.e("TAG_HYC", "onCreate:  getPrivacyAgreement" );
42 
            startActivity(new Intent(PrivacyAgreementActivity.this, WelcomeActivity.class));
 41 
            startActivity(new Intent(PrivacyAgreementActivity.this, WelcomeActivity.class));
43 
            finish();
 42 
            finish();

+ 30 - 20
app/src/main/java/com/electric/chargingpile/activity/PrivateZhuangMapActivity.java
Просмотреть файл

29 
import com.amap.api.maps.model.CameraPosition;
 29 
import com.amap.api.maps.model.CameraPosition;
30 
import com.amap.api.maps.model.LatLng;
 30 
import com.amap.api.maps.model.LatLng;
31 
import com.amap.api.maps.model.MyLocationStyle;
 31 
import com.amap.api.maps.model.MyLocationStyle;
32 
import com.amap.api.services.core.AMapException;
32 
import com.amap.api.services.core.LatLonPoint;
 33 
import com.amap.api.services.core.LatLonPoint;
33 
import com.amap.api.services.geocoder.GeocodeResult;
 34 
import com.amap.api.services.geocoder.GeocodeResult;
34 
import com.amap.api.services.geocoder.GeocodeSearch;
 35 
import com.amap.api.services.geocoder.GeocodeSearch;
126 
            //获得地图的最大和最小缩放级别
 127 
            //获得地图的最大和最小缩放级别
127 
            maxZoomLevel = aMap.getMaxZoomLevel();
 128 
            maxZoomLevel = aMap.getMaxZoomLevel();
128 
            minZoomLevel = aMap.getMinZoomLevel();
 129 
            minZoomLevel = aMap.getMinZoomLevel();
129 
            geocoderSearch = new GeocodeSearch(this);
130 
            geocoderSearch.setOnGeocodeSearchListener(this);
131 
            setUpMap();
130 
            try {
131 
                geocoderSearch = new GeocodeSearch(this);
132 
                geocoderSearch.setOnGeocodeSearchListener(this);
133 
                setUpMap();
134 
            } catch (AMapException e) {
135 
                e.printStackTrace();
136 
            }
132 
        }
 137 
        }
133 
    }
 138 
    }
134
139
432 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 437 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
433 
        mListener = onLocationChangedListener;
 438 
        mListener = onLocationChangedListener;
434 
        if (mlocationClient == null) {
 439 
        if (mlocationClient == null) {
435 
            mlocationClient = new AMapLocationClient(this);
436 
            mLocationOption = new AMapLocationClientOption();
437 
            //设置定位监听
438 
            mlocationClient.setLocationListener(this);
439 
            //设置为高精度定位模式
440 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
441 
            //设置定位参数
442 
            mlocationClient.setLocationOption(mLocationOption);
443 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
444 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
445 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
446 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
447 
            // 设置是否只定位一次,默认为false
448 
            mLocationOption.setOnceLocation(true);
449 
            //设置是否强制刷新WIFI，默认为强制刷新
450 
            mLocationOption.setWifiActiveScan(false);
451 
            mlocationClient.startLocation();
440 
            try {
441 
                mlocationClient = new AMapLocationClient(this);
442 
                mLocationOption = new AMapLocationClientOption();
443 
                //设置定位监听
444 
                mlocationClient.setLocationListener(this);
445 
                //设置为高精度定位模式
446 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
447 
                //设置定位参数
448 
                mlocationClient.setLocationOption(mLocationOption);
449 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
450 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
451 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
452 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
453 
                // 设置是否只定位一次,默认为false
454 
                mLocationOption.setOnceLocation(true);
455 
                //设置是否强制刷新WIFI，默认为强制刷新
456 
                mLocationOption.setWifiActiveScan(false);
457 
                mlocationClient.startLocation();
458
459 
            } catch (Exception e) {
460 
                e.printStackTrace();
461 
            }
452
462
453 
        }
 463 
        }
454 
    }
 464 
    }

+ 25 - 20
app/src/main/java/com/electric/chargingpile/activity/RecommendZhanActivity.java
Просмотреть файл

361 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 361 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
362 
        mListener = onLocationChangedListener;
 362 
        mListener = onLocationChangedListener;
363 
        if (mlocationClient == null) {
 363 
        if (mlocationClient == null) {
364 
            mlocationClient = new AMapLocationClient(this);
364 
            try {
365 
                mlocationClient = new AMapLocationClient(this);
365
366
366 
            mLocationOption = new AMapLocationClientOption();
367 
            //设置定位监听
368 
            mlocationClient.setLocationListener(this);
369 
            //设置为高精度定位模式
370 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Battery_Saving);
367 
                mLocationOption = new AMapLocationClientOption();
368 
                //设置定位监听
369 
                mlocationClient.setLocationListener(this);
370 
                //设置为高精度定位模式
371 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Battery_Saving);
371 
//            mLocationOption.setGpsFirst(true);
 372 
//            mLocationOption.setGpsFirst(true);
372 
//            mLocationOption.setOnceLocation(true);
 373 
//            mLocationOption.setOnceLocation(true);
373 
            mLocationOption.setInterval(1500);
374 
                mLocationOption.setInterval(1500);
374
375
375 
            //设置是否强制刷新WIFI，默认为强制刷新
376 
                //设置是否强制刷新WIFI，默认为强制刷新
376 
//            mLocationOption.setWifiActiveScan(true);
 377 
//            mLocationOption.setWifiActiveScan(true);
377 
            //设置定位参数
378 
            mlocationClient.setLocationOption(mLocationOption);
379 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
380 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
381 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
382 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
383 
            // 设置是否只定位一次,默认为false
384 
            mLocationOption.setOnceLocation(false);
385
386 
            //设置是否强制刷新WIFI，默认为强制刷新
387 
            mLocationOption.setWifiActiveScan(false);
388 
            mlocationClient.startLocation();
378 
                //设置定位参数
379 
                mlocationClient.setLocationOption(mLocationOption);
380 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
381 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
382 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
383 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
384 
                // 设置是否只定位一次,默认为false
385 
                mLocationOption.setOnceLocation(false);
386
387 
                //设置是否强制刷新WIFI，默认为强制刷新
388 
                mLocationOption.setWifiActiveScan(false);
389 
                mlocationClient.startLocation();
390
391 
            } catch (Exception e) {
392 
                e.printStackTrace();
393 
            }
389
394
390 
        }
 395 
        }
391 
    }
 396 
    }

+ 58 - 80
app/src/main/java/com/electric/chargingpile/activity/RoutePlanMapActivity.java
Просмотреть файл

68 
import com.amap.api.navi.model.AMapModelCross;
 68 
import com.amap.api.navi.model.AMapModelCross;
69 
import com.amap.api.navi.model.AMapNaviCameraInfo;
 69 
import com.amap.api.navi.model.AMapNaviCameraInfo;
70 
import com.amap.api.navi.model.AMapNaviCross;
 70 
import com.amap.api.navi.model.AMapNaviCross;
71 
import com.amap.api.navi.model.AMapNaviInfo;
71
72 
import com.amap.api.navi.model.AMapNaviLocation;
 72 
import com.amap.api.navi.model.AMapNaviLocation;
73 
import com.amap.api.navi.model.AMapNaviPath;
 73 
import com.amap.api.navi.model.AMapNaviPath;
74 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
 74 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
80 
import com.amap.api.navi.model.NaviInfo;
 80 
import com.amap.api.navi.model.NaviInfo;
81 
import com.amap.api.navi.model.NaviLatLng;
 81 
import com.amap.api.navi.model.NaviLatLng;
82 
import com.amap.api.navi.view.RouteOverLay;
 82 
import com.amap.api.navi.view.RouteOverLay;
83 
import com.amap.api.services.core.AMapException;
83 
import com.amap.api.services.core.LatLonPoint;
 84 
import com.amap.api.services.core.LatLonPoint;
84 
import com.amap.api.services.core.PoiItem;
 85 
import com.amap.api.services.core.PoiItem;
85 
import com.amap.api.services.geocoder.GeocodeResult;
 86 
import com.amap.api.services.geocoder.GeocodeResult;
86 
import com.amap.api.services.geocoder.GeocodeSearch;
 87 
import com.amap.api.services.geocoder.GeocodeSearch;
87 
import com.amap.api.services.geocoder.RegeocodeQuery;
 88 
import com.amap.api.services.geocoder.RegeocodeQuery;
88 
import com.amap.api.services.geocoder.RegeocodeResult;
 89 
import com.amap.api.services.geocoder.RegeocodeResult;
89 
import com.autonavi.tbt.TrafficFacilityInfo;
90
90 
import com.blankj.utilcode.util.EmptyUtils;
 91 
import com.blankj.utilcode.util.EmptyUtils;
91 
import com.blankj.utilcode.util.LogUtils;
 92 
import com.blankj.utilcode.util.LogUtils;
92 
import com.blankj.utilcode.util.SizeUtils;
 93 
import com.blankj.utilcode.util.SizeUtils;
414 
        if (amap == null) {
 415 
        if (amap == null) {
415 
            amap = mapView.getMap();
 416 
            amap = mapView.getMap();
416 
            Util.setMapCustomStyleFile(amap, getApplicationContext());
 417 
            Util.setMapCustomStyleFile(amap, getApplicationContext());
417 
            aMapNavi = AMapNavi.getInstance(getApplicationContext());
418 
            aMapNavi.addAMapNaviListener(this);
419 
            aMapNavi.setUseInnerVoice(true);
420 
            MyLocationStyle myLocationStyle = new MyLocationStyle();
421 
            myLocationStyle.myLocationIcon(com.amap.api.maps.model.BitmapDescriptorFactory.fromResource(R.drawable.point_icon));// 设置小蓝点的图标
422 
            amap.setMyLocationStyle(myLocationStyle);
418 
            try {
419 
                aMapNavi = AMapNavi.getInstance(getApplicationContext());
420 
                aMapNavi.addAMapNaviListener(this);
421 
                aMapNavi.setUseInnerVoice(true);
422 
                MyLocationStyle myLocationStyle = new MyLocationStyle();
423 
                myLocationStyle.myLocationIcon(com.amap.api.maps.model.BitmapDescriptorFactory.fromResource(R.drawable.point_icon));// 设置小蓝点的图标
424 
                amap.setMyLocationStyle(myLocationStyle);
425 
            } catch (com.amap.api.maps.AMapException e) {
426 
                e.printStackTrace();
427 
            }
428
423 
            //获得地图的最大和最小缩放级别
 429 
            //获得地图的最大和最小缩放级别
424 
            geocoderSearch = new GeocodeSearch(this);
425 
            geocoderSearch.setOnGeocodeSearchListener(this);
426 
            setUpMap();
430 
            try {
431 
                geocoderSearch = new GeocodeSearch(this);
432 
                geocoderSearch.setOnGeocodeSearchListener(this);
433 
                setUpMap();
434 
            } catch (AMapException e) {
435 
                e.printStackTrace();
436 
            }
437
427
438
428 
        }
 439 
        }
429 
    }
 440 
    }
747 
            routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
 758 
            routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
748 
            routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
 759 
            routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
749 
            routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
 760 
            routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
750 
            routeOverLay.setTrafficLightsVisible(false);
761 
            //routeOverLay.setTrafficLightsVisible(false);
751 
            routeOverLay.addToMap();
 762 
            routeOverLay.addToMap();
752 
            routeOverlays.put(routeIds[i], routeOverLay);
 763 
            routeOverlays.put(routeIds[i], routeOverLay);
753 
            routeOverLay.getAMapNaviPath().getSteps();
 764 
            routeOverLay.getAMapNaviPath().getSteps();
754
765
755 
            routePlanInfo.setNo(routeOverlays.get(routeIds[i]).getAMapNaviPath().getStrategy() + "");
766 
            routePlanInfo.setNo(routeOverlays.get(routeIds[i]).getAMapNaviPath().getLabels() + "");
756 
            routePlanInfo.setTime(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllTime() + "");
 767 
            routePlanInfo.setTime(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllTime() + "");
757 
            routePlanInfo.setDistance(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllLength() + "");
 768 
            routePlanInfo.setDistance(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllLength() + "");
758
769
857 
        int i = l.size();
 868 
        int i = l.size();
858
869
859 
        if (i == 1) {
 870 
        if (i == 1) {
860 
            if (l.get(0).getNo().equals("0")) {
861 
                tv_route_no1.setText("推荐");
862 
            } else if (l.get(0).getNo().equals("2")) {
863 
                tv_route_no1.setText("距离最短");
864 
            } else if (l.get(0).getNo().equals("4")) {
865 
                tv_route_no1.setText("时间最短");
866 
            } else {
867 
                tv_route_no1.setText("其他方案");
868 
            }
871 
            tv_route_no1.setText(l.get(0).getNo());
872
869 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
 873 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
870 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
 874 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
871 
            rl_route2.setVisibility(View.GONE);
 875 
            rl_route2.setVisibility(View.GONE);
873 
            view1.setVisibility(View.GONE);
 877 
            view1.setVisibility(View.GONE);
874 
            view2.setVisibility(View.GONE);
 878 
            view2.setVisibility(View.GONE);
875 
        } else if (i == 2) {
 879 
        } else if (i == 2) {
876 
            if (l.get(0).getNo().equals("0")) {
877 
                tv_route_no1.setText("推荐");
878 
            } else if (l.get(0).getNo().equals("2")) {
879 
                tv_route_no1.setText("距离最短");
880 
            } else if (l.get(0).getNo().equals("4")) {
881 
                tv_route_no1.setText("时间最短");
882 
            } else {
883 
                tv_route_no1.setText("其他方案");
884 
            }
880 
            tv_route_no1.setText(l.get(0).getNo());
881
885 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
 882 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
886 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
 883 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
887 
            if (l.get(1).getNo().equals("0")) {
888 
                tv_route_no2.setText("推荐");
889 
            } else if (l.get(1).getNo().equals("2")) {
890 
                tv_route_no2.setText("距离最短");
891 
            } else if (l.get(1).getNo().equals("4")) {
892 
                tv_route_no2.setText("时间最短");
893 
            } else {
894 
                tv_route_no2.setText("其他方案");
895 
            }
884
885 
            tv_route_no2.setText(l.get(1).getNo());
886
896 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
 887 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
897 
            tv_route_time2.setText(getSToHm(l.get(1).getTime()));
 888 
            tv_route_time2.setText(getSToHm(l.get(1).getTime()));
898
889
906 
            view2.setVisibility(View.VISIBLE);
 897 
            view2.setVisibility(View.VISIBLE);
907 
            rl_route2.setVisibility(View.VISIBLE);
 898 
            rl_route2.setVisibility(View.VISIBLE);
908 
            view1.setVisibility(View.VISIBLE);
 899 
            view1.setVisibility(View.VISIBLE);
909 
            if (l.get(0).getNo().equals("0")) {
910 
                tv_route_no1.setText("推荐");
911 
            } else if (l.get(0).getNo().equals("2")) {
912 
                tv_route_no1.setText("距离最短");
913 
            } else if (l.get(0).getNo().equals("4")) {
914 
                tv_route_no1.setText("时间最短");
915 
            } else {
916 
                tv_route_no1.setText("其他方案");
917 
            }
900
901 
            tv_route_no1.setText(l.get(0).getNo());
902
918 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
 903 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
919 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
 904 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
920
905
921 
            if (l.get(1).getNo().equals("0")) {
922 
                tv_route_no2.setText("推荐");
923 
            } else if (l.get(1).getNo().equals("2")) {
924 
                tv_route_no2.setText("距离最短");
925 
            } else if (l.get(1).getNo().equals("4")) {
926 
                tv_route_no2.setText("时间最短");
927 
            } else {
928 
                tv_route_no2.setText("其他方案");
929 
            }
906
907 
            tv_route_no2.setText(l.get(1).getNo());
908
930 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
 909 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
931 
            tv_route_time2.setText(getSToHm(l.get(1).getTime()));
 910 
            tv_route_time2.setText(getSToHm(l.get(1).getTime()));
932 
            if (l.get(2).getNo().equals("0")) {
933 
                tv_route_no3.setText("推荐");
934 
            } else if (l.get(2).getNo().equals("2")) {
935 
                tv_route_no3.setText("距离最短");
936 
            } else if (l.get(2).getNo().equals("4")) {
937 
                tv_route_no3.setText("时间最短");
938 
            } else {
939 
                tv_route_no3.setText("其他方案");
940 
            }
911 
            tv_route_no3.setText(l.get(2).getNo());
941 
            tv_route_distance3.setText(getMToKm(l.get(2).getDistance()));
 912 
            tv_route_distance3.setText(getMToKm(l.get(2).getDistance()));
942 
            tv_route_time3.setText(getSToHm(l.get(2).getTime()));
 913 
            tv_route_time3.setText(getSToHm(l.get(2).getTime()));
943 
        }
 914 
        }
1004 
    public void onNaviRouteNotify(AMapNaviRouteNotifyData aMapNaviRouteNotifyData) {
 975 
    public void onNaviRouteNotify(AMapNaviRouteNotifyData aMapNaviRouteNotifyData) {
1005 
    }
 976 
    }
1006
977
978 
    @Override
979 
    public void onGpsSignalWeak(boolean b) {
980
981 
    }
982
1007
983
1008 
    public void changeRoute(View view) {
 984 
    public void changeRoute(View view) {
1009 
        if (mMarkerCity != null) {
 985 
        if (mMarkerCity != null) {
1509
1485
1510 
    }
 1486 
    }
1511
1487
1512 
    @Override
1513 
    public void onNaviInfoUpdated(AMapNaviInfo naviInfo) {
1514
1515 
    }
1516
1488
1517 
    @Override
 1489 
    @Override
1518 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
 1490 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
1535
1507
1536 
    }
 1508 
    }
1537
1509
1538 
    @Override
1539 
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
1540
1510
1541 
    }
1542
1511
1543 
    @Override
 1512 
    @Override
1544 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
 1513 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
1605 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 1574 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
1606 
        mListener = onLocationChangedListener;
 1575 
        mListener = onLocationChangedListener;
1607 
        if (mlocationClient == null) {
 1576 
        if (mlocationClient == null) {
1608 
            mlocationClient = new AMapLocationClient(this);
1577 
            try {
1578 
                mlocationClient = new AMapLocationClient(this);
1579 
            } catch (Exception e) {
1580 
                e.printStackTrace();
1581 
            }
1609 
            mLocationOption = new AMapLocationClientOption();
 1582 
            mLocationOption = new AMapLocationClientOption();
1610 
            //设置定位监听
 1583 
            //设置定位监听
1611 
            mlocationClient.setLocationListener(this);
 1584 
            mlocationClient.setLocationListener(this);
1854 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
 1827 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
1855 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
 1828 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
1856 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
 1829 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1857 
                        routeOverLay.setTrafficLightsVisible(false);
1830 
                        //routeOverLay.setTrafficLightsVisible(false);
1858 
                        routeOverLay.addToMap();
 1831 
                        routeOverLay.addToMap();
1859 
                        routeOverlays.put(routeIds[i], routeOverLay);
 1832 
                        routeOverlays.put(routeIds[i], routeOverLay);
1860 
                    }
 1833 
                    }
1916 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
 1889 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
1917 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
 1890 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
1918 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
 1891 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1919 
                        routeOverLay.setTrafficLightsVisible(false);
1892 
                        //routeOverLay.setTrafficLightsVisible(false);
1920 
                        routeOverLay.addToMap();
 1893 
                        routeOverLay.addToMap();
1921 
                        routeOverlays.put(routeIds[i], routeOverLay);
 1894 
                        routeOverlays.put(routeIds[i], routeOverLay);
1922 
                    }
 1895 
                    }
1976 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
 1949 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
1977 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
 1950 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
1978 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
 1951 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1979 
                        routeOverLay.setTrafficLightsVisible(false);
1952 
                        //routeOverLay.setTrafficLightsVisible(false);
1980 
                        routeOverLay.addToMap();
 1953 
                        routeOverLay.addToMap();
1981 
                        routeOverlays.put(routeIds[i], routeOverLay);
 1954 
                        routeOverlays.put(routeIds[i], routeOverLay);
1982 
                    }
 1955 
                    }
2065 
                            routeOverLay.setStartPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstarr));
 2038 
                            routeOverLay.setStartPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstarr));
2066 
                            routeOverLay.setEndPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstopr));
 2039 
                            routeOverLay.setEndPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstopr));
2067 
                            routeOverLay.setWayPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_zhanwei));
 2040 
                            routeOverLay.setWayPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_zhanwei));
2068 
                            routeOverLay.setTrafficLightsVisible(false);
2041 
                            //routeOverLay.setTrafficLightsVisible(false);
2069 
                            routeOverlays.put(routeIds[i], routeOverLay);
 2042 
                            routeOverlays.put(routeIds[i], routeOverLay);
2070 
                            routeOverLay.addToMap();
 2043 
                            routeOverLay.addToMap();
2071 
                        }
 2044 
                        }
2933 
                routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
 2906 
                routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
2934 
                routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
 2907 
                routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
2935 
                routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
 2908 
                routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
2936 
                routeOverLay.setTrafficLightsVisible(false);
2909 
                //routeOverLay.setTrafficLightsVisible(false);
2937 
                routeOverLay.addToMap();
 2910 
                routeOverLay.addToMap();
2938 
                routeOverlays.put(routeIds[i], routeOverLay);
 2911 
                routeOverlays.put(routeIds[i], routeOverLay);
2939 
            }
 2912 
            }
2990 
    public View getInfoContents(Marker marker) {
 2963 
    public View getInfoContents(Marker marker) {
2991 
        return null;
 2964 
        return null;
2992 
    }
 2965 
    }
2966
2967 
    @Override
2968 
    public void onPointerCaptureChanged(boolean hasCapture) {
2969
2970 
    }
2993 
}
 2971 
}

+ 11 - 3
app/src/main/java/com/electric/chargingpile/activity/RoutePlanSelectAddressActivity.java
Просмотреть файл

1 
package com.electric.chargingpile.activity;
 1 
package com.electric.chargingpile.activity;
2
2
3
3
4 
import android.annotation.SuppressLint;
4 
import android.app.Activity;
 5 
import android.app.Activity;
5 
import android.content.ContentValues;
 6 
import android.content.ContentValues;
6 
import android.content.Context;
 7 
import android.content.Context;
28 
import android.widget.TextView;
 29 
import android.widget.TextView;
29 
import android.widget.Toast;
 30 
import android.widget.Toast;
30
31
32 
import com.amap.api.services.core.AMapException;
31 
import com.amap.api.services.core.PoiItem;
 33 
import com.amap.api.services.core.PoiItem;
32 
import com.amap.api.services.core.SuggestionCity;
 34 
import com.amap.api.services.core.SuggestionCity;
33 
import com.amap.api.services.poisearch.PoiResult;
 35 
import com.amap.api.services.poisearch.PoiResult;
96 
//        Toast.makeText(getApplicationContext(),tag,Toast.LENGTH_SHORT).show();
 98 
//        Toast.makeText(getApplicationContext(),tag,Toast.LENGTH_SHORT).show();
97 
    }
 99 
    }
98
100
101 
    @SuppressLint("Range")
99 
    private void initViews() {
 102 
    private void initViews() {
100 
        rl_mapselect = (RelativeLayout) findViewById(R.id.rl_mapselect);
 103 
        rl_mapselect = (RelativeLayout) findViewById(R.id.rl_mapselect);
101 
        rl_mapselect.setOnClickListener(this);
 104 
        rl_mapselect.setOnClickListener(this);
455 
        query.setPageSize(20);// 设置每页最多返回多少条poiitem
 458 
        query.setPageSize(20);// 设置每页最多返回多少条poiitem
456 
        query.setPageNum(currentPage);// 设置查第一页
 459 
        query.setPageNum(currentPage);// 设置查第一页
457
460
458 
        poiSearch = new PoiSearch(this, query);
459 
        poiSearch.setOnPoiSearchListener(this);
460 
        poiSearch.searchPOIAsyn();
461 
        try {
462 
            poiSearch = new PoiSearch(this, query);
463 
            poiSearch.setOnPoiSearchListener(this);
464 
            poiSearch.searchPOIAsyn();
465 
        } catch (AMapException e) {
466 
            e.printStackTrace();
467 
        }
468
461 
    }
 469 
    }
462
470
463 
    @Override
 471 
    @Override

+ 30 - 20
app/src/main/java/com/electric/chargingpile/activity/RouteSelectPointActivity.java
Просмотреть файл

26 
import com.amap.api.maps.model.CameraPosition;
 26 
import com.amap.api.maps.model.CameraPosition;
27 
import com.amap.api.maps.model.LatLng;
 27 
import com.amap.api.maps.model.LatLng;
28 
import com.amap.api.maps.model.MyLocationStyle;
 28 
import com.amap.api.maps.model.MyLocationStyle;
29 
import com.amap.api.services.core.AMapException;
29 
import com.amap.api.services.core.LatLonPoint;
 30 
import com.amap.api.services.core.LatLonPoint;
30 
import com.amap.api.services.core.PoiItem;
 31 
import com.amap.api.services.core.PoiItem;
31 
import com.amap.api.services.geocoder.GeocodeResult;
 32 
import com.amap.api.services.geocoder.GeocodeResult;
122 
            //获得地图的最大和最小缩放级别
 123 
            //获得地图的最大和最小缩放级别
123 
            maxZoomLevel = aMap.getMaxZoomLevel();
 124 
            maxZoomLevel = aMap.getMaxZoomLevel();
124 
            minZoomLevel = aMap.getMinZoomLevel();
 125 
            minZoomLevel = aMap.getMinZoomLevel();
125 
            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 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 272 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
268 
        mListener = onLocationChangedListener;
 273 
        mListener = onLocationChangedListener;
269 
        if (mlocationClient == null) {
 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
42
43 
import com.amap.api.maps.AMapUtils;
43 
import com.amap.api.maps.AMapUtils;
44 
import com.amap.api.maps.model.LatLng;
44 
import com.amap.api.maps.model.LatLng;
45 
import com.amap.api.services.core.AMapException;
45 
import com.amap.api.services.core.PoiItem;
46 
import com.amap.api.services.core.PoiItem;
46 
import com.amap.api.services.core.SuggestionCity;
47 
import com.amap.api.services.core.SuggestionCity;
47 
import com.amap.api.services.help.Inputtips;
48 
import com.amap.api.services.help.Inputtips;
912 
        query.setPageSize(30);// 设置每页最多返回多少条poiitem
913 
        query.setPageSize(30);// 设置每页最多返回多少条poiitem
913 
        query.setPageNum(currentPage);// 设置查第一页
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 
    private void doPointNameSearchQuery() {
926 
    private void doPointNameSearchQuery() {

+ 16 - 11
app/src/main/java/com/electric/chargingpile/activity/SelectCityActivity.java
Просмотреть файл

293 
        SQLiteDatabase recentVisitDb = cityOpenHelper.getWritableDatabase();
 293 
        SQLiteDatabase recentVisitDb = cityOpenHelper.getWritableDatabase();
294 
        Cursor cursor = recentVisitDb.rawQuery("select * from recentcity order by date desc limit 0, 3", null);
 294 
        Cursor cursor = recentVisitDb.rawQuery("select * from recentcity order by date desc limit 0, 3", null);
295 
        while (cursor.moveToNext()) {
 295 
        while (cursor.moveToNext()) {
296 
            String recentVisitCityName = cursor.getString(cursor.getColumnIndex("name"));
296 
            @SuppressLint("Range") String recentVisitCityName = cursor.getString(cursor.getColumnIndex("name"));
297 
            recentCityList.add(recentVisitCityName);
 297 
            recentCityList.add(recentVisitCityName);
298 
        }
 298 
        }
299 
        cursor.close();
 299 
        cursor.close();
599 
    private void setUpMap() {
 599 
    private void setUpMap() {
600 
//        //声明mLocationOption对象
 600 
//        //声明mLocationOption对象
601 
//        AMapLocationClientOption mLocationOption = null;
 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 
//设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
 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 
//设置定位间隔,单位毫秒,默认为2000ms
 613 
//设置定位间隔,单位毫秒,默认为2000ms
613 
//        mLocationOption.setInterval(2000);
 614 
//        mLocationOption.setInterval(2000);
614 
//设置定位参数
 615 
//设置定位参数
615 
        mlocationClient.setLocationOption(mLocationOption);
616 
            mlocationClient.setLocationOption(mLocationOption);
616 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
 617 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
617 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
 618 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
618 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
 619 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
619 
// 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
 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 
import com.amap.api.maps.model.CameraPosition;
 28 
import com.amap.api.maps.model.CameraPosition;
29 
import com.amap.api.maps.model.LatLng;
 29 
import com.amap.api.maps.model.LatLng;
30 
import com.amap.api.maps.model.MyLocationStyle;
 30 
import com.amap.api.maps.model.MyLocationStyle;
31 
import com.amap.api.services.core.AMapException;
31 
import com.amap.api.services.core.LatLonPoint;
 32 
import com.amap.api.services.core.LatLonPoint;
32 
import com.amap.api.services.geocoder.GeocodeResult;
 33 
import com.amap.api.services.geocoder.GeocodeResult;
33 
import com.amap.api.services.geocoder.GeocodeSearch;
 34 
import com.amap.api.services.geocoder.GeocodeSearch;
112 
            //获得地图的最大和最小缩放级别
 113 
            //获得地图的最大和最小缩放级别
113 
            maxZoomLevel = aMap.getMaxZoomLevel();
 114 
            maxZoomLevel = aMap.getMaxZoomLevel();
114 
            minZoomLevel = aMap.getMinZoomLevel();
 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 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 405 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
400 
        mListener = onLocationChangedListener;
 406 
        mListener = onLocationChangedListener;
401 
        if (mlocationClient == null) {
 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 
//            mLocationOption.setOnceLocationLatest(true);
 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 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
 154 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
155 
        mListener = onLocationChangedListener;
 155 
        mListener = onLocationChangedListener;
156 
        if (mlocationClient == null) {
 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 
import android.view.Window;
 8 
import android.view.Window;
9 
import android.view.WindowManager;
 9 
import android.view.WindowManager;
10
10
11 
import com.amap.api.maps.AMapException;
11 
import com.amap.api.maps.model.BitmapDescriptor;
 12 
import com.amap.api.maps.model.BitmapDescriptor;
12 
import com.amap.api.maps.model.BitmapDescriptorFactory;
 13 
import com.amap.api.maps.model.BitmapDescriptorFactory;
13 
import com.amap.api.navi.AMapNaviViewOptions;
 14 
import com.amap.api.navi.AMapNaviViewOptions;
24 
import com.amap.api.navi.model.AMapModelCross;
 25 
import com.amap.api.navi.model.AMapModelCross;
25 
import com.amap.api.navi.model.AMapNaviCameraInfo;
 26 
import com.amap.api.navi.model.AMapNaviCameraInfo;
26 
import com.amap.api.navi.model.AMapNaviCross;
 27 
import com.amap.api.navi.model.AMapNaviCross;
27 
import com.amap.api.navi.model.AMapNaviInfo;
28
28 
import com.amap.api.navi.model.AMapNaviLocation;
 29 
import com.amap.api.navi.model.AMapNaviLocation;
29 
import com.amap.api.navi.model.AMapNaviPath;
 30 
import com.amap.api.navi.model.AMapNaviPath;
30 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
 31 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
33 
import com.amap.api.navi.model.AimLessModeCongestionInfo;
 34 
import com.amap.api.navi.model.AimLessModeCongestionInfo;
34 
import com.amap.api.navi.model.AimLessModeStat;
 35 
import com.amap.api.navi.model.AimLessModeStat;
35 
import com.amap.api.navi.model.NaviInfo;
 36 
import com.amap.api.navi.model.NaviInfo;
36 
import com.autonavi.tbt.TrafficFacilityInfo;
37
37 
import com.electric.chargingpile.R;
 38 
import com.electric.chargingpile.R;
38
39
39 
import java.util.List;
 40 
import java.util.List;
73 
        options.setAfterRouteAutoGray(true);
 74 
        options.setAfterRouteAutoGray(true);
74 
        mAMapNaviView.setViewOptions(options);
 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 
        mAMapNavi.addAMapNaviListener(this);
 82 
        mAMapNavi.addAMapNaviListener(this);
78 
        mAMapNavi.setEmulatorNaviSpeed(60);
 83 
        mAMapNavi.setEmulatorNaviSpeed(60);
79 
        mAMapNavi.setUseInnerVoice(true);
 84 
        mAMapNavi.setUseInnerVoice(true);
189 
    public void onGpsOpenStatus(boolean b) {
 194 
    public void onGpsOpenStatus(boolean b) {
190 
    }
 195 
    }
191
196
192 
    @Override
193 
    public void onNaviInfoUpdated(AMapNaviInfo aMapNaviInfo) {
194 
    }
195
197
196 
    @Override
 198 
    @Override
197 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
 199 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
215 
        }
 217 
        }
216 
    }
 218 
    }
217
219
218 
    @Override
219 
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
220 
    }
221
220
222 
    @Override
 221 
    @Override
223 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
 222 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
302 
    }
 301 
    }
303
302
304 
    @Override
 303 
    @Override
304 
    public void onGpsSignalWeak(boolean b) {
305
306 
    }
307
308 
    @Override
305 
    public void onNaviSetting() {
 309 
    public void onNaviSetting() {
306 
    }
 310 
    }
307
311
346 
    @Override
 350 
    @Override
347 
    public void onNaviViewShowMode(int i) {
 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 
    private void setUpMap() {
 1310 
    private void setUpMap() {
1311 
//        //声明mLocationOption对象
 1311 
//        //声明mLocationOption对象
1312 
//        AMapLocationClientOption mLocationOption = null;
 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 
//设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
 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 
//设置定位间隔,单位毫秒,默认为2000ms
 1324 
//设置定位间隔,单位毫秒,默认为2000ms
1324 
//        mLocationOption.setInterval(2000);
 1325 
//        mLocationOption.setInterval(2000);
1325 
//设置定位参数
 1326 
//设置定位参数
1326 
        mlocationClient.setLocationOption(mLocationOption);
1327 
            mlocationClient.setLocationOption(mLocationOption);
1327 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
 1328 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
1328 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
 1329 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
1329 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
 1330 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
1330 
// 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
 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 
    @Override
 1341 
    @Override

+ 16 - 10
app/src/main/java/com/electric/chargingpile/activity/UserCenterActivity.java
Просмотреть файл

34
34
35 
import androidx.annotation.NonNull;
 35 
import androidx.annotation.NonNull;
36
36
37 
import com.amap.api.services.core.AMapException;
37 
import com.amap.api.services.weather.LocalDayWeatherForecast;
 38 
import com.amap.api.services.weather.LocalDayWeatherForecast;
38 
import com.amap.api.services.weather.LocalWeatherForecast;
 39 
import com.amap.api.services.weather.LocalWeatherForecast;
39 
import com.amap.api.services.weather.LocalWeatherForecastResult;
 40 
import com.amap.api.services.weather.LocalWeatherForecastResult;
293 
        loadDialog = new LoadingDialog(this);
 294 
        loadDialog = new LoadingDialog(this);
294 
        loadDialog.setCanceledOnTouchOutside(false);
 295 
        loadDialog.setCanceledOnTouchOutside(false);
295 
        mquery = new WeatherSearchQuery(MainMapActivity.location_city, WeatherSearchQuery.WEATHER_TYPE_FORECAST);
 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 
        sv = (ObservableScrollView) findViewById(R.id.sv);
 312 
        sv = (ObservableScrollView) findViewById(R.id.sv);
307 
        sv.setScrollViewListener(this);
 313 
        sv.setScrollViewListener(this);
308 
        iv_qiandao = (ImageView) findViewById(R.id.iv_qiandao);
 314 
        iv_qiandao = (ImageView) findViewById(R.id.iv_qiandao);

+ 15 - 10
app/src/main/java/com/electric/chargingpile/adapter/CityListAdapter.java
Просмотреть файл

289 
    private void setUpMap() {
 289 
    private void setUpMap() {
290 
//        //声明mLocationOption对象
 290 
//        //声明mLocationOption对象
291 
//        AMapLocationClientOption mLocationOption = null;
 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 
//设置定位模式为高精度模式，Battery_Saving为低功耗模式，Device_Sensors是仅设备模式
 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 
//设置定位间隔,单位毫秒,默认为2000ms
 303 
//设置定位间隔,单位毫秒,默认为2000ms
303 
//        mLocationOption.setInterval(2000);
 304 
//        mLocationOption.setInterval(2000);
304 
//设置定位参数
 305 
//设置定位参数
305 
        mlocationClient.setLocationOption(mLocationOption);
306 
            mlocationClient.setLocationOption(mLocationOption);
306 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
 307 
// 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
307 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
 308 
// 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
308 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
 309 
// 在定位结束后，在合适的生命周期调用onDestroy()方法
309 
// 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
 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 
        final AMapLocationClient mlocationClient;
 242 
        final AMapLocationClient mlocationClient;
243 
        //声明mLocationOption对象
 243 
        //声明mLocationOption对象
244 
        AMapLocationClientOption mLocationOption = null;
 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 
    private void sendControlParkingDownLock(AMapLocation amapLocation, ZhuangStatus zhuangStatus) {
 288 
    private void sendControlParkingDownLock(AMapLocation amapLocation, ZhuangStatus zhuangStatus) {

+ 6 - 0
app/src/main/java/com/electric/chargingpile/application/MainApplication.java
Просмотреть файл

13 
import androidx.multidex.MultiDexApplication;
13 
import androidx.multidex.MultiDexApplication;
14
14
15 
import com.alibaba.fastjson.JSONException;
15 
import com.alibaba.fastjson.JSONException;
16 
import com.amap.api.location.AMapLocationClient;
16 
import com.amap.api.maps.model.LatLng;
17 
import com.amap.api.maps.model.LatLng;
17 
import com.blankj.utilcode.util.LogUtils;
18 
import com.blankj.utilcode.util.LogUtils;
18 
import com.blankj.utilcode.util.Utils;
19 
import com.blankj.utilcode.util.Utils;
199 
        userCarIntentMode = ProfileManager.getInstance().getCarIntentModel(getApplicationContext());
200 
        userCarIntentMode = ProfileManager.getInstance().getCarIntentModel(getApplicationContext());
200 
        loginRemind();
201 
        loginRemind();
201 
        setFestival();
202 
        setFestival();
203 
        if (ProfileManager.getInstance().getPrivacyAgreement(this)) {
204 
            MainApplication.initSDK();
205 
        }
202 
    }
206 
    }
203
207
204 
    public void initJPush() {
208 
    public void initJPush() {
392 
    }
396 
    }
393
397
394 
    public static void initSDK() {
398 
    public static void initSDK() {
399 
        AMapLocationClient.updatePrivacyShow(context,true,true);
400 
        AMapLocationClient.updatePrivacyAgree(context,true);
395 
        MobSDK.init(MainApplication.context);
401 
        MobSDK.init(MainApplication.context);
396 
        MobSDK.submitPolicyGrantResult(true,null);
402 
        MobSDK.submitPolicyGrantResult(true,null);
397 
        CrashReport.initCrashReport(MainApplication.context, "900010422", BuildConfig.DEBUG);
403 
        CrashReport.initCrashReport(MainApplication.context, "900010422", BuildConfig.DEBUG);

+ 7 - 9
app/src/main/java/com/electric/chargingpile/util/TTSController.java
Просмотреть файл

10 
import com.amap.api.navi.model.AMapModelCross;
 10 
import com.amap.api.navi.model.AMapModelCross;
11 
import com.amap.api.navi.model.AMapNaviCameraInfo;
 11 
import com.amap.api.navi.model.AMapNaviCameraInfo;
12 
import com.amap.api.navi.model.AMapNaviCross;
 12 
import com.amap.api.navi.model.AMapNaviCross;
13 
import com.amap.api.navi.model.AMapNaviInfo;
13
14 
import com.amap.api.navi.model.AMapNaviLocation;
 14 
import com.amap.api.navi.model.AMapNaviLocation;
15 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
 15 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
16 
import com.amap.api.navi.model.AMapNaviTrafficFacilityInfo;
 16 
import com.amap.api.navi.model.AMapNaviTrafficFacilityInfo;
18 
import com.amap.api.navi.model.AimLessModeCongestionInfo;
 18 
import com.amap.api.navi.model.AimLessModeCongestionInfo;
19 
import com.amap.api.navi.model.AimLessModeStat;
 19 
import com.amap.api.navi.model.AimLessModeStat;
20 
import com.amap.api.navi.model.NaviInfo;
 20 
import com.amap.api.navi.model.NaviInfo;
21 
import com.autonavi.tbt.TrafficFacilityInfo;
21
22 
import com.blankj.utilcode.util.LogUtils;
 22 
import com.blankj.utilcode.util.LogUtils;
23 
import com.electric.chargingpile.R;
 23 
import com.electric.chargingpile.R;
24 
import com.iflytek.cloud.speech.SpeechConstant;
 24 
import com.iflytek.cloud.speech.SpeechConstant;
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 
    @Override
 284 
    @Override
289 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
 285 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
307
303
308 
    }
 304 
    }
309
305
310 
    @Override
311 
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
312
306
313 
    }
314
307
315 
    @Override
 308 
    @Override
316 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
 309 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
401 
    }
 394 
    }
402
395
403 
    @Override
 396 
    @Override
397 
    public void onGpsSignalWeak(boolean b) {
398
399 
    }
400
401 
    @Override
404 
    public void onNaviSetting() {
 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
Просмотреть файл


Krystal Clunies - Gogs: Go Git Service
Главная Обзор Помощь
Регистрация Войти
yhskrystal8116 (Krystal Clunies)

Подписан