devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 拍照(选择图片)并上传(包含权限动态获取)_android 拍照上传关闭页面

作者：码创造者 | 2024-08-08 19:11:29

赞

踩

android 拍照上传关闭页面

作为一个Android新手，想实现手机拍照并上传的功能，经过查找资料，已实现此功能。在此记录备忘。老鸟请忽略。

一、实现思路：

1.Android手机客户端，拍照(或选择图片)，然后上传到服务器。

2.服务器端接收手机端上传上来的图片。

二、实现步骤：

1.按惯例，先放效果图：

项目结构：

2.activity_main.xml

  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.     android:padding="5dp">
  7.  
  8.     <TextView
  9.         android:layout_width="wrap_content"
  10.         android:layout_height="wrap_content"
  11.         android:text="图片预览" />
  12.  
  13.     <ImageView
  14.         android:id="@+id/imageView"
  15.         android:layout_width="match_parent"
  16.         android:layout_height="400dp"
  17.         android:background="#fff"
  18.         android:padding="1dp"
  19.         android:scaleType="fitXY" />
  20.  
  21.     <LinearLayout
  22.         android:layout_width="wrap_content"
  23.         android:layout_height="wrap_content"
  24.         android:layout_gravity="center_horizontal"
  25.         android:orientation="horizontal">
  26.  
  27.         <Button
  28.             android:id="@+id/btnPhoto"
  29.             android:layout_width="wrap_content"
  30.             android:layout_height="wrap_content"
  31.             android:text="拍照" />
  32.  
  33.         <Button
  34.             android:id="@+id/btnSelect"
  35.             android:layout_width="wrap_content"
  36.             android:layout_height="wrap_content"
  37.             android:text="选择" />
  38.     </LinearLayout>
  39. </LinearLayout>

