相机、相册相关

主类调用：

ackage com.example.xxx.mycamera;


import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.provider.MediaStore;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;


import java.io.File;
import java.io.IOException;
import java.util.List;


import me.nereo.multi_image_selector.MultiImageSelectorActivity;
import me.nereo.multi_image_selector.MultiImageSelectorFragment;
import me.nereo.multi_image_selector.utils.FileUtils;


public class MainActivity extends AppCompatActivity {


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


    public void album(View v) {
        CameraManager.getInstance().showAlbumAction(MainActivity.this, false, 1, CameraManager.MODE_SINGLE);
    }


    public void camera(View v) {
        CameraManager.getInstance().showCameraAction(MainActivity.this);
    }


    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {


        if (requestCode == CameraManager.REQUEST_CAMERA) {
            //请求拍照
            if (resultCode == Activity.RESULT_OK) {
                if (CameraManager.mTmpFile != null) {
                    Uri o = Uri.fromFile(CameraManager.mTmpFile);
                    CameraManager.mNewPhotoUri = CameraUtil.getOutputMediaFileUri(this, CameraUtil.MEDIA_TYPE_IMAGE);
                    CameraManager.getInstance().cropImage(this, o, CameraManager.mNewPhotoUri, CameraManager.REQUEST_CODE_CROP_PHOTO);


                    Log.d("TAG", "相机 mlocitionFileUrl:" + CameraManager.mNewPhotoUri);
                }
            } else {
                while (CameraManager.mTmpFile != null && CameraManager.mTmpFile.exists()) {
                    boolean success = CameraManager.mTmpFile.delete();
                    if (success) {
                        CameraManager.mTmpFile = null;
                    }
                }
            }
        } else if (requestCode == CameraManager.REQUEST_IMAGE) {
            //请求图片
            if (resultCode == Activity.RESULT_OK) {
                // 获取返回的图片列表
                List<String> path = data.getStringArrayListExtra(MultiImageSelectorActivity.EXTRA_RESULT);
                Uri o = Uri.fromFile(new File(path.get(0)));
                CameraManager.mNewPhotoUri = CameraUtil.getOutputMediaFileUri(this, CameraUtil.MEDIA_TYPE_IMAGE);
                CameraManager.getInstance().cropImage(this, o, CameraManager.mNewPhotoUri, CameraManager.REQUEST_CODE_CROP_PHOTO);
            }


        } else if (requestCode == CameraManager.REQUEST_CODE_CROP_PHOTO) {
            //裁剪
            if (resultCode == Activity.RESULT_OK) {
                if (CameraManager.mNewPhotoUri != null) {
                    CameraManager.mCurrentFile = new File(CameraManager.mNewPhotoUri.getPath());
                    CameraManager.mlocitionFileUrl = CameraManager.mNewPhotoUri.toString();


                    Log.d("TAG", "mlocitionFileUrl:" + CameraManager.mlocitionFileUrl);
                } else {


                }
            }
        }


    }




}

 

权限：

<!-- 往SDCard写入数据权限 -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<!--请求访问使用照相设备·使用多选相册中的照相机，这里不要写这个权限，莫名闪出-->
<!--<uses-permission android:name="android.permission.CAMERA" />-->

CameraManager 抽离的相机逻辑类，让主类更集中处理业务逻辑：

package com.example.xxx.mycamera;


import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.provider.MediaStore;
import android.support.v4.app.Fragment;
import android.widget.Toast;


import java.io.File;
import java.io.IOException;


import me.nereo.multi_image_selector.MultiImageSelectorActivity;
import me.nereo.multi_image_selector.utils.FileUtils;


/**
 * 创建时间：2017/2/14
 * 编写者：
 * 功能描述：相机、相册管理类
 */


public class CameraManager {


    public static File mTmpFile;
    // 请求加载系统照相机
    public static final int REQUEST_CAMERA = 100;


