Android从本地选择图片文件转为Bitmap，并用zxing解析Bitmap

如何从本地选择图片文件

使用Intent调用系统相册后，onActivityResult函数返回的是Uri格式的路径

/**
 * 打开系统相册
 */
private void openSysAlbum() {
    Intent innerIntent = new Intent();
    if (Build.VERSION.SDK_INT < 19) {
        innerIntent.setAction(Intent.ACTION_GET_CONTENT);
    } else {
        innerIntent.setAction(Intent.ACTION_OPEN_DOCUMENT);
    }
    innerIntent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
    Intent wrapperIntent = Intent.createChooser(innerIntent, "选择二维码图片");
    startActivityForResult(wrapperIntent, SELECT_IMAGE_REQUEST_CODE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch (requestCode) {
        case SELECT_IMAGE_REQUEST_CODE:
            if (resultCode == RESULT_OK) {
                Uri uri = data.getData();
                scanningImage(uri);
            }
            break;
    }
}

如何将Uri的路径转化为Bitmap

获取Bitmap现在我查到两种解决方案：

• 一种是根据Uri查询图库的数据库，找到文件的真实路径，然后再解析为Bitmap；
• 第二种(http://blog.sina.com.cn/s/blog_5de73d0b0100zfm8.html)是直接根据Uri直接获取到InputStream，再解析为Bitmap。

两种方案都可以，我感觉第二种方案更加靠谱一点，因为系统的数据库可能会更改，但是直接获取InputStream是不会变的。

第一种方案代码

/**
 * 
 * @param intent
 */
public void ecognition(Intent intent) {
    String photo_path = null;
    // 获取选中图片的路径
    String[] proj = { MediaStore.Images.Media.DATA };
    Cursor cursor = getContentResolver().query(intent.getData(), proj, null, null, null);
    if (cursor.moveToFirst()) {
        photo_path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
        if (photo_path == null) {
            photo_path = Utils.getPath(getApplicationContext(), intent.getData());
        }
    }
    cursor.close();
    QRDecode.decodeQR(photo_path, this);
}

/**
 * 解析二维码图片
 *
 * @param picturePath
 * @param listener
 * @return
 */
public static void decodeQR(String picturePath, OnScannerCompletionListener listener) {
    try {
        decodeQR(loadBitmap(picturePath), listener);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}

public static Bitmap loadBitmap(String picturePath) throws FileNotFoundException {
    BitmapFactory.Options opt = new BitmapFactory.Options();
    opt.inJustDecodeBounds = true;
    Bitmap bitmap = BitmapFactory.decodeFile(picturePath, opt);
    // 获取到这个图片的原始宽度和高度
    int picWidth = opt.outWidth;
    int picHeight = opt.outHeight;
    // 获取画布中间方框的宽度和高度
    int screenWidth = CameraManager.MAX_FRAME_WIDTH;
    int screenHeight = CameraManager.MAX_FRAME_HEIGHT;
    // isSampleSize是表示对图片的缩放程度，比如值为2图片的宽度和高度都变为以前的1/2
    opt.inSampleSize = 1;
    // 根据屏的大小和图片大小计算出缩放比例
    if (picWidth > picHeight) {
        if (picWidth > screenWidth)
            opt.inSampleSize = picWidth / screenWidth;
    } else {
        if (picHeight > screenHeight)
            opt.inSampleSize = picHeight / screenHeight;
    }
    // 生成有像素经过缩放了的bitmap
    opt.inJustDecodeBounds = false;
    bitmap = BitmapFactory.decodeFile(picturePath, opt);
    if (bitmap == null) {
        throw new FileNotFoundException("Couldn't open " + picturePath);
    }
    return bitmap;
}

第二种方案代码（推荐）

代码来源博客：【Android】通过Uri获取Bitmap对象

/**
 * 读取一个缩放后的图片，限定图片大小，避免OOM
 * http://blog.sina.com.cn/s/blog_5de73d0b0100zfm8.html
 * @param uri       图片uri，支持“file://”、“content://”
 * @param maxWidth  最大允许宽度
 * @param maxHeight 最大允许高度
 * @return  返回一个缩放后的Bitmap，失败则返回null
 */
public static Bitmap decodeUri(Context context, Uri uri, int maxWidth, int maxHeight) {
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true; //只读取图片尺寸
    resolveUri(context, uri, options);

    //计算实际缩放比例
    int scale = 1;
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        if ((options.outWidth / scale > maxWidth &&
                options.outWidth / scale > maxWidth * 1.4) ||
                (options.outHeight / scale > maxHeight &&
                        options.outHeight / scale > maxHeight * 1.4)) {
            scale++;
        } else {
            break;
        }
    }

    options.inSampleSize = scale;
    options.inJustDecodeBounds = false;//读取图片内容
    options.inPreferredConfig = Bitmap.Config.RGB_565; //根据情况进行修改
    Bitmap bitmap = null;
    try {
        bitmap = resolveUriForBitmap(context, uri, options);
    } catch (Throwable e) {
        e.printStackTrace();
    }
    return bitmap;
}

// http://blog.sina.com.cn/s/blog_5de73d0b0100zfm8.html
private static void resolveUri(Context context, Uri uri, BitmapFactory.Options options) {
    if (uri == null) {
        return;
    }

    String scheme = uri.getScheme();
    if (ContentResolver.SCHEME_CONTENT.equals(scheme) ||
            ContentResolver.SCHEME_FILE.equals(scheme)) {
        InputStream stream = null;
        try {
            stream = context.getContentResolver().openInputStream(uri);
            BitmapFactory.decodeStream(stream, null, options);
        } catch (Exception e) {
            Log.w("resolveUri", "Unable to open content: " + uri, e);
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) {
                    Log.w("resolveUri", "Unable to close content: " + uri, e);
                }
            }
        }
    } else if (ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme)) {
        Log.w("resolveUri", "Unable to close content: " + uri);
    } else {
        Log.w("resolveUri", "Unable to close content: " + uri);
    }
}

