选取图片发送（可查看缩略图）

1. 跳转系统相册所在activity获取图片

 public static void selectPhoto(Activity activity) {
        //使用这个方法可以调用，会让用户选择照片选取工具。系统会选取所有可用的程序来供用户选择
        Intent intent = new Intent(Intent.ACTION_PICK, null);
        //如果要限制上传到服务器的图片类型时可以直接写如：”image/jpeg 、 image/png等的类型”
        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
        activity.startActivityForResult(intent, INTENT_REQUEST_CODE_ALBUM);
        //跳转到系统相册activity，requestCode = INTENT_REQUEST_CODE_ALBUM
    }

2.onActivityResult接收所选图片信息（对应：返回数据给上一个活动）

 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
//根据requestCode确定是从相册里获取后返回，返回所选图片信息
            case ImageUtils.INTENT_REQUEST_CODE_ALBUM:            
//在相册中未选取图片且按了返回键，则data=null。用户按了返回键则resultCode == RESULT_CANCELED
                if(data == null)
                    return;
                }
                if (resultCode == RESULT_OK) {//选取图片成功返回相关数据
                    if (data.getData() == null) {
                        return;
                    }
                    if (!FileUtils.isSdcardExist()) {
                        ToastUtil.showMid(this, R.string.toast_sdcard_unavailable);
                        return;
                    }
                    Uri uri = data.getData();//拿到所选图片的Uri。


                }
                break;

3.android 通过uri获取bitmap图片并压缩

主函数：

switch (requestCode) {
    case ImageUtils.INTENT_REQUEST_CODE_ALBUM:            
        if(data == null){
            return;
        }
        if (resultCode == RESULT_OK) {

        接第二部分代码

//参数1：要查询的资源的uri(The URI of the content provider to query.)
//参数2：查询该uri资源的哪几列List of columns to return
        String[] proj = { MediaStore.Images.Media.DATA };
        Cursor cursor = managedQuery(uri, proj, null, null, null);
        if (cursor != null) {
        if (cursor.getCount() > 0 && cursor.moveToFirst())   {
        String path = ImageUtils.getPath(this, uri)
//根据图片存储路径得到图片
        Bitmap bitmap = ImageUtils.getBitmapFromPath(path);

/**
判断图片是否过大，如果过大就压缩图片并将压缩图片存入SD卡；如果图片不大，则创建缩略图？
*/
     if (ImageUtils.bitmapIsLarge(bitmap)) {
// Compression Photo压缩图片
     Bitmap bitmap1 = ImageUtils.CompressionPhoto(mScreenWidth, path, 5);
 //将压缩后的图片存入sdk
     String str = ImageUtils.savePhotoToSDCard(this, bitmap1, ChatApplication.IMAG_PATH, null);
    try{MediaStore.Images.Media.insertImage(this.getContentResolver(),str, null, null);
   } catch (FileNotFoundException e) {
        e.printStackTrace()
    }
    //压缩后创建缩略图，用于消息界面的显示。
     ImageUtils.createThumbnail(this, str, THUMBNAIL_PATH + File.separator);
    //发送压缩过的图片（消息界面点击后查看到的图片）
     photoSend(str);                          
   }else {//图片不过大就创建缩略图
        if (path != null) {                                   ImageUtils.createThumbnail(this, path, THUMBNAIL_PATH
+ File.separator);
                                }
                            }
                        }
                    }
}

主函数中的分函数：
1.根据Uri获得路径pah
ImageUtils.getPath(this, uri)

 4.4及以上获取图片的方法
  @TargetApi(Build.VERSION_CODES.KITKAT)
    public static String getPath(final Context context, final Uri uri) {

        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;

        // DocumentProvider
        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
            // ExternalStorageProvider
            if (isExternalStorageDocument(uri)) {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];

                if ("primary".equalsIgnoreCase(type)) {
                    return Environment.getExternalStorageDirectory() + "/" + split[1];
                }
            }
            // DownloadsProvider
            else if (isDownloadsDocument(uri)) {

                final String id = DocumentsContract.getDocumentId(uri);
                final Uri contentUri = ContentUris.withAppendedId(
                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));

                return getDataColumn(context, contentUri, null, null);
            }
            // MediaProvider
            else if (isMediaDocument(uri)) {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];

                Uri contentUri = null;
                if ("image".equals(type)) {
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                } else if ("video".equals(type)) {
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                } else if ("audio".equals(type)) {
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                }

                final String selection = "_id=?";
                final String[] selectionArgs = new String[] { split[1] };

                return getDataColumn(context, contentUri, selection, selectionArgs);
            }
        }
        // MediaStore (and general)
        else if ("content".equalsIgnoreCase(uri.getScheme())) {

            // Return the remote address
            if (isGooglePhotosUri(uri))
                return uri.getLastPathSegment();

            return getDataColumn(context, uri, null, null);
        }
        // File
        else if ("file".equalsIgnoreCase(uri.getScheme())) {
            return uri.getPath();
        }

        return null;
    }

    public static String getDataColumn(Context context, Uri uri, String selection,
                                       String[] selectionArgs) {

        Cursor cursor = null;
        final String column = "_data";
        final String[] projection = { column };

        try {
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                    null);
            if (cursor != null && cursor.moveToFirst()) {
                final int index = cursor.getColumnIndexOrThrow(column);
                return cursor.getString(index);
            }
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return null;
    }

    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is ExternalStorageProvider.
     */
    public static boolean isExternalStorageDocument(Uri uri) {
        return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }

    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is DownloadsProvider.
     */
    public static boolean isDownloadsDocument(Uri uri) {
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }

    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is MediaProvider.
     */
    public static boolean isMediaDocument(Uri uri) {
        return "com.android.providers.media.documents".equals(uri.getAuthority());
    }

    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is Google Photos.
     */
    public static boolean isGooglePhotosUri(Uri uri) {
        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
    }