    /**
     * 系统照相机
     * @param activity
     */
    public void showCameraAction(Activity activity) {
        // 跳转到系统照相机
        Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if (cameraIntent.resolveActivity(activity.getPackageManager()) != null) {
            // 设置系统相机拍照后的输出路径
            // 创建临时文件
            try {
                mTmpFile = FileUtils.createTmpFile(activity);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (mTmpFile != null && mTmpFile.exists()) {
                cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mTmpFile));
                // 此值在最低质量最小文件尺寸时是0，在最高质量最大文件尺寸时是１
                //cameraIntent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0);
                activity.startActivityForResult(cameraIntent, REQUEST_CAMERA);
            } else {
                Toast.makeText(activity, "图片错误", Toast.LENGTH_SHORT).show();
            }
        } else {
            Toast.makeText(activity, me.nereo.multi_image_selector.R.string.msg_no_camera, Toast.LENGTH_SHORT).show();
        }
    }
    public void showCameraAction(Fragment fragment) {
        // 跳转到系统照相机
        Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if (cameraIntent.resolveActivity(fragment.getContext().getPackageManager()) != null) {
            // 设置系统相机拍照后的输出路径
            // 创建临时文件
            try {
                mTmpFile = FileUtils.createTmpFile(fragment.getContext());
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (mTmpFile != null && mTmpFile.exists()) {
                cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mTmpFile));
                // 此值在最低质量最小文件尺寸时是0，在最高质量最大文件尺寸时是１
                //cameraIntent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 0);
                fragment.startActivityForResult(cameraIntent, REQUEST_CAMERA);
            } else {
                Toast.makeText(fragment.getContext(), "图片错误", Toast.LENGTH_SHORT).show();
            }
        } else {
            Toast.makeText(fragment.getContext(), me.nereo.multi_image_selector.R.string.msg_no_camera, Toast.LENGTH_SHORT).show();
        }
    }


    public static Uri mNewPhotoUri;
    //存储本地头像地址
    public static String mlocitionFileUrl;
    public static File mCurrentFile;


    //图库选择回调
    public static final int REQUEST_IMAGE = 11;
    //裁剪图片
    public static final int REQUEST_CODE_CROP_PHOTO = 12;
    //裁剪照片==图片输出大小
    public static final int PHOTO_OUTPUT_X = 600;
    public static final int PHOTO_OUTPUT_Y = 600;


    public static final int MODE_SINGLE = MultiImageSelectorActivity.MODE_SINGLE;//单选
    public static final int MODE_MULTI = MultiImageSelectorActivity.MODE_MULTI;//多选


    /**
     * 三方相册库（封装了系统相册）
     * @param activity
     */
    public void showAlbumAction(Activity activity, boolean isShowCamera, int maxCount, int mode) {
        Intent intent = new Intent(activity, MultiImageSelectorActivity.class);
        // 是否显示调用相机拍照
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SHOW_CAMERA, isShowCamera);
        // 最大图片选择数量
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SELECT_COUNT, maxCount);
        // 设置模式 (支持 单选/MultiImageSelectorActivity.MODE_SINGLE 或者 多选/MultiImageSelectorActivity.MODE_MULTI)
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SELECT_MODE, mode);
        // 默认选择图片,回填选项(支持String ArrayList)
        //  intent.putStringArrayListExtra(MultiImageSelectorActivity.EXTRA_DEFAULT_SELECTED_LIST, defaultDataArray);
        activity.startActivityForResult(intent, REQUEST_IMAGE);
    }


    public void showAlbumAction(Fragment fragment, boolean isShowCamera, int maxCount, int mode) {
        Intent intent = new Intent(fragment.getContext(), MultiImageSelectorActivity.class);
        // 是否显示调用相机拍照
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SHOW_CAMERA, isShowCamera);
        // 最大图片选择数量
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SELECT_COUNT, maxCount);
        // 设置模式 (支持 单选/MultiImageSelectorActivity.MODE_SINGLE 或者 多选/MultiImageSelectorActivity.MODE_MULTI)
        intent.putExtra(MultiImageSelectorActivity.EXTRA_SELECT_MODE, mode);
        // 默认选择图片,回填选项(支持String ArrayList)
        //  intent.putStringArrayListExtra(MultiImageSelectorActivity.EXTRA_DEFAULT_SELECTED_LIST, defaultDataArray);
        fragment.startActivityForResult(intent, REQUEST_IMAGE);
    }


    private boolean isFreeCut = false;
    public static int aspectX = 1;
    public static int aspectY = 1;
    public static int outputX = 600;
    public static int outputY = 600;
    /**
     * 调用系统裁减功能，裁减某张指定的图片，并输出到指定的位置
     *
     * @param
     * @param originalFileUri 原始图片位置
     * @param outputFileUri   裁减后图片的输出位置，两个地址最好不一样。如果一样的话，有的手机上面无法保存裁减的结果
     * @return
     */
    public void cropImage(Activity activity, Uri originalFileUri, Uri outputFileUri, int requestCode) {
        if (originalFileUri == null) {
            return;
        }
        final Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(originalFileUri, "image/*");
        intent.putExtra("crop", "true");
        if (!isFreeCut) {
            //默认长宽等比裁剪
            intent.putExtra("aspectX", aspectX);
            intent.putExtra("aspectY", aspectY);
            // 裁剪后输出图片的尺寸大小
            if(outputX != 0){
                intent.putExtra("outputX", outputX);
                intent.putExtra("outputY", outputY);
            }
        }
        intent.putExtra("scale", true);
        intent.putExtra("scaleUpIfNeeded", true); // 部分机型没有设置该参数截图会有黑边
        intent.putExtra("return-data", false);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.PNG.toString());
        // 不启用人脸识别
        intent.putExtra("noFaceDetection", false);
        activity.startActivityForResult(intent, requestCode);
    }
    public void cropImage(Fragment fragment, Uri originalFileUri, Uri outputFileUri, int requestCode) {
        if (originalFileUri == null) {
            return;
        }
        final Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(originalFileUri, "image/*");
        intent.putExtra("crop", "true");
        if (!isFreeCut) {
            //默认长宽等比裁剪
            intent.putExtra("aspectX", aspectX);
            intent.putExtra("aspectY", aspectY);
            // 裁剪后输出图片的尺寸大小
            if(outputX != 0){
                intent.putExtra("outputX", outputX);
                intent.putExtra("outputY", outputY);
            }
        }
        intent.putExtra("scale", true);
        intent.putExtra("scaleUpIfNeeded", true); // 部分机型没有设置该参数截图会有黑边
        intent.putExtra("return-data", false);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.PNG.toString());
        // 不启用人脸识别
        intent.putExtra("noFaceDetection", false);
        fragment.startActivityForResult(intent, requestCode);
    }


    /**
     * 设置是否剪辑和是否自由剪辑
     * @param isFreeCut 是否自由剪辑(不限定宽高)
     */
    public void setIsFreeCut(boolean isFreeCut) {
        this.isFreeCut = isFreeCut;
    }


    /**获取完整的图片*/
