点击查看大图（长按保存图片）

最近做项目时有需求，我就在参考原博客（点击查看大图原博客链接 ）后自己又添加方法，最终实现了长按图片获取原图url以后，自动保存图片到本地。

界面是这个样子的：

    

下面附上关键部分的代码：

 

@Override
    public void onClickable(int viewId) {
        switch (viewId) {
            case R.id.iv_download:
            //点击下载按钮进行下载保存操作
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //网络请求放到子线程
                        final Bitmap b = returnBitmap(imgPath);
                        if (b != null) {
                            runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    saveImgToLocal(b);
                                }
                            });
                        }

                    }
                }).start();

                break;
        }
    }
    /**
     * 根据图片的url路径获得Bitmap对象
     *
     * @param url
     * @return
     */
    private Bitmap returnBitmap(String url) {
        URL fileUrl = null;
        Bitmap bitmap = null;

        try {
            fileUrl = new URL(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

        try {
            HttpURLConnection conn = (HttpURLConnection) fileUrl
                    .openConnection();
            conn.setDoInput(true);
            conn.connect();
            InputStream is = conn.getInputStream();
            bitmap = BitmapFactory.decodeStream(is);
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bitmap;

    }

  /**
     * 保存Bitmap图片对象
     *
     * @param bitmap
     */
    private void saveImgToLocal(Bitmap bitmap) {
        FileUtils.savePhoto(this, bitmap, new FileUtils.SaveResultCallback() {
            @Override
            public void onSavedSuccess() {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        //保存成功后弹出一个提示框
                        Dialog dialog = new DialogUtils(ShowWebImageActivity.this);
                        dialog.setContentView(R.layout.dialog_download_success);
                        dialog.show();
                    }
                });
            }

            @Override
            public void onSavedFailed() {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        //保存失败后弹出一个提示框
                        Dialog dialog = new DialogUtils(ShowWebImageActivity.this);
                        dialog.setContentView(R.layout.dialog_download_failure);
                        dialog.show();
                    }
                });
            }
        });

    }

FileUtils工具类

