Android 사진 가 져 오기,그림 자 르 기,그림 압축
31143 단어 Android사진 가 져 오기그림 을 재단 하 다압축 그림
지난 프로젝트 를 진행 하면 서 사진 업로드 에 대한 고민 이 컸 다.사진 업 로드 는 주로 두 부분 으로 나 뉘 는데 먼저 그림 을 가 져 와 야 하고 그림 을 가 져 오 면 파일 에서 가 져 오 거나 사진 을 찍 어서 가 져 올 수 있다.두 번 째 부분 이 야 말로 사진 을 올 리 는 것 이 고 두 부분 모두 시행 착 오 를 많이 걸 었 다.안 드 로 이 드 시스템 의 파편 화가 심각 하기 때문에 우 리 는 첫 번 째 기기 에서 그림 을 얻 을 수 있 지만 기 계 를 바 꾸 면 그림 을 얻 을 수 없다 는 문제 가 발생 할 수 있 습 니 다.그리고 안 드 로 이 드 6.0,7.0 이후 에 도 어느 정도 어 울 려 야 개발 자 에 게 는 매우 아 픕 니 다.초보 자 이기 때문에 고려 하지 않 은 것 이 많 고 어 울 리 기 도 어렵다.
요 며칠 동안 github 에서 라 이브 러 리(주 소 는 여기TakePhoto를 찾 았 습 니 다.간단 한 학습 을 통 해 사용 하기에 매우 간단 하고 서로 다른 기종 간 에 똑 같은 효 과 를 얻 을 수 있다 는 것 을 알 게 되 었 습 니 다.더 중요 한 것 은 설정 에 따라 다른 효 과 를 낼 수 있다 는 것 이다.
이제 사용법 을 보 겠 습 니 다.
그림 가 져 오기
1)TakePhoto 대상 가 져 오기
1)상속 을 통한 방식
TakePhotoActivity,TakePhotoFragment Activity,TakePhotoFragment 세 가지 중 하 나 를 계승 한다.
getTakePhoto()를 통 해 TakePhoto 인 스 턴 스 를 가 져 와 관련 작업 을 진행 합 니 다.
다음 방법 을 다시 써 서 결 과 를 얻 습 니 다.
void takeSuccess(TResult result);
void takeFail(TResult result,String msg);
void takeCancel();
이런 방법 은 사용 하기 가 간단 하지만 맞 춤 형 제작 성 이 높 지 않 아 지 정 된 Activity 를 계승 해 야 한다 고 느 꼈 다.가끔 은 BaseActivity 를 봉 하여 더 이상 고치 고 싶 지 않다.상속 을 통 해 실제 프로젝트 의 수 요 를 만족 시 키 지 못 할 때 도 있다.2)조립 을 통 해 사용
TakePhoto.TakeResultListener,InvokeListener 인 터 페 이 스 를 실현 합 니 다.
onCreate,onActivity Result,onSave InstanceState 방법 에서 TakePhoto 를 사용 하 는 방법 을 호출 합 니 다.
onRequestPermissions Result(int requestCode,String[]permissions,int[]grantResults)를 다시 쓰 고 다음 코드 를 추가 합 니 다.
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
// Android6.0、7.0
TPermissionType type=PermissionManager.onRequestPermissionsResult(requestCode,permissions,grantResults);
PermissionManager.handlePermissionsResult(this,type,invokeParam,this);
}
TPermissionType invoke(InvokeParam invokeParam)방법 을 다시 쓰 고 다음 코드 를 추가 합 니 다.
@Override
public TPermissionType invoke(InvokeParam invokeParam) {
TPermissionType type=PermissionManager.checkPermission(TContextWrap.of(this),invokeParam.getMethod());
if(TPermissionType.WAIT.equals(type)){
this.invokeParam=invokeParam;
}
return type;
}
다음 코드 를 추가 하여 TakePhoto 인 스 턴 스 가 져 오기:
/**
* TakePhoto
* @return
*/
public TakePhoto getTakePhoto(){
if (takePhoto==null){
takePhoto= (TakePhoto) TakePhotoInvocationHandler.of(this).bind(new TakePhotoImpl(this,this));
}
return takePhoto;
}
2)사용자 정의 UI매개 변 수 를 사용자 정의 할 수 있 을 뿐만 아니 라 UI 에 대한 사용자 정의 도 가능 합 니 다.예 를 들 어 사용자 정의 앨범,사용자 정의 Toolbar,사용자 정의 상태 표시 줄,사용자 정의 알림 문자,사용자 정의 재단 도구(자체 테이프 의 TakePhoto 재단 을 사용 해 야 합 니 다).
3)TakePhoto 대상 을 통 해 그림 가 져 오기
앨범 에서 가 져 오 는 것 도 지원 하고 사진 찍 는 것 도 지원 합 니 다.
*
* @param outPutUri
* @param options
*/
void onPickFromCaptureWithCrop(Uri outPutUri, CropOptions options);
/**
*
* @param outPutUri
* @param options
*/
void onPickFromGalleryWithCrop(Uri outPutUri, CropOptions options);
/**
*
* @param outPutUri
* @param options
*/
void onPickFromDocumentsWithCrop(Uri outPutUri, CropOptions options);
/**
* ,
* @param limit
* @param options
* */
void onPickMultipleWithCrop(int limit, CropOptions options);
4)커팅 설정CropOptions 는 재단 에 사용 되 는 설정 클래스 로 그림 의 재단 비율,최대 출력 크기,TakePhoto 자체 의 재단 도 구 를 사용 하여 재단 할 지 여부 등 개성 화 된 설정 을 할 수 있 습 니 다.
압축 그림 onEnableCompress(CompressConfig config,boolean showCompressDialog)
압축 도구 takePhoto 에 자체 압축 알고리즘 을 지정 하고 제3자 Luban 을 통 해 압축 할 수 있 습 니 다.
TakePhoto 에 대한 2 차 패키지
포장 은 두 번 째 방법 에 대한 포장 으로 주로 첫 번 째 사상 포장 을 참고 했다.
TakePhoto 에 대한 라 이브 러 리 코드 는 모두 TakePhotoUtil 도구 클래스 에 봉 인 됩 니 다.코드 를 보십시오.
public class TakePhotoUtil implements TakePhoto.TakeResultListener, InvokeListener {
private static final String TAG = TakePhotoUtil.class.getName();
private TakePhoto takePhoto;
private InvokeParam invokeParam;
private Activity activity;
private Fragment fragment;
public TakePhotoUtil(Activity activity){
this.activity = activity;
}
public TakePhotoUtil(Fragment fragment){
this.fragment = fragment;
}
/**
* TakePhoto
* @return
*/
public TakePhoto getTakePhoto(){
if (takePhoto==null){
takePhoto= (TakePhoto) TakePhotoInvocationHandler.of(this).bind(new TakePhotoImpl(activity,this));
}
return takePhoto;
}
public void onCreate(Bundle savedInstanceState){
getTakePhoto().onCreate(savedInstanceState);
}
public void onSaveInstanceState(Bundle outState){
getTakePhoto().onSaveInstanceState(outState);
}
public void onActivityResult(int requestCode, int resultCode, Intent data){
getTakePhoto().onActivityResult(requestCode, resultCode, data);
}
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
PermissionManager.TPermissionType type=PermissionManager.onRequestPermissionsResult(requestCode,permissions,grantResults);
PermissionManager.handlePermissionsResult(activity,type,invokeParam,this);
}
/**
*
* @param result
*/
@Override
public void takeSuccess(TResult result) {
if(listener != null){
listener.takeSuccess(result);
}
// deleteCachePic();
}
@Override
public void takeFail(TResult result, String msg) {
if(listener != null){
listener.takeFail(result, msg);
}
// deleteCachePic();
}
@Override
public void takeCancel() {
if(listener != null){
listener.takeCancel();
}
}
public void deleteCachePic(){
File file=new File(Environment.getExternalStorageDirectory(), "/takephoto/");
if(!file.exists()) return;
File[] files = file.listFiles();
for (File f: files) {
f.delete();
}
}
public interface TakePhotoListener{
void takeSuccess(TResult result);
void takeFail(TResult result, String msg);
void takeCancel();
}
public TakePhotoListener listener;
public void setTakePhotoListener(SimpleTakePhotoListener listener){
this.listener = listener;
}
public static class SimpleTakePhotoListener implements TakePhotoListener{
@Override
public void takeSuccess(TResult result) {
}
@Override
public void takeFail(TResult result, String msg) {
}
@Override
public void takeCancel() {
}
}
@Override
public PermissionManager.TPermissionType invoke(InvokeParam invokeParam) {
PermissionManager.TPermissionType type=PermissionManager.checkPermission(TContextWrap.of(activity),invokeParam.getMethod());
if(PermissionManager.TPermissionType.WAIT.equals(type)){
this.invokeParam=invokeParam;
}
return type;
}
/**
*
* @param select_type
*/
public void takePhoto(Select_type select_type, SimpleTakePhotoListener listener){
takePhoto(select_type, null, listener);
}
public void takePhoto(Select_type select_type, PhotoConfigOptions cropOptions, SimpleTakePhotoListener listener){
if (takePhoto == null){
Toast.makeText(activity, " ", Toast.LENGTH_SHORT).show();
return;
}
setTakePhotoListener(listener);
if(cropOptions == null){
cropOptions = new PhotoConfigOptions();
}
cropOptions.configCompress(); //
cropOptions.configTakePhoto(); //
File file=new File(Environment.getExternalStorageDirectory(), "/takephoto/"+System.currentTimeMillis() + ".jpg");
if (!file.getParentFile().exists())file.getParentFile().mkdirs();
Uri imageUri = Uri.fromFile(file);
switch (select_type){
case PICK_BY_SELECT: //
if(cropOptions.limit > 1){
if(cropOptions.crop == true){
takePhoto.onPickMultipleWithCrop(cropOptions.limit, cropOptions.getCropOptions());
}else {
takePhoto.onPickMultiple(cropOptions.limit);
}
}
if(cropOptions.chooseFromFile){
if(cropOptions.crop == true){
takePhoto.onPickFromDocumentsWithCrop(imageUri, cropOptions.getCropOptions());
}else {
takePhoto.onPickFromDocuments();
}
}else {
if(cropOptions.crop == true){
takePhoto.onPickFromGalleryWithCrop(imageUri, cropOptions.getCropOptions());
}else {
takePhoto.onPickFromGallery();
}
}
break;
case PICK_BY_TAKE: //
if(cropOptions.crop == true){
takePhoto.onPickFromCaptureWithCrop(imageUri, cropOptions.getCropOptions());
}else {
takePhoto.onPickFromCapture(imageUri);
}
break;
default:
break;
}
}
/**
*
*/
public class PhotoConfigOptions{
//
private boolean crop = true; //
private boolean withWonCrop = true; // ,
private boolean cropSize = true; //
//
private boolean useOwnCompressTool = true; //
private boolean isCompress = true; //
private boolean showProgressBar = true; //
// private
private int maxSize = 102400;
//
private boolean useOwnGallery = true; //
private boolean chooseFromFile = false; //
private int limit = 1; // , TakePhoto
//
private boolean savePic = true; //
private boolean correctTool = false; //
private int height = 800;
private int width = 800;
/**
*
* @return
*/
public CropOptions getCropOptions(){
if(crop == false) return null;
CropOptions.Builder builder = new CropOptions.Builder();
if(cropSize){
builder.setOutputX(width).setOutputY(height);
}else {
builder.setAspectX(width).setAspectY(height);
}
builder.setWithOwnCrop(withWonCrop); //
return builder.create();
}
/**
*
*/
public void configCompress(){
if(isCompress == false) {
takePhoto.onEnableCompress(null, false);
return;
}
CompressConfig config;
if(useOwnCompressTool){
config = new CompressConfig.Builder()
.setMaxSize(maxSize)
.setMaxPixel(width>height?width:height)
.enableReserveRaw(savePic)
.create();
}else {
LubanOptions options = new LubanOptions.Builder()
.setMaxHeight(height)
.setMaxWidth(maxSize)
.create();
config = CompressConfig.ofLuban(options);
config.enableReserveRaw(savePic);
}
takePhoto.onEnableCompress(config, showProgressBar);
}
public void configTakePhoto(){
TakePhotoOptions.Builder builder = new TakePhotoOptions.Builder();
if(useOwnGallery){
builder.setWithOwnGallery(true);
}
if(correctTool){
builder.setCorrectImage(true);
}
takePhoto.setTakePhotoOptions(builder.create());
}
public void setCrop(boolean crop) {
this.crop = crop;
}
public void setWithWonCrop(boolean withWonCrop) {
this.withWonCrop = withWonCrop;
}
public void setCropSize(boolean cropSize) {
this.cropSize = cropSize;
}
public void setUseOwnCompressTool(boolean useOwnCompressTool) {
this.useOwnCompressTool = useOwnCompressTool;
}
public void setCompress(boolean compress) {
isCompress = compress;
}
public void setShowProgressBar(boolean showProgressBar) {
this.showProgressBar = showProgressBar;
}
public void setMaxSize(int maxSize) {
this.maxSize = maxSize;
}
public void setUseOwnGallery(boolean useOwnGallery) {
this.useOwnGallery = useOwnGallery;
}
public void setChooseFromFile(boolean chooseFromFile) {
this.chooseFromFile = chooseFromFile;
}
public void setLimit(int limit) {
this.limit = limit;
}
public void setSavePic(boolean savePic) {
this.savePic = savePic;
}
public void setCorrectTool(boolean correctTool) {
this.correctTool = correctTool;
}
public void setHeight(int height) {
this.height = height;
}
public void setWidth(int width) {
this.width = width;
}
}
/**
* ,
*/
public enum Select_type{
PICK_BY_SELECT, PICK_BY_TAKE
}
}
BaseTake PhotoActivity 를 봉 인 했 습 니 다.코드 는 다음 과 같 습 니 다.
protected TakePhotoUtil takePhotoUtil;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
takePhotoUtil = new TakePhotoUtil(this);
if(useTakePhoto()){
takePhotoUtil.onCreate(savedInstanceState);
}
super.onCreate(savedInstanceState);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
if(useTakePhoto()){
takePhotoUtil.onSaveInstanceState(outState);
}
super.onSaveInstanceState(outState);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if(useTakePhoto()){
takePhotoUtil.onActivityResult(requestCode, resultCode, data);
}
super.onActivityResult(requestCode, resultCode, data);
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
if(useTakePhoto()){
takePhotoUtil.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
protected boolean useTakePhoto(){
return false;
}
다른 업무 에 대한 패 키 징 은 BaseActivity 를 하나 더 패 키 징 하여 BaseTake PhotoActivity 에서 계승 할 수 있 습 니 다.그러면 BaseActivity 의 사용 에 영향 을 주지 않 을 수 있 습 니 다.만약 에 저희 가 주 Activity 에서 그림 을 얻 는 기능 을 사용 하려 면 두 단계 가 필요 합 니 다.1)TakePhoto 기능 오픈
@Override
protected boolean useTakePhoto() {
return true;
}
2)그림 가 져 오기
takePhotoUtil.takePhoto(TakePhotoUtil.Select_type.PICK_BY_TAKE, new TakePhotoUtil.SimpleTakePhotoListener(){
@Override
public void takeSuccess(TResult result) {
String s = result.getImage().getCompressPath();
Bitmap bitmap = BitmapFactory.decodeFile(s);
iv.setImageBitmap(bitmap);
}
});
takePhoto()의 첫 번 째 매개 변 수 는 앨범 에서 가 져 오고 사진 을 찍 어서 가 져 오 는 매개 변수 입 니 다.두 번 째 매개 변 수 는 성공 적 으로 감청 에 실 패 했 습 니 다.세 개의 반전 이 있 습 니 다.일부 반전 이 필요 하지 않 기 때문에 Listener 에 적합 합 니 다.원 하 는 방법 만 바 꾸 면 됩 니 다.가 져 오 는 데 성공 하면 TResult 봉 인 된 매개 변 수 를 통 해 원 하 는 그림 과 그림 주 소 를 가 져 올 수 있 습 니 다.가 져 온 그림 주소 에 대해 업로드 처 리 를 할 수 있 습 니 다.사진 업로드
okhttp 3 를 통 해 업로드 기능 을 실현 할 수 있 습 니 다.
MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM);
RequestBody requestBody = RequestBody.create(MediaType.parse(MULTIPART_FORM_DATA), file);
MultipartBody.Part part = MultipartBody.Part.createFormData("dir", file.getName(), requestBody);
builder.addPart(part);
Request.Builder builder1 = new Request.Builder().url(url).post(builder.build());
Request request = builder1.build();
HttpUtils.client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if(response.isSuccessful()){
final String s = response.body().string();
((Activity)context).runOnUiThread(new Runnable() {
@Override
public void run() {
}
});
}
}
});
대략 코드 는 위 와 같다.마지막.
그 당시 에 이 라 이브 러 리 를 찾 지 못 했 기 때문에 회사 에 가서 다른 안 드 로 이 드 를 만 드 는 사람 에 게 물 었 습 니 다.그 가 봉 인 된 코드 를 보 았 습 니 다.확실히 배 울 만 한 가치 가 있 습 니 다.그의 코드 도 안 드 로 이 드 7.0 에 적합 하고 코드 를 붙 여서 나중에 공부 할 수 있 습 니 다.
public class CameraUtil {
private static final int REQUEST_CAPTURE_CAMERA = 1221;
private static final int REQUEST_CROP = 1222;
private static final int REQUEST_OPEN_ALBUM = 1223;
private static final String TAG = "Camera";
private static Uri mCacheUri;
private CameraUtil() {
}
@RequiresPermission(allOf = {Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA})
public static void getImageFromCamera(Activity activity) {
if (checkExternalStorageState(activity)) {
activity.startActivityForResult(getImageFromCamera(activity.getApplicationContext()), REQUEST_CAPTURE_CAMERA);
}
}
@RequiresPermission(allOf = {Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA})
@Deprecated
public static void getImageFromCamera(Fragment fragment) {
if (checkExternalStorageState(fragment.getContext())) {
fragment.startActivityForResult(getImageFromCamera(fragment.getContext()), REQUEST_CAPTURE_CAMERA);
}
}
private static Intent getImageFromCamera(Context context) {
Intent getImageByCamera = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
mCacheUri = getCachePhotoUri(context.getApplicationContext());
getImageByCamera.putExtra(MediaStore.EXTRA_OUTPUT, mCacheUri);
getImageByCamera.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
grantUriPermission(context, getImageByCamera, mCacheUri);
return getImageByCamera;
}
private static boolean checkExternalStorageState(Context context) {
if (TextUtils.equals(Environment.getExternalStorageState(), Environment.MEDIA_MOUNTED)) {
return true;
}
Toast.makeText(context.getApplicationContext(), " SD ", Toast.LENGTH_LONG).show();
return false;
}
@SuppressWarnings("ResultOfMethodCallIgnored")
public static File getCachePhotoFile() {
File file = new File(Environment.getExternalStorageDirectory(), "/lenso/cache/CameraTakePhoto" + System.currentTimeMillis() + ".jpg");
if (!file.getParentFile().exists()) file.getParentFile().mkdirs();
return file;
}
private static Uri getCachePhotoUri(Context context) {
return FileProvider.getUriForFile(context, getAuthority(context), getCachePhotoFile());
}
private static Uri getCachePhotoUri(Context context, File file) {
return FileProvider.getUriForFile(context, getAuthority(context), file);
}
public static void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data, OnActivityResultListener listener) {
onActivityResult(activity, null, requestCode, resultCode, data, listener);
}
/**
* getCachePhotoFile().getParentFile().getAbsolutePath()
* @param dir
* @return
*/
public static boolean deleteDir(File dir) {
if (dir != null && dir.isDirectory()) {
String[] children = dir.list();
for (int i = 0; i < children.length; i++) {
boolean success = deleteDir(new File(dir, children[i]));
if (!success) {
return false;
}
}
}
return dir.delete();
}
public static File saveBitmap(Bitmap bitmap) {
File file = getCachePhotoFile();
if (bitmap == null || bitmap.isRecycled()) return file;
FileOutputStream outputStream = null;
try {
outputStream = new FileOutputStream(file);
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (outputStream != null)
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
bitmap.recycle();
}
return file;
}
public static void copy(File file, File point) {
if (!file.exists()) return;
if (!point.getParentFile().exists()) point.getParentFile().mkdirs();
BufferedInputStream inputStream = null;
BufferedOutputStream outputStream = null;
try {
inputStream = new BufferedInputStream(new FileInputStream(file));
outputStream = new BufferedOutputStream(new FileOutputStream(point));
byte[] buff = new byte[1024 * 1024 * 2];
int len;
while ((len = inputStream.read(buff)) != -1) {
outputStream.write(buff, 0, len);
outputStream.flush();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
closeStream(inputStream);
closeStream(outputStream);
}
}
private static void closeStream(Closeable closeable) {
if (closeable != null) try {
closeable.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void onActivityResult(Activity activity, CropOption crop, int requestCode, int resultCode, Intent data, OnActivityResultListener listener) {
if (resultCode == Activity.RESULT_CANCELED) return;
Uri uri;
switch (requestCode) {
case REQUEST_OPEN_ALBUM:
uri = data.getData();
if (uri != null) {
mCacheUri = getCachePhotoUri(activity);
copy(new File(getRealFilePath(activity, uri)), new File(getRealFilePath(activity, mCacheUri)));
} else {
Bitmap bitmap = data.getParcelableExtra("data");
File file = saveBitmap(bitmap);
mCacheUri = getCachePhotoUri(activity, file);
}
case REQUEST_CAPTURE_CAMERA:
uri = mCacheUri;
if (listener != null) {
listener.requestCaptureCamera(getRealFilePath(activity, uri), null);
}
if (crop == null) return;
crop.setSource(uri);
Intent intent = crop.create();
grantUriPermission(activity, intent, crop.getOutput());
activity.startActivityForResult(intent, REQUEST_CROP);
break;
case REQUEST_CROP:
if (listener != null && data != null)
{
listener.requestCrop(getRealFilePath(activity, mCacheUri), (Bitmap) data.getParcelableExtra("data"));
}
break;
}
}
@RequiresPermission(allOf = {Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE})
public static void getImageFromAlbum(Activity activity) {
Intent intent = new Intent(Intent.ACTION_PICK);
intent.setType("image/*");//
activity.startActivityForResult(intent, REQUEST_OPEN_ALBUM);
}
@RequiresPermission(allOf = {Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE})
@Deprecated
public static void getImageFromAlbum(Fragment fragment) {
Intent intent = new Intent(Intent.ACTION_PICK);
intent.setType("image/*");//
fragment.startActivityForResult(intent, REQUEST_OPEN_ALBUM);
}
public interface OnActivityResultListener {
void requestCaptureCamera(String path, Bitmap bitmap);
void requestCrop(String path, Bitmap bitmap);
}
/**
* Try to return the absolute file path from the given Uri
*
* @param context context
* @param uri uri
* @return the file path or null
*/
public static String getRealFilePath(final Context context, final Uri uri) {
if (null == uri) return null;
String path = uri.toString();
if (path.startsWith("content://" + getAuthority(context) + "/rc_external_path")) {
return path.replace("content://" + getAuthority(context) + "/rc_external_path", Environment.getExternalStorageDirectory().getAbsolutePath());
}
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 = context.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;
}
private static String getAuthority(Context context) {
return context.getPackageName() + ".FileProvider";
}
public static class CropOption {
private int aspectX=1;//x
private int aspectY=1;//y
private boolean returnData = false;// bitmap, uri
private String outputFormat;// JPG PNG ...
private int outputX=200;// bitmap
private int outputY=200;// bitmap
private Uri output;//
private Uri source;// uri
private boolean noFaceDetection = true;//
// get set
private Intent create() {
if (source == null)
throw new NullPointerException(" uri");
Intent intent = new Intent("com.android.camera.action.CROP");
intent.setDataAndType(source, "image/*");
intent.putExtra("crop", "true");
if (aspectX > 0)
intent.putExtra("aspectX", aspectX);
if (aspectY > 0)
intent.putExtra("aspectY", aspectY);
if (outputX > 0)
intent.putExtra("outputX", outputX);
if (outputY > 0)
intent.putExtra("outputY", outputY);
intent.putExtra("return-data", returnData);
if (!returnData) {
output = output == null ? source : output;
outputFormat = outputFormat == null ? Bitmap.CompressFormat.JPEG.toString() : outputFormat;
intent.putExtra(MediaStore.EXTRA_OUTPUT, output);
intent.putExtra("outputFormat", outputFormat);
intent.setType("image/*");
intent.putExtra("noFaceDetection", noFaceDetection);
}
return intent;
}
}
private static void grantUriPermission(Context context, Intent intent, Uri uri) {
List<ResolveInfo> resInfoList = context.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
for (ResolveInfo resolveInfo : resInfoList) {
String packageName = resolveInfo.activityInfo.packageName;
context.grantUriPermission(packageName, uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION | Intent.FLAG_GRANT_READ_URI_PERMISSION);
}
}
}
//xml
<?xml version="1.0" encoding="utf-8"?>
<resources >
<paths>
<external-path path="" name="rc_external_path" />
</paths>
</resources>
//
<provider
android:name="android.support.v4.content.FileProvider"
android:authorities="com.lenso.FileProvider"
android:exported="false"
android:grantUriPermissions="true">
<meta-data
android:name="android.support.FILE_PROVIDER_PATHS"
android:resource="@xml/file_path" />
</provider>
현지에서 얻 은 것 과 사진 을 찍 어서 얻 은 관련 기능 도 봉 하여 배 울 만 한 가치 가 있 습 니 다.왜냐하면 많은 구덩이 가 있 기 때 문 입 니 다.이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Bitrise에서 배포 어플리케이션 설정 테스트하기이 글은 Bitrise 광고 달력의 23일째 글입니다. 자체 또는 당사 등에서 Bitrise 구축 서비스를 사용합니다. 그나저나 며칠 전 Bitrise User Group Meetup #3에서 아래 슬라이드를 발표했...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.