//    private void getPic() {
//        Intent intent = new Intent(Intent.ACTION_PICK);
//        intent.putExtra("return-data", true);
//        intent.setType("image/*"); // 说明你想获得图片
//        startActivityForResult(intent, PHONTO);
//    }


    private static CameraManager cameraManager;
    private CameraManager(){
    }
    //唯一实例入口
    public static CameraManager getInstance(){
        if(null == cameraManager){
            synchronized (CameraManager.class){
                if(null == cameraManager) {
                    cameraManager = new CameraManager();
                }
            }
        }
        return cameraManager;
    }
}

 

CameraUtil 相机工具类（只调用其中部分方法）

package com.example.xxx.mycamera;


import android.app.Activity;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.media.MediaScannerConnection;
import android.media.MediaScannerConnection.MediaScannerConnectionClient;
import android.net.Uri;
import android.os.Build;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.text.TextUtils;


import java.io.File;


public final class CameraUtil {
    public static final int MEDIA_TYPE_IMAGE = 1;
    public static final int MEDIA_TYPE_VIDEO = 2;


    /**
     * Create a file Uri for saving an image or video
     *
     * @param context
     * @param type    the type of the file you want saved {@link #MEDIA_TYPE_IMAGE}
     *                {@link #MEDIA_TYPE_VIDEO}
     * @return return the uri of the file ,if create failed,return null
     */
    public static Uri getOutputMediaFileUri(Context context, int type) {
        File file = getOutputMediaFile(context, type);
        if (file == null) {
            return null;
        }
        return Uri.fromFile(file);
    }


