Picasso nie może załadować dużych obrazów (z aparatu i lokalnego Uri)

Question

Mam problem z użyciem Picasso, próbując załadować duże obrazy z lokalnego pliku Uri o formacie : //com.android.providers.media.documents/document/ imageXXYYZZ zarówno z galerii, jak i z kamery.

wczytuję obrazów ze standardowego połączenia:

Picasso.load(image_url) 
     .resize(600, 240) 
     .centerCrop() 
     .into(imageTarget); 

I załączony tu Target i kiedy otrzymuję błąd onBitmapFailed(Drawable errorDrawable) wyzwolone. Również, gdy loguję Picasso uzyskać:

06-23 12:13:54.267 22393-22393/it.b3lab.friendipity D/Picasso﹕ Main  created  [R100] Request{content://com.android.providers.media.documents/document/image%3A13345 resize(600,240) centerCrop} 
06-23 12:13:54.277 22393-23010/it.b3lab.friendipity D/Picasso﹕ Dispatcher enqueued  [R100]+9ms 
06-23 12:13:54.285 22393-23038/it.b3lab.friendipity D/Picasso﹕ Hunter  executing [R100]+15ms 
06-23 12:13:54.813 22393-23010/it.b3lab.friendipity D/Picasso﹕ Dispatcher batched  [R100]+546ms for error 
06-23 12:13:55.014 22393-23010/it.b3lab.friendipity D/Picasso﹕ Dispatcher delivered [R100]+746ms 
06-23 12:13:55.024 22393-22393/it.b3lab.friendipity I/picasso﹕ failed to load bitmap 
06-23 12:13:55.024 22393-22393/it.b3lab.friendipity D/Picasso﹕ Main  errored  [R100]+756ms 

Dzieje się tak tylko jak powiedziałem powyżej, gdy próbuję załadować duże obrazy z galerii (powyżej około 1 MB) oraz z zamiarem kamery przy użyciu hi-res smartfon z kamerą (w moim przypadku to Moto G działający pod systemem Android 5.0.1). Nie otrzymuję tego błędu za pomocą Samsunga S2 na Androida 4.4.

Każda pomoc będzie naprawdę doceniona! Dzięki

Answer 1

Spróbuj tego:

Uri uri = Uri.parse(imageUri); 
Picasso.with(context) 
    .load(uri) 
    .fit() 
    .resize(600, 240) 
    .skipMemoryCache() 
    .transform(new DocumentExifTransformation(this, uri)) 
    .into(imageView); 

Gdybym nie działa spojrzeć tutaj https://github.com/square/picasso/issues/539

Answer 2

Trzeba rozwiązać URI treści do URI absolut. Np. Tak:

public String getAbsolutePathFromURI(Uri contentUri) { 
    String[] proj = { MediaStore.Images.Media.DATA }; 
    Cursor cursor = activity.getContentResolver().query(contentUri, proj, null, null, null); 
    int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); 
    cursor.moveToFirst(); 
    String path = cursor.getString(columnIndex); 
    cursor.close(); 
    return path; 
} 

Answer 3

Spędziłem dużo czasu zastanawiając się, jak załadować duży obraz do widoku obrazu za pomocą Picassa. Pracował nad genymotionem, ale nie działał na moim motorze x. W końcu zdecydowałem się na ręczną zmianę rozmiaru obrazu wewnątrz zadania asynchronicznego, a następnie załadowanie go do widoku obrazu bez użycia Picassa.

new AsyncTask<String, Void, Void>() { 
       @Override 
       protected Void doInBackground(String... params) { 
        String path = params[0]; 
        final Bitmap resizedBitmap = ImageUtils.getResizedBitmap(200, 200, PATH_TO_IMAGE); 
        getActivity().runOnUiThread(new Runnable() { 
         @Override 
         public void run() { 
          imageView.setImageBitmap(resizedBitmap); 
         } 
        }); 
        return null; 
       } 
      }.execute(imageLoadPath); 

można znaleźć ImageUtils.getResizedBitmap() metodę here

Answer 4

Picasso nie powiedzie się, ale działa to idealny

public static void resizeImage(String file, int maxTargetWidth, int maxTargetHeight) { 
    try { 
     InputStream in = new FileInputStream(file); 

     BitmapFactory.Options options = new BitmapFactory.Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeStream(in, null, options); 
     close(in); 

     int inWidth = options.outWidth; 
     int inHeight = options.outHeight; 

     in = new FileInputStream(file); 
     options = new BitmapFactory.Options(); 
     options.inSampleSize = Math.max(inWidth/maxTargetWidth, inHeight/maxTargetHeight); 
     Bitmap roughBitmap = BitmapFactory.decodeStream(in, null, options); 

     Matrix m = new Matrix(); 
     RectF inRect = new RectF(0, 0, roughBitmap.getWidth(), roughBitmap.getHeight()); 
     RectF outRect = new RectF(0, 0, maxTargetWidth, maxTargetHeight); 
     m.setRectToRect(inRect, outRect, CENTER); 
     float[] values = new float[9]; 
     m.getValues(values); 

     Bitmap resizedBitmap = createScaledBitmap(roughBitmap, 
       (int) (roughBitmap.getWidth() * values[0]), (int) (roughBitmap.getHeight() * values[4]), 
       true); 

     resizedBitmap = rotateBitmap(file, resizedBitmap); 
     FileOutputStream out = new FileOutputStream(file); 
     resizedBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out); 
     close(out); 
    } catch (Exception e) { 
     error(e); 
    } 
} 

private static Bitmap rotateBitmap(String src, Bitmap bitmap) { 
    try { 
     int orientation = new ExifInterface(src).getAttributeInt(TAG_ORIENTATION, 1); 
     Matrix matrix = new Matrix(); 
     if (orientation == ORIENTATION_NORMAL) return bitmap; 
     if (orientation == ORIENTATION_FLIP_HORIZONTAL) matrix.setScale(-1, 1); 
     else if (orientation == ORIENTATION_ROTATE_180) matrix.setRotate(180); 
     else if (orientation == ORIENTATION_FLIP_VERTICAL) { 
      matrix.setRotate(180); 
      matrix.postScale(-1, 1); 
     } else if (orientation == ORIENTATION_TRANSPOSE) { 
      matrix.setRotate(90); 
      matrix.postScale(-1, 1); 
     } else if (orientation == ORIENTATION_ROTATE_90) { 
      matrix.setRotate(90); 
     } else if (orientation == ORIENTATION_TRANSVERSE) { 
      matrix.setRotate(-90); 
      matrix.postScale(-1, 1); 
     } else if (orientation == ORIENTATION_ROTATE_270) { 
      matrix.setRotate(-90); 
     } else return bitmap; 
     try { 
      Bitmap oriented = createBitmap(bitmap, 0, 0, 
        bitmap.getWidth(), bitmap.getHeight(), matrix, true); 
      bitmap.recycle(); 
      return oriented; 
     } catch (OutOfMemoryError e) { 
      error(e); 
     } 
    } catch (IOException e) { 
     error(e); 
    } 
    return bitmap; 
}