0

以下代码将图像从 Amazon S3 下载到设备中，然后我尝试将图像加载到图库中。我的问题与设备（Nexus 7）和模拟器不同。我下面的代码是阅读stackoverflow答案的累积。

1）在模拟器DDMS中，我在设备中的/data/data/myprojectname/file/test.jpg下找到文件test.jpg文件的大小是正确的。但是，当我尝试使用下面的意图方法加载图像时，它会显示“不幸的是相机已停止工作”。

2) 对于 Nexus 7，图库只是显示没有图像。我真的无法使用 Astro 文件管理器找到图像“test.jpg”，为什么会这样？

另外，为什么模拟器和设备会有不同的行为？

这让我发疯，提前感谢您的帮助。

码头。

showInGallery.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            try {
                // Ensure that the image will be treated as such.
                ResponseHeaderOverrides override = new ResponseHeaderOverrides();
                override.setContentType( "image/jpeg" );


                // Generate the presigned URL.
                Date expirationDate = new Date( System.currentTimeMillis() + 3600000 );   // Added an hour's worth of milliseconds to the current time.
                GeneratePresignedUrlRequest urlRequest = new GeneratePresignedUrlRequest( Constants.getPictureBucket(), Constants.PICTURE_NAME );
                urlRequest.setExpiration( expirationDate );
                urlRequest.setResponseHeaders( override );

                URL url = s3Client.generatePresignedUrl( urlRequest );
                /* Open a connection to that URL. */
                File file = new File(PATH + Constants.PICTURE_NAME);
                URLConnection ucon = url.openConnection();

                /*
                * Define InputStreams to read from the URLConnection.
                */
                InputStream is = ucon.getInputStream();
                BufferedInputStream bis = new BufferedInputStream(is);

                /*
                * Read bytes to the Buffer until there is nothing more to read(-1).
                */
                ByteArrayBuffer baf = new ByteArrayBuffer(50);
                int current = 0;
                while ((current = bis.read()) != -1) {
                    baf.append((byte) current);
                }

                /* Convert the Bytes read to a String. */
                String fileName = "test.jpg";
                //FileOutputStream fos = new FileOutputStream(fileName);
                FileOutputStream fos = openFileOutput(fileName, Context.MODE_PRIVATE);
                fos.write(baf.toByteArray());
                fos.close();

                /* read the file */
                File filePath = getFileStreamPath(fileName);

                Intent intent = new Intent();
                intent.setAction(Intent.ACTION_VIEW);
                intent.setDataAndType(Uri.parse(filePath.toString()), "image/*");
                startActivity(intent);


            }
            catch ( Exception exception ) {
                S3UploaderActivity.this.displayAlert( "Browser Failure", exception.getMessage() );
            }
        }
    });
4

2 回答 2

1

你应该考虑使用延迟加载，看看这个项目：

https://github.com/thest1/LazyList

于 2012-09-10T11:11:45.300 回答
0

我不得不修改 LazyList 中的 ImageLoader 以适应我的使用。以下代码调用 Amazon S3，由于签名不同，每次调用的 url 都不同。

        // Generate the presigned URL.
        Date expirationDate = new Date( System.currentTimeMillis() + 3600000 );   // Added an hour's worth of milliseconds to the current time.
        GeneratePresignedUrlRequest urlRequest = new GeneratePresignedUrlRequest( Constants.PICTURE_BUCKET, menuItemArray[position].getImageFileName() );
        urlRequest.setExpiration( expirationDate );
        urlRequest.setResponseHeaders( override );
        URL url = s3Client.generatePresignedUrl( urlRequest );
        imageLoader.DisplayImage(url.toString(), holder.image);

所以这就是我修改 ImageLoader 的方式，基本上是将 url 截断为 jpeg（假设所有调用都是针对 jpeg 文件的），并在放置它并从内存缓存中检索时丢弃其余部分。希望这可以帮助某人:)

package com.suite.android.menu;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.OutOfMemoryError;
import java.lang.Runnable;
import java.lang.String;
import java.lang.Throwable;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
 import java.util.WeakHashMap;
 import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;

