林业外业采集APP 安卓拍照上传服务器，从服务器获取图像加载ImageView显示功能实现

本文链接：https://blog.csdn.net/jackiesky1206/article/details/145097090

直接上代码：

.net core IIS服务器端接收数据并按照指定路径，指定文件名保存图像文件API

文件名：UpLoadImageController

Controller：UpLoadImage

Action：UploadImageFromAndroid

/// <summary>
/// 图像上传控制器
/// </summary>
public class UpLoadImageController : Controller
{
    /// <summary>
    /// 获取来自Android客户端的图像资源，并根据指定路径和文件名保存图像文件
    /// </summary>
    /// <param name="file">图像文件 必须和安卓OkHttp3的定义相同</param>
    /// <param name="filename">需要保存的文件名</param>
    /// <param name="filepath">需要保存的文件路径</param>
    /// <returns></returns>
    [HttpPost]
    public ActionResult UploadImageFromAndroid([FromForm(Name = "file")] IFormFile file,string filename,string filepath)
    {
        //获得当前项目的静态资源文件路径
        var basePath = AppContext.BaseDirectory.Split("\\bin\\")[0]+"/wwwroot/";
        Debug.WriteLine("basePath:"+basePath);
        //定义文件保存路径
        var savePath = basePath + filepath;
        Debug.WriteLine("savePath:" + savePath);
        try
        {
            //检测文件保存路径是否存在，不存在自动创建
            if (!Directory.Exists(savePath))
            {
                Directory.CreateDirectory(savePath);
            }
            //判断文件是否为空，不为空保存
            if (file != null)
            {
                //定义保存文件完整路径
                string url = savePath + "/" + filename+".jpg";
                Debug.WriteLine("saveFile:" + url);
                //获取文件后缀
                var fileExtension = Path.GetExtension(file.FileName);
                //判断后缀是否是图片
                const string fileFilt = ".gif|.jpg|.jpeg|.png";
                if (fileFilt.IndexOf(fileExtension.ToLower(), StringComparison.Ordinal) <= -1)
                {
                    return null;  //如果文件后缀不是图片，返回空
                }
                //将文件写入磁盘
                using (FileStream fs = System.IO.File.Create(url))
                {
                    file.CopyTo(fs);
                    fs.Flush();
                    return Json(new { msg = "success" });
                }
            }
            //异常处理，返回Message为失败
            return Json(new { msg = "faild" });
        }
        catch (Exception ex)
        {
            //异常处理，返回Message为失败
            Console.WriteLine(ex.ToString());
            return Json(new { msg = "faild" });
        }
    }
}

关键代码在安卓端，安卓端实现功能如下：

1、用户点击按钮选择图像，

2、图像加载完成后，用户点击上传按钮开始上传图片

其中用到了图片选择控件，包括：从相册选择，拍照，界面如下：

一、创建主窗口布局文件和Activity：

（1）主窗口（activity_selectpicture.xml）

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center_horizontal"
    android:orientation="vertical">

    <Button
        android:id="@+id/selectbutton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:background="@drawable/bg_button_shape"
        android:text="选择图片"
        android:textColor="@color/white" />

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="150dp"
        android:layout_height="210dp"
        android:layout_marginTop="15dp"
        android:layout_marginBottom="15dp"
        android:adjustViewBounds="true"
        android:scaleType="centerCrop"
        android:src="@mipmap/touxiang" />

    <Button
        android:id="@+id/upImageToServer"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="@drawable/bg_button_shape"
        android:paddingLeft="10dp"
        android:paddingRight="10dp"
        android:text="上传图片到服务器"
        android:textColor="@color/white" />
</LinearLayout>

（2）创建主窗口Activity（SelectPictureActiity.java）

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;

import com.jackiesky.qingzhou.qingzhoulinye.CameraImage.ChoosePictureDialog;
import com.jackiesky.qingzhou.qingzhoulinye.CameraImage.ChoosePictureUtils;
import com.jackiesky.qingzhou.qingzhoulinye.CameraImage.ConstantUtil;
import com.jackiesky.qingzhou.qingzhoulinye.Classes.PermissionClass;
import com.jackiesky.qingzhou.qingzhoulinye.Classes.SelectPictureClass;
import com.jackiesky.qingzhou.qingzhoulinye.R;

import java.io.File;