    /**
     * Create a file for saving an image or video,is default in the
     * ../Pictures/[you app PackageName] directory
     *
     * @param context
     * @param type    the type of the file you want saved {@link #MEDIA_TYPE_IMAGE}
     *                {@link #MEDIA_TYPE_VIDEO}
     * @return return the file you create,if create failed,return null
     */
    private static File getOutputMediaFile(Context context, int type) {
        String filePath = null;
        if (type == MEDIA_TYPE_IMAGE) {
            filePath = FileUtil.getRandomImageFilePath();
        } else if (type == MEDIA_TYPE_VIDEO) {
            //filePath = FileUtil.getRandomVideoFilePath();
        } else {
            return null;
        }
        if (TextUtils.isEmpty(filePath)) {
            return null;
        } else {
            return new File(filePath);
        }
    }


    /**
     * invoke the system Camera app and capture a image。 you can received the
     * capture result in {@link Activity.onActivityResult(int,int,Intent)}。 If
     * successed,you can use the outputUri to get the image
     *
     * @param activity
     * @param outputUri   拍照后图片的存储路径
     * @param requestCode
     */
    public static void captureImage(Activity activity, Uri outputUri, int requestCode) {
        final Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputUri);
        activity.startActivityForResult(intent, requestCode);
    }


    /**
     * 调用系统裁减功能，裁减某张指定的图片，并输出到指定的位置
     *
     * @param activity
     * @param originalFileUri 原始图片位置
     * @param outputFileUri   裁减后图片的输出位置，两个地址最好不一样。如果一样的话，有的手机上面无法保存裁减的结果
     * @return
     */
    public static void cropImage(Activity activity, Uri originalFileUri, Uri outputFileUri, int requestCode, int aspectX, int aspectY, int outputX,
                                 int outputY) {
        if (originalFileUri == null) {
            return;
        }
        final Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(originalFileUri, "image/*");
        intent.putExtra("crop", "true");
        // aspectX aspectY 是宽高的比例
        intent.putExtra("aspectX", aspectX);
        intent.putExtra("aspectY", aspectY);
        intent.putExtra("outputX", outputX);
        intent.putExtra("outputY", outputY);


        intent.putExtra("scale", true);
        intent.putExtra("scaleUpIfNeeded", true); // 部分机型没有设置该参数截图会有黑边
        intent.putExtra("return-data", false);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.PNG.toString());
        // 不启用人脸识别
        intent.putExtra("noFaceDetection", false);
        activity.startActivityForResult(intent, requestCode);
    }


    /**
     * 调用系统图库选择照片 使用 {@link getImagePathFromUri}方法从
     * onActivityResult的data.getData()中解析获得的Uri
     *
     * @param activity
     * @param requestCode
     * @return
     */
    public static void pickImageSimple(Activity activity, int requestCode) {
        Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        activity.startActivityForResult(intent, requestCode);
    }


    /**
     * 获得The data stream for the file
     */
    public static String getImagePathFromUri(Context context, Uri uri) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            if (DocumentsContract.isDocumentUri(context, uri)) {
                return getImagePathFromUriKitkat(context, uri);
            }
        }




        return getImagePathFromUriSimple(context, uri);
    }


    /**
     * 4.4以下
     *
     * @param context
     * @param uri
     */
    private static String getImagePathFromUriSimple(Context context, Uri uri) {
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = context.getContentResolver().query(uri, proj, null, null, null);


        String path = null;
        try {
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);


            if (cursor.moveToFirst()) {
                path = cursor.getString(column_index);
            }


        } catch (Exception e) {


        }
        if (cursor!=null){
            cursor.close();
        }


        return path;


    }


    /**
     * 4.4以上的Document Uri
     *
     * @param context
     * @param uri
     * @return
     */
    private static String getImagePathFromUriKitkat(Context context, Uri uri) {
        String wholeID = DocumentsContract.getDocumentId(uri);
        if (TextUtils.isEmpty(wholeID) || !wholeID.contains(":")) {
            return null;
        }
        // 获得资源唯一ID
        String id = wholeID.split(":")[1];
        // 定义索引字段
        String[] column = {MediaStore.Images.Media.DATA};
        String sel = MediaStore.Images.Media._ID + "=?";


        Cursor cursor = context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column, sel, new String[]{id}, null);
        int columnIndex = cursor.getColumnIndex(column[0]);


        String filePath = null;
        if (cursor.moveToFirst()) {
            // DATA字段就是本地资源的全路径
            filePath = cursor.getString(columnIndex);
        }
        // 切记要关闭游标
        cursor.close();
        return filePath;
    }


    /**
     * 调用系统图库选择照片,裁减后返回
     * ,4.4上无法确定用户是否是在图库里选择的照片，所以不使用该方法，使用pickImageSimple，返回后在调用裁减
     *
     * @param activity
     * @param filePath    拍照后图片的存储路径
     * @param requestCode
     * @return
     */
    @Deprecated
    public static void pickImageCrop(Activity activity, Uri outputUri, int requestCode, int aspectX, int aspectY, int outputX, int outputY) {
        // Intent intent = new Intent(Intent.ACTION_GET_CONTENT, null);
        Intent intent = new Intent();
        // 根据版本号不同使用不同的Action
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
            intent.setAction(Intent.ACTION_GET_CONTENT);
        } else {
            intent.setAction(Intent.ACTION_OPEN_DOCUMENT);
            intent.addCategory(Intent.CATEGORY_OPENABLE);
        }


        intent.setType("image/*");
        intent.putExtra("crop", "true");
        // 裁剪框比例
        intent.putExtra("aspectX", aspectX);
        intent.putExtra("aspectY", aspectY);
        // 图片输出大小
        intent.putExtra("outputX", outputX);
        intent.putExtra("outputY", outputY);
        intent.putExtra("scale", true);
        intent.putExtra("scaleUpIfNeeded", true); // 部分机型没有设置该参数截图会有黑边
        intent.putExtra("return-data", false);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputUri);


        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        // 不启用人脸识别
        intent.putExtra("noFaceDetection", false);
        activity.startActivityForResult(intent, requestCode);
    }


    public static interface ScannerResult {
        void onResult(boolean success);
    }


    /**
     * 扫描某张指定的图片放入系统媒体库
     */
    public static void scannerImage(Activity activity, final Uri fileUri, final ScannerResult scannerResult) {
        if (fileUri == null) {
            if (scannerResult != null) {
                scannerResult.onResult(false);
            }
            return;
        }
        sMediaScannerConnection = new MediaScannerConnection(activity, new MediaScannerConnectionClient() {
            public void onMediaScannerConnected() {
                sMediaScannerConnection.scanFile(fileUri.getPath(), "image/*");
            }


            public void onScanCompleted(String path, Uri uri) {
                sMediaScannerConnection.disconnect();
                if (scannerResult != null) {
                    scannerResult.onResult(uri != null);
                }
            }
        });
        sMediaScannerConnection.connect();
    }


    private static MediaScannerConnection sMediaScannerConnection;


    /**
     * 查询某张图片有没有被扫描到媒体库
     *
     * @param activity
     * @param filePath
     * @return 返回这个图片在媒体库的Uri，如果没有扫描到媒体库，则返回null
     */
    public static Uri isImageFileInMedia(Context context, String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            return null;
        }
        Cursor cursor = context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, null,
                MediaStore.Images.Media.DISPLAY_NAME + "='" + file.getName() + "'", null, null);
        Uri uri = null;
        if (cursor != null && cursor.getCount() > 0) {
            cursor.moveToLast();
            long id = cursor.getLong(0);
            uri = ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id);
        }
        return uri;
    }


}

 