3.MainActivity.java

  1. package com.qingshan.note;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.annotation.RequiresApi;
  5. import androidx.appcompat.app.AppCompatActivity;
  6. import androidx.core.app.ActivityCompat;
  7. import androidx.core.content.ContextCompat;
  8.  
  9. import android.Manifest;
  10. import android.app.AlertDialog;
  11. import android.content.ContentValues;
  12. import android.content.DialogInterface;
  13. import android.content.Intent;
  14. import android.content.pm.PackageManager;
  15. import android.graphics.Bitmap;
  16. import android.graphics.BitmapFactory;
  17. import android.graphics.Matrix;
  18. import android.net.Uri;
  19. import android.os.Build;
  20. import android.os.Bundle;
  21. import android.os.Environment;
  22. import android.provider.MediaStore;
  23. import android.provider.Settings;
  24. import android.view.View;
  25. import android.widget.Button;
  26. import android.widget.ImageView;
  27. import android.widget.Toast;
  28.  
  29. import java.io.BufferedReader;
  30. import java.io.DataInputStream;
  31. import java.io.DataOutputStream;
  32. import java.io.File;
  33. import java.io.FileInputStream;
  34. import java.io.FileNotFoundException;
  35. import java.io.FileOutputStream;
  36. import java.io.IOException;
  37. import java.io.InputStreamReader;
  38. import java.io.OutputStream;
  39. import java.net.HttpURLConnection;
  40. import java.net.URL;
  41. import java.text.SimpleDateFormat;
  42. import java.util.ArrayList;
  43. import java.util.Date;
  44. import java.util.HashMap;
  45. import java.util.Iterator;
  46. import java.util.List;
  47. import java.util.Map;
  48.  
  49. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  50.     private Button btnPhoto, btnSelect;
  51.     private Intent intent;
  52.     private final int CAMERA = 1;//事件枚举(可以自定义)
  53.     private final int CHOOSE = 2;//事件枚举(可以自定义)
  54.     private final String postUrl = "http://qingshanboke.com/Home/AndoridUploadFile";//接收上传图片的地址
  55.     String photoPath = "";//要上传的图片路径
  56.     private final int permissionCode = 100;//权限请求码
  57.  
  58.     //权限集合，对应在AndroidManifest.xml文件中添加配置
  59.     //    <uses-permission android:name="android.permission.CAMERA" />
  60.     //    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  61.     //    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  62.     //    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
  63.     //    <uses-permission android:name="android.permission.INTERNET"/>
  64.     String[] permissions = new String[]{
  65.             Manifest.permission.CAMERA,
  66.             Manifest.permission.WRITE_EXTERNAL_STORAGE,
  67.             Manifest.permission.ACCESS_NETWORK_STATE,
  68.             Manifest.permission.ACCESS_WIFI_STATE,
  69.             Manifest.permission.INTERNET
  70.     };
  71.     AlertDialog alertDialog;
  72.  
  73.     @Override
  74.     protected void onCreate(Bundle savedInstanceState) {
  75.         super.onCreate(savedInstanceState);
  76.         setContentView(R.layout.activity_main);
  77.         //6.0才用动态权限
  78.         if (Build.VERSION.SDK_INT >= 23) {
  79.             checkPermission();
  80.         }
  81.  
  82.         btnPhoto = findViewById(R.id.btnPhoto);
  83.         btnSelect = findViewById(R.id.btnSelect);
  84.         btnPhoto.setOnClickListener(this);
  85.         btnSelect.setOnClickListener(this);
  86.     }
  87.  
  88.     //检查权限
  89.     private void checkPermission() {
  90.         List<String> permissionList = new ArrayList<>();
  91.         for (int i = 0; i < permissions.length; i++) {
  92.             if (ContextCompat.checkSelfPermission(this, permissions[i]) != PackageManager.PERMISSION_GRANTED) {
  93.                 permissionList.add(permissions[i]);
  94.             }
  95.         }
  96.         if (permissionList.size() <= 0) {
  97.             //说明权限都已经通过，可以做你想做的事情去
  98.  
  99.         } else {
  100.             //存在未允许的权限
  101.             ActivityCompat.requestPermissions(this, permissions, permissionCode);
  102.         }
  103.     }
  104.  
  105.     //授权后回调函数
  106.     @Override
  107.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  108.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  109.         boolean haspermission = false;
  110.         if (permissionCode == requestCode) {
  111.             for (int i = 0; i < grantResults.length; i++) {
  112.                 if (grantResults[i] == -1) {
  113.                     haspermission = true;
  114.                 }
  115.             }
  116.             if (haspermission) {
  117.                 //跳转到系统设置权限页面，或者直接关闭页面，不让他继续访问
  118.                 permissionDialog();
  119.             } else {
  120.                 //全部权限通过，可以进行下一步操作
  121.             }
  122.         }
  123.     }
  124.  
  125.     //打开手动设置应用权限
  126.     private void permissionDialog() {
  127.         if (alertDialog == null) {
  128.             alertDialog = new AlertDialog.Builder(this)
  129.                     .setTitle("提示信息")
  130.                     .setMessage("当前应用缺少必要权限，该功能暂时无法使用。如若需要，请单击【确定】按钮前往设置中心进行权限授权。")
  131.                     .setPositiveButton("设置", new DialogInterface.OnClickListener() {
  132.                         @Override
  133.                         public void onClick(DialogInterface dialog, int which) {
  134.                             cancelPermissionDialog();
  135.                             Uri packageURI = Uri.parse("package:" + getPackageName());
  136.                             Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, packageURI);
  137.                             startActivity(intent);
  138.                         }
  139.                     })
  140.                     .setNegativeButton("取消", new DialogInterface.OnClickListener() {
  141.                         @Override
  142.                         public void onClick(DialogInterface dialog, int which) {
  143.                             cancelPermissionDialog();
  144.                         }
  145.                     })
  146.                     .create();
  147.         }
  148.         alertDialog.show();
  149.     }
  150.  
  151.     //用户取消授权
  152.     private void cancelPermissionDialog() {
  153.         alertDialog.cancel();
  154.     }
  155.  
  156.     @Override
  157.     public void onClick(View v) {
  158.         switch (v.getId()) {
  159.  
  160.             //拍照按钮事件
  161.             case R.id.btnPhoto:
  162.                 //方法一：这样拍照只能取到缩略图（不清晰）
  163.                 //intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
  164.                 //startActivityForResult(intent, CAMERA);
  165.  
  166.  
  167.                 //方法二：指定加载路径图片路径（保存原图，清晰）
  168.                 String SD_PATH = Environment.getExternalStorageDirectory().getPath() + "/拍照上传示例/";
  169.                 SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
  170.                 String fileName = format.format(new Date(System.currentTimeMillis())) + ".JPEG";
  171.                 photoPath = SD_PATH + fileName;
  172.                 File file = new File(photoPath);
  173.                 if (!file.getParentFile().exists()) {
  174.                     file.getParentFile().mkdirs();
  175.                 }
  176.  
  177.                 //兼容7.0以上的版本
  178.                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
  179.                     try {
  180.                         ContentValues values = new ContentValues(1);
  181.                         values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpg");
  182.                         values.put(MediaStore.Images.Media.DATA, photoPath);
  183.                         Uri tempuri = getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
  184.                         Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  185.                         intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
  186.                         if (tempuri != null) {
  187.                             intent.putExtra(MediaStore.EXTRA_OUTPUT, tempuri);
  188.                             intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
  189.                         }
  190.                         startActivityForResult(intent, CAMERA);
  191.                     } catch (Exception e) {
  192.                         e.printStackTrace();
  193.                     }
  194.                 } else {
  195.                     intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  196.                     Uri uri = Uri.fromFile(file);
  197.                     intent.putExtra(MediaStore.EXTRA_OUTPUT, uri); //指定拍照后的存储路径，保存原图
  198.                     startActivityForResult(intent, CAMERA);
  199.                 }
  200.                 break;
  201.  
  202.             //选择按钮事件
  203.             case R.id.btnSelect:
  204.                 intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
  205.                 startActivityForResult(intent, CHOOSE);
  206.                 break;
  207.         }
  208.     }
  209.  
  210.     @RequiresApi(api = Build.VERSION_CODES.O)
  211.     @Override
  212.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  213.         super.onActivityResult(requestCode, resultCode, data);
  214.         switch (requestCode) {
  215.             // 调用照相机拍照
  216.             case CAMERA:
  217.                 if (resultCode == RESULT_OK) {
  218.                     //对应方法一：图片未保存，需保存文件到本地
  219. //                    Bundle bundle = data.getExtras();
  220. //                    Bitmap bitmap = (Bitmap) bundle.get("data");
  221. //                    String savePath;
  222. //                    String SD_PATH = Environment.getExternalStorageDirectory().getPath() + "/拍照上传示例/";
  223. //                    SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
  224. //                    String fileName = format.format(new Date(System.currentTimeMillis())) + ".JPEG";
  225. //                    if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
  226. //                        savePath = SD_PATH;
  227. //                    } else {
  228. //                        Toast.makeText(MainActivity.this, "保存失败！", Toast.LENGTH_SHORT).show();
  229. //                        return;
  230. //                    }
  231. //                    photoPath = savePath + fileName;
  232. //                    File file = new File(photoPath);
  233. //                    try {
  234. //                        if (!file.exists()) {
  235. //                            file.getParentFile().mkdirs();
  236. //                            file.createNewFile();
  237. //                        }
  238. //                        FileOutputStream stream = new FileOutputStream(file);
  239. //                        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
  240. //                        Toast.makeText(MainActivity.this, "保存成功,位置:" + file.getAbsolutePath(), Toast.LENGTH_SHORT).show();
  241. //                    } catch (IOException e) {
  242. //                        e.printStackTrace();
  243. //                    }
  244.  
  245.                     //对应方法二：图片已保存，只需读取就行了
  246.                     try {
  247.                         FileInputStream stream = new FileInputStream(photoPath);
  248.                         Bitmap bitmap = BitmapFactory.decodeStream(stream);
  249.  
  250.                         //预览图片
  251.                         ImageView image = findViewById(R.id.imageView);
  252.                         image.setImageBitmap(bitmap);
  253.  
  254.                         //上传图片（Android 4.0 之后不能在主线程中请求HTTP请求）
  255.                         File file = new File(photoPath);
  256.                         if (file.exists()) {
  257.                             new Thread(new Runnable() {
  258.                                 @Override
  259.                                 public void run() {
  260.                                     //文本字段（用于验证用户身份）
  261.                                     HashMap<String, String> form = new HashMap<String, String>();
  262.                                     form.put("username", "zhangqs");
  263.                                     form.put("password", "123456");
  264.  
  265.                                     //图片字段
  266.                                     HashMap<String, String> file = new HashMap<String, String>();
  267.                                     file.put(PathHelper.getFileNameFromPath(photoPath), photoPath);
  268.                                     formUpload(postUrl, form, file);
  269.                                 }
  270.                             }).start();
  271.                         }
  272.                     } catch (FileNotFoundException e) {
  273.                         e.printStackTrace();
  274.                     }
  275.                 }
  276.                 break;
  277.             // 选择图片库的图片
  278.             case CHOOSE:
  279.                 if (resultCode == RESULT_OK) {
  280.                     try {
  281.                         Uri uri = data.getData();
  282.                         photoPath = PathHelper.getRealPathFromUri(MainActivity.this, uri);
  283.                         Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), uri);
  284.  
  285.                         //压缩图片
  286.                         bitmap = scaleBitmap(bitmap, (float) 0.5);
  287.  
  288.                         //预览图片
  289.                         ImageView image = findViewById(R.id.imageView);
  290.                         image.setImageBitmap(bitmap);
  291.  
  292.                         //上传图片（Android 4.0 之后不能在主线程中请求HTTP请求）
  293.                         File file = new File(photoPath);
  294.                         if (file.exists()) {
  295.                             new Thread(new Runnable() {
  296.                                 @Override
  297.                                 public void run() {
  298.                                     //文本字段（用于验证用户身份）
  299.                                     HashMap<String, String> form = new HashMap<String, String>();
  300.                                     form.put("username", "zhangqs");
  301.                                     form.put("password", "123456");
  302.  
  303.                                     //图片字段
  304.                                     HashMap<String, String> file = new HashMap<String, String>();
  305.                                     file.put(PathHelper.getFileNameFromPath(photoPath), photoPath);
  306.                                     formUpload(postUrl, form, file);
  307.                                 }
  308.                             }).start();
  309.                         }
  310.  
  311.                     } catch (IOException e) {
  312.                         e.printStackTrace();
  313.                     }
  314.                 }
  315.                 break;
  316.         }
  317.     }
  318.  
  319.     //压缩图片
  320.     public Bitmap scaleBitmap(Bitmap origin, float ratio) {
  321.         if (origin == null) {
  322.             return null;
  323.         }
  324.         int width = origin.getWidth();
  325.         int height = origin.getHeight();
  326.         Matrix matrix = new Matrix();
  327.         matrix.preScale(ratio, ratio);
  328.         Bitmap newBM = Bitmap.createBitmap(origin, 0, 0, width, height, matrix, false);
  329.         return newBM;
  330.     }
  331.  
  332.     //POST 表单提交
  333.     @RequiresApi(api = Build.VERSION_CODES.O)
  334.     public static String formUpload(String posturl, Map<String, String> textMap, Map<String, String> fileMap) {
  335.         String res = "";
  336.         HttpURLConnection conn = null;
  337.         String BOUNDARY = "---------------------------123821742118716"; //boundary就是request头和上传文件内容的分隔符
  338.         try {
  339.             URL url = new URL(posturl);
  340.             conn = (HttpURLConnection) url.openConnection();
  341.             conn.setConnectTimeout(5000);
  342.             conn.setReadTimeout(30000);
  343.             conn.setDoOutput(true);
  344.             conn.setDoInput(true);
  345.             conn.setUseCaches(false);
  346.             conn.setRequestMethod("POST");
  347.             conn.setRequestProperty("Connection", "Keep-Alive");
  348.             conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.6)");
  349.             conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + BOUNDARY);
  350.  
  351.             OutputStream out = new DataOutputStream(conn.getOutputStream());
  352.  
  353.             // text
  354.             if (textMap != null) {
  355.                 StringBuffer buffer = new StringBuffer();
  356.                 Iterator iter = textMap.entrySet().iterator();
  357.                 while (iter.hasNext()) {
  358.                     Map.Entry entry = (Map.Entry) iter.next();
  359.                     String inputName = (String) entry.getKey();
  360.                     String inputValue = (String) entry.getValue();
  361.                     if (inputValue == null) {
  362.                         continue;
  363.                     }
  364.                     buffer.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
  365.                     buffer.append("Content-Disposition: form-data; name=\"" + inputName + "\"\r\n\r\n");
  366.                     buffer.append(inputValue);
  367.                 }
  368.                 out.write(buffer.toString().getBytes());
  369.             }
  370.  
  371.             // file
  372.             if (fileMap != null) {
  373.                 Iterator iter = fileMap.entrySet().iterator();
  374.                 while (iter.hasNext()) {
  375.                     Map.Entry entry = (Map.Entry) iter.next();
  376.                     String inputName = (String) entry.getKey();
  377.                     String inputValue = (String) entry.getValue();
  378.                     if (inputValue == null) {
  379.                         continue;
  380.                     }
  381.                     File file = new File(inputValue);
  382.                     String filename = file.getName();
  383.                     String contentType = "";
  384.                     if (filename.endsWith(".jpg")) {
  385.                         contentType = "image/jpg";
  386.                     } else if (filename.endsWith(".png")) {
  387.                         contentType = "image/png";
  388.                     } else if (contentType == null || contentType.equals("")) {
  389.                         contentType = "application/octet-stream";
  390.                     }
  391.  
  392.                     StringBuffer buffer = new StringBuffer();
  393.                     buffer.append("\r\n").append("--").append(BOUNDARY).append("\r\n");
  394.                     buffer.append("Content-Disposition: form-data; name=\"" + inputName + "\"; filename=\"" + filename + "\"\r\n");
  395.                     buffer.append("Content-Type:" + contentType + "\r\n\r\n");
  396.  
  397.                     out.write(buffer.toString().getBytes());
  398.  
  399.                     DataInputStream in = new DataInputStream(new FileInputStream(file));
  400.                     int bytes = 0;
  401.                     byte[] bufferOut = new byte[1024];
  402.                     while ((bytes = in.read(bufferOut)) != -1) {
  403.                         out.write(bufferOut, 0, bytes);
  404.                     }
  405.                     in.close();
  406.                 }
  407.             }
  408.  
  409.             byte[] endData = ("\r\n--" + BOUNDARY + "--\r\n").getBytes();
  410.             out.write(endData);
  411.             out.flush();
  412.             out.close();
  413.  
  414.             // 读取返回数据
  415.             StringBuffer buffer = new StringBuffer();
  416.             BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
  417.             String line = null;
  418.             while ((line = reader.readLine()) != null) {
  419.                 buffer.append(line).append("\n");
  420.             }
  421.             res = buffer.toString();
  422.             reader.close();
  423.             reader = null;
  424.         } catch (Exception e) {
  425.             System.out.println("发送POST请求出错。" + posturl);
  426.             e.printStackTrace();
  427.         } finally {
  428.             if (conn != null) {
  429.                 conn.disconnect();
  430.                 conn = null;
  431.             }
  432.         }
  433.         return res;
  434.     }
  435.  
  436.  
  437. }

