//        webView.setWebChromeClient(((H5Activity) mContext).mOpenFileWebChromeClient);
155
156 129
        webView.getSettings().setDomStorageEnabled(true);
157 130
158 131
        webView.setWebViewClient(new WebViewClient() {
@ -734,6 +707,240 @@ public class HomeWebActivity extends Activity implements View.OnClickListener, P
734 707
        super.onPause();
735 708
        MobclickAgent.onPause(this);
736 709
    }
710
    @Override
711
    public void onRequestPermissionsResult(int requestCode,
712
                                           @NonNull String[] permissions,
713
                                           @NonNull int[] grantResults) {
714
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
715
716
        // EasyPermissions handles the request result.
717
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
718
    }
719
720
    @Override
721
    public void onPermissionsGranted(int requestCode, List<String> perms) {
722
723
    }
724
725
    @Override
726
    public void onPermissionsDenied(int requestCode, List<String> perms) {
727
728
    }
729
730
    public class OpenFileWebChromeClient extends WebChromeClient {
731
        public static final int REQUEST_FILE_PICKER = 1;
732
        public ValueCallback<Uri> mFilePathCallback;
733
        public ValueCallback<Uri[]> mFilePathCallbacks;
734
        Activity mContext;
735
736
        public OpenFileWebChromeClient(Activity mContext) {
737
            super();
738
            this.mContext = mContext;
739
        }
740
741
        @Override
742
        public void onReceivedTitle(WebView view, String title) {
743
            super.onReceivedTitle(view, title);
744
            Log.d("ANDROID_LAB", "TITLE=" + title);
745
            txtTitle.setText(title);
746
        }
747
748
        @Override
749
        public void onProgressChanged(WebView view, int newProgress) {
750
            super.onProgressChanged(view, newProgress);
751
//            pb_webBar.setProgress(newProgress);
752
        }
753
754
        @Override
755
        public void onGeolocationPermissionsShowPrompt(String origin,
756
                                                       GeolocationPermissions.Callback callback) {
757
            callback.invoke(origin, true, false);
758
            // TODO Auto-generated method stub
759
            super.onGeolocationPermissionsShowPrompt(origin, callback);
760
        }
761
762
        // Android < 3.0 调用这个方法
763
        public void openFileChooser(ValueCallback<Uri> filePathCallback) {
764
            mFilePathCallback = filePathCallback;
765
            permissionTask();
766
        }
767
768
        // 3.0 + 调用这个方法
769
        public void openFileChooser(ValueCallback filePathCallback, String acceptType) {
770
            mFilePathCallback = filePathCallback;
771
            permissionTask();
772
        }
773
774
        // / js上传文件的<input type="file" name="fileField" id="fileField" />事件捕获
775
        // Android > 4.1.1 调用这个方法
776
        public void openFileChooser(ValueCallback<Uri> filePathCallback, String acceptType, String capture) {
777
            mFilePathCallback = filePathCallback;
778
            permissionTask();
779
        }
780
781
        @Override
782
        public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback, FileChooserParams fileChooserParams) {
783
            mFilePathCallbacks = filePathCallback;
784
            permissionTask();
785
            return true;
786
        }
787
    }
788
789
    @AfterPermissionGranted(RC_ALBUM_PERM)
790
    public void permissionTask() {
791
        if (isPermissionOK()) {
792
            openImageChooserActivity();
793
        } else {
794
            EasyPermissions.requestPermissions(
795
                    this, "充电桩想要获取您的图片读取权限,是否允许?",
796
                    RC_ALBUM_PERM,
797
                    Manifest.permission.CAMERA,
798
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
799
                    Manifest.permission.READ_EXTERNAL_STORAGE);
800
        }
801
    }
802
803
    private boolean isPermissionOK() {
804
        return EasyPermissions.hasPermissions(this,
805
                Manifest.permission.WRITE_EXTERNAL_STORAGE,
806
                Manifest.permission.READ_EXTERNAL_STORAGE,
807
                Manifest.permission.CAMERA
808
        );
809
    }
