ved-code">//设置是否强制刷新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
Vedi File 

@ -1401,7 +1401,7 @@ public class MainMapActivity extends Activity implements LocationSource, AMapLoc
1401 1401
1402 1402 
        changeButton();
1403 1403
1404 
        if (hasLocationPermission() && center == null) {
1404 
        if (hasLocationPermission() && center == null && mlocationClient!=null) {
1405 1405 
            mlocationClient.startLocation();
1406 1406 
        }
1407 1407 
    }
 
@ -1504,62 +1504,65 @@ public class MainMapActivity extends Activity implements LocationSource, AMapLoc
1504 1504 
    public void activate(OnLocationChangedListener listener) {
1505 1505 
        mListener = listener;
1506 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 1515 
//            mLocationOption.setGpsFirst(true);
1515 1516 
//            mLocationOption.setOnceLocation(true);
1516 
            mLocationOption.setInterval(1500);
1517 
                mLocationOption.setInterval(1500);
1517 1518
1518 
            //设置是否强制刷新WIFI，默认为强制刷新
1519 
                //设置是否强制刷新WIFI，默认为强制刷新
1519 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 1546 
                                EasyPermissions.requestPermissions(
1547 1547 
                                        this,
1548 1548 
                                        "为了定位您的位置，推荐充电桩，充电桩位置路线导航需要开启位置权限，是否前往开启?",
1549 1549 
                                        RC_Location_FIRST_PERM,
1550 1550 
                                        Manifest.permission.ACCESS_FINE_LOCATION,
1551 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
Vedi File 

@ -397,35 +397,40 @@ public class NewSelectCityActivity extends AppCompatActivity implements ISelectC
397 397 
    }
398 398
399 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 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 436 
    private void insertData(CityRecord cityRecord) {

+ 19 - 14
app/src/main/java/com/electric/chargingpile/activity/OfflineMapActivity.java
Vedi File 

@ -238,20 +238,25 @@ public class OfflineMapActivity extends Activity implements
238 238 
        mAllOfflineMapList = (ExpandableListView) provinceContainer
239 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
Vedi File 

@ -348,43 +348,48 @@ public class PileDetailsActivity extends AppCompatActivity implements View.OnCli
348 348 
        final AMapLocationClient mlocationClient;
349 349 
        //声明mLocationOption对象
350 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 395 
    private void sendControlParkingDownLock(AMapLocation amapLocation, PileData pileData) {

+ 0 - 1
app/src/main/java/com/electric/chargingpile/activity/PrivacyAgreementActivity.java
Vedi File 

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

+ 30 - 20
app/src/main/java/com/electric/chargingpile/activity/PrivateZhuangMapActivity.java
Vedi File 

@ -29,6 +29,7 @@ import com.amap.api.maps.model.BitmapDescriptorFactory;
29 29 
import com.amap.api.maps.model.CameraPosition;
30 30 
import com.amap.api.maps.model.LatLng;
31 31 
import com.amap.api.maps.model.MyLocationStyle;
32 
import com.amap.api.services.core.AMapException;
32 33 
import com.amap.api.services.core.LatLonPoint;
33 34 
import com.amap.api.services.geocoder.GeocodeResult;
34 35 
import com.amap.api.services.geocoder.GeocodeSearch;
 
@ -126,9 +127,13 @@ public class PrivateZhuangMapActivity extends Activity implements View.OnClickLi
126 127 
            //获得地图的最大和最小缩放级别
127 128 
            maxZoomLevel = aMap.getMaxZoomLevel();
128 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,23 +437,28 @@ public class PrivateZhuangMapActivity extends Activity implements View.OnClickLi
432 437 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
433 438 
        mListener = onLocationChangedListener;
434 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
Vedi File 

@ -361,31 +361,36 @@ public class RecommendZhanActivity extends Activity implements View.OnClickListe
361 361 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
362 362 
        mListener = onLocationChangedListener;
363 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 372 
//            mLocationOption.setGpsFirst(true);
372 373 
//            mLocationOption.setOnceLocation(true);
373 
            mLocationOption.setInterval(1500);
374 
                mLocationOption.setInterval(1500);
374 375
375 
            //设置是否强制刷新WIFI，默认为强制刷新
376 
                //设置是否强制刷新WIFI，默认为强制刷新
376 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
Vedi File 

@ -68,7 +68,7 @@ import com.amap.api.navi.model.AMapLaneInfo;
68 68 
import com.amap.api.navi.model.AMapModelCross;
69 69 
import com.amap.api.navi.model.AMapNaviCameraInfo;
70 70 
import com.amap.api.navi.model.AMapNaviCross;
71 
import com.amap.api.navi.model.AMapNaviInfo;
71
72 72 
import com.amap.api.navi.model.AMapNaviLocation;
73 73 
import com.amap.api.navi.model.AMapNaviPath;
74 74 
import com.amap.api.navi.model.AMapNaviRouteNotifyData;
 
@ -80,13 +80,14 @@ import com.amap.api.navi.model.AimLessModeStat;
80 80 
import com.amap.api.navi.model.NaviInfo;
81 81 
import com.amap.api.navi.model.NaviLatLng;
82 82 
import com.amap.api.navi.view.RouteOverLay;
83 
import com.amap.api.services.core.AMapException;
83 84 
import com.amap.api.services.core.LatLonPoint;
84 85 
import com.amap.api.services.core.PoiItem;
85 86 
import com.amap.api.services.geocoder.GeocodeResult;
86 87 
import com.amap.api.services.geocoder.GeocodeSearch;
87 88 
import com.amap.api.services.geocoder.RegeocodeQuery;
88 89 
import com.amap.api.services.geocoder.RegeocodeResult;
89 
import com.autonavi.tbt.TrafficFacilityInfo;
90
90 91 
import com.blankj.utilcode.util.EmptyUtils;
91 92 
import com.blankj.utilcode.util.LogUtils;
92 93 
import com.blankj.utilcode.util.SizeUtils;
 
@ -414,16 +415,26 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
414 415 
        if (amap == null) {
415 416 
            amap = mapView.getMap();
416 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,12 +758,12 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
747 758 
            routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
748 759 
            routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
749 760 
            routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
750 
            routeOverLay.setTrafficLightsVisible(false);
761 
            //routeOverLay.setTrafficLightsVisible(false);
751 762 
            routeOverLay.addToMap();
752 763 
            routeOverlays.put(routeIds[i], routeOverLay);
753 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 767 
            routePlanInfo.setTime(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllTime() + "");
757 768 
            routePlanInfo.setDistance(routeOverlays.get(routeIds[i]).getAMapNaviPath().getAllLength() + "");
758 769 
@ -857,15 +868,8 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
857 868 
        int i = l.size();
858 869
859 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 873 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
870 874 
            tv_route_time1.setText(getSToHm(l.get(0).getTime()));
871 875 
            rl_route2.setVisibility(View.GONE);
 
@ -873,26 +877,13 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
873 877 
            view1.setVisibility(View.GONE);
874 878 
            view2.setVisibility(View.GONE);
875 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 882 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
886 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 887 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
897 888 
            tv_route_time2.setText(getSToHm(l.get(1).getTime()));
898 889 
@ -906,38 +897,18 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
906 897 
            view2.setVisibility(View.VISIBLE);
907 898 
            rl_route2.setVisibility(View.VISIBLE);
908 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 903 
            tv_route_distance1.setText(getMToKm(l.get(0).getDistance()));
919 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 909 
            tv_route_distance2.setText(getMToKm(l.get(1).getDistance()));
931 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 912 
            tv_route_distance3.setText(getMToKm(l.get(2).getDistance()));
942 913 
            tv_route_time3.setText(getSToHm(l.get(2).getTime()));
943 914 
        }
 
@ -1004,6 +975,11 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1004 975 
    public void onNaviRouteNotify(AMapNaviRouteNotifyData aMapNaviRouteNotifyData) {
1005 976 
    }
1006 977
978 
    @Override
979 
    public void onGpsSignalWeak(boolean b) {
980
981 
    }
982
1007 983
1008 984 
    public void changeRoute(View view) {
1009 985 
        if (mMarkerCity != null) {
 
@ -1509,10 +1485,6 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1509 1485
1510 1486 
    }
1511 1487
1512 
    @Override
1513 
    public void onNaviInfoUpdated(AMapNaviInfo naviInfo) {
1514
1515 
    }
1516 1488
1517 1489 
    @Override
1518 1490 
    public void updateCameraInfo(AMapNaviCameraInfo[] aMapNaviCameraInfos) {
 
@ -1535,10 +1507,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1535 1507
1536 1508 
    }
1537 1509
1538 
    @Override
1539 
    public void OnUpdateTrafficFacility(TrafficFacilityInfo trafficFacilityInfo) {
1540 1510
1541 
    }
1542 1511
1543 1512 
    @Override
1544 1513 
    public void OnUpdateTrafficFacility(AMapNaviTrafficFacilityInfo aMapNaviTrafficFacilityInfo) {
 
@ -1605,7 +1574,11 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1605 1574 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
1606 1575 
        mListener = onLocationChangedListener;
1607 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 1582 
            mLocationOption = new AMapLocationClientOption();
1610 1583 
            //设置定位监听
1611 1584 
            mlocationClient.setLocationListener(this);
 
@ -1854,7 +1827,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1854 1827 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
1855 1828 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
1856 1829 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1857 
                        routeOverLay.setTrafficLightsVisible(false);
1830 
                        //routeOverLay.setTrafficLightsVisible(false);
1858 1831 
                        routeOverLay.addToMap();
1859 1832 
                        routeOverlays.put(routeIds[i], routeOverLay);
1860 1833 
                    }
 
@ -1916,7 +1889,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1916 1889 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_start)));
1917 1890 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_route_end)));
1918 1891 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1919 
                        routeOverLay.setTrafficLightsVisible(false);
1892 
                        //routeOverLay.setTrafficLightsVisible(false);
1920 1893 
                        routeOverLay.addToMap();
1921 1894 
                        routeOverlays.put(routeIds[i], routeOverLay);
1922 1895 
                    }
 
@ -1976,7 +1949,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
1976 1949 
                        routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
1977 1950 
                        routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
1978 1951 
                        routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
1979 
                        routeOverLay.setTrafficLightsVisible(false);
1952 
                        //routeOverLay.setTrafficLightsVisible(false);
1980 1953 
                        routeOverLay.addToMap();
1981 1954 
                        routeOverlays.put(routeIds[i], routeOverLay);
1982 1955 
                    }
 
@ -2065,7 +2038,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
2065 2038 
                            routeOverLay.setStartPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstarr));
2066 2039 
                            routeOverLay.setEndPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_newstopr));