public class ImageLoader {

MemoryCache memoryCache=new MemoryCache();
FileCache fileCache;
private Map<ImageView, String> imageViews=Collections.synchronizedMap(new WeakHashMap<ImageView, String>());
ExecutorService executorService; 

public ImageLoader(Context context){
    fileCache=new FileCache(context);
    executorService=Executors.newFixedThreadPool(5);
}

final int stub_id=R.drawable.stub;
public void DisplayImage(String url, ImageView imageView)
{

    String truncURL = truncateJPEG(url); // required as every amazon s3 call slightly different
    imageViews.put(imageView, truncURL);
    Bitmap bitmap=memoryCache.get(truncURL);
    if(bitmap!=null)
        imageView.setImageBitmap(bitmap);
    else
    {
        queuePhoto(url, imageView);
        imageView.setImageResource(stub_id);
    }
}

private String truncateJPEG(String s)
{
    int pos = s.indexOf("jpeg");
    String newURL = s.substring(0, pos+4);   //account for jpeg
    return newURL;
}

private void queuePhoto(String url, ImageView imageView)
{
    PhotoToLoad p=new PhotoToLoad(url, imageView);
    executorService.submit(new PhotosLoader(p));
}

private Bitmap getBitmap(String url) 
{
    File f=fileCache.getFile(url);

    //from SD cache
    Bitmap b = decodeFile(f);
    if(b!=null)
        return b;

    //from web
    try {
        Bitmap bitmap=null;
        URL imageUrl = new URL(url);
        HttpURLConnection conn = (HttpURLConnection)imageUrl.openConnection();
        conn.setConnectTimeout(30000);
        conn.setReadTimeout(30000);
        conn.setInstanceFollowRedirects(true);
        InputStream is=conn.getInputStream();
        OutputStream os = new FileOutputStream(f);
        Utils.CopyStream(is, os);
        os.close();
        bitmap = decodeFile(f);
        return bitmap;
    } catch (Throwable ex){
       ex.printStackTrace();
       if(ex instanceof OutOfMemoryError)
           memoryCache.clear();
       return null;
    }
}

//decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f){
    try {
        //decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(new FileInputStream(f),null,o);

        //Find the correct scale value. It should be the power of 2.
        final int REQUIRED_SIZE=70;
        int width_tmp=o.outWidth, height_tmp=o.outHeight;
        int scale=1;
        while(true){
            if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE)
                break;
            width_tmp/=2;
            height_tmp/=2;
            scale*=2;
        }

        //decode with inSampleSize
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize=scale;
        return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
    } catch (FileNotFoundException e) {}
    return null;
}

//Task for the queue
private class PhotoToLoad
{
    public String url;
    public ImageView imageView;
    public PhotoToLoad(String u, ImageView i){
        url=u; 
        imageView=i;
    }
}

class PhotosLoader implements Runnable {
    PhotoToLoad photoToLoad;
    PhotosLoader(PhotoToLoad photoToLoad){
        this.photoToLoad=photoToLoad;
    }

    @java.lang.Override
    public void run() {
        if(imageViewReused(photoToLoad))
            return;
        Bitmap bmp=getBitmap(photoToLoad.url);
        String newURL = truncateJPEG(photoToLoad.url);  // every amazon s3 call different so need to do this
        memoryCache.put(newURL, bmp);
        if(imageViewReused(photoToLoad))
            return;
        BitmapDisplayer bd=new BitmapDisplayer(bmp, photoToLoad);
        Activity a=(Activity)photoToLoad.imageView.getContext();
        a.runOnUiThread(bd);
    }
}

boolean imageViewReused(PhotoToLoad photoToLoad){
    String tag=imageViews.get(photoToLoad.imageView);
    if(tag==null || !tag.equals(truncateJPEG(photoToLoad.url)))
        return true;
    return false;
}

//Used to display bitmap in the UI thread
class BitmapDisplayer implements Runnable
{
    Bitmap bitmap;
    PhotoToLoad photoToLoad;
    public BitmapDisplayer(Bitmap b, PhotoToLoad p){bitmap=b;photoToLoad=p;}
    public void run()
    {
        if(imageViewReused(photoToLoad))
            return;
        if(bitmap!=null)
            photoToLoad.imageView.setImageBitmap(bitmap);
        else
            photoToLoad.imageView.setImageResource(stub_id);
    }
}

public void clearCache() {
    memoryCache.clear();
    fileCache.clear();
}

}
于 2012-09-13T09:16:40.003 回答