810
811
    private void openImageChooserActivity() {
812
        new MaterialDialog.Builder(this).items(R.array.photo).positiveText("取消")
813
                .onPositive(new MaterialDialog.SingleButtonCallback() {
814
                    @Override
815
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
816
                        if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
817
                            mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(null);
818
                            mOpenFileWebChromeClient.mFilePathCallbacks = null;
819
                        }
820
821
                        if (mOpenFileWebChromeClient.mFilePathCallback != null) {
822
                            mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(null);
823
                            mOpenFileWebChromeClient.mFilePathCallback = null;
824
                        }
825
                        dialog.dismiss();
826
                    }
827
                }).cancelable(false)
828
                .canceledOnTouchOutside(false).itemsCallback(new MaterialDialog.ListCallback() {
829
            @Override
830
            public void onSelection(MaterialDialog dialog, View itemView, int position, CharSequence text) {
831
                if (position == 0){
832
                    takeCamera();
833
                } else if (position == 1) {
834
                    takePhoto();
835
                }
836
            }
837
        }).show();
838
    }
839
840
    // 选择图片
841
    private void takePhoto() {
842
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
843
        intent.addCategory(Intent.CATEGORY_OPENABLE);
844
        intent.setType("image/*");
845
        startActivityForResult(Intent.createChooser(intent, "Image Choose"), FILE_CHOOSER_RESULT_CODE);
846
    }
847
848
    // 拍照
849
    private void takeCamera() {
850
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
851
        if (ImageUitl.hasSdcard()) {
852
            String fileName = "android" + System.currentTimeMillis() / 1000 + ".jpg";
853
            cameraFilePath = ImageUitl.getPath(Environment.getExternalStorageDirectory() + "/" + "cdz") + "/" + fileName;
854
            File imageFile = ImageUitl.getFile(cameraFilePath);
855
            Uri uri = parseUri(imageFile);
856
            intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
857
            try{
858
                startActivityForResult(intent, FILE_CAMERA_RESULT_CODE);
859
            } catch (Exception e) {
860
                e.printStackTrace();
861
            }
862
863
        }
864
    }
865
866
    private Uri parseUri(File cameraFile) {
867
        Uri imageUri;
868
        String authority = getPackageName() + ".provider";
869
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
870
            //通过FileProvider创建一个content类型的Uri
871
            imageUri = FileProvider.getUriForFile(getApplicationContext(), authority, cameraFile);
872
        } else {
873
            imageUri = Uri.fromFile(cameraFile);
874
        }
875
        return imageUri;
876
    }
877
878
    @Override
879
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
880
        super.onActivityResult(requestCode, resultCode, data);
881
        if (null == mOpenFileWebChromeClient.mFilePathCallback && null == mOpenFileWebChromeClient.mFilePathCallbacks) return;
882
        if (resultCode != RESULT_OK) {
883
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
884
                mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(null);
885
                mOpenFileWebChromeClient.mFilePathCallbacks = null;
886
            }
887
888
            if (mOpenFileWebChromeClient.mFilePathCallback != null) {
889
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(null);
890
                mOpenFileWebChromeClient.mFilePathCallback = null;
891
            }
892
            return;
893
        }
894
895
        Uri result = null;
896
        if (requestCode == FILE_CAMERA_RESULT_CODE) {
897
            if (null != data && null != data.getData()) {
898
                result = data.getData();
899
            }
900
            if (result == null && ImageUitl.hasFile(cameraFilePath)) {
901
                result = Uri.fromFile(new File(cameraFilePath));
902
            }
903
904
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
905
                mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(new Uri[]{result});
906
                mOpenFileWebChromeClient.mFilePathCallbacks = null;
907
            } else if (mOpenFileWebChromeClient.mFilePathCallback != null) {
908
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(result);
909
                mOpenFileWebChromeClient.mFilePathCallback = null;
910
            }