2067 2040 
                            routeOverLay.setWayPointBitmap(BitmapFactory.decodeResource(this.getResources(), R.drawable.icon_zhanwei));
2068 
                            routeOverLay.setTrafficLightsVisible(false);
2041 
                            //routeOverLay.setTrafficLightsVisible(false);
2069 2042 
                            routeOverlays.put(routeIds[i], routeOverLay);
2070 2043 
                            routeOverLay.addToMap();
2071 2044 
                        }
 
@ -2933,7 +2906,7 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
2933 2906 
                routeOverLay.setStartPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstarr)));
2934 2907 
                routeOverLay.setEndPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_newstopr)));
2935 2908 
                routeOverLay.setWayPointBitmap(drawableToBitamp(getResources().getDrawable(R.drawable.icon_zhanwei)));
2936 
                routeOverLay.setTrafficLightsVisible(false);
2909 
                //routeOverLay.setTrafficLightsVisible(false);
2937 2910 
                routeOverLay.addToMap();
2938 2911 
                routeOverlays.put(routeIds[i], routeOverLay);
2939 2912 
            }
 
@ -2990,4 +2963,9 @@ public class RoutePlanMapActivity extends Activity implements LocationSource, AM
2990 2963 
    public View getInfoContents(Marker marker) {
2991 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
Vedi File 

@ -1,6 +1,7 @@
1 1 
package com.electric.chargingpile.activity;
2 2
3 3
4 
import android.annotation.SuppressLint;
4 5 
import android.app.Activity;
5 6 
import android.content.ContentValues;
6 7 
import android.content.Context;
 
@ -28,6 +29,7 @@ import android.widget.SimpleCursorAdapter;
28 29 
import android.widget.TextView;
29 30 
import android.widget.Toast;
30 31
32 
import com.amap.api.services.core.AMapException;
31 33 
import com.amap.api.services.core.PoiItem;
32 34 
import com.amap.api.services.core.SuggestionCity;
33 35 
import com.amap.api.services.poisearch.PoiResult;
 
@ -96,6 +98,7 @@ public class RoutePlanSelectAddressActivity extends Activity implements View.OnC
96 98 
//        Toast.makeText(getApplicationContext(),tag,Toast.LENGTH_SHORT).show();
97 99 
    }
98 100
101 
    @SuppressLint("Range")
99 102 
    private void initViews() {
100 103 
        rl_mapselect = (RelativeLayout) findViewById(R.id.rl_mapselect);
101 104 
        rl_mapselect.setOnClickListener(this);
 
@ -455,9 +458,14 @@ public class RoutePlanSelectAddressActivity extends Activity implements View.OnC
455 458 
        query.setPageSize(20);// 设置每页最多返回多少条poiitem
456 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 471 
    @Override

+ 30 - 20
app/src/main/java/com/electric/chargingpile/activity/RouteSelectPointActivity.java
Vedi File 

@ -26,6 +26,7 @@ import com.amap.api.maps.UiSettings;
26 26 
import com.amap.api.maps.model.CameraPosition;
27 27 
import com.amap.api.maps.model.LatLng;
28 28 
import com.amap.api.maps.model.MyLocationStyle;
29 
import com.amap.api.services.core.AMapException;
29 30 
import com.amap.api.services.core.LatLonPoint;
30 31 
import com.amap.api.services.core.PoiItem;
31 32 
import com.amap.api.services.geocoder.GeocodeResult;
 
@ -122,9 +123,13 @@ public class RouteSelectPointActivity extends Activity implements View.OnClickLi
122 123 
            //获得地图的最大和最小缩放级别
123 124 
            maxZoomLevel = aMap.getMaxZoomLevel();
124 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,23 +272,28 @@ public class RouteSelectPointActivity extends Activity implements View.OnClickLi
267 272 
    public void activate(OnLocationChangedListener onLocationChangedListener) {
268 273 
        mListener = onLocationChangedListener;
269 274 
        if (mlocationClient == null) {
270 
            mlocationClient = new AMapLocationClient(this);
271 
            mLocationOption = new AMapLocationClientOption();
272 
            //设置定位监听
273 
            mlocationClient.setLocationListener(this);
274 
            //设置为高精度定位模式
275 
            mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
276 
            //设置定位参数
277 
            mlocationClient.setLocationOption(mLocationOption);
278 
            // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
279 
            // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
280 
            // 在定位结束后，在合适的生命周期调用onDestroy()方法
281 
            // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
282 
            // 设置是否只定位一次,默认为false
283 
            mLocationOption.setOnceLocation(true);
284 
            //设置是否强制刷新WIFI，默认为强制刷新
285 
            mLocationOption.setWifiActiveScan(false);
286 
            mlocationClient.startLocation();
275 
            try {
276 
                mlocationClient = new AMapLocationClient(this);
277 
                mLocationOption = new AMapLocationClientOption();
278 
                //设置定位监听
279 
                mlocationClient.setLocationListener(this);
280 
                //设置为高精度定位模式
281 
                mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
282 
                //设置定位参数
283 
                mlocationClient.setLocationOption(mLocationOption);
284 
                // 此方法为每隔固定时间会发起一次定位请求，为了减少电量消耗或网络流量消耗，
285 
                // 注意设置合适的定位时间的间隔（最小间隔支持为2000ms），并且在合适时间调用stopLocation()方法来取消定位请求
286 
                // 在定位结束后，在合适的生命周期调用onDestroy()方法
287 
                // 在单次定位情况下，定位无论成功与否，都无需调用stopLocation()方法移除请求，定位sdk内部会移除
288 
                // 设置是否只定位一次,默认为false
289 
                mLocationOption.setOnceLocation(true);
290 
                //设置是否强制刷新WIFI，默认为强制刷新
291 
                mLocationOption.setWifiActiveScan(false);
292 
                mlocationClient.startLocation();
293
294 
            } catch (Exception e) {
295 
                e.printStackTrace();
296 
            }
287 297
288 298 
        }
289 299 
    }

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

@ -42,6 +42,7 @@ import android.widget.Toast;
42 42
43 43 
import com.amap.api.maps.AMapUtils;
44 44 
import com.amap.api.maps.model.LatLng;
45 
import com.amap.api.services.core.AMapException;
45 46 
import com.amap.api.services.core.PoiItem;
46 47 
import com.amap.api.services.core.SuggestionCity;
47 48 
import com.amap.api.services.help.Inputtips;

@ -912,9 +913,14 @@ public class SearchActivity extends Activity implements OnClickListener, Inputti
912 913 
        query.setPageSize(30);// 设置每页最多返回多少条poiitem
913 914 
        query.setPageNum(currentPage);// 设置查第一页
914 915
915 
        poiSearch = new PoiSearch(this, query);
916 
        poiSearch.setOnPoiSearchListener(this);
917 
        poiSearch.searchPOIAsyn();
916 
        try {
917 
            poiSearch = new PoiSearch(this, query);
918 
            poiSearch.setOnPoiSearchListener(this);
919 
            poiSearch.searchPOIAsyn();
920 
        } catch (AMapException e) {
921 
            e.printStackTrace();
922 
        }
923
918 924 
    }