FileUtil 文件工具类：

package com.example.xxx.mycamera;


import android.graphics.Bitmap;
import android.os.Environment;
import android.util.Log;




import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;


public class FileUtil {


	private static final int TYPE_IMAGE = 1;
	private static final int TYPE_ADUIO = 2;
	private static final int TYPE_VIDEO = 3;


	/**
	 * {@link #TYPE_IMAGE}<br/>
	 * {@link #TYPE_ADUIO}<br/>
	 * {@link #TYPE_VIDEO} <br/>
	 * 
	 * @param type
	 * @return
	 */
	private static String getPublicFilePath(int type) {
		String fileDir = null;
		String fileSuffix = null;
		switch (type) {
		case TYPE_ADUIO:
			fileDir = MyApplication.getInstance().mVoicesDir;
			fileSuffix = ".mp3";
			break;
		case TYPE_VIDEO:
			fileDir = MyApplication.getInstance().mVideosDir;
			fileSuffix = ".mp4";
			break;
		case TYPE_IMAGE:
			fileDir = MyApplication.getInstance().mPicturesDir;
			fileSuffix = ".jpg";
			break;
		}
		if (fileDir == null) {
			return null;
		}
		File file = new File(fileDir);
		if (!file.exists()) {
			if (!file.mkdirs()) {
				return null;
			}
		}
		return fileDir + File.separator + UUID.randomUUID().toString().replaceAll("-", "") + fileSuffix;
	}