911
        } else if (requestCode == FILE_CHOOSER_RESULT_CODE) {
912
            if (data != null) {
913
                result = data.getData();
914
            }
915
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
916
                onActivityResultCallbacks(data);
917
            } else if (mOpenFileWebChromeClient.mFilePathCallback != null) {
918
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(result);
919
                mOpenFileWebChromeClient.mFilePathCallback = null;
920
            }
921
        }
922
    }
923
924
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
925
    private void onActivityResultCallbacks(Intent intent) {
926
        Uri[] results = null;
927
        if (intent != null) {
928
            String dataString = intent.getDataString();
929
            ClipData clipData = intent.getClipData();
930
            if (clipData != null) {
931
                results = new Uri[clipData.getItemCount()];
932
                for (int i=0;i<clipData.getItemCount();i++) {
933
                    ClipData.Item item = clipData.getItemAt(i);
934
                    results[i] = item.getUri();
935
                }
936
            }
937
            if (dataString != null) {
938
                results = new Uri[] {Uri.parse(dataString)};
939
            }
940
            mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(results);
941
            mOpenFileWebChromeClient.mFilePathCallbacks = null;
942
        }
943
    }
737 944
738 945
739 946
}

+ 2 - 0
app/src/main/java/com/electric/chargingpile/activity/MainMapActivity.java

@ -5548,6 +5548,8 @@ public class MainMapActivity extends Activity implements LocationSource, AMapLoc
5548 5548
                            } else {
5549 5549
                                url = MainApplication.list_addetail.get(result).getUrl() + "?cdzshareid=" + MainApplication.list_addetail.get(result).getId();
5550 5550
                            }
5551
//                            url = "http://192.168.1.104:8000/";
5552
//                            url = "https://www.d1ev.com/special/t/application.html?s=JUU1JUE1JTg3JUU3JTkxJTlFJUU1JUIwJThGJUU4JTlBJTgyJUU4JTlBJTgxLCVFNiVBQyVBNyVFNiU4QiU4OVIxLCVFNSU4QyU5NyVFNiVCMSVCREVDMw==";
5551 5553
5552 5554
//                                intent_text,intent_icon,intent_title,intent_url;
5553 5555
                            intent145.putExtra("url", url);

+ 187 - 60
app/src/main/java/com/electric/chargingpile/activity/MyWebViewActivity.java

@ -16,7 +16,11 @@ import android.net.Uri;
16 16
import android.net.http.SslError;
17 17
import android.os.Build;
18 18
import android.os.Bundle;
19
import android.os.Environment;
19 20
import android.os.Handler;
21
import android.provider.MediaStore;
22
import android.support.annotation.NonNull;
23
import android.support.v4.content.FileProvider;
20 24
import android.util.Log;
21 25
import android.view.KeyEvent;
22 26
import android.view.View;
@ -27,6 +31,7 @@ import android.webkit.SslErrorHandler;
27 31
import android.webkit.ValueCallback;
28 32
import android.webkit.WebBackForwardList;
29 33
import android.webkit.WebChromeClient;
34
import android.webkit.WebSettings;
30 35
import android.webkit.WebView;
31 36
import android.webkit.WebViewClient;
32 37
import android.widget.ImageView;
@ -35,6 +40,8 @@ import android.widget.RelativeLayout;
35 40
import android.widget.TextView;
36 41
import android.widget.Toast;
37 42
43
import com.afollestad.materialdialogs.DialogAction;
44
import com.afollestad.materialdialogs.MaterialDialog;
38 45
import com.blankj.utilcode.util.LogUtils;
39 46
import com.electric.chargingpile.R;
40 47
import com.electric.chargingpile.application.MainApplication;
@ -43,6 +50,7 @@ import com.electric.chargingpile.data.User;
43 50
import com.electric.chargingpile.manager.ProfileManager;
44 51
import com.electric.chargingpile.util.BarColorUtil;
45 52
import com.electric.chargingpile.util.DES3;
53
import com.electric.chargingpile.util.ImageUitl;
46 54
import com.electric.chargingpile.util.JsonUtils;
47 55
import com.electric.chargingpile.util.MediaUtility;
48 56
import com.electric.chargingpile.util.ToastUtil;
@ -95,6 +103,11 @@ public class MyWebViewActivity extends Activity implements PlatformActionListene
95 103
    private android.view.animation.Animation animation;