919 925
920 926 
    private void doPointNameSearchQuery() {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -13,6 +13,7 @@ import android.util.Log;
13 13 
import androidx.multidex.MultiDexApplication;
14 14
15 15 
import com.alibaba.fastjson.JSONException;
16 
import com.amap.api.location.AMapLocationClient;
16 17 
import com.amap.api.maps.model.LatLng;
17 18 
import com.blankj.utilcode.util.LogUtils;
18 19 
import com.blankj.utilcode.util.Utils;

@ -199,6 +200,9 @@ public class MainApplication extends MultiDexApplication {
199 200 
        userCarIntentMode = ProfileManager.getInstance().getCarIntentModel(getApplicationContext());
200 201 
        loginRemind();
201 202 
        setFestival();
203 
        if (ProfileManager.getInstance().getPrivacyAgreement(this)) {
204 
            MainApplication.initSDK();
205 
        }
202 206 
    }
203 207
204 208 
    public void initJPush() {

@ -392,6 +396,8 @@ public class MainApplication extends MultiDexApplication {
392 396 
    }
393 397
394 398 
    public static void initSDK() {
399 
        AMapLocationClient.updatePrivacyShow(context,true,true);
400 
        AMapLocationClient.updatePrivacyAgree(context,true);
395 401 
        MobSDK.init(MainApplication.context);
396 402 
        MobSDK.submitPolicyGrantResult(true,null);
397 403 
        CrashReport.initCrashReport(MainApplication.context, "900010422", BuildConfig.DEBUG);

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

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


冗余代码删除 · f6c3209481 - Gogs: Go Git Service
Sākums Izpētīt Palīdzība
Reģistrēties Pierakstīties
dudu
/
cdzApp
Vērot 2
Pievienot zvaigznīti 1
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Revīzijas 421 Laidieni 18 Vikivietne
Pārlūkot izejas kodu

冗余代码删除

huyuguo 4 gadi atpakaļ
vecāks
5c68143e90
revīzija
f6c3209481
41 mainītis faili ar 0 papildinājumiem un 1732 dzēšanām
Dalītais skats Rādīt salīdzināšanas statistiku
  1. 0 40
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/AndroidManifest.xml
  2. 0 74
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/ImageFloder.java
  3. 0 436
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/ImageLoader.java
  4. 0 356
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/SelectPhotoActivity.java
  5. 0 98
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/CommonAdapter.java
  6. 0 116
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/GirdItemAdapter.java
  7. 0 89
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/ImageFloderAdapter.java
  8. 0 126
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/ViewHolder.java
  9. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-hdpi/ic_launcher.png
  10. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-mdpi/ic_launcher.png
  11. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph.png
  12. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph1.png
  13. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph_highlighted.png
  14. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph_highlighted1.png
  15. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/dir_choose.png
  16. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/ic_launcher.png
  17. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/navigationbar_arrow_down.png
  18. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/navigationbar_arrow_up.png
  19. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pic_dir.png
  20. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/picture_unselected.png
  21. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pictures_no.png
  22. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pictures_selected.png
  23. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xxhdpi/dir_choose.png
  24. BIN
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xxhdpi/ic_launcher.png
  25. 0 8
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable/photo_btn_selector.xml
  26. 0 30
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable/photo_select_btn_selector.xml
  27. 0 16
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/activity_main.xml
  28. 0 25
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/grid_item.xml
  29. 0 22
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/grid_item2.xml
  30. 0 17
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/image_select_dirlist.xml
  31. 0 56
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/list_dir_item.xml
  32. 0 52
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/photo_select_view.xml
  33. 0 76
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/select_photo_header.xml
  34. 0 12
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/menu/main.xml
  35. 0 11
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-v11/styles.xml
  36. 0 12
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-v14/styles.xml
  37. 0 10
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-w820dp/dimens.xml
  38. 0 27
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/colors.xml
  39. 0 7
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/dimens.xml
  40. 0 8
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/strings.xml
  41. 0 8
      app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/styles.xml

+ 0 - 40
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/AndroidManifest.xml
Parādīt failu 

@ -1,40 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
3 
    package="com.example.imageselected"
4 
    android:versionCode="1"
5 
    android:versionName="1.0" >
6
7 
    <uses-sdk
8 
        android:minSdkVersion="24"
9 
        android:targetSdkVersion="29" />
10
11 
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
12 
    <uses-permission android:name="com.android.browser.permission.WRITE_HISTORY_BOOKMARKS" />
13 
    <uses-permission android:name="com.android.browser.permission.READ_HISTORY_BOOKMARKS" />
14 
    <uses-permission android:name="android.permission.CAMERA" />
15 
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
16 
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
17 
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
18 
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
19 
    <uses-permission android:name="android.permission.CAMERA" />
20 
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
21 
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
22 
    <uses-permission android:name="android.permission.WAKE_LOCK" />
23
24 
    <application
25 
        android:allowBackup="true"
26 
        android:icon="@drawable/ic_launcher"
27 
        android:label="@string/app_name"
28 
        android:theme="@style/AppTheme" >
29 
        <activity
30 
            android:name=".photo.SelectPhotoActivity"
31 
            android:label="@string/app_name" >
32 
            <intent-filter>
33 
                <action android:name="android.intent.action.MAIN" />
34
35 
                <category android:name="android.intent.category.LAUNCHER" />
36 
            </intent-filter>
37 
        </activity>
38 
    </application>
39
40 
</manifest>

+ 0 - 74
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/ImageFloder.java
Parādīt failu 

@ -1,74 +0,0 @@
1 
package com.example.imageselected.photo;
2
3 
/**
4 
 * 图片的实体类
5 
 * @author Administrator
6 
 *
7 
 */
8 
public class ImageFloder{
9 
	/**
10 
	 * 图片的文件夹路径
11 
	 */
12 
	private String dir;
13
14 
	/**
15 
	 * 第一张图片的路径
16 
	 */
17 
	private String firstImagePath;
18
19 
	/**
20 
	 * 文件夹的名称
21 
	 */
22 
	private String name;
23
24 
	/**
25 
	 * 图片的数量
26 
	 */
27 
	private int count;
28
29 
	private boolean  isSelected;
30
31 
	public boolean isSelected() {
32 
		return isSelected;
33 
	}
34
35 
	public void setSelected(boolean isSelected) {
36 
		this.isSelected = isSelected;
37 
	}
38
39 
	public void setName(String name) {
40 
		this.name = name;
41 
	}
42
43 
	public String getDir(){
44 
		return dir;
45 
	}
46
47 
	public void setDir(String dir){
48 
		this.dir = dir;
49 
		int lastIndexOf = this.dir.lastIndexOf("/");
50 
		this.name = this.dir.substring(lastIndexOf);
51 
	}
52
53 
	public String getFirstImagePath(){
54 
		return firstImagePath;
55 
	}
56
57 
	public void setFirstImagePath(String firstImagePath){
58 
		this.firstImagePath = firstImagePath;
59 
	}
60
61 
	public String getName(){
62 
		return name;
63 
	}
64 
	public int getCount(){
65 
		return count;
66 
	}
67
68 
	public void setCount(int count){
69 
		this.count = count;
70 
	}
71
72
73
74 
}

+ 0 - 436
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/ImageLoader.java
Parādīt failu 

@ -1,436 +0,0 @@
1 
package com.example.imageselected.photo;
2
3 
import java.lang.reflect.Field;
4 
import java.util.LinkedList;
5 
import java.util.concurrent.ExecutorService;
6 
import java.util.concurrent.Executors;
7 
import java.util.concurrent.Semaphore;
8
9 
import android.graphics.Bitmap;
10 
import android.graphics.BitmapFactory;
11 
import android.os.Handler;
12 
import android.os.Looper;
13 
import android.os.Message;
14 
import androidx.collection.LruCache;
15 
import android.util.DisplayMetrics;
16 
import android.util.Log;
17 
import android.view.ViewGroup.LayoutParams;
18 
import android.widget.ImageView;
19
20 
public class ImageLoader
21 
{
22 
	/**
23 
	 * ͼƬ����ĺ�����
24 
	 */
25 
	private LruCache<String, Bitmap> mLruCache;
26 
	/**
27 
	 * �̳߳�
28 
	 */
29 
	private ExecutorService mThreadPool;
30 
	/**
31 
	 * �̳߳ص��߳�������Ĭ��Ϊ1
32 
	 */
33 
	private int mThreadCount = 1;
34 
	/**
35 
	 * ���еĵ��ȷ�ʽ
36 
	 */
37 
	private Type mType = Type.LIFO;
38 
	/**
39 
	 * �������
40 
	 */
41 
	private LinkedList<Runnable> mTasks;
42 
	/**
43 
	 * ��ѯ���߳�
44 
	 */
45 
	private Thread mPoolThread;
46 
	private Handler mPoolThreadHander;
47
48 
	/**
49 
	 * ������UI�̵߳�handler�����ڸ�ImageView����ͼƬ
50 
	 */
51 
	private Handler mHandler;
52
53 
	/**
54 
	 * ����һ��ֵΪ1���ź�������ֹmPoolThreadHanderδ��ʼ�����
55 
	 */
56 
	private volatile Semaphore mSemaphore = new Semaphore(0);
57
58 
	/**
59 
	 * ����һ��ֵΪ1���ź����������̳߳��ڲ�Ҳ��һ�������̣߳���ֹ����������ٶȹ��죬ʹLIFOЧ��������
60 
	 */
61 
	private volatile Semaphore mPoolSemaphore;
62
63 
	private static ImageLoader mInstance;
64
65 
	/**
66 
	 * ���еĵ��ȷ�ʽ
67 
	 *
68 
	 * @author zhy
69 
	 *
70 
	 */
71 
	public enum Type
72 
	{
73 
		FIFO, LIFO
74 
	}
75
76
77 
	/**
78 
	 * ������ø�ʵ������
79 
	 *
80 
	 * @return
81 
	 */
82 
	public static ImageLoader getInstance()
83 
	{
84
85 
		if (mInstance == null)
86 
		{
87 
			synchronized (ImageLoader.class)
88 
			{
89 
				if (mInstance == null)
90 
				{
91 
					mInstance = new ImageLoader(1, Type.LIFO);
92 
				}
93 
			}
94 
		}
95 
		return mInstance;
96 
	}
97
98 
	private ImageLoader(int threadCount, Type type)
99 
	{
100 
		init(threadCount, type);
101 
	}
102
103 
	private void init(int threadCount, Type type)
104 
	{
105 
		// loop thread
106 
		mPoolThread = new Thread()
107 
		{
108 
			@Override
109 
			public void run()
110 
			{
111 
				Looper.prepare();
112
113 
				mPoolThreadHander = new Handler()
114 
				{
115 
					@Override
116 
					public void handleMessage(Message msg)
117 
					{
118 
						mThreadPool.execute(getTask());
119 
						try
120 
						{
121 
							mPoolSemaphore.acquire();
122 
						} catch (InterruptedException e)
123 
						{
124 
						}
125 
					}
126 
				};
127 
				// �ͷ�һ���ź���
128 
				mSemaphore.release();
129 
				Looper.loop();
130 
			}
131 
		};
132 
		mPoolThread.start();
133
134 
		// ��ȡӦ�ó����������ڴ�
135 
		int maxMemory = (int) Runtime.getRuntime().maxMemory();
136 
		int cacheSize = maxMemory / 8;
137 
		mLruCache = new LruCache<String, Bitmap>(cacheSize)
138 
		{
139 
			@Override
140 
			protected int sizeOf(String key, Bitmap value)
141 
			{
142 
				return value.getRowBytes() * value.getHeight();
143 
			};
144 
		};
145
146 
		mThreadPool = Executors.newFixedThreadPool(threadCount);
147 
		mPoolSemaphore = new Semaphore(threadCount);
148 
		mTasks = new LinkedList<Runnable>();
149 
		mType = type == null ? Type.LIFO : type;
150
151 
	}
152
153 
	/**
154 
	 * ����ͼƬ
155 
	 *
156 
	 * @param path
157 
	 * @param imageView
158 
	 */
159 
	public void loadImage(final String path, final ImageView imageView)
160 
	{
161 
		// set tag
162 
		imageView.setTag(path);
163 
		// UI�߳�
164 
		if (mHandler == null)
165 
		{
166 
			mHandler = new Handler()
167 
			{
168 
				@Override
169 
				public void handleMessage(Message msg)
170 
				{
171 
					ImgBeanHolder holder = (ImgBeanHolder) msg.obj;
172 
					ImageView imageView = holder.imageView;
173 
					Bitmap bm = holder.bitmap;
174 
					String path = holder.path;
175 
					if (imageView.getTag().toString().equals(path))
176 
					{
177 
						imageView.setImageBitmap(bm);
178 
					}
179 
				}
180 
			};
181 
		}
182
183 
		Bitmap bm = getBitmapFromLruCache(path);
184 
		if (bm != null)
185 
		{
186 
			ImgBeanHolder holder = new ImgBeanHolder();
187 
			holder.bitmap = bm;
188 
			holder.imageView = imageView;
189 
			holder.path = path;
190 
			Message message = Message.obtain();
191 
			message.obj = holder;
192 
			mHandler.sendMessage(message);
193 
		} else
194 
		{
195 
			addTask(new Runnable()
196 
			{
197 
				@Override
198 
				public void run()
199 
				{
200
201 
					ImageSize imageSize = getImageViewWidth(imageView);
202
203 
					int reqWidth = imageSize.width;
204 
					int reqHeight = imageSize.height;
205
206 
					Bitmap bm = decodeSampledBitmapFromResource(path, reqWidth,
207 
							reqHeight);
208 
					addBitmapToLruCache(path, bm);
209 
					ImgBeanHolder holder = new ImgBeanHolder();
210 
					holder.bitmap = getBitmapFromLruCache(path);
211 
					holder.imageView = imageView;
212 
					holder.path = path;
213 
					Message message = Message.obtain();
214 
					message.obj = holder;
215 
					// Log.e("TAG", "mHandler.sendMessage(message);");
216 
					mHandler.sendMessage(message);
217 
					mPoolSemaphore.release();
218 
				}
219 
			});
220 
		}
221
222 
	}
223
224 
	/**
225 
	 * ���һ������
226 
	 *
227 
	 * @param runnable
228 
	 */
229 
	private synchronized void addTask(Runnable runnable)
230 
	{
231 
		try
232 
		{
233 
			// �����ź�������ֹmPoolThreadHanderΪnull
234 
			if (mPoolThreadHander == null)
235 
				mSemaphore.acquire();
236 
		} catch (InterruptedException e)
237 
		{
238 
		}
239 
		mTasks.add(runnable);
240
241 
		mPoolThreadHander.sendEmptyMessage(0x110);
242 
	}
243
244 
	/**
245 
	 * ȡ��һ������
246 
	 *
247 
	 * @return
248 
	 */
249 
	private synchronized Runnable getTask()
250 
	{
251 
		if (mType == Type.FIFO)
252 
		{
253 
			return mTasks.removeFirst();
254 
		} else if (mType == Type.LIFO)
255 
		{
256 
			return mTasks.removeLast();
257 
		}
258 
		return null;
259 
	}
260
261 
	/**
262 
	 * ������ø�ʵ������
263 
	 *
264 
	 * @return
265 
	 */
266 
	public static ImageLoader getInstance(int threadCount, Type type)
267 
	{
268
269 
		if (mInstance == null)
270 
		{
271 
			synchronized (ImageLoader.class)
272 
			{
273 
				if (mInstance == null)
274 
				{
275 
					mInstance = new ImageLoader(threadCount, type);
276 
				}
277 
			}
278 
		}
279 
		return mInstance;
280 
	}
281
282
283 
	/**
284 
	 * ����ImageView����ʵ���ѹ���Ŀ�͸�
285 
	 *
286 
	 * @param imageView
287 
	 * @return
288 
	 */
289 
	private ImageSize getImageViewWidth(ImageView imageView)
290 
	{
291 
		ImageSize imageSize = new ImageSize();
292 
		final DisplayMetrics displayMetrics = imageView.getContext()
293 
				.getResources().getDisplayMetrics();
294 
		final LayoutParams params = imageView.getLayoutParams();
295
296 
		int width = params.width == LayoutParams.WRAP_CONTENT ? 0 : imageView
297 
				.getWidth(); // Get actual image width
298 
		if (width <= 0)
299 
			width = params.width; // Get layout width parameter
300 
		if (width <= 0)
301 
			width = getImageViewFieldValue(imageView, "mMaxWidth"); // Check
302 
																	// maxWidth
303 
																	// parameter
304 
		if (width <= 0)
305 
			width = displayMetrics.widthPixels;
306 
		int height = params.height == LayoutParams.WRAP_CONTENT ? 0 : imageView
307 
				.getHeight(); // Get actual image height
308 
		if (height <= 0)
309 
			height = params.height; // Get layout height parameter
310 
		if (height <= 0)
311 
			height = getImageViewFieldValue(imageView, "mMaxHeight"); // Check
312 
																		// maxHeight
313 
																		// parameter
314 
		if (height <= 0)
315 
			height = displayMetrics.heightPixels;
316 
		imageSize.width = width;
317 
		imageSize.height = height;
318 
		return imageSize;
319
320 
	}
321
322 
	/**
323 
	 * ��LruCache�л�ȡһ��ͼƬ����������ھͷ���null��
324 
	 */
325 
	private Bitmap getBitmapFromLruCache(String key)
326 
	{
327 
		return mLruCache.get(key);
328 
	}
329
330 
	/**
331 
	 * ��LruCache�����һ��ͼƬ
332 
	 *
333 
	 * @param key
334 
	 * @param bitmap
335 
	 */
336 
	private void addBitmapToLruCache(String key, Bitmap bitmap)
337 
	{
338 
		if (getBitmapFromLruCache(key) == null)
339 
		{
340 
			if (bitmap != null)
341 
				mLruCache.put(key, bitmap);
342 
		}
343 
	}
344
345 
	/**
346 
	 * ����inSampleSize������ѹ��ͼƬ
347 
	 *
348 
	 * @param options
349 
	 * @param reqWidth
350 
	 * @param reqHeight
351 
	 * @return
352 
	 */
353 
	private int calculateInSampleSize(BitmapFactory.Options options,
354 
			int reqWidth, int reqHeight)
355 
	{
356 
		// ԴͼƬ�Ŀ��
357 
		int width = options.outWidth;
358 
		int height = options.outHeight;
359 
		int inSampleSize = 1;
360
361 
		if (width > reqWidth && height > reqHeight)
362 
		{
363 
			// �����ʵ�ʿ�Ⱥ�Ŀ���ȵı���
364 
			int widthRatio = Math.round((float) width / (float) reqWidth);
365 
			int heightRatio = Math.round((float) width / (float) reqWidth);
366 
			inSampleSize = Math.max(widthRatio, heightRatio);
367 
		}
368 
		return inSampleSize;
369 
	}
370
371 
	/**
372 
	 * ���ݼ����inSampleSize���õ�ѹ����ͼƬ
373 
	 *
374 
	 * @param pathName
375 
	 * @param reqWidth
376 
	 * @param reqHeight
377 
	 * @return
378 
	 */
379 
	private Bitmap decodeSampledBitmapFromResource(String pathName,
380 
			int reqWidth, int reqHeight)
381 
	{
382 
		// ��һ�ν�����inJustDecodeBounds����Ϊtrue������ȡͼƬ��С
383 
		final BitmapFactory.Options options = new BitmapFactory.Options();
384 
		options.inJustDecodeBounds = true;
385 
		BitmapFactory.decodeFile(pathName, options);
386 
		// �������涨��ķ�������inSampleSizeֵ
387 
		options.inSampleSize = calculateInSampleSize(options, reqWidth,
388 
				reqHeight);
389 
		// ʹ�û�ȡ����inSampleSizeֵ�ٴν���ͼƬ
390 
		options.inJustDecodeBounds = false;
391 
		Bitmap bitmap = BitmapFactory.decodeFile(pathName, options);
392
393 
		return bitmap;
394 
	}
395
396 
	private class ImgBeanHolder
397 
	{
398 
		Bitmap bitmap;
399 
		ImageView imageView;
400 
		String path;
401 
	}
402
403 
	private class ImageSize
404 
	{
405 
		int width;
406 
		int height;
407 
	}
408
409 
	/**
410 
	 * ������ImageView���õ�����Ⱥ͸߶�
411 
	 *
412 
	 * @param object
413 
	 * @param fieldName
414 
	 * @return
415 
	 */
416 
	private static int getImageViewFieldValue(Object object, String fieldName)
417 
	{
418 
		int value = 0;
419 
		try
420 
		{
421 
			Field field = ImageView.class.getDeclaredField(fieldName);
422 
			field.setAccessible(true);
423 
			int fieldValue = (Integer) field.get(object);
424 
			if (fieldValue > 0 && fieldValue < Integer.MAX_VALUE)
425 
			{
426 
				value = fieldValue;
427
428 
				Log.e("TAG", value + "");
429 
			}
430 
		} catch (Exception e)
431 
		{
432 
		}
433 
		return value;
434 
	}
435
436 
}

+ 0 - 356
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/SelectPhotoActivity.java
Parādīt failu 

@ -1,356 +0,0 @@
1 
package com.example.imageselected.photo;
2
3 
import java.io.File;
4 
import java.io.FilenameFilter;
5 
import java.text.SimpleDateFormat;
6 
import java.util.ArrayList;
7 
import java.util.Arrays;
8 
import java.util.Date;
9 
import java.util.HashSet;
10 
import java.util.List;
11
12
13 
import com.example.imageselected.R;
14 
import com.example.imageselected.photo.adapter.GirdItemAdapter;
15 
import com.example.imageselected.photo.adapter.ImageFloderAdapter;
16 
import com.example.imageselected.photo.adapter.GirdItemAdapter.OnPhotoSelectedListener;
17
18 
import android.app.Activity;
19 
import android.app.ProgressDialog;
20 
import android.content.ContentResolver;
21 
import android.content.Intent;
22 
import android.database.Cursor;
23 
import android.graphics.drawable.BitmapDrawable;
24 
import android.net.Uri;
25 
import android.os.Bundle;
26 
import android.os.Environment;
27 
import android.os.Handler;
28 
import android.os.Message;
29 
import android.provider.MediaStore;
30 
import android.util.DisplayMetrics;
31 
import android.util.Log;
32 
import android.view.LayoutInflater;
33 
import android.view.View;
34 
import android.view.Window;
35 
import android.view.WindowManager;
36 
import android.view.View.OnClickListener;
37 
import android.view.ViewGroup.LayoutParams;
38 
import android.widget.AdapterView;
39 
import android.widget.AdapterView.OnItemClickListener;
40 
import android.widget.Button;
41 
import android.widget.GridView;
42 
import android.widget.ImageView;
43 
import android.widget.LinearLayout;
44 
import android.widget.ListView;
45 
import android.widget.PopupWindow;
46 
import android.widget.PopupWindow.OnDismissListener;
47 
import android.widget.RelativeLayout;
48 
import android.widget.TextView;
49 
import android.widget.Toast;
50 
/**
51 
 * 相册图片选择
52 
 * @author Administrator
53 
 *
54 
 */
55 
public class SelectPhotoActivity extends Activity  {
56
57 
	private GridView photoGrid;//图片列表
58
59 
	private Button photoBtn;//底部下一步按钮
60
61 
	private TextView titleName;//头部的标题
62
63 
	private ImageView titleIcon;//头部的三角图标
64
65 
	private ProgressDialog mProgressDialog;
66
67 
	private HashSet<String> mDirPaths = new HashSet<String>();// 临时的辅助类，用于防止同一个文件夹的多次扫描
68
69 
	private List<ImageFloder> mImageFloders = new ArrayList<ImageFloder>();// 扫描拿到所有的图片文件夹
70
71 
	int totalCount = 0;
72
73 
	private File mImgDir=new File("");// 图片数量最多的文件夹
74
75 
	private int mPicsSize;//存储文件夹中的图片数量
76
77 
	private List<String> mImgs=new ArrayList<String>();//所有的图片
78
79 
	private int mScreenHeight;
80
81 
	private LinearLayout dirLayout;
82
83 
	private TextView quxiaoBtn;
84
85 
	private ListView dirListView;
86
87 
	private RelativeLayout headLayout;
88
89 
	private int mScreenWidth;
90
91 
	private ImageFloderAdapter floderAdapter;
92
93 
	private GirdItemAdapter girdItemAdapter;
94
95 
	private PopupWindow popupWindow;
96
97 
	private View dirview;
98
99 
	private static final int TAKE_CAMERA_PICTURE = 1000;//拍照
100
101 
	private String path;
102
103 
	private File dir;
104
105 
	private String imagename;
106 
	@Override
107 
	protected void onCreate(Bundle savedInstanceState) {
108 
		super.onCreate(savedInstanceState);
109 
		requestWindowFeature(Window.FEATURE_NO_TITLE);
110 
		setContentView(R.layout.photo_select_view);
111 
		GirdItemAdapter.mSelectedImage.clear();
112 
		DisplayMetrics outMetrics = new DisplayMetrics();
113 
		getWindowManager().getDefaultDisplay().getMetrics(outMetrics);
114 
		mScreenHeight = outMetrics.heightPixels;
115 
		mScreenWidth = outMetrics.widthPixels;
116 
		setView();
117 
		getImages();
118 
		initEvent();
119 
	}
120 
	/**
121 
	 * 获取控件
122 
	 */
123 
	private void setView() {
124 
		photoGrid=(GridView)findViewById(R.id.gird_photo_list);
125 
		photoBtn=(Button)findViewById(R.id.selected_photo_btn);
126 
		titleName=(TextView)this.findViewById(R.id.selected_photo_name_text);
127 
		quxiaoBtn=(TextView)findViewById(R.id.quxiao_btn);
128 
		titleIcon=(ImageView)findViewById(R.id.selected_photo_icon);
129 
		headLayout=(RelativeLayout)findViewById(R.id.selected_photo_header_layout);
130 
		titleIcon.setBackgroundResource(R.drawable.navigationbar_arrow_down);
131 
	}
132 
	/**
133 
	 * 利用ContentProvider扫描手机中的图片，此方法在运行在子线程中 完成图片的扫描，最终获得jpg最多的那个文件夹
134 
	 */
135 
	private void getImages(){
136 
		if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
137 
			Toast.makeText(this, "暂无外部存储", Toast.LENGTH_SHORT).show();
138 
			return;
139 
		}
140 
		// 显示进度条
141 
		mProgressDialog = ProgressDialog.show(this, null, "正在加载...");
142 
		new Thread(new Runnable(){
143 
			@Override
144 
			public void run(){
145 
				String firstImage = null;
146 
				Uri mImageUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
147 
				ContentResolver mContentResolver = SelectPhotoActivity.this.getContentResolver();
148 
				// 只查询jpeg和png的图片
149 
				Cursor mCursor = mContentResolver.query(mImageUri, null,
150 
						MediaStore.Images.Media.MIME_TYPE + "=? or "
151 
								+ MediaStore.Images.Media.MIME_TYPE + "=?",
152 
								new String[] { "image/jpeg", "image/png" },
153 
								MediaStore.Images.Media.DATE_MODIFIED);
154 
				Log.e("TAG", mCursor.getCount() + "");
155 
				while (mCursor.moveToNext()){
156 
					// 获取图片的路径
157 
					String path = mCursor.getString(mCursor.getColumnIndex(MediaStore.Images.Media.DATA));
158 
					Log.e("TAG", path);
159 
					// 拿到第一张图片的路径
160 
					if (firstImage == null)
161 
						firstImage = path;
162 
					// 获取该图片的父路径名
163 
					File parentFile = new File(path).getParentFile();
164 
					if (parentFile == null)
165 
						continue;
166 
					String dirPath = parentFile.getAbsolutePath();
167 
					ImageFloder imageFloder = null;
168 
					// 利用一个HashSet防止多次扫描同一个文件夹（不加这个判断，图片多起来还是相当恐怖的~~）
169 
					if (mDirPaths.contains(dirPath)){
170 
						continue;
171 
					} else{
172 
						mDirPaths.add(dirPath);
173 
						// 初始化imageFloder
174 
						imageFloder = new ImageFloder();
175 
						imageFloder.setDir(dirPath);
176 
						imageFloder.setFirstImagePath(path);
177 
					}
178 
					if(parentFile.list()==null)continue ;
179 
					int picSize = parentFile.list(new FilenameFilter(){
180 
						@Override
181 
						public boolean accept(File dir, String filename){
182 
							if (filename.endsWith(".jpg")
183 
									|| filename.endsWith(".png")
184 
									|| filename.endsWith(".jpeg"))
185 
								return true;
186 
							return false;
187 
						}
188 
					}).length;
189 
					totalCount += picSize;
190 
					imageFloder.setCount(picSize);
191 
					mImageFloders.add(imageFloder);
192
193 
					if (picSize > mPicsSize){
194 
						mPicsSize = picSize;
195 
						mImgDir = parentFile;
196 
					}
197 
				}
198 
				mCursor.close();
199
200 
				// 扫描完成，辅助的HashSet也就可以释放内存了
201 
				mDirPaths = null;
202
203 
				// 通知Handler扫描图片完成
204 
				mHandler.sendEmptyMessage(0x110);
205
206 
			}
207 
		}).start();
208
209 
	}
210 
	private Handler mHandler = new Handler(){
211 
		public void handleMessage(android.os.Message msg){
212 
			mProgressDialog.dismiss();
213 
			setDataView();// 为View绑定数据
214 
		}
215 
	};
216
217
218 
	/**
219 
	 * 为View绑定数据
220 
	 */
221 
	public void setDataView(){
222 
		path=Environment.getExternalStorageDirectory() + "/"+"test/photo/";
223 
		dir=new File(path);
224 
		if(!dir.exists())dir.mkdirs();
225 
		if (mImgDir == null){
226 
			Toast.makeText(getApplicationContext(), "一张图片没扫描到",Toast.LENGTH_SHORT).show();
227 
			return;
228 
		}
229
230 
		if(mImgDir.exists()){
231 
			mImgs = Arrays.asList(mImgDir.list());
232 
		}
233
234 
		//可以在此设置最大选择照片的数量
235 
		girdItemAdapter=new GirdItemAdapter(this, mImgs, mImgDir.getAbsolutePath(),10);
236 
		photoGrid.setAdapter(girdItemAdapter);
237 
		girdItemAdapter.setOnPhotoSelectedListener(new OnPhotoSelectedListener() {
238 
			@Override
239 
			public void takePhoto() {
240 
				imagename=getTimeName(System.currentTimeMillis())+".jpg";
241 
				String state = Environment.getExternalStorageState();
242 
				if (state.equals(Environment.MEDIA_MOUNTED)) {
243 
					Intent intent=new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
244 
					File f=new File(dir, imagename);//localTempImgDir和localTempImageFileName是自己定义的名字
245 
					Uri u=Uri.fromFile(f);
246 
					intent.putExtra(MediaStore.Images.Media.ORIENTATION, 0);
247 
					intent.putExtra(MediaStore.EXTRA_OUTPUT, u);
248 
					startActivityForResult(intent, TAKE_CAMERA_PICTURE);
249 
				} else {
250 
					Toast.makeText(SelectPhotoActivity.this, "请插入SD卡",Toast.LENGTH_SHORT).show();
251 
				}
252 
			}
253 
			@Override
254 
			public void photoClick(List<String> number) {
255 
				photoBtn.setText("下一步("+number.size() + "张)");
256 
			}
257 
		});
258 
	}
259 
	/**
260 
	 * 初始化展示文件夹的popupWindw
261 
	 */
262 
	private void initListDirPopupWindw(){
263 
		if(popupWindow==null){
264 
			dirview=LayoutInflater.from(SelectPhotoActivity.this).inflate(R.layout.image_select_dirlist, null);
265 
			dirListView=(ListView)dirview.findViewById(R.id.id_list_dirs);
266 
			popupWindow =new PopupWindow(dirview, LayoutParams.MATCH_PARENT, mScreenHeight*3/5);
267 
			floderAdapter=new ImageFloderAdapter(SelectPhotoActivity.this, mImageFloders);
268 
			dirListView.setAdapter(floderAdapter);
269 
		}
270 
		popupWindow.setFocusable(true);
271 
		popupWindow.setOutsideTouchable(true);
272 
		// 这个是为了点击“返回Back”也能使其消失，并且并不会影响你的背景
273 
		popupWindow.setBackgroundDrawable(new BitmapDrawable());
274 
		// 显示的位置为:屏幕的宽度的一半-PopupWindow的高度的一半
275 
		titleIcon.setBackgroundResource(R.drawable.navigationbar_arrow_up);
276 
		popupWindow.showAsDropDown(headLayout,0,0);
277 
		popupWindow.setOnDismissListener(new OnDismissListener() {
278 
			@Override
279 
			public void onDismiss() {
280 
				titleIcon.setBackgroundResource(R.drawable.navigationbar_arrow_down);
281 
			}
282 
		});
283 
		dirListView.setOnItemClickListener(new OnItemClickListener() {
284 
			@Override
285 
			public void onItemClick(AdapterView<?> parent, View view,
286 
					int position, long id) {
287 
				titleName.setText(mImageFloders.get(position).getName());
288 
				mImgDir = new File(mImageFloders.get(position).getDir());
289 
				mImgs = Arrays.asList(mImgDir.list(new FilenameFilter(){
290 
					@Override
291 
					public boolean accept(File dir, String filename)
292 
					{
293 
						if (filename.endsWith(".jpg") || filename.endsWith(".png")
294 
								|| filename.endsWith(".jpeg"))
295 
							return true;
296 
						return false;
297 
					}
298 
				}));
299 
				for (int i = 0; i < mImageFloders.size(); i++) {
300 
					mImageFloders.get(i).setSelected(false);
301 
				}
302 
				mImageFloders.get(position).setSelected(true);
303 
				floderAdapter.changeData(mImageFloders);
304 
				girdItemAdapter.changeData(mImgs, mImageFloders.get(position).getDir());
305 
				if(popupWindow!=null){
306 
					popupWindow.dismiss();
307 
				}
308 
			}
309 
		});
310
311 
	}
312
313 
	/**
314 
	 * 监听事件
315 
	 */
316 
	private void initEvent(){
317 
		quxiaoBtn.setOnClickListener(new OnClickListener() {
318 
			@Override
319 
			public void onClick(View v) {
320 
				// TODO Auto-generated method stub
321 
				finish();
322 
			}
323 
		});
324 
		/**
325 
		 * 为底部的布局设置点击事件，弹出popupWindow
326 
		 */
327 
		titleName.setOnClickListener(new OnClickListener(){
328 
			@Override
329 
			public void onClick(View v){
330 
				// 初始化展示文件夹的popupWindw
331 
				initListDirPopupWindw();
332 
			}
333 
		});
334 
		photoBtn.setOnClickListener(new OnClickListener() {
335 
			@Override
336 
			public void onClick(View v) {
337 
				Toast.makeText(SelectPhotoActivity.this, GirdItemAdapter.mSelectedImage.toString(), Toast.LENGTH_SHORT).show();
338 
			}
339 
		});
340 
	}
341 
	public static String getTimeName(long time){
342 
		SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
343 
		Date date = new Date(time);
344 
		return formatter.format(date);
345 
	}
346
347 
	@Override
348 
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
349 
		super.onActivityResult(requestCode, resultCode, data);
350 
		switch (requestCode) {
351 
		case TAKE_CAMERA_PICTURE:
352 
			Toast.makeText(this, path+imagename, Toast.LENGTH_SHORT).show();
353 
			break;
354 
		}
355 
	}
356 
}

+ 0 - 98
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/CommonAdapter.java
Parādīt failu 

@ -1,98 +0,0 @@
1 
package com.example.imageselected.photo.adapter;
2
3 
import java.util.ArrayList;
4 
import java.util.LinkedList;
5 
import java.util.List;
6
7 
import android.content.Context;
8 
import android.util.Log;
9 
import android.view.LayoutInflater;
10 
import android.view.View;
11 
import android.view.ViewGroup;
12 
import android.widget.BaseAdapter;
13
14 
import com.example.imageselected.R;
15
16
17 
public abstract class CommonAdapter<T> extends BaseAdapter
18 
{
19 
	final int VIEW_TYPE = 2;
20 
	final int TYPE_1 = 0;
21 
	final int TYPE_2 = 1;
22 
	protected LayoutInflater mInflater;
23 
	protected Context mContext;
24 
	protected List<T> mDatas;
25 
	private String mDirPath;
26 
	public CommonAdapter(Context context, List<T> mDatas)
27 
	{
28 
		this.mContext = context;
29 
		this.mInflater = LayoutInflater.from(mContext);
30 
		this.mDatas = mDatas;
31 
		this.mDirPath=mDirPath;
32 
	}
33 
	@Override
34 
	public int getCount()
35 
	{
36 
		return mDatas.size()+1;
37 
	}
38
39 
	@Override
40 
	public T getItem(int position)
41 
	{
42 
		return mDatas.get(position);
43 
	}
44
45 
	@Override
46 
	public long getItemId(int position)
47 
	{
48 
		return position;
49 
	}
50
51 
	@Override
52 
	public View getView(int position, View convertView, ViewGroup parent)
53 
	{
54 
		int type = getItemViewType(position);
55 
		final ViewHolder viewHolder = getViewHolder(position, convertView,
56 
				parent,type);
57 
		switch (type){
58 
			case TYPE_1:
59 
				convert(viewHolder, getItem(0),type);
60 
				break;
61 
			case TYPE_2:
62 
				convert(viewHolder, getItem(position-1),type);
63 
				break;
64 
		}
65 
		return viewHolder.getConvertView();
66
67 
	}
68 
	public int getItemViewType(int position) {
69 
		if(position==0){
70 
			return TYPE_1;
71 
		}else{
72 
			return TYPE_2;
73 
		}
74 
	}
75
76 
	@Override
77 
	public int getViewTypeCount() {
78 
		return VIEW_TYPE;
79 
	}
80
81 
	public abstract void convert(ViewHolder helper, T item,int type);
82
83 
	private ViewHolder getViewHolder(int position, View convertView,
84 
			ViewGroup parent,int type)
85 
	{	int mItemLayoutId= R.layout.grid_item;
86 
		switch (type){
87 
			case TYPE_1:
88 
				mItemLayoutId= R.layout.grid_item2;
89 
				break;
90 
			case TYPE_2:
91 
				mItemLayoutId=R.layout.grid_item;
92 
				break;
93 
		}
94 
		return ViewHolder.get(mContext, convertView, parent,mItemLayoutId ,
95 
				position);
96 
	}
97
98 
}

+ 0 - 116
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/GirdItemAdapter.java
Parādīt failu 

@ -1,116 +0,0 @@
1 
package com.example.imageselected.photo.adapter;
2
3 
import java.util.ArrayList;
4 
import java.util.LinkedList;
5 
import java.util.List;
6
7
8 
import android.annotation.SuppressLint;
9 
import android.content.Context;
10 
import android.graphics.Color;
11 
import android.util.Log;
12 
import android.view.LayoutInflater;
13 
import android.view.View;
14 
import android.view.ViewGroup;
15 
import android.view.View.OnClickListener;
16 
import android.widget.BaseAdapter;
17 
import android.widget.ImageButton;
18 
import android.widget.ImageView;
19 
import android.widget.LinearLayout;
20 
import android.widget.Toast;
21
22 
import com.example.imageselected.R;
23
24
25 
public class GirdItemAdapter extends CommonAdapter<String>{
26 
	private String mDirPath;
27 
	private  Context context;
28 
	public static List<String> mSelectedImage = new LinkedList<String>();
29 
	private int maxSize=5;
30 
	public GirdItemAdapter(Context context, List<String> mDatas,String mDirPath,int maxSize) {
31 
		super(context,mDatas);
32 
		this.maxSize=maxSize;
33 
		this.mDirPath=mDirPath;
34 
		this.context=context;
35 
	}
36 
	public void changeData(List<String> mDatas,String mDirPath){
37 
		this.mDatas = mDatas;
38 
		this.mDirPath=mDirPath;
39 
		notifyDataSetChanged();
40 
	}
41
42 
	@Override
43 
	public void convert(ViewHolder helper, String item,int type) {
44 
		switch (type) {
45 
			case TYPE_1:
46 
				final LinearLayout mImageView = helper.getView(R.id.id_item_image2);
47 
				mImageView.setOnClickListener(new OnClickListener() {
48 
					@Override
49 
					public void onClick(View v) {
50 
						onPhotoSelectedListener.takePhoto();
51 
					}
52 
				});
53 
				break;
54 
			case TYPE_2:
55 
				final ImageView myImageView = helper.getView(R.id.id_item_image);
56 
				final ImageButton myImageSelected = helper.getView(R.id.id_item_select);
57 
				myImageSelected.setImageResource(R.drawable.picture_unselected);
58 
				myImageView.setImageResource(R.drawable.pictures_no);
59 
				myImageView.setBackgroundResource(R.drawable.pictures_no);
60 
				helper.setImageByUrl(R.id.id_item_image,mDirPath + "/"+item);
61 
				myImageView.setColorFilter(null);
62 
				myImageView.setOnClickListener(new MyOnClickListener(helper,item));
63 
				if (mSelectedImage.contains(mDirPath + "/" + item)){
64 
					myImageSelected.setImageResource(R.drawable.pictures_selected);
65 
					myImageView.setColorFilter(Color.parseColor("#77000000"));
66 
				} else{
67 
					myImageSelected.setImageResource(R.drawable.picture_unselected);
68 
					myImageView.setColorFilter(Color.parseColor("#00000000"));
69 
				}
70 
				break;
71
72 
			default:
73 
				break;
74 
		}
75 
	}
76
77 
	class MyOnClickListener implements OnClickListener{
78 
		String item;
79 
		ViewHolder helper;
80 
		ImageView myitemImageView ;
81 
		ImageButton myitemImageSelected;
82 
		MyOnClickListener(ViewHolder helper,String item){
83 
			this.item=item;
84 
			this.helper=helper;
85 
			myitemImageSelected=helper.getView(R.id.id_item_select);
86 
			myitemImageView= helper.getView(R.id.id_item_image);
87 
		}
88 
		@Override
89 
		public void onClick(View v) {
90 
			if (mSelectedImage.contains(mDirPath + "/" + item)){
91 
				mSelectedImage.remove(mDirPath + "/" + item);
92 
				myitemImageSelected.setImageResource( R.drawable.picture_unselected);
93 
				myitemImageView.setColorFilter(null);
94 
			} else{
95 
				if(mSelectedImage.size()>=maxSize){
96 
					Toast.makeText(context, "最多上传"+maxSize+"张", Toast.LENGTH_SHORT).show();
97 
					return ;
98 
				}
99 
				mSelectedImage.add(mDirPath + "/" + item);
100 
				myitemImageSelected.setImageResource( R.drawable.pictures_selected);
101 
				myitemImageView.setColorFilter(Color.parseColor("#77000000"));
102 
			}
103 
			onPhotoSelectedListener.photoClick(mSelectedImage);
104 
		}
105
106 
	}
107 
	public OnPhotoSelectedListener onPhotoSelectedListener;
108 
	public void setOnPhotoSelectedListener(OnPhotoSelectedListener onPhotoSelectedListener){
109 
		this.onPhotoSelectedListener=onPhotoSelectedListener;
110 
	}
111 
	public  interface OnPhotoSelectedListener{
112 
		public void photoClick(List<String> number);
113 
		public void takePhoto();
114 
	}
115
116 
}

+ 0 - 89
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/ImageFloderAdapter.java
Parādīt failu 

@ -1,89 +0,0 @@
1 
package com.example.imageselected.photo.adapter;
2
3 
import java.util.List;
4
5 
import com.example.imageselected.R;
6 
import com.example.imageselected.photo.ImageFloder;
7 
import com.example.imageselected.photo.ImageLoader;
8 
import com.example.imageselected.photo.ImageLoader.Type;
9
10 
import android.content.Context;
11 
import android.view.LayoutInflater;
12 
import android.view.View;
13 
import android.view.ViewGroup;
14 
import android.widget.BaseAdapter;
15 
import android.widget.ImageView;
16 
import android.widget.RelativeLayout;
17 
import android.widget.TextView;
18 
/**
19 
 * Ïà²áÁбíÀà
20 
 * @author Administrator
21 
 *
22 
 */
23 
public class ImageFloderAdapter extends BaseAdapter{
24 
	private Context context;
25 
	private List<ImageFloder> list;
26
27 
	public ImageFloderAdapter(Context context, List<ImageFloder> list) {
28 
		super();
29 
		this.context = context;
30 
		this.list = list;
31 
	}
32
33 
	public void changeData(List<ImageFloder> list){
34 
		this.list=list;
35 
		notifyDataSetChanged();
36 
	}
37 
	@Override
38 
	public int getCount() {
39 
		// TODO Auto-generated method stub
40 
		return list.size();
41 
	}
42
43 
	@Override
44 
	public ImageFloder getItem(int position) {
45 
		// TODO Auto-generated method stub
46 
		return list.get(position);
47 
	}
48
49 
	@Override
50 
	public long getItemId(int position) {
51 
		// TODO Auto-generated method stub
52 
		return position;
53 
	}
54
55 
	@Override
56 
	public View getView(int position, View convertView, ViewGroup parent) {
57 
		ViewHolder holder=null;
58 
		if(convertView==null){
59 
			convertView=LayoutInflater.from(context).inflate(R.layout.list_dir_item, null);
60 
			holder=new ViewHolder();
61 
			holder.dirItemIcon=(ImageView)convertView.findViewById(R.id.id_dir_choose);
62 
			holder.dirItemImage=(ImageView)convertView.findViewById(R.id.id_dir_item_image);
63 
			holder.dirItemName=(TextView)convertView.findViewById(R.id.id_dir_item_name);
64 
			holder.dirItemNum=(TextView)convertView.findViewById(R.id.id_dir_item_count);
65 
			convertView.setTag(holder);
66 
		}else{
67 
			holder=(ViewHolder) convertView.getTag();
68 
		}
69 
		ImageLoader.getInstance(3,Type.LIFO).loadImage(list.get(position).getFirstImagePath(), holder.dirItemImage);
70 
		holder.dirItemName.setText(list.get(position).getName());
71 
		holder.dirItemNum.setText(list.get(position).getCount()+"ÕÅ");
72 
		if(list.get(position).isSelected())
73 
			holder.dirItemIcon.setVisibility(View.VISIBLE);
74 
		else
75 
			holder.dirItemIcon.setVisibility(View.INVISIBLE);
76 
		return convertView;
77 
	}
78
79 
	class ViewHolder{
80 
		ImageView dirItemImage;
81 
		TextView dirItemName;
82 
		TextView dirItemNum;
83 
		ImageView dirItemIcon;
84 
		RelativeLayout listdirLayout;
85 
	}
86
87
88
89 
}

+ 0 - 126
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/java/com/example/imageselected/photo/adapter/ViewHolder.java
Parādīt failu 

@ -1,126 +0,0 @@
1 
package com.example.imageselected.photo.adapter;
2
3 
import android.content.Context;
4 
import android.graphics.Bitmap;
5 
import android.util.SparseArray;
6 
import android.view.LayoutInflater;
7 
import android.view.View;
8 
import android.view.ViewGroup;
9 
import android.widget.ImageView;
10 
import android.widget.TextView;
11
12 
import com.example.imageselected.photo.ImageLoader;
13
14
15 
public class ViewHolder
16 
{
17 
	private final SparseArray<View> mViews;
18 
	private int mPosition;
19 
	private View mConvertView;
20
21 
	private ViewHolder(Context context, ViewGroup parent, int layoutId,
22 
			int position)
23 
	{
24 
		this.mPosition = position;
25 
		this.mViews = new SparseArray<View>();
26 
		mConvertView = LayoutInflater.from(context).inflate(layoutId, parent,
27 
				false);
28 
		// setTag
29 
		mConvertView.setTag(this);
30 
	}
31
32 
	/**
33 
	 * 拿到一个ViewHolder对象
34 
	 *
35 
	 * @param context
36 
	 * @param convertView
37 
	 * @param parent
38 
	 * @param layoutId
39 
	 * @param position
40 
	 * @return
41 
	 */
42 
	public static ViewHolder get(Context context, View convertView,
43 
			ViewGroup parent, int layoutId, int position)
44 
	{
45 
		ViewHolder holder = null;
46 
		if (convertView == null)
47 
		{
48 
			holder = new ViewHolder(context, parent, layoutId, position);
49 
		} else
50 
		{
51 
			holder = (ViewHolder) convertView.getTag();
52 
			holder.mPosition = position;
53 
		}
54 
		return holder;
55 
	}
56
57 
	public View getConvertView()
58 
	{
59 
		return mConvertView;
60 
	}
61
62 
	/**
63 
	 * 通过控件的Id获取对于的控件，如果没有则加入views
64 
	 *
65 
	 * @param viewId
66 
	 * @return
67 
	 */
68 
	public <T extends View> T getView(int viewId)
69 
	{
70 
		View view = mViews.get(viewId);
71 
		if (view == null)
72 
		{
73 
			view = mConvertView.findViewById(viewId);
74 
			mViews.put(viewId, view);
75 
		}
76 
		return (T) view;
77 
	}
78
79
80
81 
	/**
82 
	 * 为ImageView设置图片
83 
	 *
84 
	 * @param viewId
85 
	 * @param drawableId
86 
	 * @return
87 
	 */
88 
	public ViewHolder setImageResource(int viewId, int drawableId)
89 
	{
90 
		ImageView view = getView(viewId);
91 
		view.setImageResource(drawableId);
92
93 
		return this;
94 
	}
95
96 
	/**
97 
	 * 为ImageView设置图片
98 
	 *
99 
	 * @param viewId
100 
	 * @return
101 
	 */
102 
	public ViewHolder setImageBitmap(int viewId, Bitmap bm)
103 
	{
104 
		ImageView view = getView(viewId);
105 
		view.setImageBitmap(bm);
106 
		return this;
107 
	}
108
109 
	/**
110 
	 * 为ImageView设置图片
111 
	 *
112 
	 * @param viewId
113 
	 * @return
114 
	 */
115 
	public ViewHolder setImageByUrl(int viewId, String url)
116 
	{
117 
		ImageLoader.getInstance(3, ImageLoader.Type.LIFO).loadImage(url, (ImageView) getView(viewId));
118 
		return this;
119 
	}
120
121 
	public int getPosition()
122 
	{
123 
		return mPosition;
124 
	}
125
126 
}

BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-hdpi/ic_launcher.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-mdpi/ic_launcher.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph1.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph_highlighted.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/compose_photo_photograph_highlighted1.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/dir_choose.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/ic_launcher.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/navigationbar_arrow_down.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/navigationbar_arrow_up.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pic_dir.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/picture_unselected.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pictures_no.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xhdpi/pictures_selected.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xxhdpi/dir_choose.png
Parādīt failu


BIN
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable-xxhdpi/ic_launcher.png
Parādīt failu


+ 0 - 8
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable/photo_btn_selector.xml
Parādīt failu 

@ -1,8 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<selector xmlns:android="http://schemas.android.com/apk/res/android">
3
4 
    <item android:state_pressed="true" android:drawable="@drawable/compose_photo_photograph_highlighted"></item>
5 
    <item android:state_pressed="false"  android:drawable="@drawable/compose_photo_photograph"></item>
6 
    <item android:drawable="@drawable/compose_photo_photograph"></item>
7
8 
</selector>

+ 0 - 30
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/drawable/photo_select_btn_selector.xml
Parādīt failu 

@ -1,30 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<selector xmlns:android="http://schemas.android.com/apk/res/android">
3
4 
    <item android:state_pressed="true" android:state_enabled="true"><shape>
5 
            <corners android:radius="6dip" />
6
7 
            <solid android:color="#E56311" />
8 
        </shape></item>
9 
    <item android:state_pressed="false" android:state_enabled="true"><shape>
10 
            <corners android:radius="6dip" />
11
12 
            <solid android:color="#F78A00" />
13 
        </shape></item>
14 
    <item><shape>
15 
            <corners android:radius="6dip" />
16
17 
            <solid android:color="#F78A00" />
18 
        </shape></item>
19 
    <item android:state_enabled="false"><shape>
20 
            <corners android:radius="6dip" />
21
22 
            <solid android:color="#FFFFFF" />
23 
        </shape></item>
24 
    <item android:state_enabled="true"><shape>
25 
            <corners android:radius="6dip" />
26
27 
            <solid android:color="#F78A00" />
28 
        </shape></item>
29
30 
</selector>

+ 0 - 16
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/activity_main.xml
Parādīt failu 

@ -1,16 +0,0 @@
1 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
2 
    xmlns:tools="http://schemas.android.com/tools"
3 
    android:layout_width="match_parent"
4 
    android:layout_height="match_parent"
5 
    android:paddingBottom="@dimen/activity_vertical_margin"
6 
    android:paddingLeft="@dimen/activity_horizontal_margin"
7 
    android:paddingRight="@dimen/activity_horizontal_margin"
8 
    android:paddingTop="@dimen/activity_vertical_margin"
9 
    tools:context="com.example.imageselected.MainActivity" >
10
11 
    <TextView
12 
        android:layout_width="wrap_content"
13 
        android:layout_height="wrap_content"
14 
        android:text="@string/hello_world" />
15
16 
</RelativeLayout>

+ 0 - 25
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/grid_item.xml
Parādīt failu 

@ -1,25 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:layout_width="fill_parent"
4 
    android:layout_height="fill_parent" >
5
6 
    <ImageView
7 
        android:id="@+id/id_item_image"
8 
        android:layout_width="fill_parent"
9 
        android:layout_height="120dp"
10 
        android:background="@drawable/pictures_no"
11 
        android:scaleType="centerCrop" />
12
13 
    <ImageButton
14 
        android:id="@+id/id_item_select"
15 
        android:clickable="false"
16 
        android:layout_width="wrap_content"
17 
        android:layout_height="wrap_content"
18 
        android:layout_alignParentRight="true"
19 
        android:layout_alignParentTop="true"
20 
        android:layout_marginRight="3dp"
21 
        android:layout_marginTop="3dp"
22 
        android:background="@null"
23 
        android:src="@drawable/pictures_selected" />
24
25 
</RelativeLayout>

+ 0 - 22
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/grid_item2.xml
Parādīt failu 

@ -1,22 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:layout_width="fill_parent"
4 
    android:layout_height="fill_parent" >
5
6 
    <LinearLayout
7 
        android:orientation="horizontal"
8 
        android:gravity="center"
9 
         android:id="@+id/id_item_image2"
10 
        android:layout_width="match_parent"
11 
        android:layout_height="120dp" >
12
13 
        <ImageView
14 
            android:layout_width="wrap_content"
15 
            android:layout_gravity="center"
16 
            android:layout_height="wrap_content"
17 
            android:background="@drawable/photo_btn_selector"
18 
            android:scaleType="centerCrop" />
19
20 
    </LinearLayout>
21
22 
</RelativeLayout>

+ 0 - 17
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/image_select_dirlist.xml
Parādīt failu 

@ -1,17 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:layout_width="match_parent"
4 
    android:layout_height="wrap_content"
5 
    android:visibility="visible"
6 
    android:background="#a0ffffff" >
7
8 
    <ListView
9 
        android:id="@+id/id_list_dirs"
10 
        android:layout_width="fill_parent"
11 
        android:layout_height="match_parent"
12 
        android:divider="#EEE3D9"
13 
        android:background="#a0ffffff"
14 
        android:dividerHeight="1px" >
15 
    </ListView>
16
17 
</LinearLayout>

+ 0 - 56
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/list_dir_item.xml
Parādīt failu 

@ -1,56 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:layout_width="fill_parent"
4 
    android:layout_height="wrap_content"
5 
    android:id="@+id/list_dir_layout"
6 
    android:padding="5dp" >
7
8 
    <ImageView
9 
        android:id="@+id/id_dir_item_image"
10 
        android:layout_width="100dp"
11 
        android:layout_height="100dp"
12 
        android:layout_alignParentLeft="true"
13 
        android:layout_centerVertical="true"
14 
        android:background="@drawable/pic_dir"
15 
        android:paddingBottom="17dp"
16 
        android:paddingLeft="12dp"
17 
        android:paddingRight="12dp"
18 
        android:paddingTop="9dp"
19 
        android:scaleType="fitXY"
20 
        android:src="@drawable/ic_launcher" />
21
22 
    <LinearLayout
23 
        android:layout_width="wrap_content"
24 
        android:layout_height="wrap_content"
25 
        android:layout_centerVertical="true"
26 
        android:layout_marginLeft="10dp"
27 
        android:layout_toRightOf="@id/id_dir_item_image"
28 
        android:orientation="vertical" >
29
30 
        <TextView
31 
            android:id="@+id/id_dir_item_name"
32 
            android:layout_width="wrap_content"
33 
            android:layout_height="wrap_content"
34 
            android:text="所有图片"
35 
            android:textSize="10sp" />
36
37 
        <TextView
38 
            android:id="@+id/id_dir_item_count"
39 
            android:layout_width="wrap_content"
40 
            android:layout_height="wrap_content"
41 
            android:layout_gravity="center"
42 
            android:text="4723张"
43 
            android:textColor="#444"
44 
            android:textSize="8sp" />
45 
    </LinearLayout>
46
47 
    <ImageView
48 
        android:id="@+id/id_dir_choose"
49 
        android:layout_width="wrap_content"
50 
        android:layout_height="wrap_content"
51 
        android:layout_alignParentRight="true"
52 
        android:layout_centerVertical="true"
53 
        android:layout_marginRight="20dp"
54 
        android:src="@drawable/dir_choose" />
55
56 
</RelativeLayout>

+ 0 - 52
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/photo_select_view.xml
Parādīt failu 

@ -1,52 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:layout_width="match_parent"
4 
    android:layout_height="match_parent"
5 
    android:orientation="vertical" >
6
7 
    <include layout="@layout/select_photo_header" />
8
9 
    <LinearLayout
10 
        android:layout_width="match_parent"
11 
        android:layout_height="wrap_content"
12 
        android:layout_weight="1"
13 
        android:orientation="vertical" >
14
15 
        <GridView
16 
            android:id="@+id/gird_photo_list"
17 
            android:layout_width="match_parent"
18 
            android:layout_height="wrap_content"
19 
            android:horizontalSpacing="5dp"
20 
            android:verticalSpacing="5dp"
21 
            android:numColumns="3" >
22 
        </GridView>
23 
    </LinearLayout>
24
25 
    <TextView
26 
        android:id="@+id/textView4"
27 
        android:layout_width="match_parent"
28 
        android:layout_height="0.5dip"
29 
        android:background="@color/gray"
30 
        android:text="TextView" />
31
32 
    <LinearLayout
33 
        android:layout_width="match_parent"
34 
        android:layout_gravity="center_vertical"
35 
        android:gravity="right"
36 
        android:layout_height="50dp" >
37
38 
        <Button
39 
            android:id="@+id/selected_photo_btn"
40 
            android:layout_width="wrap_content"
41 
            android:layout_height="35dp"
42 
            android:paddingLeft="10dp"
43 
            android:paddingRight="10dp"
44 
            android:textSize="12sp"
45 
            android:layout_gravity="center_vertical"
46 
            android:layout_marginRight="10dp"
47 
            android:textColor="@color/white"
48 
            android:background="@drawable/photo_select_btn_selector"
49 
            android:text="下一步" />
50 
    </LinearLayout>
51
52 
</LinearLayout>

+ 0 - 76
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/layout/select_photo_header.xml
Parādīt failu 

@ -1,76 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 
    android:id="@+id/selected_photo_header_layout"
4 
    android:layout_width="match_parent"
5 
    android:layout_height="wrap_content"
6 
    android:orientation="vertical"
7 
    android:visibility="visible" >
8
9
10 
    <LinearLayout
11 
        android:id="@+id/header_layout"
12 
        android:layout_width="match_parent"
13 
        android:layout_height="wrap_content"
14 
        android:background="@color/white"
15 
        android:orientation="vertical" >
16
17 
        <LinearLayout
18 
            android:layout_width="match_parent"
19 
            android:layout_height="45dp" >
20
21 
            <TextView
22 
                android:id="@+id/quxiao_btn"
23 
                android:layout_width="wrap_content"
24 
                android:layout_height="wrap_content"
25 
                android:layout_gravity="center"
26 
                android:layout_marginLeft="5dp"
27 
                android:gravity="center"
28 
                android:text=""
29 
                android:textColor="@color/orange_text" />
30
31 
            <LinearLayout
32 
                android:layout_width="0dp"
33 
                android:layout_height="match_parent"
34 
                android:layout_gravity="center"
35 
                android:layout_weight="1"
36 
                android:gravity="center" >
37
38 
                <TextView
39 
                    android:id="@+id/selected_photo_name_text"
40 
                    android:layout_width="wrap_content"
41 
                    android:layout_height="match_parent"
42 
                    android:layout_marginRight="5dp"
43 
                    android:ellipsize="end"
44 
                    android:gravity="center"
45 
                    android:singleLine="true"
46 
                    android:text="相机胶卷"
47 
                    android:textSize="16sp" />
48
49 
                <ImageView
50 
                    android:id="@+id/selected_photo_icon"
51 
                    android:layout_width="wrap_content"
52 
                    android:layout_height="wrap_content"
53 
                    android:layout_gravity="center"
54 
                    android:gravity="center" />
55 
            </LinearLayout>
56
57 
            <TextView
58 
                android:id="@+id/textView3"
59 
                android:layout_width="wrap_content"
60 
                android:layout_height="wrap_content"
61 
                android:layout_gravity="center"
62 
                android:layout_marginRight="5dp"
63 
                android:gravity="center"
64 
                android:text="确定"
65 
                android:visibility="invisible" />
66 
        </LinearLayout>
67
68 
        <TextView
69 
            android:id="@+id/textView4"
70 
            android:layout_width="match_parent"
71 
            android:layout_height="0.5dip"
72 
            android:background="@color/gray"
73 
            android:text="TextView" />
74 
    </LinearLayout>
75
76 
</RelativeLayout>

+ 0 - 12
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/menu/main.xml
Parādīt failu 

@ -1,12 +0,0 @@
1 
<menu xmlns:android="http://schemas.android.com/apk/res/android"
2 
    xmlns:app="http://schemas.android.com/apk/res-auto"
3 
    xmlns:tools="http://schemas.android.com/tools"
4 
    tools:context="com.example.imageselected.MainActivity" >
5
6 
    <item
7 
        android:id="@+id/action_settings"
8 
        android:orderInCategory="100"
9 
        android:title="@string/action_settings"
10 
        app:showAsAction="never"/>
11
12 
</menu>

+ 0 - 11
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-v11/styles.xml
Parādīt failu 

@ -1,11 +0,0 @@
1 
<resources>
2
3 
    <!--
4 
        Base application theme for API 11+. This theme completely replaces
5 
        AppBaseTheme from res/values/styles.xml on API 11+ devices.
6 
    -->
7 
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light">
8 
        <!-- API 11 theme customizations can go here. -->
9 
    </style>
10
11 
</resources>

+ 0 - 12
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-v14/styles.xml
Parādīt failu 

@ -1,12 +0,0 @@
1 
<resources>
2
3 
    <!--
4 
        Base application theme for API 14+. This theme completely replaces
5 
        AppBaseTheme from BOTH res/values/styles.xml and
6 
        res/values-v11/styles.xml on API 14+ devices.
7 
    -->
8 
    <style name="AppBaseTheme" parent="Theme.AppCompat.Light.DarkActionBar">
9 
        <!-- API 14 theme customizations can go here. -->
10 
    </style>
11
12 
</resources>

+ 0 - 10
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values-w820dp/dimens.xml
Parādīt failu 

@ -1,10 +0,0 @@
1 
<resources>
2
3 
    <!--
4 
         Example customization of dimensions originally defined in res/values/dimens.xml
5 
         (such as screen margins) for screens with more than 820dp of available width. This
6 
         would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively).