2.根据路径获得位图
ImageUtils.getBitmapFromPath(path);

  public static Bitmap getBitmapFromPath(String path) {
        return BitmapFactory.decodeFile(path);
    }

3.压缩图片
ImageUtils.CompressionPhoto(mScreenWidth, path, 5);

 public static Bitmap CompressionPhoto(float screenWidth, String filePath, int ratio) {
        Bitmap bitmap = ImageUtils.getBitmapFromPath(filePath);
        Bitmap compressionBitmap = null;
        float scaleWidth = screenWidth / (bitmap.getWidth() * ratio);
        float scaleHeight = screenWidth / (bitmap.getHeight() * ratio);
        Matrix matrix = new Matrix();
        matrix.postScale(scaleWidth, scaleHeight);
        try {
            compressionBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
                    bitmap.getHeight(), matrix, true);
        }
        catch (Exception e) {
            return bitmap;
        }
        return compressionBitmap;
    }

public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height,
Matrix m, boolean filter)

        public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height,
            Matrix m, boolean filter) {

        checkXYSign(x, y);
        checkWidthHeight(width, height);
        if (x + width > source.getWidth()) {
            throw new IllegalArgumentException("x + width must be <= bitmap.width()");
        }
        if (y + height > source.getHeight()) {
            throw new IllegalArgumentException("y + height must be <= bitmap.height()");
        }

        // check if we can just return our argument unchanged
        if (!source.isMutable() && x == 0 && y == 0 && width == source.getWidth() &&
                height == source.getHeight() && (m == null || m.isIdentity())) {
            return source;
        }

        int neww = width;
        int newh = height;
        Canvas canvas = new Canvas();
        Bitmap bitmap;
        Paint paint;

        Rect srcR = new Rect(x, y, x + width, y + height);
        RectF dstR = new RectF(0, 0, width, height);

        Config newConfig = Config.ARGB_8888;
        final Config config = source.getConfig();
        // GIF files generate null configs, assume ARGB_8888
        if (config != null) {
            switch (config) {
                case RGB_565:
                    newConfig = Config.RGB_565;
                    break;
                case ALPHA_8:
                    newConfig = Config.ALPHA_8;
                    break;
                //noinspection deprecation
                case ARGB_4444:
                case ARGB_8888:
                default:
                    newConfig = Config.ARGB_8888;
                    break;
            }
        }

        if (m == null || m.isIdentity()) {
            bitmap = createBitmap(neww, newh, newConfig, source.hasAlpha());
            paint = null;   // not needed
        } else {
            final boolean transformed = !m.rectStaysRect();

            RectF deviceR = new RectF();
            m.mapRect(deviceR, dstR);

            neww = Math.round(deviceR.width());
            newh = Math.round(deviceR.height());

            bitmap = createBitmap(neww, newh, transformed ? Config.ARGB_8888 : newConfig,
                    transformed || source.hasAlpha());

            canvas.translate(-deviceR.left, -deviceR.top);
            canvas.concat(m);

            paint = new Paint();
            paint.setFilterBitmap(filter);
            if (transformed) {
                paint.setAntiAlias(true);
            }
        }

        // The new bitmap was created from a known bitmap source so assume that
        // they use the same density
        bitmap.mDensity = source.mDensity;
        bitmap.setHasAlpha(source.hasAlpha());
        bitmap.setPremultiplied(source.mRequestPremultiplied);

        canvas.setBitmap(bitmap);
        canvas.drawBitmap(source, srcR, dstR, paint);
        canvas.setBitmap(null);

        return bitmap;
    }