96 104
    private static final int RC_CALL_PERM = 123;
97 105
106
    private static final int RC_ALBUM_PERM = 127;
107
    private final static int FILE_CHOOSER_RESULT_CODE = 128;  // 图片
108
    private final static int FILE_CAMERA_RESULT_CODE = 129; // 拍照
109
    private String cameraFilePath;  // 拍照图片路径
110
98 111
    @Override
99 112
    protected void onCreate(Bundle savedInstanceState) {
100 113
        super.onCreate(savedInstanceState);
@ -160,6 +173,9 @@ public class MyWebViewActivity extends Activity implements PlatformActionListene
160 173
        webView.getSettings().setGeolocationDatabasePath(dir);
161 174
        webView.setWebChromeClient(mOpenFileWebChromeClient);
162 175
        webView.getSettings().setDomStorageEnabled(true);
176
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
177
            webView.getSettings().setMixedContentMode(WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
178
        }
163 179
//        webView.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
164 180
        webView.getSettings().setJavaScriptCanOpenWindowsAutomatically(true); //支持通过JS打开新窗口
165 181
        webView.addJavascriptInterface(this, "cdz");
@ -1219,16 +1235,30 @@ public class MyWebViewActivity extends Activity implements PlatformActionListene
1219 1235
    }
1220 1236
1221 1237
    @Override
1238
    public void onRequestPermissionsResult(int requestCode,
1239
                                           @NonNull String[] permissions,
1240
                                           @NonNull int[] grantResults) {
1241
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
1242
1243
        // EasyPermissions handles the request result.
1244
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
1245
    }
1246
1247
    @Override
1222 1248
    public void onPermissionsGranted(int requestCode, List<String> perms) {
1223 1249
1224 1250
    }
1225 1251
1226 1252
    @Override
1227 1253
    public void onPermissionsDenied(int requestCode, List<String> perms) {
1228
        if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
1229
            new AppSettingsDialog.Builder(MyWebViewActivity.this,
1230
                    "该功能需要开启拨号权限,是否前往开启?").build().show();
1254
        if (requestCode == RC_ALBUM_PERM) {
1255
            mOpenFileWebChromeClient.mFilePathCallback = null;
1256
            mOpenFileWebChromeClient.mFilePathCallbacks = null;
1231 1257
        }
1258
//        if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
1259
//            new AppSettingsDialog.Builder(MyWebViewActivity.this,
1260
//                    "该功能需要开启拨号权限,是否前往开启?").build().show();
1261
//        }
1232 1262
    }
