如何从android上的url获取数据

Question

我使用 ImageLoader 库显示来自 url 的图像。它运行正常，直到它从韩文格式的 url 获取数据。我由 asyntask 处理，或编码 unicode utf8，但一切都失败了。它无法从这种 url 格式获取数据。

网址来源： http://dazone.crewcloud.net/MailAttach/1/_CrewChat/AttachFile/0/635927107253177274/명치명치.png

Url unicode utf8 名称： http://dazone.crewcloud.net/MailAttach/1/_CrewChat/AttachFile/0/635927107253177274/%EB%AA%85%EC%B9%98%EB%AA%85%EC%B9%98.png

我的代码：

ImageLoader.getInstance().displayImage(new Prefs().getServerSite() + url, view, Statics.options, new ImageLoadingListener() {
            @Override
            public void onLoadingStarted(String s, View view) {

            }

            @Override
            public void onLoadingFailed(String s, View view2, FailReason failReason) {
                String name = s.substring(s.lastIndexOf("/") + 1, s.lastIndexOf("."));
                String type = s.substring(s.lastIndexOf("."));
                String query = null;
                try {
                    query = URLEncoder.encode(name, "utf-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                String urlNew = s.substring(0, s.lastIndexOf("/")+1)+query+type;
                if(!TextUtils.isEmpty(urlNew))
                {
                    LoadImage loadImage = new LoadImage(view);
                    loadImage.execute(new String[]{urlNew});
                }
                    //ImageLoader.getInstance().displayImage(urlNew,view, Statics.options2);
            }

            @Override
            public void onLoadingComplete(String s, View view2, Bitmap bitmap) {
                view.setImageBitmap(bitmap);
            }

            @Override
            public void onLoadingCancelled(String s, View view) {

            }
        });

LoadImage.java 公共类 LoadImage 扩展 AsyncTask {

private ImageView imageView;
public LoadImage(ImageView imageView) {
    this.imageView = imageView;
}

@Override
    protected Bitmap doInBackground(String... urls) {
        Bitmap map = null;
        for (String url : urls) {
            map = downloadImage(url);
        }
        return map;
    }

    // Sets the Bitmap returned by doInBackground
    @Override
    protected void onPostExecute(Bitmap result) {
        imageView.setImageBitmap(result);
    }

    // Creates Bitmap from InputStream and returns it
    private Bitmap downloadImage(String url) {
        Bitmap bitmap = null;
        InputStream stream = null;
        BitmapFactory.Options bmOptions = new BitmapFactory.Options();
        bmOptions.inSampleSize = 1;

        try {
            stream = getHttpConnection(url);
            bitmap = BitmapFactory.
                    decodeStream(stream, null, bmOptions);
            stream.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return bitmap;
    }

    // Makes HttpURLConnection and returns InputStream
    private InputStream getHttpConnection(String urlString)
            throws IOException {
        InputStream stream = null;
        URL url = new URL(urlString);
        URLConnection connection = url.openConnection();

        try {
            HttpURLConnection httpConnection = (HttpURLConnection) connection;
            httpConnection.setRequestMethod("GET");
            httpConnection.connect();

            if (httpConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                stream = httpConnection.getInputStream();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return stream;
    }
}

Answer 1

I didnt used any lib to load image from uri but i have write code to load image and save in memory cache, Create class as per below -

------------ImageLoader.class--------



  package com.example.test;

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    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.os.Handler;
    import android.content.Context;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.widget.ImageView;

    import com.example.test.R;

    public class ImageLoader {

        // Initialize MemoryCache
       public MemoryCache memoryCache = new MemoryCache();

        public FileCache fileCache;

        //Create Map (collection) to store image and image url in key value pair
        private Map<ImageView, String> imageViews = Collections.synchronizedMap(
                                               new WeakHashMap<ImageView, String>());
        ExecutorService executorService;

        //handler to display images in UI thread
        Handler handler = new Handler();

        public ImageLoader(Context context){

            fileCache = new FileCache(context);

            // Creates a thread pool that reuses a fixed number of
            // threads operating off a shared unbounded queue.
            executorService=Executors.newFixedThreadPool(5);

        }

        // default image show in list (Before online image download)
        final int stub_id= R.drawable.ic_launcher;

        public void DisplayImage(String url, ImageView imageView)
        {
            //Store image and url in Map
            imageViews.put(imageView, url);

            //Check image is stored in MemoryCache Map or not (see MemoryCache.java)
            Bitmap bitmap = memoryCache.get(url);

            if(bitmap!=null){
                // if image is stored in MemoryCache Map then
                // Show image in listview row
                imageView.setImageBitmap(bitmap);
            }
            else
            {
                //queue Photo to download from url
                queuePhoto(url, imageView);

                //Before downloading image show default image
                imageView.setImageResource(stub_id);
            }
        }

        private void queuePhoto(String url, ImageView imageView)
        {
            // Store image and url in PhotoToLoad object
            PhotoToLoad p = new PhotoToLoad(url, imageView);

            // pass PhotoToLoad object to PhotosLoader runnable class
            // and submit PhotosLoader runnable to executers to run runnable
            // Submits a PhotosLoader runnable task for execution 

            executorService.submit(new PhotosLoader(p));
        }

        //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;
            }

            @Override
            public void run() {
                try{
                    //Check if image already downloaded
                    if(imageViewReused(photoToLoad))
                        return;
                    // download image from web url
                    Bitmap bmp = getBitmap(photoToLoad.url);

                    // set image data in Memory Cache
                    memoryCache.put(photoToLoad.url, bmp);

                    if(imageViewReused(photoToLoad))
                        return;

                    // Get bitmap to display
                    BitmapDisplayer bd=new BitmapDisplayer(bmp, photoToLoad);

                    // Causes the Runnable bd (BitmapDisplayer) to be added to the message queue.
                    // The runnable will be run on the thread to which this handler is attached.
                    // BitmapDisplayer run method will call
                    handler.post(bd);

                }catch(Throwable th){
                    th.printStackTrace();
                }
            }
        }





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

            //from SD cache
            //CHECK : if trying to decode file which not exist in cache return null
            Bitmap b = decodeFile(f);
            if(b!=null)
                return b;

            // Download image file 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();

                // Constructs a new FileOutputStream that writes to file
                // if file not exist then it will create file
                OutputStream os = new FileOutputStream(f);

                // See Utils class CopyStream method
                // It will each pixel from input stream and
                // write pixels to output stream (file)
                Utils.CopyStream(is, os);

                os.close();
                conn.disconnect();

                //Now file created and going to resize file with defined height
                // Decodes image and scales it to reduce memory consumption
                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;
                FileInputStream stream1=new FileInputStream(f);
                BitmapFactory.decodeStream(stream1,null,o);
                stream1.close();

              //Find the correct scale value. It should be the power of 2.

                // Set width/height of recreated image
                final int REQUIRED_SIZE=1085;

                int width_tmp=o.outWidth, height_tmp=o.outHeight;
                int scale=1;
                while(true){
                    if(width_tmp < REQUIRED_SIZE || height_tmp < REQUIRED_SIZE)
                        break;
                   /* width_tmp/=2;
                    height_tmp/=2;
                    scale*=2;*/
                    width_tmp = 510;
                    height_tmp = 310;
                 }

                //decode with current scale values
                BitmapFactory.Options o2 = new BitmapFactory.Options();
                o2.inSampleSize=scale;
                FileInputStream stream2=new FileInputStream(f);
                Bitmap bitmap=BitmapFactory.decodeStream(stream2, null, o2);
                stream2.close();
                return bitmap;

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

        boolean imageViewReused(PhotoToLoad photoToLoad){

            String tag=imageViews.get(photoToLoad.imageView);
            //Check url is already exist in imageViews MAP
            if(tag==null || !tag.equals(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;

                // Show bitmap on UI
                if(bitmap!=null)
                    photoToLoad.imageView.setImageBitmap(bitmap);
                else
                    photoToLoad.imageView.setImageResource(stub_id);
            }
        }

        public void clearCache() {
            //Clear cache directory downloaded images and stored data in maps
            memoryCache.clear();
            fileCache.clear();
        }

    }


-------------------FileCache.class -----------------

package com.example.test;

import java.io.File;
import android.content.Context;

public class FileCache {

    private File cacheDir;

    public FileCache(Context context){

        //Find the dir at SDCARD to save cached images

        if (android.os.Environment.getExternalStorageState().equals(
                                     android.os.Environment.MEDIA_MOUNTED))
        {
            //if SDCARD is mounted (SDCARD is present on device and mounted)
            cacheDir = new File(
                       android.os.Environment.getExternalStorageDirectory(),"LazyList");
        }
        else
        {
            // if checking on simulator the create cache dir in your application context
            cacheDir=context.getCacheDir();
        }

        if(!cacheDir.exists()){
            // create cache dir in your application context
            cacheDir.mkdirs();
        }
    }

    public File getFile(String url){
        //Identify images by hashcode or encode by URLEncoder.encode.
        String filename=String.valueOf(url.hashCode());

        File f = new File(cacheDir, filename);
        return f;

    }

    public void clear(){
        // list all files inside cache directory
        File[] files=cacheDir.listFiles();
        if(files==null)
            return;
        //delete all cache directory files
        for(File f:files)
            f.delete();
    }

}


----------------------MemoryCache.class--------------

package com.example.test;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import android.graphics.Bitmap;
import android.util.Log;

public class MemoryCache {

    private static final String TAG = "MemoryCache";

    //Last argument true for LRU ordering
    private Map<String, Bitmap> cache = Collections.synchronizedMap(
            new LinkedHashMap<String, Bitmap>(10,1.5f,true));

   //current allocated size
    private long size=0;

    //max memory cache folder used to download images in bytes
    private long limit=1000000;

    public MemoryCache(){

        //use 25% of available heap size
        setLimit(Runtime.getRuntime().maxMemory()/4);
    }

    public void setLimit(long new_limit){

        limit=new_limit;
        Log.i(TAG, "MemoryCache will use up to "+limit/1024./1024.+"MB");
    }

    public Bitmap get(String id){
        try{
            if(!cache.containsKey(id))
                return null;

            return cache.get(id);

        }catch(NullPointerException ex){
            ex.printStackTrace();
            return null;
        }
    }

    public void put(String id, Bitmap bitmap){
        try{
            if(cache.containsKey(id))
                size-=getSizeInBytes(cache.get(id));
            cache.put(id, bitmap);
            size+=getSizeInBytes(bitmap);
            checkSize();
        }catch(Throwable th){
            th.printStackTrace();
        }
    }

    private void checkSize() {
        Log.i(TAG, "cache size="+size+" length="+cache.size());
        if(size>limit){

            //least recently accessed item will be the first one iterated
            Iterator<Entry<String, Bitmap>> iter=cache.entrySet().iterator();

            while(iter.hasNext()){
                Entry<String, Bitmap> entry=iter.next();
                size-=getSizeInBytes(entry.getValue());
                iter.remove();
                if(size<=limit)
                    break;
            }
            Log.i(TAG, "Clean cache. New size "+cache.size());
        }
    }

    public void clear() {
        try{
             // Clear cache
            cache.clear();
            size=0;
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }

    long getSizeInBytes(Bitmap bitmap) {
        if(bitmap==null)
            return 0;
        return bitmap.getRowBytes() * bitmap.getHeight();
    }
}


----------------------Utils.class------------------

package com.example.test;

import java.io.InputStream;
import java.io.OutputStream;

public class Utils {
    public static void CopyStream(InputStream is, OutputStream os)
    {
        final int buffer_size=1024;
        try
        {

            byte[] bytes=new byte[buffer_size];
            for(;;)
            {
              //Read byte from input stream

              int count=is.read(bytes, 0, buffer_size);
              if(count==-1)
                  break;

              //Write byte from output stream
              os.write(bytes, 0, count);
            }
        }
        catch(Exception ex){}
    }
}

-----To load image from uri write following code -----------

ImageView imageView1 = (ImageView)findViewById(R.id.imageView1);

    String  img = "https://s3.amazonaws.com/SchApp/e1e5cf55-2f4b-467a-987e-155a708eaefe_bg.JPEG";
    ImageLoader imageLoader = new ImageLoader(MainActivity.this);

     imageView1.setTag(img);    
    imageLoader.DisplayImage(img, imageView1);