4.辅助类 PathHelper.java

  1. package com.qingshan.note;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.content.ContentUris;
  5. import android.content.Context;
  6. import android.database.Cursor;
  7. import android.net.Uri;
  8. import android.os.Build;
  9. import android.provider.DocumentsContract;
  10. import android.provider.MediaStore;
  11.  
  12. //Android 路径辅助类
  13. public class PathHelper {
  14.  
  15.     //适配api19以下(不包括api19),根据uri获取图片的绝对路径
  16.     public static String getRealPathFromUri(Context context, Uri uri) {
  17.         int sdkVersion = Build.VERSION.SDK_INT;
  18.         if (sdkVersion >= 19) { // api >= 19
  19.             return getRealPathFromUriAboveApi19(context, uri);
  20.         } else { // api < 19
  21.             return getRealPathFromUriBelowAPI19(context, uri);
  22.         }
  23.     }
  24.  
  25.     /**
  26.      * 适配api19以下(不包括api19),根据uri获取图片的绝对路径
  27.      *
  28.      * @param context 上下文对象
  29.      * @param uri     图片的Uri
  30.      * @return 如果Uri对应的图片存在, 那么返回该图片的绝对路径, 否则返回null
  31.      */
  32.     private static String getRealPathFromUriBelowAPI19(Context context, Uri uri) {
  33.         return getDataColumn(context, uri, null, null);
  34.     }
  35.  
  36.     /**
  37.      * 适配api19及以上,根据uri获取图片的绝对路径
  38.      *
  39.      * @param context 上下文对象
  40.      * @param uri     图片的Uri
  41.      * @return 如果Uri对应的图片存在, 那么返回该图片的绝对路径, 否则返回null
  42.      */
  43.     @SuppressLint("NewApi")
  44.     private static String getRealPathFromUriAboveApi19(Context context, Uri uri) {
  45.         String filePath = null;
  46.         if (DocumentsContract.isDocumentUri(context, uri)) {
  47.             // 如果是document类型的 uri, 则通过document id来进行处理
  48.             String documentId = DocumentsContract.getDocumentId(uri);
  49.             if (isMediaDocument(uri)) { // MediaProvider
  50.                 // 使用':'分割
  51.                 String id = documentId.split(":")[1];
  52.                 String selection = MediaStore.Images.Media._ID + "=?";
  53.                 String[] selectionArgs = {id};
  54.                 filePath = getDataColumn(context, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, selection, selectionArgs);
  55.             } else if (isDownloadsDocument(uri)) { // DownloadsProvider
  56.                 Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(documentId));
  57.                 filePath = getDataColumn(context, contentUri, null, null);
  58.             }
  59.         } else if ("content".equalsIgnoreCase(uri.getScheme())) {
  60.             // 如果是 content 类型的 Uri
  61.             filePath = getDataColumn(context, uri, null, null);
  62.         } else if ("file".equals(uri.getScheme())) {
  63.             // 如果是 file 类型的 Uri,直接获取图片对应的路径
  64.             filePath = uri.getPath();
  65.         }
  66.         return filePath;
  67.     }
  68.  
  69.     private static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
  70.         String path = null;
  71.         String[] projection = new String[]{MediaStore.Images.Media.DATA};
  72.         Cursor cursor = null;
  73.         try {
  74.             cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
  75.             if (cursor != null && cursor.moveToFirst()) {
  76.                 int columnIndex = cursor.getColumnIndexOrThrow(projection[0]);
  77.                 path = cursor.getString(columnIndex);
  78.             }
  79.         } catch (Exception e) {
  80.             e.printStackTrace();
  81.         } finally {
  82.             if (cursor != null) {
  83.                 cursor.close();
  84.             }
  85.         }
  86.         return path;
  87.     }
  88.  
  89.     private static boolean isMediaDocument(Uri uri) {
  90.         return "com.android.providers.media.documents".equals(uri.getAuthority());
  91.     }
  92.  
  93.     private static boolean isDownloadsDocument(Uri uri) {
  94.         return "com.android.providers.downloads.documents".equals(uri.getAuthority());
  95.     }
  96.  
  97.     //从路径中提取文件名
  98.     public static String getFileNameFromPath(String path) {
  99.         int start = path.lastIndexOf("/");
  100.         int end = path.lastIndexOf(".");
  101.         if (start != -1 && end != -1) {
  102.             return path.substring(start + 1, end);
  103.         } else {
  104.             return null;
  105.         }
  106.  
  107.     }
  108. }