1233 1263
1234 1264
    private boolean hasCallPhonePermission() {
@ -1270,52 +1300,119 @@ public class MyWebViewActivity extends Activity implements PlatformActionListene
1270 1300
        // Android < 3.0 调用这个方法
1271 1301
        public void openFileChooser(ValueCallback<Uri> filePathCallback) {
1272 1302
            mFilePathCallback = filePathCallback;
1273
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
1274
            intent.addCategory(Intent.CATEGORY_OPENABLE);
1275
            intent.setType("*/*");
1276
            mContext.startActivityForResult(
1277
                    Intent.createChooser(intent, "File Chooser"),
1278
                    REQUEST_FILE_PICKER);
1303
            permissionTask();
1279 1304
        }
1280 1305
1281 1306
        // 3.0 + 调用这个方法
1282
        public void openFileChooser(ValueCallback filePathCallback,
1283
                                    String acceptType) {
1307
        public void openFileChooser(ValueCallback filePathCallback, String acceptType) {
1284 1308
            mFilePathCallback = filePathCallback;
1285
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
1286
            intent.addCategory(Intent.CATEGORY_OPENABLE);
1287
            intent.setType("*/*");
1288
            mContext.startActivityForResult(
1289
                    Intent.createChooser(intent, "File Chooser"),
1290
                    REQUEST_FILE_PICKER);
1309
            permissionTask();
1291 1310
        }
1292 1311
1293 1312
        // / js上传文件的<input type="file" name="fileField" id="fileField" />事件捕获
1294 1313
        // Android > 4.1.1 调用这个方法
1295
        public void openFileChooser(ValueCallback<Uri> filePathCallback,
1296
                                    String acceptType, String capture) {
1314
        public void openFileChooser(ValueCallback<Uri> filePathCallback, String acceptType, String capture) {
1297 1315
            mFilePathCallback = filePathCallback;
1298
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
1299
            intent.addCategory(Intent.CATEGORY_OPENABLE);
1300
            intent.setType("*/*");
1301
            mContext.startActivityForResult(
1302
                    Intent.createChooser(intent, "File Chooser"),
1303
                    REQUEST_FILE_PICKER);
1316
            permissionTask();
1304 1317
        }
1305 1318
1306
        public boolean onShowFileChooser(WebView webView,
1307
                                         ValueCallback<Uri[]> filePathCallback) {
1319
        @Override
1320
        public boolean onShowFileChooser(WebView webView, ValueCallback<Uri[]> filePathCallback, FileChooserParams fileChooserParams) {
1308 1321
            mFilePathCallbacks = filePathCallback;
1309
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
1310
            intent.addCategory(Intent.CATEGORY_OPENABLE);
1311
            intent.setType("*/*");
1312
            mContext.startActivityForResult(
1313
                    Intent.createChooser(intent, "File Chooser"),
1314
                    REQUEST_FILE_PICKER);
1322
            permissionTask();
1315 1323
            return true;
1316 1324
        }
1317 1325
    }
1318 1326
1327
    @AfterPermissionGranted(RC_ALBUM_PERM)
1328
    public void permissionTask() {
1329
        if (isPermissionOK()) {
1330
            openImageChooserActivity();
1331
        } else {
1332
            EasyPermissions.requestPermissions(
1333
                    this, "充电桩想要获取您的图片读取权限,是否允许?",
1334
                    RC_ALBUM_PERM,
1335
                    Manifest.permission.CAMERA,
1336
                    Manifest.permission.WRITE_EXTERNAL_STORAGE,
1337
                    Manifest.permission.READ_EXTERNAL_STORAGE);
1338
        }
1339
    }
1340
1341
    private boolean isPermissionOK() {
1342
        return EasyPermissions.hasPermissions(this,
1343
                Manifest.permission.WRITE_EXTERNAL_STORAGE,
1344
                Manifest.permission.READ_EXTERNAL_STORAGE,
1345
                Manifest.permission.CAMERA
1346
        );
1347
    }
1348
1349
    private void openImageChooserActivity() {
1350
        new MaterialDialog.Builder(this).items(R.array.photo).positiveText("取消")
1351
                .onPositive(new MaterialDialog.SingleButtonCallback() {
1352
                    @Override
1353
                    public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {
1354
                        if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
1355
                            mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(null);
1356
                            mOpenFileWebChromeClient.mFilePathCallbacks = null;
1357
                        }
1358
1359
                        if (mOpenFileWebChromeClient.mFilePathCallback != null) {
1360
                            mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(null);
1361
                            mOpenFileWebChromeClient.mFilePathCallback = null;
1362
                        }
1363
                        dialog.dismiss();
1364
                    }
1365
                }).cancelable(false)
1366
                .canceledOnTouchOutside(false).itemsCallback(new MaterialDialog.ListCallback() {
1367
            @Override
1368
            public void onSelection(MaterialDialog dialog, View itemView, int position, CharSequence text) {
1369
                if (position == 0){
1370
                    takeCamera();
1371
                } else if (position == 1) {
1372
                    takePhoto();
1373
                }
1374
            }
1375
        }).show();
1376
    }
1377
1378
    // 选择图片
1379
    private void takePhoto() {
1380
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
1381
        intent.addCategory(Intent.CATEGORY_OPENABLE);
1382
        intent.setType("image/*");
1383
        startActivityForResult(Intent.createChooser(intent, "Image Choose"), FILE_CHOOSER_RESULT_CODE);
1384
    }
1385
1386
    // 拍照
1387
    private void takeCamera() {
1388
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
1389
        if (ImageUitl.hasSdcard()) {
1390
            String fileName = "android" + System.currentTimeMillis() / 1000 + ".jpg";
1391
            cameraFilePath = ImageUitl.getPath(Environment.getExternalStorageDirectory() + "/" + "cdz") + "/" + fileName;
1392
            File imageFile = ImageUitl.getFile(cameraFilePath);
1393
            Uri uri = parseUri(imageFile);
1394
            intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
1395
            try{
1396
                startActivityForResult(intent, FILE_CAMERA_RESULT_CODE);
1397
            } catch (Exception e) {
1398
                e.printStackTrace();
1399
            }
1400
1401
        }
1402
    }
1403
1404
    private Uri parseUri(File cameraFile) {
1405
        Uri imageUri;
1406
        String authority = getPackageName() + ".provider";
1407
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
1408
            //通过FileProvider创建一个content类型的Uri
1409
            imageUri = FileProvider.getUriForFile(getApplicationContext(), authority, cameraFile);
1410
        } else {
1411
            imageUri = Uri.fromFile(cameraFile);
1412
        }
1413
        return imageUri;
1414
    }
1415
1319 1416
    public class MyWebViewClient extends WebViewClient {
1320 1417
        @Override
1321 1418
        public void onPageStarted(WebView view, String url, Bitmap favicon) {
@ -1366,38 +1463,68 @@ public class MyWebViewActivity extends Activity implements PlatformActionListene
1366 1463
    }
1367 1464
1368 1465
    @Override
1369
    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
1370
        if (requestCode == OpenFileWebChromeClient.REQUEST_FILE_PICKER) {
1466
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
1467
        super.onActivityResult(requestCode, resultCode, data);
1468
        if (null == mOpenFileWebChromeClient.mFilePathCallback && null == mOpenFileWebChromeClient.mFilePathCallbacks) return;
1469
        if (resultCode != RESULT_OK) {
1470
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
1471
                mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(null);
1472
                mOpenFileWebChromeClient.mFilePathCallbacks = null;
1473
            }
1474
1371 1475
            if (mOpenFileWebChromeClient.mFilePathCallback != null) {
1372
                Uri result = intent == null || resultCode != Activity.RESULT_OK ? null
1373
                        : intent.getData();
1374
                if (result != null) {
1375
                    String path = MediaUtility.getPath(getApplicationContext(),
1376
                            result);
1377
                    Uri uri = Uri.fromFile(new File(path));
1378
                    mOpenFileWebChromeClient.mFilePathCallback
1379
                            .onReceiveValue(uri);
1380
                } else {
1381
                    mOpenFileWebChromeClient.mFilePathCallback
1382
                            .onReceiveValue(null);
1383
                }
1476
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(null);
1477
                mOpenFileWebChromeClient.mFilePathCallback = null;
1384 1478
            }
1479
            return;
1480
        }
1481
1482
        Uri result = null;
1483
        if (requestCode == FILE_CAMERA_RESULT_CODE) {
1484
            if (null != data && null != data.getData()) {
1485
                result = data.getData();
1486
            }
1487
            if (result == null && ImageUitl.hasFile(cameraFilePath)) {
1488
                result = Uri.fromFile(new File(cameraFilePath));
1489
            }
1490
1385 1491
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
1386
                Uri result = intent == null || resultCode != Activity.RESULT_OK ? null
1387
                        : intent.getData();
1388
                if (result != null) {
1389
                    String path = MediaUtility.getPath(getApplicationContext(),
1390
                            result);
1391
                    Uri uri = Uri.fromFile(new File(path));
1392
                    mOpenFileWebChromeClient.mFilePathCallbacks
1393
                            .onReceiveValue(new Uri[]{uri});
1394
                } else {
1395
                    mOpenFileWebChromeClient.mFilePathCallbacks
1396
                            .onReceiveValue(null);
1397
                }
1492
                mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(new Uri[]{result});
1493
                mOpenFileWebChromeClient.mFilePathCallbacks = null;
1494
            } else if (mOpenFileWebChromeClient.mFilePathCallback != null) {
1495
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(result);
1496
                mOpenFileWebChromeClient.mFilePathCallback = null;
1497
            }
1498
        } else if (requestCode == FILE_CHOOSER_RESULT_CODE) {
1499
            if (data != null) {
1500
                result = data.getData();
1501
            }
1502
            if (mOpenFileWebChromeClient.mFilePathCallbacks != null) {
1503
                onActivityResultCallbacks(data);
1504
            } else if (mOpenFileWebChromeClient.mFilePathCallback != null) {
1505
                mOpenFileWebChromeClient.mFilePathCallback.onReceiveValue(result);
1506
                mOpenFileWebChromeClient.mFilePathCallback = null;
1398 1507
            }
1508
        }
1509
    }