public class SelectPictureActiity extends Activity implements View.OnClickListener{
    private Button selectbutton, upimagebutton;  //定义选择图片和上传图片按钮
    private ImageView image;  //存放图片的ImageView
    private ChoosePictureDialog choosePictrueDialog;  //选择图片dialog

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_selectpicture);

        initView();
    }

    //初始化View
    private void initView(){
        selectbutton = findViewById(R.id.selectbutton);
        image = findViewById(R.id.imageView);
        upimagebutton = findViewById(R.id.upImageToServer);
        selectbutton.setOnClickListener(this);
        upimagebutton.setOnClickListener(this);
    }

    // android 7.0后需要检测权限，权限设置结果
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        //权限设置
        PermissionClass.getSelectPicturePermission(SelectPictureActiity.this,choosePictrueDialog,requestCode,grantResults);
    }

    /**
     * 选择图片返回Activity后处理
     */
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case ConstantUtil.RESULT_PHOTO_CODE:
                /**
                 * 拍照，获取返回结果
                 */
                SelectPictureClass.closeDialog(choosePictrueDialog);
                //拍照成功resultCode返回-1；不拍照按返回键，resultCode返回0，导致程序闪退
                if(resultCode == -1) {
                    SelectPictureClass.showCameraPictureForImageView(this, image);
                }
                break;
            case ConstantUtil.RESULT_LOAD_CODE:
                /**
                 * 从相册中选择图片，获取返回结果
                 */
                SelectPictureClass.closeDialog(choosePictrueDialog);
                SelectPictureClass.showAlbumPictureForImageView(this,data,image);
                break;

        }
    }

    //如果switch case R.id.XXXX标注红下划线，
    //需要在项目的gradle.properties 加入如下代码：android.nonFinalResIds=false
    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.selectbutton:  //选择图片
                // 打开选择图片Dialog
                choosePictrueDialog=new ChoosePictureDialog(SelectPictureActiity.this);
                choosePictrueDialog.showChoosePictureDialog();
                break;
            case R.id.upImageToServer:  //上传图片
                //上传图片到服务器
                Bitmap bitmap =ChoosePictureUtils.getBitmapFromImageView(image);  //将imageView中的图片转换成Bitmap数据
                File file = ChoosePictureUtils.saveImageFileFromBitmap(bitmap);    //将Bitmap数据保存为File图片文件
                //ChoosePictureUtils.uploadImage("http://192.168.2.191:8088/Uploadimage/UploadImageFromAndroid",file.getPath(),512);   //上传压缩后的图片文件到服务器
                ChoosePictureUtils.uploadImage("http://192.168.2.199:4843/Uploadimage/UploadImageFromAndroid",file);  //File原文件上传服务器
                Toast.makeText(SelectPictureActiity.this,"图片上传成功！",Toast.LENGTH_SHORT).show();
                break;
        }
    }
}

二、项目中用到的几个类

1、ChoosePictureDialog.java //选项图片Dialog对话框

2、ChoosePictrueUtil.java //选择图片管理类

3、UploadPictureUtil.java //上传图片管理类

4、ConstantUtil.java //常量管理类

5、fileProvider.java //FileProvider自定义类，用于共享文件权限

6、PermissionUtil.java //权限管理类

（1）、ChoosePictureDialog.java //选项图片Dialog对话框

xml布局文件（dialog_selectpicture.xml）：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@drawable/radius_shape"
    android:orientation="vertical"
    android:paddingLeft="15dp"
    android:paddingTop="15dp"
    android:paddingRight="15dp"
    android:paddingBottom="15dp">


    <Button
        android:id="@+id/AlbumButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@drawable/rect_shape"
        android:text="从本地相册获取" />

    <View
        android:id="@+id/view"
        android:layout_width="match_parent"
        android:layout_height="2px"
        android:background="@color/light_gray" />

    <Button
        android:id="@+id/CameraButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@drawable/rect_shape"
        android:text="现场拍照" />

    <View
        android:id="@+id/view2"
        android:layout_width="match_parent"
        android:layout_height="2px"
        android:background="@color/light_gray" />

    <Button
        android:id="@+id/CancelButton"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@drawable/rect_shape"
        android:text="取消" />

</LinearLayout>

Java代码：

import android.Manifest;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.pm.PackageManager;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;


import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.DialogFragment;

import com.jackiesky.qingzhou.qingzhoulinye.R;

public class ChoosePictureDialog implements View.OnClickListener{
    private Context context;
    private Dialog dialog;
    private Button albumBtn, cameraBtn, cancelBtn;
    private DialogFragment fragment;