// http://blog.sina.com.cn/s/blog_5de73d0b0100zfm8.html
private static Bitmap resolveUriForBitmap(Context context, Uri uri, BitmapFactory.Options options) {
    if (uri == null) {
        return null;
    }

    Bitmap bitmap = null;
    String scheme = uri.getScheme();
    if (ContentResolver.SCHEME_CONTENT.equals(scheme) ||
            ContentResolver.SCHEME_FILE.equals(scheme)) {
        InputStream stream = null;
        try {
            stream = context.getContentResolver().openInputStream(uri);
            bitmap = BitmapFactory.decodeStream(stream, null, options);
        } catch (Exception e) {
            Log.w("resolveUriForBitmap", "Unable to open content: " + uri, e);
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) {
                    Log.w("resolveUriForBitmap", "Unable to close content: " + uri, e);
                }
            }
        }
    } else if (ContentResolver.SCHEME_ANDROID_RESOURCE.equals(scheme)) {
        Log.w("resolveUriForBitmap", "Unable to close content: " + uri);
    } else {
        Log.w("resolveUriForBitmap", "Unable to close content: " + uri);
    }

    return bitmap;
}

如何用zxing解析Bitmap

/**
 * 解析二维码图片
 *
 * @param srcBitmap
 * @return
 */
public static com.google.zxing.Result decodeQR(Bitmap srcBitmap) {
    com.google.zxing.Result result = null;
    if (srcBitmap != null) {
        int width = srcBitmap.getWidth();
        int height = srcBitmap.getHeight();
        int[] pixels = new int[width * height];
        srcBitmap.getPixels(pixels, 0, width, 0, 0, width, height);
        // 新建一个RGBLuminanceSource对象
        RGBLuminanceSource source = new RGBLuminanceSource(width, height, pixels);
        // 将图片转换成二进制图片
        BinaryBitmap binaryBitmap = new BinaryBitmap(new GlobalHistogramBinarizer(source));
        QRCodeReader reader = new QRCodeReader();// 初始化解析对象
        try {
            result = reader.decode(binaryBitmap, CodeHints.getDefaultDecodeHints());// 开始解析
        } catch (NotFoundException e) {
            e.printStackTrace();
        } catch (ChecksumException e) {
            e.printStackTrace();
        } catch (FormatException e) {
            e.printStackTrace();
        }
    }
    return result;
}

其中CodeHints是一个自定义类，类代码：

import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.DecodeHintType;
import com.google.zxing.EncodeHintType;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

import android.text.TextUtils;

public class CodeHints {
    private static Map<DecodeHintType, Object> DECODE_HINTS = new EnumMap<DecodeHintType, Object>(DecodeHintType.class);
    private static Map<EncodeHintType, Object> ENCODE_HINTS = new EnumMap<>(EncodeHintType.class);

    static {
        List<BarcodeFormat> formats = new ArrayList<BarcodeFormat>();
        formats.add(BarcodeFormat.QR_CODE);
        DECODE_HINTS.put(DecodeHintType.POSSIBLE_FORMATS, formats);
//      DECODE_HINTS.put(DecodeHintType.CHARACTER_SET, "UTF-8");

        ENCODE_HINTS.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
//      ENCODE_HINTS.put(EncodeHintType.CHARACTER_SET, "UTF-8");
    }

    /**
     * 获取默认解析QR参数
     * 
     * @return
     */
    public static Map<DecodeHintType, Object> getDefaultDecodeHints() {
        return DECODE_HINTS;
    }

    /**
     * 获取自定义解析QR参数
     * 
     * @param characterSet
     *            编码方式
     * @return
     */
    public static Map<DecodeHintType, Object> getCustomDecodeHints(String characterSet) {
        Map<DecodeHintType, Object> decodeHints = new EnumMap<DecodeHintType, Object>(DecodeHintType.class);
        List<BarcodeFormat> formats = new ArrayList<BarcodeFormat>();
        formats.add(BarcodeFormat.QR_CODE);
        // 设置解码格式
        decodeHints.put(DecodeHintType.POSSIBLE_FORMATS, formats);
        // 设置编码方式
        if (TextUtils.isEmpty(characterSet)) {
            characterSet = "UTF-8";
        }
        decodeHints.put(DecodeHintType.CHARACTER_SET, characterSet);
        return decodeHints;
    }

    /**
     * 获取默认生成QR参数
     * 
     * @return
     */
    public static Map<EncodeHintType, Object> getDefaultEncodeHints() {
        return ENCODE_HINTS;
    }

    /**
     * 获取自定义生成QR参数
     * 
     * @param level
     *            容错率 L,M,Q,H
     * @param version
     *            版本号 1-40
     * @param characterSet
     *            编码方式
     * @return
     */
    public static Map<EncodeHintType, Object> getCustomEncodeHints(ErrorCorrectionLevel level, Integer version,
            String characterSet) {
        Map<EncodeHintType, Object> encodeHints = new EnumMap<>(EncodeHintType.class);
        // 设置容错率
        if (level != null) {
            encodeHints.put(EncodeHintType.ERROR_CORRECTION, level);
        }
        // 设置版本号
        if (version >= 1 && version <= 40) {
            encodeHints.put(EncodeHintType.QR_VERSION, version);
        }
        // 设置编码方式
        if (!TextUtils.isEmpty(characterSet)) {
//          characterSet = "UTF-8";
            encodeHints.put(EncodeHintType.CHARACTER_SET, characterSet);
        }
        return encodeHints;
    }

}