1399 1510
1400
            mOpenFileWebChromeClient.mFilePathCallback = null;
1511
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
1512
    private void onActivityResultCallbacks(Intent intent) {
1513
        Uri[] results = null;
1514
        if (intent != null) {
1515
            String dataString = intent.getDataString();
1516
            ClipData clipData = intent.getClipData();
1517
            if (clipData != null) {
1518
                results = new Uri[clipData.getItemCount()];
1519
                for (int i=0;i<clipData.getItemCount();i++) {
1520
                    ClipData.Item item = clipData.getItemAt(i);
1521
                    results[i] = item.getUri();
1522
                }
1523
            }
1524
            if (dataString != null) {
1525
                results = new Uri[] {Uri.parse(dataString)};
1526
            }
1527
            mOpenFileWebChromeClient.mFilePathCallbacks.onReceiveValue(results);
1401 1528
            mOpenFileWebChromeClient.mFilePathCallbacks = null;
1402 1529
        }
1403 1530
    }

+ 43 - 0
app/src/main/java/com/electric/chargingpile/util/ImageUitl.java

@ -7,11 +7,13 @@ import android.graphics.Bitmap;
7 7
import android.graphics.BitmapFactory;
8 8
import android.graphics.Matrix;
9 9
import android.net.Uri;
10
import android.os.Environment;
10 11
import android.util.Log;
11 12
12 13
import java.io.ByteArrayInputStream;
13 14
import java.io.ByteArrayOutputStream;
14 15
import java.io.File;
16
import java.io.IOException;
15 17
import java.io.InputStream;
16 18
17 19
/**
@ -396,4 +398,45 @@ public class ImageUitl {
396 398
        bitmap = compressImage(bitmap, 100);//质量压缩
397 399
        return bitmap;
398 400
    }
401
402
    public static boolean hasSdcard() {
403
        if (android.os.Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
404
            return true;
405
        } else {
406
            return false;
407
        }
408
    }
409
410
    public static String getPath(String path) {
411
        File f = new File(path);
412
        if (!f.exists()) {
413
            f.mkdirs();
414
        }
415
        return f.getAbsolutePath();
416
    }
417
418
    public static File getFile(String path) {
419
        File f = new File(path);
420
        if (!f.exists()) {
421
            try {
422
                f.createNewFile();
423
            } catch (IOException e) {
424
                e.printStackTrace();
425
            }
426
        }
427
        return f;
428
    }
429
430
    public static boolean hasFile(String path) {
431
        try {
432
            File f = new File(path);
433
            if (!f.exists()) {
434
                return false;
435
            }
436
        } catch (Exception e) {
437
            return false;
438
        }
439
        return true;
440
    }
441
399 442
}

+ 0 - 72
app/src/main/java/com/electric/chargingpile/util/OpenFileWebChromeClient.java

@ -1,72 +0,0 @@
1
package com.electric.chargingpile.util;
2
3
import android.app.Activity;
4
import android.content.Intent;
5
import android.net.Uri;
6
import android.webkit.ValueCallback;
7
import android.webkit.WebChromeClient;
8
import android.webkit.WebView;
9
10
/**
11
 * Created by Demon on 16/7/19.
12
 */