    //枚举对话框显示位置
    public enum ChoosePictureDialogGravity {
        GRAVITY_BOTTOM,
        GRAVITY_CENTER,
        GRAVITY_LEFT,
        GRAVITY_RIGHT,
        GRAVITY_TOP
    }

    /**
     * 获取对话框
     * @return
     */
    public Dialog getDialog() {
        return dialog;
    }

    /**
     * 获取从本地相册选择图片按钮
     * @return
     */
    public Button getAlbumBtn() {
        return albumBtn;
    }

    /**
     * 获取现场拍照按钮
     * @return
     */
    public Button getCameraBtn() {
        return cameraBtn;
    }

    /**
     * 获取取消按钮
     * @return
     */
    public Button getCancelBtn() {
        return cancelBtn;
    }

    /**
     * ChoosePictureDialog
     * @param context
     */
    public ChoosePictureDialog(Context context) {
        this(context, R.style.MyDialog);
        this.context = context;
    }

    /**
     * ChoosePictureDialog 带样式
     * @param context
     * @param themeResId
     */
    public ChoosePictureDialog(Context context, int themeResId) {
        this.context = context;
        dialog = new Dialog(context, themeResId);
        init();  //初始化
        CheckPermissionAndStartPhoto();  //检测权限
    }

    /**
     * 初始化
     */
    private void init() {
        View view = LayoutInflater.from(context).inflate(R.layout.dialog_selectpicture, null);
        albumBtn = view.findViewById(R.id.AlbumButton);   //相册
        albumBtn.setOnClickListener(this);
        cameraBtn = view.findViewById(R.id.CameraButton);  //拍照
        cameraBtn.setOnClickListener(this);
        cancelBtn = view.findViewById(R.id.CancelButton);  //取消
        cancelBtn.setOnClickListener(this);
        //设置view
        dialog.setContentView(view);
        // 按返回键是否取消
        dialog.setCancelable(true);
        // 点击Dialog外围是否取消
        dialog.setCanceledOnTouchOutside(true);
        // 设置文本字体
        this.setBtnSize(16);
        // 设置文本颜色
        this.setBtnColor("#0099CC");
        // 设置底部显示
        this.setChoosePictureDialogGravity(ChoosePictureDialogGravity.GRAVITY_BOTTOM);
        // 设置宽度
        this.setChoosePictureDialogWidth(100);
    }

    // 是否展示
    public boolean isShowing() {
        return dialog != null && dialog.isShowing();
    }

    // 设置Dialog所依赖的Fragment
    public ChoosePictureDialog setFragment(DialogFragment fragment) {
        this.fragment = fragment;
        return this;
    }