	/**
	 * {@link #TYPE_ADUIO}<br/>
	 * {@link #TYPE_VIDEO} <br/>
	 * 
	 * @param type
	 * @return
	 */
	private static String getPrivateFilePath(int type, String userId) {
		String fileDir = null;
		String fileSuffix = null;
		switch (type) {
		case TYPE_ADUIO:
			fileDir = MyApplication.getInstance().mAppDir + File.separator + userId + File.separator + Environment.DIRECTORY_MUSIC;
			fileSuffix = ".mp3";
			break;
		case TYPE_VIDEO:
			fileDir = MyApplication.getInstance().mAppDir + File.separator + userId + File.separator + Environment.DIRECTORY_MOVIES;
			fileSuffix = ".mp4";
			break;
		}
		if (fileDir == null) {
			return null;
		}
		File file = new File(fileDir);
		if (!file.exists()) {
			if (!file.mkdirs()) {
				return null;
			}
		}
		return fileDir + File.separator + UUID.randomUUID().toString().replaceAll("-", "") + fileSuffix;
	}


	public static String getRandomImageFilePath() {
		return getPublicFilePath(TYPE_IMAGE);
	}


//	public static String getRandomAudioFilePath() {
//		User user = MyApplication.getInstance().mLoginUser;
//		if (user != null && !TextUtils.isEmpty(user.getUserId())) {
//			return getPrivateFilePath(TYPE_ADUIO, user.getUserId());
//		} else {
//			return getPublicFilePath(TYPE_ADUIO);
//		}
//	}


//	public static String getRandomAudioAmrFilePath() {
//		User user = MyApplication.getInstance().mLoginUser;
//		String filePath = null;
//		if (user != null && !TextUtils.isEmpty(user.getUserId())) {
//			filePath = getPrivateFilePath(TYPE_ADUIO, user.getUserId());
//		} else {
//			filePath = getPublicFilePath(TYPE_ADUIO);
//		}
//		if (!TextUtils.isEmpty(filePath)) {
//			return filePath.replace(".mp3", ".amr");
//		} else {
//			return null;
//		}
//	}


//	public static String getRandomVideoFilePath() {
//		User user = MyApplication.getInstance().mLoginUser;
//		if (user != null && !TextUtils.isEmpty(user.getUserId())) {
//			return getPrivateFilePath(TYPE_VIDEO, user.getUserId());
//		} else {
//			return getPublicFilePath(TYPE_VIDEO);
//		}
//	}