7 
    -->
8 
    <dimen name="activity_horizontal_margin">64dp</dimen>
9
10 
</resources>

+ 0 - 27
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/colors.xml
Parādīt failu 

@ -1,27 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<resources>
3 
   <color name="gray">#AFAFAF</color>
4 
    <color name="orange">#CC6600</color>
5 
    <color name="pink">#FFE6E6</color>
6 
    <color name="yellow">#F99503</color>
7 
    <color name="blue">#00AED6</color>
8 
    <color name="white">#FFFFFF</color>
9 
    <color name="red">#D80000</color>
10 
    <color name="black">#000000</color>
11
12
13 
     <color name="common_orange_color">#ff601e</color>
14 
    <color name="common_orange_pressed_color">#ea4500</color>
15 
    <color name="common_white_color">#ffffff</color>
16
17 
    <color name="common_dark_grey_text_color">#7c7c7c</color>
18 
    <color name="common_light_grey_text_color">#969696</color>
19 
    <color name="btn_gray_normal">#c0c0c0</color>
20 
    <color name="orange_text">#F78A00</color>
21
22
23 
    <!-- actiondialog-->
24 
    <color name="ui_action_dialog_gray">#e0e6e6e6</color>
25 
    <color name="ui_action_dialog_color">#e0ffffff</color>
26 
    <color name="ui_action_dialog_textviewcolor">#0048fc</color>
27 
</resources>

+ 0 - 7
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/dimens.xml
Parādīt failu 

@ -1,7 +0,0 @@
1 
<resources>
2
3 
    <!-- Default screen margins, per the Android Design guidelines. -->
4 
    <dimen name="activity_horizontal_margin">16dp</dimen>
5 
    <dimen name="activity_vertical_margin">16dp</dimen>
6
7 
</resources>

+ 0 - 8
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/strings.xml
Parādīt failu 

@ -1,8 +0,0 @@
1 
<?xml version="1.0" encoding="utf-8"?>
2 
<resources>
3
4 
    <string name="app_name">ImageSelected</string>
5 
    <string name="hello_world">Hello world!</string>
6 
    <string name="action_settings">Settings</string>
7
8 
</resources>

+ 0 - 8
app/src/main/res/drawable-xhdpi/╥бн╒пем╪ф╛╡╩╢Мбр/ImageSelected1/app/src/main/res/values/styles.xml
Parādīt failu 

@ -1,8 +0,0 @@
1 
<resources>
2
3 
    <!-- Base application theme. -->
4 
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
5 
        <!-- Customize your theme here. -->
6 
    </style>
7
8 
</resources>