    // 检查权限后启动拍照
    public ChoosePictureDialog CheckPermissionAndStartPhoto() {
        Log.v("msgg","startphoto");
        // 判断是否需要拍照权限
        int checkCallPhonePermission = ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA);
        if (checkCallPhonePermission != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.CAMERA}, ConstantUtil.PERMISSION_CAMERA_REQUEST_CODE);
        } else {
            // 判断是否需要sdcard中读取数据的权限
            int checkCallSDReadPermission = ContextCompat.checkSelfPermission(context, Manifest.permission.READ_EXTERNAL_STORAGE);
            if (checkCallSDReadPermission != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, ConstantUtil.PERMISSION_READ_EXTERNAL_STORAGE_REQUEST_CODE);
            } else {
                // 判断是否需要写入数据到扩展存储卡(SD)的权限
                int checkCallSDWritePermission = ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE);
                if (checkCallSDWritePermission != PackageManager.PERMISSION_GRANTED) {
                    ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, ConstantUtil.PERMISSION_WRITE_EXTERNAL_STORAGE_REQUEST_CODE);
                } else {
                    if (onPhotoListener != null) {
                        onPhotoListener.onPhoto();
                    } else {
                        // 启动拍照
                        if (fragment != null && fragment.getContext() == context)
                            ChoosePictrueUtil.startPhoto2(fragment);
                        else
                            ChoosePictrueUtil.startPhoto2(context);
                    }
                }
            }
        }
        return this;
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.AlbumButton:  //从本地相册选择
                if (ClickUtil.isFastClick())
                    return;
                closeChoosePictureDialog();
                if (onLocalListener != null) {
                    onLocalListener.onLocal();
                } else {
                    // 启动本地相册
                    if (fragment != null && fragment.getContext() == context)
                        ChoosePictrueUtil.startLocal2(fragment);
                    else
                        ChoosePictrueUtil.startLocal2(context);
                }
                break;
            case R.id.CameraButton:   //现场拍照
                if (ClickUtil.isFastClick())
                    return;
                closeChoosePictureDialog();
                if (onLocalListener != null) {
                    onLocalListener.onLocal();
                } else {
                    // 启动相机拍照
                    ChoosePictrueUtil.startPhoto(context);
                }
                break;
            case R.id.CancelButton:   //取消
                if (ClickUtil.isFastClick())
                    return;
                closeChoosePictureDialog();
                if (onCancelListener != null) {
                    onCancelListener.onCancel();
                }
                break;
        }
    }

    /**
     * 设置三个按钮的高度
     *
     * @param pixels 待设置高度px
     */
    public ChoosePictureDialog setBtnHeight(int pixels) {
        try {
            albumBtn.getLayoutParams().height = pixels;
            cameraBtn.getLayoutParams().height = pixels;
            cancelBtn.getLayoutParams().height = pixels;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

    /**
     * 设置三个按钮的字体颜色
     *
     * @param color 颜色值16进制
     */
    public ChoosePictureDialog setBtnColor(String color) {
        try {
            albumBtn.setTextColor(Color.parseColor(color));
            cameraBtn.setTextColor(Color.parseColor(color));
            cancelBtn.setTextColor(Color.parseColor(color));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

    /**
     * 设置三个按钮的字体大小
     *
     * @param size 字体大小值
     */
    public ChoosePictureDialog setBtnSize(float size) {
        albumBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        cameraBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        cancelBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        return this;
    }

    /**
     * 修改本地按钮文本颜色
     *
     * @param color 文本颜色
     */
    public ChoosePictureDialog setLocalBtnColor(String color) {
        try {
            albumBtn.setTextColor(Color.parseColor(color));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

    /**
     * 修改拍照按钮文本颜色
     *
     * @param color 文本颜色
     */
    public ChoosePictureDialog setPhotoBtnColor(String color) {
        try {
            cameraBtn.setTextColor(Color.parseColor(color));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

    /**
     * 修改取消按钮文本颜色
     *
     * @param color 文本颜色
     */
    public ChoosePictureDialog setCancelBtnColor(String color) {
        try {
            cancelBtn.setTextColor(Color.parseColor(color));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

    /**
     * 修改本地按钮文本字体大小
     *
     * @param size 字体大小
     */
    public ChoosePictureDialog setLocalBtnSize(float size) {
        albumBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        return this;
    }

    /**
     * 修改拍照按钮文本字体大小
     *
     * @param size 字体大小
     */
    public ChoosePictureDialog setPhotoBtnSize(float size) {
        cameraBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        return this;
    }

    /**
     * 修改取消按钮文本字体大小
     *
     * @param size 字体大小
     */
    public ChoosePictureDialog setCancelBtnSize(float size) {
        cancelBtn.setTextSize(TypedValue.COMPLEX_UNIT_SP, size);
        return this;
    }

    /**
     * 修改本地按钮文本
     *
     * @param text 文本信息
     */
    public ChoosePictureDialog setLocalBtnText(CharSequence text) {
        if (!TextUtils.isEmpty(text))
            albumBtn.setText(text);
        return this;
    }

    /**
     * 修改拍照按钮文本
     *
     * @param text 文本信息
     */
    public ChoosePictureDialog setPhotoBtnText(CharSequence text) {
        if (!TextUtils.isEmpty(text))
            cameraBtn.setText(text);
        return this;
    }

    /**
     * 修改取消按钮文本
     *
     * @param text 文本信息
     */
    public ChoosePictureDialog setCancelBtnText(CharSequence text) {
        if (!TextUtils.isEmpty(text))
            cancelBtn.setText(text);
        return this;
    }

    /**
     * 按返回键是否取消
     *
     * @param cancelable true 取消 false 不取消  默认true
     */
    public ChoosePictureDialog setCancelable(boolean cancelable) {
        if (dialog != null)
            dialog.setCancelable(cancelable);
        return this;
    }

    /**
     * 点击Dialog外围是否取消
     *
     * @param cancelable true 取消 false 不取消  默认false
     */
    public ChoosePictureDialog setCanceledOnTouchOutside(boolean cancelable) {
        if (dialog != null)
            dialog.setCanceledOnTouchOutside(cancelable);
        return this;
    }

    /**
     * 设置取消事件
     *
     * @param onCancelListener 取消事件
     */
    public ChoosePictureDialog setOnCancelListener(DialogInterface.OnCancelListener onCancelListener) {
        if (dialog != null)
            dialog.setOnCancelListener(onCancelListener);
        return this;
    }

    /**
     * 设置Dialog显示位置
     *
     * @param ChoosePictureDialogGravity 左上右下中
     */
    public ChoosePictureDialog setChoosePictureDialogGravity(ChoosePictureDialogGravity ChoosePictureDialogGravity) {
        Window window = dialog.getWindow();
        int gravity = Gravity.CENTER;
        if (ChoosePictureDialogGravity == ChoosePictureDialogGravity.GRAVITY_BOTTOM) {
            gravity = Gravity.BOTTOM;
        } else if (ChoosePictureDialogGravity == ChoosePictureDialogGravity.GRAVITY_CENTER) {
            gravity = Gravity.CENTER;
        } else if (ChoosePictureDialogGravity == ChoosePictureDialogGravity.GRAVITY_LEFT) {
            gravity = Gravity.START;
        } else if (ChoosePictureDialogGravity == ChoosePictureDialogGravity.GRAVITY_RIGHT) {
            gravity = Gravity.END;
        } else if (ChoosePictureDialogGravity == ChoosePictureDialogGravity.GRAVITY_TOP) {
            gravity = Gravity.TOP;
        }
        if (window != null)
            window.getAttributes().gravity = gravity;
        return this;
    }

    /**
     * 设置背景层透明度
     *
     * @param dimAmount 0~1
     */
    public ChoosePictureDialog setDimAmount(float dimAmount) {
        Window window = dialog.getWindow();
        if (window != null) {
            WindowManager.LayoutParams lp = window.getAttributes();
            // 设置背景层透明度
            lp.dimAmount = dimAmount;
            window.setAttributes(lp);
        }
        return this;
    }

    /**
     * 设置Window动画
     *
     * @param style R文件
     */
    public ChoosePictureDialog setWindowAnimations(int style) {
        if (dialog != null) {
            Window window = dialog.getWindow();
            if (window != null) {
                window.setWindowAnimations(style);
            }
        }
        return this;
    }

    /**
     * 设置Dialog宽度
     *
     * @param proportion 和屏幕的宽度比(10代表10%) 0~100
     */
    public ChoosePictureDialog setChoosePictureDialogWidth(int proportion) {
        if (dialog != null) {
            Window window = dialog.getWindow();
            if (window != null) {
                WindowManager.LayoutParams lp = window.getAttributes();
                lp.width = getScreenW(context) * proportion / 100;
                window.setAttributes(lp);
            }
        }
        return this;
    }

    /**
     * 设置Dialog高度
     *
     * @param proportion 和屏幕的高度比(10代表10%) 0~100
     */
    public ChoosePictureDialog setChoosePictureDialogHeight(int proportion) {
        if (dialog != null) {
            Window window = dialog.getWindow();
            if (window != null) {
                WindowManager.LayoutParams lp = window.getAttributes();
                lp.height = getScreenH(context) * proportion / 100;
                window.setAttributes(lp);
            }
        }
        return this;
    }

    /**
     * 获取屏幕宽度
     */
    private int getScreenW(Context aty) {
        DisplayMetrics dm = aty.getResources().getDisplayMetrics();
        return dm.widthPixels;
    }

    /**
     * 获取屏幕的高度
     */
    private int getScreenH(Context context) {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        if (wm != null)
            wm.getDefaultDisplay().getMetrics(outMetrics);
        return outMetrics.heightPixels;
    }

    /**
     * 展示Dialog
     */
    public ChoosePictureDialog showChoosePictureDialog() {
        if (dialog != null && !dialog.isShowing())
            dialog.show();
        return this;
    }

    /**
     * 关闭Dialog
     */
    public ChoosePictureDialog closeChoosePictureDialog() {
        if (dialog != null)
            dialog.cancel();
        return this;
    }

    /**
     * 设置背景
     *
     * @param resource 资源文件地址
     */
    public ChoosePictureDialog setBackgroundDrawable(int resource) {
        if (dialog != null && dialog.getWindow() != null)
            dialog.getWindow().setBackgroundDrawableResource(resource);
        return this;
    }

    /**
     * 设置背景
     *
     * @param drawable drawable资源
     */
    public ChoosePictureDialog setBackgroundDrawable(Drawable drawable) {
        if (dialog != null && dialog.getWindow() != null)
            dialog.getWindow().setBackgroundDrawable(drawable);
        return this;
    }

    // 本地按钮点击接口
    public interface OnLocalListener {
        void onLocal();
    }

    private OnLocalListener onLocalListener;

    public ChoosePictureDialog setOnLocalListener(OnLocalListener onLocalListener) {
        this.onLocalListener = onLocalListener;
        return this;
    }

    // 拍照按钮点击接口
    public interface OnPhotoListener {
        void onPhoto();
    }

    private OnPhotoListener onPhotoListener;

    public ChoosePictureDialog setOnPhotoListener(OnPhotoListener onPhotoListener) {
        this.onPhotoListener = onPhotoListener;
        return this;
    }

    // 取消按钮点击接口
    public interface OnCancelListener {
        void onCancel();
    }

    private OnCancelListener onCancelListener;

    public ChoosePictureDialog setOnCancelListener(OnCancelListener onCancelListener) {
        this.onCancelListener = onCancelListener;
        return this;
    }
}

(2)、ChoosePictrueUtil.java 选择图片管理类

import android.app.Activity;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.widget.Toast;

import androidx.fragment.app.DialogFragment;

import java.io.File;

public class ChoosePictrueUtil {

    public static Uri photoUri;// 拍照URI，拍照相对于新生产的，所有要进行转换
    public static String imgPath;// 图片地址

    // 生成一个URI地址
    public static Uri createImageViewUri(Context context) {
        String name = "tmp" + System.currentTimeMillis();
        ContentValues values = new ContentValues();
        values.put(MediaStore.Images.Media.TITLE, name);
        values.put(MediaStore.Images.Media.DISPLAY_NAME, name + ".png");
        values.put(MediaStore.Images.Media.MIME_TYPE, "image/*");
        return context.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
    }

    // 刪除URI
    public static void deleteUri(Context context, Uri uri) {
        context.getContentResolver().delete(uri, null, null);
    }

    // 启动拍照1
    public static void startPhoto(Context context) {
        photoUri = createImageViewUri(context);
        if (photoUri != null) {
            Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            intent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri); // 将拍照后的图像保存到photoUri
            ((Activity) context).startActivityForResult(intent, ConstantUtil.RESULT_PHOTO_CODE);
        }
    }

    // 启动拍照1
    public static void startPhoto(DialogFragment fragment) {
        if (fragment.getContext() != null)
            photoUri = createImageViewUri(fragment.getContext());
        if (photoUri != null) {
            Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            intent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri); // 将拍照后的图像保存到photoUri
            fragment.startActivityForResult(intent, ConstantUtil.RESULT_PHOTO_CODE);
        }
    }

    // 启动拍照2
    public static void startPhoto2(Context context) {
        try {
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                // 创建文件夹
                boolean isSuccess = true;
                File dirFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath(), "DialogPhotoCache");
                if (!dirFile.exists()) {
                    isSuccess = dirFile.mkdirs();
                }
                if (isSuccess) {
                    // 创建文件
                    imgPath = dirFile.getAbsolutePath() + File.separator + System.currentTimeMillis() + ".png";
                    File imgFile = new File(imgPath);
                    Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    // 判断是否是AndroidN以及更高的版本
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                        photoUri = fileProvider.getUriForFile(context, context.getApplicationContext().getPackageName() + ".fileProvider", imgFile);
                        // 添加权限
                        openCameraIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
                    } else
                        photoUri = Uri.fromFile(imgFile);
                    openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri);
                    ((Activity) context).startActivityForResult(openCameraIntent, ConstantUtil.RESULT_PHOTO_CODE);
                }
            } else {
                Toast.makeText(context, "SD卡不存在,请插入SD卡！", Toast.LENGTH_SHORT).show();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 启动拍照3
    public static void startPhoto2(DialogFragment fragment) {
        try {
            if (fragment.getContext() != null) {
                if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
                    // 创建文件夹
                    boolean isSuccess = true;
                    File dirFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath(), "ZDialogPhotoCache");
                    if (!dirFile.exists()) {
                        isSuccess = dirFile.mkdirs();
                    }
                    if (isSuccess) {
                        // 创建文件
                        imgPath = dirFile.getAbsolutePath() + File.separator + System.currentTimeMillis() + ".png";
                        File imgFile = new File(imgPath);
                        Intent openCameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        // 判断是否是AndroidN以及更高的版本
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                            photoUri = fileProvider.getUriForFile(fragment.getContext(), fragment.getContext().getApplicationContext().getPackageName() + ".fileProvider", imgFile);
                            // 添加权限
                            openCameraIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
                        } else
                            photoUri = Uri.fromFile(imgFile);
                        openCameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri);
                        fragment.startActivityForResult(openCameraIntent, ConstantUtil.RESULT_PHOTO_CODE);
                    }
                } else {
                    Toast.makeText(fragment.getContext(), "SD卡不存在,请插入SD卡！", Toast.LENGTH_SHORT).show();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 从相册中获取1
    public static void startLocal(Context context) {
        // 调用android的图库
        Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
        ((Activity) context).startActivityForResult(intent, ConstantUtil.RESULT_LOAD_CODE);
    }

    // 从相册中获取1
    public static void startLocal(DialogFragment fragment) {
        // 调用android的图库
        Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
        fragment.startActivityForResult(intent, ConstantUtil.RESULT_LOAD_CODE);
    }

    // 从相册中获取，此模式支持长按多选
    public static void startLocal2(Context context) {
        // 调用android的图库
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        intent.setType("image/*");
        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
        ((Activity) context).startActivityForResult(intent, ConstantUtil.RESULT_LOAD_CODE);
    }

    // 从相册中获取，此模式支持长按多选
    public static void startLocal2(DialogFragment fragment) {
        // 调用android的图库
        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        intent.setType("image/*");
        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
        fragment.startActivityForResult(intent, ConstantUtil.RESULT_LOAD_CODE);
    }
}

3、UploadPictureUtil.java //上传图片管理类

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Environment;
import android.widget.ImageView;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class UploadPictureUtil {


    /***
     * 将Bitmap数据保存为File图片文件
     * @param bitmap  待保存为图像文件的Bitmap数据
     * @return file
     */
    // 把位图数据保存到指定路径的图片文件
    public static File saveImageFileFromBitmap(Bitmap bitmap) {
        //指定文件保存在手机的临时路径
        String imagepath = Environment.getExternalStorageDirectory()+File.separator+"QingZhouLinYe"+File.separator+"UploadPicture"+File.separator;
        String imagename= "temp.png";
        //判断文件夹是否存在
        if(!new File(imagepath).exists()){
            //如果文件夹不存在，则自动创建
            new File(imagepath).mkdir();
        }
        // 根据指定的文件路径构建文件输出流对象
        try (FileOutputStream fos = new FileOutputStream(imagepath+imagename)) {
            // 把位图数据压缩到文件输出流中
            bitmap.compress(Bitmap.CompressFormat.PNG, 80, fos);  //压缩比例80%
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new File(imagepath+imagename);
    }

    /**
     * 从ImageView获取图片Bitmap数据
     * @param imageview  imageview控件
     * @return bitmap
     */
    public static Bitmap getBitmapFromImageView(ImageView imageview){
        Drawable drawable = imageview.getDrawable();
        if(drawable == null){
            return  null;
        }
        Bitmap bitmap;
        if(drawable instanceof BitmapDrawable){
            bitmap = ((BitmapDrawable)drawable).getBitmap();
        }else{
            bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),drawable.getIntrinsicHeight(),Bitmap.Config.ARGB_8888);
            Canvas canvas = new Canvas(bitmap);
            drawable.setBounds(0,0,canvas.getWidth(),canvas.getHeight());;
            drawable.draw(canvas);
        }
        return bitmap;
    }

    /**
     * 图片无压缩直接上传图片
     * @param url  上传图片服务器路径
     * @param file  需要上传的图片文件
     */
    public static void uploadImage(String url,File file){
        OkHttpClient okHttpClient = new OkHttpClient();
        RequestBody image = RequestBody.create(MediaType.parse("image/jpg"), file);
        RequestBody requestBody = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)    //请求类型
                .addFormDataPart("filename", "证件照")    //参数1  name值filename必须和服务器端接收参数一致
                .addFormDataPart("filepath","renyuan/zhengjianzhao")  //参数2  name值filepath必须和服务器端接收参数一致
                .addFormDataPart("file", file.getPath(), image)  //待上传的图片文件  name值file必须和服务器端接收参数一致
                .build();
        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {

            }
        });
    }

    /**
     * 压缩图片后上传图片
     * @param url  上传图片服务器路径
     * @param imagePath    图片路径
     * @param desWidth    压缩宽度
     */
    public static void uploadImage(String url, String imagePath,float desWidth) {
        //下面这两句是用于压缩的，不需要的话可以直接删除掉
        Bitmap compressbitmap = compressImageFromFile(imagePath,desWidth);
        File file = compressImage(compressbitmap);
        //调用重载，发送post请求
        uploadImage(url,file);
    }


    //图片压缩
    public static Bitmap compressImageFromFile(String srcPath, float desWidth) {
        BitmapFactory.Options newOpts = new BitmapFactory.Options();
        newOpts.inJustDecodeBounds = true;//只读边,不读内容
        Bitmap bitmap;
        bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        float desHeight = desWidth * h / w;
        int be = 1;
        if (w > h && w > desWidth) {
            be = (int) (newOpts.outWidth / desWidth);
        } else if (w < h && h > desHeight) {
            be = (int) (newOpts.outHeight / desHeight);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;//设置采样率

        newOpts.inPreferredConfig = Bitmap.Config.ARGB_8888;//该模式是默认的,可不设
        newOpts.inPurgeable = true;// 同时设置才会有效
        newOpts.inInputShareable = true;//。当系统内存不够时候图片自动被回收

        bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
        return bitmap;
    }

    /**
     * 压缩图片（质量压缩）
     *
     * @param image
     */
    public static File compressImage(Bitmap image) {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;

        while (baos.toByteArray().length / 1024 > 100) {  //循环判断如果压缩后图片是否大于100kb,大于继续压缩
            baos.reset();//重置baos即清空baos
            options -= 10;//每次都减少10
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
            long length = baos.toByteArray().length;
        }
        File file = new File(Environment.getExternalStorageDirectory() + "/temp.png");
        try {
            FileOutputStream fos = new FileOutputStream(file);
            try {
                fos.write(baos.toByteArray());
                fos.flush();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        return file;
    }
}

4、ConstantUtil.java 常量管理类

public class ConstantUtil {
    public static final int PERMISSION_CAMERA_REQUEST_CODE = 222;// 拍照权限请求码
    public static final int PERMISSION_READ_EXTERNAL_STORAGE_REQUEST_CODE = 223;// sdcard中读取数据的权限请求码
    public static final int PERMISSION_WRITE_EXTERNAL_STORAGE_REQUEST_CODE = 224;// 写入数据到扩展存储卡(SD)请求码

    public static final int REQUEST_CROP_CODE = 10; // 裁剪请求码
    public static final int RESULT_LOAD_CODE = 11; // 从本地相册中获取
    public static final int RESULT_PHOTO_CODE = 12; // 拍照
}

5、 fileProvider.java FileProvider自定义类，用于Adnroid 6以后权限共享资源

此文件可以为空，也可以进行自定义，只允许访问指定资源，

运用此文件，可以省去在AndroidManifest.xml文件中添加FileProvider节点。

import androidx.core.content.FileProvider;

public class fileProvider extends FileProvider {
}

6、权限管理类

public class PermissionUtil {
    //检测相机和SD卡读写权限
    public static void getSelectPicturePermission(Activity activity, ChoosePictureDialog dialog,int requestCode, int[] grantResults){
        switch (requestCode) {
            case ConstantUtil.PERMISSION_CAMERA_REQUEST_CODE:
                if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    dialog.CheckCameraPermission();
                } else {
                    Toast.makeText(activity, "获取拍照权限失败", Toast.LENGTH_SHORT).show();
                }
                break;
            case ConstantUtil.PERMISSION_READ_EXTERNAL_STORAGE_REQUEST_CODE:
                if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    dialog.CheckCameraPermission();
                } else {
                    Toast.makeText(activity, "sdcard中读取数据的权限失败", Toast.LENGTH_SHORT).show();
                }
                break;
            case ConstantUtil.PERMISSION_WRITE_EXTERNAL_STORAGE_REQUEST_CODE:
                if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    dialog.CheckCameraPermission();
                } else {
                    Toast.makeText(activity, "写入数据到扩展存储卡(SD)权限失败", Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }
}

主要代码就这些，其他的一些资源文件大家自己解决吧。

下一步增加显示上传进度和从服务器加载网络图片功能