Wie kann ich auf das zwischengespeicherte Bild von Picasso zugreifen, um eine gemeinsame Absicht zu erstellen?

Question

Ich benutze Picasso, um den Cache der Bilder zu helfen.

Die Frage ist, wie kann ich auf das heruntergeladene Bild zugreifen, um eine gemeinsame Absicht zu machen?

irgendwelche Ideen? Vielen Dank!

Answer 1

Ich hoffe, dass Sie meine Frage verstehen :-)

für meine Verspätung Sorry, ich eine Lösung gefunden, aber kein gutes ...

Zuerst habe ich wirklich für eine Weile gesucht und schaute auf den Code von Picasso. Es scheint, als ob Sie Ihren eigenen Downloader und andere Sachen zur Verfügung stellen sollten. Aber dann, warum sollte ich die lib ...

Und dann, ich nehme an, es ist Picasso Design/Architektur, um nur die Datei im internen Speicher zwischenzuspeichern. Vielleicht, weil der externe Speicher nicht immer verfügbar ist (wie der Benutzer seine SD-Karte an seinen Computer anschließen kann), oder vielleicht, weil der externe Speicher nicht so schnell ist wie der interne ... Das ist meine Vermutung. Mit anderen Worten, andere Apps können nicht auf den internen Speicher der aktuellen App zugreifen, sodass die Freigabe nicht möglich ist.

So machte ich eine wirklich gewöhnliche Lösung. Ich warte nur auf Picasso, geben Sie die Bitmap, und komprimieren Sie es in eine Datei in der externen Datei, dann machen Sie die Freigabe. Es scheint wie eine schlechte Lösung, aber es löst wirklich das Problem, ja ...

Sie sollten wissen, ob das externe Cache-Verzeichnis verfügbar ist oder nicht. Wenn nicht, können Sie die Freigabe nicht ausführen. Und Sie müssen die Komprimierung Aufgabe in einen Hintergrund-Thread, so dass die externe Datei zwischengespeichert ... Scheint es wie eine schlechte Lösung? Ich denke, so ...

Unten ist mein Projektcode können Sie einen Versuch ...

private boolean mSaved; // a flag, whether the image is saved in external storage 
private MenuItem mShare; 
private Intent mIntent; 
private ShareActionProvider mShareActionProvider; 
private File mImage; // the external image file would be saved... 


private Target target = new Target() { 
    @Override 
    public void onBitmapLoaded(final Bitmap bitmap, Picasso.LoadedFrom from) { 
     new Thread(new Runnable() { 
      @Override 
      public void run() { 
       FileOutputStream os = null; 
       try { 
        String dir = CatnutUtils.mkdir(getActivity(), Constants.FANTASY_DIR); // check the exteral dir avaiable or not... 
        String[] paths = Uri.parse(mUrl).getPath().split("/"); 
        mImage = new File(dir + File.separator + paths[2] + Constants.JPG); // resoleve the file name 
       } catch (Exception e) { // the external storage not available... 
        Log.e(TAG, "create dir error!", e); 
        return; 
       } 
       try { 
        if (mImage.length() > 10) { // > 0 means the file exists 
         // the file exists, done. 
         mIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(mImage)); 
         mSaved = true; 
         return; 
        } 
        os = new FileOutputStream(mImage); 
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os); 
        mIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(mImage)); 
        mSaved = true; 
       } catch (FileNotFoundException e) { 
        Log.e(TAG, "io error!", e); 
       } finally { 
        if (os != null) { 
         try { 
          os.close(); 
         } catch (IOException e) { 
          Log.e(TAG, "io closing error!", e); 
         } 
        } 
       } 
      } 
     }).start(); 
     mFantasy.setImageBitmap(bitmap); 
    } 
@Override 
    public void onBitmapFailed(Drawable errorDrawable) { 
     mFantasy.setImageDrawable(errorDrawable); 
    } 

    @Override 
    public void onPrepareLoad(Drawable placeHolderDrawable) { 
     if (placeHolderDrawable != null) { 
      mFantasy.setImageDrawable(placeHolderDrawable); 
     } 
    } 
}; 

@Override 
public void onPrepareOptionsMenu(Menu menu) { 
    mShare.setEnabled(mSaved); 
} 

public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 
    inflater.inflate(R.menu.fantasy, menu); 
    mShare = menu.findItem(R.id.action_share); 
    mShareActionProvider = (ShareActionProvider) mShare.getActionProvider(); 
    mShare.setActionProvider(mShareActionProvider); 

    mShareActionProvider.setShareIntent(mIntent); 
} 

Schließlich rufen Picasso.with(getActivity()).load(mUrl).into(target);

Wenn die Datei gespeichert wird, kann der Benutzer klicken Sie auf die teilen Sie das Menü teilen.

Answer 2

Ich habe gerade dieses Handbuch mit einer sehr guten Lösung gefunden.

https://guides.codepath.com/android/Sharing-Content-with-Intents

Der Code wird wie folgt sein:

// Can be triggered by a view event such as a button press 
public void onShareItem(View v) { 
    // Get access to bitmap image from view 
    ImageView ivImage = (ImageView) findViewById(R.id.ivResult); 
    // Get access to the URI for the bitmap 
    Uri bmpUri = getLocalBitmapUri(ivImage); 
    if (bmpUri != null) { 
     // Construct a ShareIntent with link to image 
     Intent shareIntent = new Intent(); 
     shareIntent.setAction(Intent.ACTION_SEND); 
     shareIntent.putExtra(Intent.EXTRA_STREAM, bmpUri); 
     shareIntent.setType("image/*"); 
     // Launch sharing dialog for image 
     startActivity(Intent.createChooser(shareIntent, "Share Image"));  
    } else { 
     // ...sharing failed, handle error 
    } 
} 

// Returns the URI path to the Bitmap displayed in specified ImageView 
public Uri getLocalBitmapUri(ImageView imageView) { 
    // Extract Bitmap from ImageView drawable 
    Drawable drawable = imageView.getDrawable(); 
    Bitmap bmp = null; 
    if (drawable instanceof BitmapDrawable){ 
     bmp = ((BitmapDrawable) imageView.getDrawable()).getBitmap(); 
    } else { 
     return null; 
    } 
    // Store image to default external storage directory 
    Uri bmpUri = null; 
    try { 
     File file = new File(Environment.getExternalStoragePublicDirectory( 
      Environment.DIRECTORY_DOWNLOADS), "share_image_" + System.currentTimeMillis() + ".png"); 
     file.getParentFile().mkdirs(); 
     FileOutputStream out = new FileOutputStream(file); 
     bmp.compress(Bitmap.CompressFormat.PNG, 90, out); 
     out.close(); 
     bmpUri = Uri.fromFile(file); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return bmpUri; 
} 

Es besteht im Wesentlichen in der Bitmap aus der Imageview abgerufen und an eine lokale temporäre Datei speichern und verwenden sie dann für den Austausch. Ich habe es getestet und es scheint gut zu funktionieren.