13
14
public class OpenFileWebChromeClient extends WebChromeClient {
15
    public static final int REQUEST_FILE_PICKER = 1;
16
    public ValueCallback<Uri> mFilePathCallback;
17
    public ValueCallback<Uri[]> mFilePathCallbacks;
18
    Activity mContext;
19
20
    public OpenFileWebChromeClient(Activity mContext) {
21
        super();
22
        this.mContext = mContext;
23
    }
24
25
    // Android < 3.0 调用这个方法
26
    public void openFileChooser(ValueCallback<Uri> filePathCallback) {
27
        mFilePathCallback = filePathCallback;
28
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
29
        intent.addCategory(Intent.CATEGORY_OPENABLE);
30
        intent.setType("*/*");
31
        mContext.startActivityForResult(Intent.createChooser(intent, "File Chooser"),
32
                REQUEST_FILE_PICKER);
33
    }
34
35
    // 3.0 + 调用这个方法
36
    public void openFileChooser(ValueCallback filePathCallback,
37
                                String acceptType) {
38
        mFilePathCallback = filePathCallback;
39
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
40
        intent.addCategory(Intent.CATEGORY_OPENABLE);
41
        intent.setType("*/*");
42
        mContext.startActivityForResult(Intent.createChooser(intent, "File Chooser"),
43
                REQUEST_FILE_PICKER);
44
    }
45
46
    //  / js上传文件的<input type="file" name="fileField" id="fileField" />事件捕获
47
    // Android > 4.1.1 调用这个方法
48
    public void openFileChooser(ValueCallback<Uri> filePathCallback,
49
                                String acceptType, String capture) {
50
        mFilePathCallback = filePathCallback;
51
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
52
        intent.addCategory(Intent.CATEGORY_OPENABLE);
53
        intent.setType("*/*");
54
        mContext.startActivityForResult(Intent.createChooser(intent, "File Chooser"),
55
                REQUEST_FILE_PICKER);
56
    }
57
58
    @Override
59
    public boolean onShowFileChooser(WebView webView,
60
                                     ValueCallback<Uri[]> filePathCallback,
61
                                     WebChromeClient.FileChooserParams fileChooserParams) {
62
        mFilePathCallbacks = filePathCallback;
63
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
64
        intent.addCategory(Intent.CATEGORY_OPENABLE);
65
        intent.setType("*/*");
66
        mContext.startActivityForResult(Intent.createChooser(intent, "File Chooser"),
67
                REQUEST_FILE_PICKER);
68
        return true;
69
    }
70
71
72
}

+ 4 - 0
app/src/main/res/values/arrays.xml

@ -13,6 +13,10 @@
13 13
        <item>"Android provides a rich application framework that allows you to build innovative apps and games for mobile devices in a Java language environment. The documents listed in the left navigation provide details about how to build apps using Android's various APIs."</item>
14 14
        <item>"test"</item>
15 15
    </string-array>
16
    <string-array name="photo">
17
        <item>拍照</item>
18
        <item>照片图库</item>
19
    </string-array>
16 20
17 21
    <string-array name="color_arr">
18 22
        <item>@color/lvse</item>

Veronique Trethowan - Gogs: Go Git Service
uk-driving-licence-online3548 (Veronique Trethowan)

Следване