5.AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.qingshan.note">
  4.  
  5.     <!-- 因为拍照需要写入文件 所以需要申请读取内存的权限 -->
  6.     <uses-permission android:name="android.permission.CAMERA" />
  7.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  8.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  9.     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
  10.     <uses-permission android:name="android.permission.INTERNET"/>
  11.  
  12.     <application
  13.         android:networkSecurityConfig="@xml/network_security_config"
  14.         android:allowBackup="true"
  15.         android:icon="@mipmap/ic_launcher"
  16.         android:label="@string/app_name"
  17.         android:usesCleartextTraffic="true"
  18.         android:roundIcon="@mipmap/ic_launcher_round"
  19.         android:supportsRtl="true"
  20.         android:theme="@style/AppTheme">
  21.  
  22.         <activity android:name=".MainActivity">
  23.             <intent-filter>
  24.                 <action android:name="android.intent.action.MAIN" />
  25.  
  26.                 <category android:name="android.intent.category.LAUNCHER" />
  27.             </intent-filter>
  28.         </activity>
  29.     </application>
  30.  
  31. </manifest>

6.\res\xml\network_security_config.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <network-security-config>
  3.     <base-config cleartextTrafficPermitted="true"  />
  4.     <domain-config cleartextTrafficPermitted="true" >
  5.         <domain includeSubdomains="true">127.0.0.1</domain>
  6.         <domain includeSubdomains="true">192.168.100.192</domain>
  7.         <domain includeSubdomains="true">localhost</domain>
  8.         <domain includeSubdomains="true">qingshanboke.com</domain>
  9.     </domain-config>
  10. </network-security-config>

