Подтвердить что ты не робот

Загрузка с камеры и галереи не работает должным образом во всех версиях

Я пытаюсь использовать ряд обучающих программ и примеров кода для получения изображения из галереи или камеры, а затем обрезать изображение и загрузить его на сервер. Я был реализован код для этого в этом коде, столкнувшись с некоторыми проблемами.

  • В предустановленных устройствах Lollipop, когда я обрезаю изображение с помощью приложения с фотографиями, изображение не получает отражения в представлении изображения, но оно показывает сообщение как сохраненное изображение.
  • В телефоне nexus камера и галерея не работают.
  • 5.0 в нескольких устройствах, когда я обрезаю изображение, получая изображение, как показано ниже image

ниже - это мой фрагмент кода.

public void getPhoto() {

        final String[] items = new String[] { "Take from camera",
                "Select from gallery" };
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(),
                android.R.layout.select_dialog_item, items);
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

        builder.setTitle("Select Image");
        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int item) { // pick from
                                                                    // camera
                if (item == 0) {
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    intent.putExtra(
                            "android.intent.extras.CAMERA_FACING",
                            android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT);
                    mImageCaptureUri = Uri.fromFile(new File(Environment
                            .getExternalStorageDirectory(), "tmp_avatar_"
                            + String.valueOf(System.currentTimeMillis())
                            + ".jpg"));

                    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT,
                            mImageCaptureUri);

                    try {
                        intent.putExtra("return-data", true);
                        startActivityForResult(intent, PICK_FROM_CAMERA);
                    } catch (ActivityNotFoundException e) {
                        e.printStackTrace();
                    }
                } else { // pick from file
                    Intent intent = new Intent(Intent.ACTION_PICK);
                    intent.setType("image/*");
                    // startActivityForResult(intent, SELECT_PICTURE);
                    startActivityForResult(intent, PICK_FROM_FILE);
                }
            }
        });

        final AlertDialog dialog = builder.create();
        dialog.show();

    }

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

        if (resultCode != Activity.RESULT_OK)
            return;

        switch (requestCode) {
        case PICK_FROM_CAMERA:
            doCrop();

            break;

        case PICK_FROM_FILE:
            mImageCaptureUri = data.getData();
            doCrop();
            break;

        case CROP_FROM_CAMERA:
            Bundle extras = data.getExtras();
            if (extras != null) {
                photo = extras.getParcelable("data");
                profile_image = encodeTobase64(photo);
                saveType = "photo";
                try {
                    JSONObject obj = new JSONObject();
                    obj.put("user_id", user_id);
                    obj.put("mode", saveType);
                    obj.put("photo", profile_image);
                    obj.put("is_profile", 1);
                    saveResponse(obj);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }

            }
            File f = new File(mImageCaptureUri.getPath());
            if (f.exists())
                f.delete();
            break;
        }
    }

    private void doCrop() {
        final ArrayList<CropOption> cropOptions = new ArrayList<CropOption>();
        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setType("image/*");
        List<ResolveInfo> list = getActivity().getPackageManager()
                .queryIntentActivities(intent, 0);
        int size = list.size();
        if (size == 0) {
            Toast.makeText(getActivity(), "Can not find image crop app",
                    Toast.LENGTH_SHORT).show();
            return;
        } else {
            intent.setData(mImageCaptureUri);
            intent.putExtra("crop", "true");
            intent.putExtra("outputX", 300);
            intent.putExtra("outputY", 300);
            intent.putExtra("aspectX", 1);
            intent.putExtra("aspectY", 1);
            intent.putExtra("scale", true);
            intent.putExtra("circleCrop", new String(""));
            intent.putExtra("return-data", true);
            if (size == 1) {
                Intent i = new Intent(intent);
                ResolveInfo res = list.get(0);

                i.setComponent(new ComponentName(res.activityInfo.packageName,
                        res.activityInfo.name));
                startActivityForResult(i, CROP_FROM_CAMERA);
            } else {
                for (ResolveInfo res : list) {
                    final CropOption co = new CropOption();

                    co.title = getActivity().getPackageManager()
                            .getApplicationLabel(
                                    res.activityInfo.applicationInfo);
                    co.icon = getActivity().getPackageManager()
                            .getApplicationIcon(
                                    res.activityInfo.applicationInfo);
                    co.appIntent = new Intent(intent);
                    co.appIntent
                            .setComponent(new ComponentName(
                                    res.activityInfo.packageName,
                                    res.activityInfo.name));
                    cropOptions.add(co);
                }

                CropOptionAdapter adapter = new CropOptionAdapter(
                        getActivity(), cropOptions);

                AlertDialog.Builder builder = new AlertDialog.Builder(
                        getActivity());
                builder.setTitle("Choose Crop App");
                builder.setAdapter(adapter,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int item) {
                                startActivityForResult(
                                        cropOptions.get(item).appIntent,
                                        CROP_FROM_CAMERA);
                            }
                        });

                builder.setOnCancelListener(new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialog) {

                        if (mImageCaptureUri != null) {
                            getActivity().getContentResolver().delete(
                                    mImageCaptureUri, null, null);
                            mImageCaptureUri = null;
                        }
                    }
                });

                AlertDialog alert = builder.create();

                alert.show();
            }
        }
    }

    public String encodeTobase64(Bitmap image) {
        Bitmap immagex = image;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        immagex.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        image_Array = baos.toByteArray();
        String imageEncoded = Base64
                .encodeToString(image_Array, Base64.DEFAULT);
        return imageEncoded;
    }