package com.test.wwy.utils;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.ActivityCompat;
import android.util.Log;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class FileUtils {
    private Context mContext;
    private String TAG = "FileUtils";
    /**
     * sd卡的根目录
     */
    private static String mSdRootPath = Environment
            .getExternalStorageDirectory().getPath();
    /**
     * 手机的缓存根目录
     */
    private static String mDataRootPath = null;

    /**
     * 保存Image的目录名
     */
    private final static String FOLDER_NAME = "/AndroidImage";

    /**
     * 图文详情图片缓存
     */
    private final static String IMAGE_RICHTEXT = "/RichTextImage";

    public FileUtils(Context context) {
        mContext = context;
        mDataRootPath = context.getCacheDir().getPath();
    }

    /**
     * 获取手机根目录，若有SD卡就是SD卡根目录，否则为手机缓存目录
     *
     * @return
     */
    public String getRootDirectory() {
        return Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED) ? mSdRootPath : mDataRootPath;
    }

    /**
     * 获取储存Image的目录
     *
     * @return
     */
    public String getStorageDirectory() {
        return Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED) ? mSdRootPath + FOLDER_NAME
                : mDataRootPath + FOLDER_NAME;
    }

    public String getRichTextImageDirectory() {
        return Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED) ? mSdRootPath + IMAGE_RICHTEXT
                : mDataRootPath + IMAGE_RICHTEXT;
    }

    /**
     * @param fileName
     * @param bitmap
     * @return 保存的图片的路径
     */
    public String savaRichTextImage(String fileName, Bitmap bitmap) {
        fileName = fileName.replaceAll("[^\\w]", "");
        if (bitmap == null) {
            return null;
        }
        String result = null;
        String path = getRichTextImageDirectory();
        File folderFile = new File(path);
        if (!folderFile.exists()) {
            folderFile.mkdirs();
        }
        File file = new File(path + File.separator + fileName + ".jpg");
        if (file.exists()) {
            file.delete();
        }
        try {
            file.createNewFile();
            FileOutputStream fos = new FileOutputStream(file);
            bitmap.compress(CompressFormat.JPEG, 100, fos);
            fos.flush();
            fos.close();
            result = file.getAbsolutePath();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            Log.i(TAG, "savaImage() has FileNotFoundException");
        } catch (IOException e) {
            e.printStackTrace();
            Log.i(TAG, "savaImage() has IOException");
        }

        return result;
    }

    public void deleteRichTextImage() {
        String path = getRichTextImageDirectory();
        File f = new File(path);
        deleteFile(f);
    }

    public void deleteFile(File file) {
        if (file.isFile()) {
            file.delete();
            return;
        }
        if (file.isDirectory()) {
            File[] childFile = file.listFiles();
            if (childFile == null || childFile.length == 0) {
                file.delete();
                return;
            }
            for (File f : childFile) {
                deleteFile(f);
            }
            file.delete();
        }
    }

    /**
     * 根据Uri获取图片文件的绝对路径
     */
    public String getFilePathFromUri(final Uri uri) {
        if (null == uri) {
            return null;
        }

        final String scheme = uri.getScheme();
        String data = null;
        if (scheme == null) {
            data = uri.getPath();
        } else if (ContentResolver.SCHEME_FILE.equals(scheme)) {
            data = uri.getPath();
        } else if (ContentResolver.SCHEME_CONTENT.equals(scheme)) {
            Cursor cursor = mContext.getContentResolver().query(uri,
                    new String[]{MediaStore.Images.ImageColumns.DATA}, null,
                    null, null);
            if (null != cursor) {
                if (cursor.moveToFirst()) {
                    int index = cursor
                            .getColumnIndex(MediaStore.Images.ImageColumns.DATA);
                    if (index > -1) {
                        data = cursor.getString(index);
                    }
                }
                cursor.close();
            }
        }
        return data;
    }

    public static void checkForPermission(Context mContext) {
        /**
         * 动态获取权限，Android 6.0 新特性，一些保护权限，除了要在AndroidManifest中声明权限，还要使用如下代码动态获取
         */
        if (Build.VERSION.SDK_INT >= 23) {
            int REQUEST_EXTERNAL_STORAGE = 1;
            String[] PERMISSIONS_STORAGE = {
                    android.Manifest.permission.READ_EXTERNAL_STORAGE,
                    android.Manifest.permission.WRITE_EXTERNAL_STORAGE
            };
            int permission = ActivityCompat.checkSelfPermission(mContext, android.Manifest.permission.WRITE_EXTERNAL_STORAGE);

            if (permission != PackageManager.PERMISSION_GRANTED) {
                // We don't have permission so prompt the user
                ActivityCompat.requestPermissions(
                        (Activity) mContext,
                        PERMISSIONS_STORAGE,
                        REQUEST_EXTERNAL_STORAGE
                );
            }
        }
    }

    /**
     * 保存图片到本地
     */
    public static void savePhoto(final Context context, final Bitmap bmp, final String imgUrl, final SaveResultCallback saveResultCallback) {
        final File sdDir = getSDPath();
        if (sdDir == null) {
            T.showShort(context, "设备自带的存储不可用");
            return;
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                File appDir = new File(sdDir, "CollegeDaily_Photo");
                if (!appDir.exists()) {
                    appDir.mkdirs();
                }
//				SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");//设置以当前时间格式为图片名称
//				String fileName = df.format(new Date()) + ".png";
                String fileName = MD5Utils.stringToMd5(imgUrl) + ".png";//设置以当前url为图片名称
                File file = new File(appDir.getPath(), fileName);
                try {
                    FileOutputStream fos = new FileOutputStream(file);
                    bmp.compress(CompressFormat.PNG, 100, fos);
                    fos.flush();
                    fos.close();
                    saveResultCallback.onSavedSuccess();
                } catch (FileNotFoundException e) {
                    saveResultCallback.onSavedFailed();
                    e.printStackTrace();
                } catch (IOException e) {
                    saveResultCallback.onSavedFailed();
                    e.printStackTrace();
                }

                //保存图片后发送广播通知更新数据库
                Uri uri = Uri.fromFile(file);
                context.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, uri));
            }
        }).start();
    }

    public static File getSDPath() {
        File sdDir = null;
        boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED); //判断sd卡是否存在
        if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory();//获取跟目录
        }
        return sdDir;
    }

    public interface SaveResultCallback {
        void onSavedSuccess();

        void onSavedFailed();
    }

    /**
     * 复制图片到本地
     * @param context
     * @param oldpath
     * @param localPath
     */
    public static void copyPhotoToLocal(Context context,String oldpath,String localPath){
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldpath);
            if (oldfile.exists()) { //文件存在时
                InputStream inStream = new FileInputStream(oldpath); //读入原文件
                FileOutputStream fs = new FileOutputStream(localPath);
                byte[] buffer = new byte[1444];
                int length;
                while ( (byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread; //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();

                //保存图片后发送广播通知更新数据库
                Uri uri = Uri.fromFile(new File(localPath));
                context.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, uri));
            }
        }
        catch (Exception e) {
            e.printStackTrace();

        }
    }
}

最后欢迎大家评论并及时与我交流学习！