7.服务器端接收（asp.net mvc 接收）

  1.         public ActionResult AndoridUploadFile()
  2.         {
  3.             var userName = Request.Params["username"];
  4.             var password = Request.Params["password"];
  5.             if (string.IsNullOrEmpty(userName) || string.IsNullOrEmpty(password))
  6.             {
  7.                 return Content("抱歉，用户名和密码错误！");
  8.             }
  9.             //todo:身份验证
  10.  
  11.             var dir = PathHelper.GetMapPath("~/Uploadfiles/" + DateTime.Now.ToString("yyyy-MM"));
  12.             if (!Directory.Exists(dir))
  13.             {
  14.                 Directory.CreateDirectory(dir);
  15.             }
  16.             for (int i = 0; i < Request.Files.Count; i++)
  17.             {
  18.                 var path = Path.Combine(dir, DateTime.Now.ToString("yyyyMMddHHmmss") + ".jpg");
  19.                 if (Request.Files[i] != null)
  20.                 {
  21.                     Request.Files[i].SaveAs(path);
  22.                 }
  23.             }
  24.             return Content("{\"isSuccess\":true}");
  25.         }

三、注意事项

1.Android发起http请求时，默认请求地址需https，需要增加 network-security-config 配置来允许使用http。（详见上面6.\res\xml\network_security_config.xml）

2.发起post提交时，往往需要做接口身份识别，需要将文本字段和图片字段一起提交，构造表单时，需要 "Content-Type", "multipart/form-data; boundary..."。

3.拍照时，默认只能取到缩略图，不够清晰，若要取到原图，需要在拍照时，传入指定保存位置，在回调函数中只需读取就可以了。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号