`

комментарий, прежде чем дублировать этот вопрос, потому что я был проверен много, но не нашел для этого решения, пожалуйста, дайте мне знать, если вам нужна дополнительная информация.

4b9b3361

Ответ 1

Я использую этот код, и он работает над любой версией Android Примечание. Вы можете опустить код пользовательского диалога в selectImage или создать для него настраиваемое диалоговое окно

Добавьте следующее в компиляцию файла builddle build 'com.theartofdev.edmodo:android-image-cropper:2.1.+'

 private File photoFile = null;
    public void selectImage() {
            final Dialog dialog = new Dialog(this, R.style.CustomDialog);
            dialog.setContentView(R.layout.custom_dialog);
            dialog.setCancelable(true);
            dialog.getWindow().setBackgroundDrawableResource(android.R.color.transparent);
            final TextView camrea= (TextView) dialog.findViewById(R.id.text);
            final TextView lib= (TextView) dialog.findViewById(R.id.text1);
            final TextView cancel= (TextView) dialog.findViewById(R.id.text2);
            camrea.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    dispatchTakePictureIntent() ;
                    dialog.cancel();
                }
            });
            lib.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (Build.VERSION.SDK_INT < 19) {
                        Intent intent = new Intent();
                        intent.setType("image/*");
                        intent.setAction(Intent.ACTION_GET_CONTENT);
                        intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
                        startActivityForResult(Intent.createChooser(intent, "Complete action using"), 200);
                    } else {
                        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
                        intent.addCategory(Intent.CATEGORY_OPENABLE);
                        intent.setType("image/*");
                        intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
                        startActivityForResult(intent, 300);
                    }
                    dialog.cancel();
                }
            });
            cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    dialog.cancel();
                }
            });
            dialog.show();

        }



         private void dispatchTakePictureIntent() {
            MarshMallowPermission marshMallowPermission = new MarshMallowPermission(this);
            if (!marshMallowPermission.checkPermissionForCamera()) {
                marshMallowPermission.requestPermissionForCamera();
            } else {
                if (!marshMallowPermission.checkPermissionForExternalStorage()) {
                    marshMallowPermission.requestPermissionForExternalStorage();
                } else {
                    Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    // Ensure that there a camera activity to handle the intent
                    if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
                        // Create the File where the photo should go
                        try {
                            photoFile = createImageFile();
                        } catch (IOException ex) {
                            // Error occurred while creating the File
                        }
                        // Continue only if the File was successfully created
                        if (photoFile != null) {
                            takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(photoFile));
                            //Log.d("Uri","Activity started");
                            startActivityForResult(takePictureIntent, 100);
                        }
                    }
                }
            }

            private void startCropImage(Uri crop) {
    CropImage.activity(crop)
            .setGuidelines(CropImageView.Guidelines.ON)
            .setAutoZoomEnabled(true)
            .setShowCropOverlay(true)
            .setActivityTitle("Crop Image")
            .start(this);

}

private File createImageFile() throws IOException {
    @SuppressLint("SimpleDateFormat")
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    String imageFileName = "JPEG_" + timeStamp + "_";
    File storageDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
    return File.createTempFile(
            imageFileName,/* prefix */
            ".jpg",       /* suffix */
            storageDir    /* directory */);
}

 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode != RESULT_OK)
            return;

      if (requestCode == CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE) {
        final CropImage.ActivityResult result = CropImage.getActivityResult(data);
        Log.d(TAG," : Image-URI :"+result.getUri());


    }else if (requestCode == 100) {
            if("com.google.android.apps.docs.storage".equals(Uri.fromFile(photoFile).getAuthority()))
                Toast.makeText(RegistrationActivity.this, "File Not On Device", Toast.LENGTH_SHORT).show();
            else {
               startCropImage(Uri.fromFile(photoFile));
            }



        } else if (requestCode == 200) {
            mIsImageUploadUri=Uri.parse(getPathFromURI(getApplicationContext(),Uri.parse(data.getData().toString())));
            final Uri selectedImage = Uri.parse(getPathFromURI(getApplicationContext(),data.getData()));
             //Log.d(TAG,"Uri"+ selectedImage.toString());
            if("com.google.android.apps.docs.storage".equals(selectedImage.getAuthority()))
                Toast.makeText(RegistrationActivity.this, "File Not On Device", Toast.LENGTH_SHORT).show();
            else {

                 startCropImage(data.getData());

            }

        }else if (requestCode == 300) {
            final Uri originalUri = data.getData();
            final int takeFlags = data.getFlags() & (Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
            //noinspection ResourceType
            getContentResolver().takePersistableUriPermission(originalUri, takeFlags);
             Log.d(TAG,"Uri"+ originalUri.toString());
            if("com.google.android.apps.docs.storage".equals(originalUri.getAuthority()))
                Toast.makeText(RegistrationActivity.this, "File Not On Device", Toast.LENGTH_SHORT).show();
            else {

                startCropImage(originalUri);
            }
        }
    }
        @TargetApi(Build.VERSION_CODES.KITKAT)
        public static String getPathFromURI(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 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 column_index = cursor.getColumnIndexOrThrow(column);
                    return cursor.getString(column_index);
                }
            } finally {
                if (cursor != null)
                    cursor.close();
            }
            return null;
        }
        public static boolean isExternalStorageDocument(Uri uri) {
            return "com.android.externalstorage.documents".equals(uri.getAuthority());
        }
        public static boolean isDownloadsDocument(Uri uri) {
            return "com.android.providers.downloads.documents".equals(uri.getAuthority());
        }
        public static boolean isMediaDocument(Uri uri) {
            return "com.android.providers.media.documents".equals(uri.getAuthority());
        }

Ответ 2

Если пользователь хочет сделать снимок:

 Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                        if (takePictureIntent.resolveActivity(BaseActivity.this.getPackageManager()) != null) {
                            File photoFile = null;
                            try {
                                photoFile = ImageVideoUtil.createImageFile();
                            } catch (IOException ex) {
                                ex.printStackTrace();
                            }
                            if (photoFile != null) {
                                imagePath = Uri.fromFile(photoFile);
                                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, imagePath);
                                startActivityForResult(takePictureIntent, ApplicationConstants.REQUEST_CAMERA);
                            }
                        }

Если пользователь хочет выбрать из камеры, вы можете использовать:

Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                        startActivityForResult(intent, ApplicationConstants.REQUEST_GALLERY);
                        dialog.dismiss();

И в результате вашей деятельности вы можете получить uri и использовать его:

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        BaseFragment fragment = (BaseFragment) getSupportFragmentManager().findFragmentById(R.id.fl_main);
        if (resultCode == RESULT_OK) {
            Bitmap bitmap = null;
            switch (requestCode) {
                case ApplicationConstants.REQUEST_CAMERA:
                    if (imagePath != null && fragment instanceof PhotoView) {
                        bitmap = Tools.fromGallery(this, imagePath);
                        if (bitmap != null) {
                            bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth() / 2, bitmap.getHeight() / 2);
                            ((PhotoView) fragment).onPhotoSet(bitmap);
                        }
                    }
                    break;

                case ApplicationConstants.REQUEST_GALLERY:
                    Uri uri = data.getData();
                    imagePath = uri;
                    bitmap = Tools.fromGallery(this, uri);
                    if (bitmap != null && fragment instanceof PhotoView) {
                        bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth() / 2, bitmap.getHeight() / 2);
                        ((PhotoView) fragment).onPhotoSet(bitmap);
                    }
                    break;

                case ApplicationConstants.REQUEST_VIDEO:
                    if (fragment instanceof VideoView) {
                        ((VideoView) fragment).onVideoSelected(videoPath);
                    }
                    break;
            }

        }
    }

Здесь класс ImageVideoUtil, который поможет вам обрезать, масштабировать, сохранять и читать операции с видеоизображением.

public class ImageVideoUtil {

    public static void startCameraIntent(Activity activity) {

        Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        // Ensure that there a camera activity to handle the intent
        if (takePictureIntent.resolveActivity(activity.getPackageManager()) != null) {
            // Create the File where the photo should go
            File photoFile = null;
            try {
                photoFile = createImageFile();
            } catch (IOException ex) {
                // Error occurred while creating the File
                ex.printStackTrace();
            }
            // Continue only if the File was successfully created
            if (photoFile != null) {
                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(photoFile));
                activity.startActivityForResult(takePictureIntent, ApplicationConstants.REQUEST_CAMERA);
            }
        }
    }

    public static File createImageFile() throws IOException {
        // Create an image file name
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String imageFileName = "SnapSense" + timeStamp + "_";
        File storageDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        File image = File.createTempFile(imageFileName, /* prefix */
                ApplicationConstants.DEFAULT_IMGAE_SUFFIX, /* suffix */
                storageDir /* directory */
        );

        // Save a file: path for use with ACTION_VIEW intents
        return image;
    }

    public static File createVideoFile() throws IOException {
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String imageFileName = "SnapSense" + timeStamp + "_";
        File storageDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES);
        File video = File.createTempFile(imageFileName, /* prefix */
                ApplicationConstants.DEFAULT_VIDEO_SUFFIX, /* suffix */
                storageDir /* directory */
        );

        // Save a file: path for use with ACTION_VIEW intents
        return video;
    }

    public static Bitmap decodeBitmap(Bitmap bmp) {
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            bmp.compress(Bitmap.CompressFormat.PNG, 50, out);
            return BitmapFactory.decodeStream(new ByteArrayInputStream(out.toByteArray()));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return bmp;
    }
}

Наконец, вот некоторые другие статические методы, которые помогут вам:

public static Bitmap fromGallery(Context context, final Uri selectedImageUri) {
        try {
            Bitmap bm = MediaStore.Images.Media.getBitmap(context.getContentResolver(), selectedImageUri);
            ExifInterface exif = new ExifInterface(selectedImageUri.getPath());
            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            int angle = 0;
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    angle = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    angle = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    angle = 270;
                    break;
                default:
                    angle = 0;
                    break;
            }
            Matrix mat = new Matrix();
            if (angle == 0 && bm.getWidth() > bm.getHeight())
                mat.postRotate(90);
            else
                mat.postRotate(angle);

            return Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), mat, true);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (OutOfMemoryError oom) {
            oom.printStackTrace();
        }
        return null;
    }

    public static String getRealPathFromURI(Activity activity, Uri contentUri) {
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = activity.managedQuery(contentUri, proj, null, null, null);
        int column_index = cursor
                .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    }

Надеюсь, мой код поможет вам. Удачи.

Ответ 3

У меня такая же проблема на прошлой неделе, и я, наконец, ее разрешу, она немного отличается в моем случае, я получаю изображение в Base64 с сервера, а затем обрезаю его

здесь код

byte[] decodedString = Base64.decode(imageJson, Base64.DEFAULT);
Bitmap tmp = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
bitmapDecoded = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

int h = metrics.heightPixels;
int w = metrics.widthPixels;
Bitmap resized = Bitmap.createScaledBitmap(tmp, tmp.getWidth(), (int) (tmp.getHeight()*1.6), true);
imageView.setImageBitmap(canvas.getCircleBitmap(resized, w,h));

imageJson - это изображение в Base64, которое String я преобразую в Bitmap, после того как я получу размер экрана, размер растрового изображения здесь для квадратного изображения, потому что у меня есть изображение 16/9, это, возможно, не полезно для вас, и, наконец, я покажу растровое изображение в imageView и обрезаю его с помощью метода canvas getCircleBitmap

вот метод

public Bitmap getCircleBitmap(Bitmap bitmap,int width, int height) {
    final Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
            bitmap.getHeight(), Bitmap.Config.ARGB_8888);
    final Canvas canvas = new Canvas(output);
    final int color = Color.RED;
    final Paint paint = new Paint();
    final Rect rect = new Rect((int)(bitmap.getWidth()*0.054), (int) (height*0.005), (int) (bitmap.getWidth()*0.945), (bitmap.getHeight()));
    final RectF rectF = new RectF(rect);

    paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    paint.setColor(color);
    canvas.drawOval(rectF, paint);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    canvas.drawBitmap(bitmap, rect, rect, paint);
    bitmap.recycle();

    return output;
}

Вы можете изменить значение прямоугольника, подходящего для использования Я объявляю этот метод в классе canvas, который расширяет представление, действительно надеюсь, что это тоже поможет вам и извините за мой английский

Ответ 4

i также сталкивается с этой проблемой. Теперь ее работая отлично, потому что я использую библиотеку

 **compile 'com.soundcloud.android:android-crop:[email protected]'**

public Uri mImageCaptureUri = null;

Выберите изображение из галереи

Intent i = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(i, PICK_FROM_FILE);

это добавление к методу onActivityResult

 //call this line after crop it 

   if(requestCode == Crop.REQUEST_CROP){
        handleCrop(resultCode, data);
    }

  case PICK_FROM_FILE:

            mImageCaptureUri = data.getData();
            beginCrop(mImageCaptureUri);
            break;


private void beginCrop(Uri source) {
    Uri destination = Uri.fromFile(new File(getCacheDir(), "cropped"));
    Crop.of(source, destination).asSquare().start(this);
}
private void handleCrop(int resultCode, Intent result) {

    if (resultCode == RESULT_OK) {
       // mImage.setImageURI(Crop.getOutput(result));
        Picasso.with(SettingsActivity.this).load(Crop.getOutput(result)).transform(new RoundTransform()).into(mImage);
        mImageCaptureUri=Crop.getOutput(result);
        getImageUri(mImageCaptureUri);     //this method uri stored to sdcard
    } else if (resultCode == Crop.RESULT_ERROR) {
        Toast.makeText(this, Crop.getError(result).getMessage(), Toast.LENGTH_SHORT).show();
    }
}

Ответ 5

Я столкнулся с той же проблемой в Nexus. Я использовал Android Image Cropper, который очень легкий и гибкий.

compile 'com.theartofdev.edmodo: android-image-cropper: 2.2. +'

Ответ 6

В каждой версии есть собственный способ получить путь: Попробуйте этот метод будет работать для каждой версии, ИТ РАБОТАЕТ ДЛЯ МЕНЯ:

public static String getRealPathFromURI(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];
            }

            // TODO handle non-primary volumes
        }
        // 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 getDataColumn(context, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}