4.将图片存入sd卡并获取存储路径
String str = ImageUtils.savePhotoToSDCard(this, bitmap1, ChatApplication.IMAG_PATH, null);

 public static String savePhotoToSDCard(Context context, Bitmap bitmap, String filedir, String paramFilename) {

        if (!FileUtils.isSdcardExist()) {
            return null;
        }
        FileUtils.createDirFile(filedir);
        int quality = 60; // 缩略图没必要高质量
        String filename = paramFilename;

        if (TextUtils.isEmpty(paramFilename)) {
            filename = UUID.randomUUID().toString() + ".jpg";
            quality = 100;
        }

        String newFilePath = filedir + File.separator + filename;
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(newFilePath);
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, fileOutputStream);
            fileOutputStream.flush();
            fileOutputStream.close();

//            MediaStore.Images.Media.insertImage(context.getContentResolver(),
//                    filedir, filename, null);
        }
        catch (IOException e1) {
            return null;
        }
        return newFilePath;
    }

5.获得图片的缩略图并存储
ImageUtils.createThumbnail(this, path, THUMBNAIL_PATH
+ File.separator);

 public static void createThumbnail(Context context, String path, String dir) {
        int imagePX = dp2px(context, 100);
        savePhotoToSDCard(context, decodedBitmapFromPath(path, imagePX, imagePX), dir,
                FileUtils.getNameByPath(path));
    }

6.判断图片大小
public static boolean bitmapIsLarge(Bitmap bitmap)

 public static boolean bitmapIsLarge(Bitmap bitmap) {
        final int MAX_WIDTH = 60;
        final int MAX_HEIGHT = 60;
        Bundle bundle = getBitmapWidthAndHeight(bitmap);
        if (bundle != null) {
            int width = bundle.getInt("width");
            int height = bundle.getInt("height");
            if (width > MAX_WIDTH && height > MAX_HEIGHT) {
                return true;
            }
        }
        return false;
    }

获取图片的长度和宽度
public static Bundle getBitmapWidthAndHeight(Bitmap bitmap)

 public static Bundle getBitmapWidthAndHeight(Bitmap bitmap) {
        Bundle bundle = null;
        if (bitmap != null) {
            bundle = new Bundle();
            bundle.putInt("width", bitmap.getWidth());
            bundle.putInt("height", bitmap.getHeight());
            return bundle;
        }
        return null;
    }