	/**
	 * 根据图片名称把bitmap保存到本地
	 *
	 * @param bm
	 * @param savePath
	 * @param picName
	 * @throws IOException
	 */
	public static void saveBitmapToPath(Bitmap bm, String savePath, String picName) throws IOException {
		Log.e("", "保存图片");
		if (bm == null){
			return;
		}


		File file = new File(savePath);
		if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
			if (!file.exists() || !file.isDirectory()) {
				file.mkdir();
			}
			String suffixStr = null;
			if (picName.length() >= 4 && picName.lastIndexOf('.') != -1) {
				suffixStr = picName.substring(picName.lastIndexOf('.'));
				if (!".jpg".equals(suffixStr))
					suffixStr = null;
			}


			File f = new File(savePath, picName + (suffixStr == null ? ".jpg" : ""));
			if (f.exists()) {
				f.delete();
			}
			FileOutputStream out = new FileOutputStream(f);
			bm.compress(Bitmap.CompressFormat.JPEG, 90, out);
			out.flush();
			out.close();
			Log.e("", "已经保存");
		}
	}


	// ///


	public static void createFileDir(String fileDir) {
		File fd = new File(fileDir);
		if (!fd.exists()) {
			fd.mkdirs();
		}
	}


	/**
	 * 
	 * @param fullName
	 */
	public static void delFile(String fullName) {
		File file = new File(fullName);
		if (file.exists()) {
			if (file.isFile()) {
				try {
					file.delete();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}


	/**
	 * 删除文件夹里面的所有文件
	 * 
	 * @param path
	 *            String 文件夹路径 如 /sdcard/data/
	 */
	public static void delAllFile(String path) {
		File file = new File(path);
		if (!file.exists()) {
			return;
		}
		if (!file.isDirectory()) {
			return;
		}
		String[] tempList = file.list();
		File temp = null;
		for (int i = 0; i < tempList.length; i++) {
			System.out.println(path + tempList[i]);
			if (path.endsWith(File.separator)) {
				temp = new File(path + tempList[i]);
			} else {
				temp = new File(path + File.separator + tempList[i]);
			}
			if (temp.isFile()) {
				temp.delete();
			}
			if (temp.isDirectory()) {
				delAllFile(path + "/" + tempList[i]); // 先删除文件夹里面的文件
				delFolder(path + "/" + tempList[i]); // 再删除空文件夹
			}
		}
	}


	/**
	 * 删除文件夹
	 * 
	 *            String 文件夹路径及名称 如/sdcard/data/
	 *            String
	 * @return boolean
	 */
	public static void delFolder(String folderPath) {
		try {
			delAllFile(folderPath); // 删除完里面所有内容
			String filePath = folderPath;
			filePath = filePath.toString();
			File myFilePath = new File(filePath);
			myFilePath.delete(); // 删除空文件夹
		} catch (Exception e) {
			System.out.println("删除文件夹操作出错");
			e.printStackTrace();
		}
	}


	/*
	* 输入流转字符串
	*
	* */
	public static String inputStream2String(InputStream is)  throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		int i=-1;
		while((i = is.read() ) != -1){
			baos.write(i);
		}
		return baos.toString();
	}




}

全局初始化文件路径：

package com.example.xxx.mycamera;


import android.app.Application;
import android.content.Context;
import android.os.Environment;


import java.io.File;


/**
 * Created by hermithermit on 16/3/3.
 */
public class MyApplication extends Application {


    private static MyApplication mInstance;


    @Override
    public void onCreate() {
        super.onCreate();
        mInstance = this;
        initAppDir();
    }


    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);


    }


    public static MyApplication getInstance(){
        return mInstance;
    }




    /* 文件缓存的目录 */
    public String mAppDir;
    public String mPicturesDir;
    public String mVoicesDir;
    public String mVideosDir;
    public String mFilesDir;


    private void initAppDir() {
        try {
            File file = getExternalFilesDir(null);
            if (!file.exists()) {
                file.mkdirs();
            }
            mAppDir = file.getAbsolutePath();


            file = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
            if (!file.exists()) {
                file.mkdirs();
            }
            mPicturesDir = file.getAbsolutePath();


            file = getExternalFilesDir(Environment.DIRECTORY_MUSIC);
            if (!file.exists()) {
                file.mkdirs();
            }
            mVoicesDir = file.getAbsolutePath();


            file = getExternalFilesDir(Environment.DIRECTORY_MOVIES);
            if (!file.exists()) {
                file.mkdirs();
            }
            mVideosDir = file.getAbsolutePath();


            file = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
            if (!file.exists()) {
                file.mkdirs();
            }
            mFilesDir = file.getAbsolutePath();
        }catch (Exception e){


        }


    }


}