Java 图像加载器“；SkImageDecoder:：出厂时返回null“；

我将我的视图imageview传递到我创建的imageloader类中，但由于某种原因，我得到了这个错误“SkImageDecoder:：Factory returned null”，这似乎只发生在一些图像上，url应该可以处理。它将只加载10个列表中的3个。我想知道这个任务是否不是线程安全的，或者我可能错过了什么。看看下面

图像加载器：

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.failed_load;

    public void displayImage(String url, ImageView imageView) {
        System.out.println(url);

        imageViews.put(imageView, url);
        Bitmap bitmap = memoryCache.get(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
        } else {
            queuePhoto(url, imageView);
            imageView.setImageResource(stub_id);
        }

    }

    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(3000);
            conn.setReadTimeout(3000);
            conn.setInstanceFollowRedirects(true);
            InputStream is = conn.getInputStream();
            OutputStream os = new FileOutputStream(f);
            IOUtils.copy(is, os);// Util.CopyStream(is, os); //TODO DELETE
            os.close();
            bitmap = decodeFile(f);
            return bitmap;
        } catch (Exception ex) {
            ex.printStackTrace();
            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.
            // TODO Can change image content here.
            final int REQUIRED_SIZE = 512;
            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;
        }

        @Override
        public void run() {
            if (imageViewReused(photoToLoad)) {
                return;
            }
            Bitmap bmp = getBitmap(photoToLoad.url);
            memoryCache.put(photoToLoad.url, 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(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();
    }

}

公共类ImageLoader{
MemoryCache MemoryCache=新的MemoryCache（）；
文件缓存文件缓存；
私有地图图像视图=集合
.synchronizedMap（新WeakHashMap（））；
执行服务执行服务；
公共图像加载器（上下文）{
fileCache=新的fileCache（上下文）；
executorService=Executors.newFixedThreadPool（5）；
}
最终int stub_id=R.drawable.failed_load；
public void displayImage（字符串url，ImageView）{
System.out.println（url）；
put（imageView，url）；
位图位图=memoryCache.get（url）；
if（位图！=null）{
设置图像位图（位图）；
}否则{
队列照片（url、imageView）；
setImageResource（存根id）；
}
}
私有void队列照片（字符串url，ImageView）{
PhotoToLoad p=新的PhotoToLoad（url，imageView）；
executorService.submit（新的PhotoLoader（p））；
}
私有位图getBitmap（字符串url）{
文件f=fileCache.getFile（url）；
//从SD缓存
位图b=解码文件（f）；
如果（b！=null）{
返回b；
}
//从网络
试一试{
位图=空；
URL imageUrl=新URL（URL）；
HttpURLConnection conn=（HttpURLConnection）imageUrl
.openConnection（）；
连接设置连接超时（3000）；
连接设置读取超时（3000）；
conn.setInstanceFollowRedirects（真）；
InputStream is=conn.getInputStream（）；
OutputStream os=新文件OutputStream（f）；
IOUtils.copy（is，os）；//Util.CopyStream（is，os）；//TODO DELETE
os.close（）；
位图=解码文件（f）；
返回位图；
}捕获（例外情况除外）{
例如printStackTrace（）；
返回null；
}
}
//对图像进行解码和缩放以减少内存消耗
私有位图解码文件（文件f）{
试一试{
//解码图像大小
BitmapFactory.Options o=新的BitmapFactory.Options（）；
o、 inJustDecodeBounds=true；
解码流（新的FileInputStream（f），null，o）；
//找到正确的刻度值。它应该是2的幂。
//TODO可以在此处更改图像内容。
所需的最终int_SIZE=512；
内部宽度=o.向外宽度，高度=o.向外高度；
int标度=1；
while（true）{
如果（宽度\u tmp/2<要求的\u尺寸
||高度（tmp/2<所需尺寸）
打破
宽度_tmp/=2；
高度_tmp/=2；
比例*=2；
}
//用inSampleSize解码
BitmapFactory.Options o2=新的BitmapFactory.Options（）；
o2.inSampleSize=刻度；
返回BitmapFactory.decodeStream（新文件输入流（f），null，o2）；
}catch（filenotfounde异常）{
}
返回null；
}
//队列的任务
私有类光电负载{
公共字符串url；
公共影像视图；
公共PhotoToLoad（字符串u，图像视图i）{
url=u；
imageView=i；
}
}
类photoloader实现可运行{
光电负载光电负载；
PhotoLoader（PhotoToLoad PhotoToLoad）{
this.photoToLoad=photoToLoad；
}
@凌驾
公开募捐{
if（图像视图重用（光电加载））{
返回；
}
位图bmp=getBitmap（photoLoad.url）；
memoryCache.put（photoload.url，bmp）；
if（图像视图重用（光电加载））{
返回；
}
BitmapDisplayer bd=新的BitmapDisplayer（bmp，photoToLoad）；
活动a=（活动）photoToLoad.imageView.getContext（）；
a、 runOnUiThread（bd）；
}
}
布尔图像视图（PhotoToLoad PhotoToLoad）{
String tag=imageViews.get（photoload.imageView）；
if（tag==null | |！tag.equals（photoload.url））{
返回true；
}
返回false；
}
//用于在UI线程中显示位图
类BitmapDisplayer实现可运行{
位图；
光电负载光电负载；
公共位图显示器（位图b、PhotoToLoad p）{
位图=b；
光电负载=p；
}
公开募捐{
if（图像视图重用（光电加载））{
返回；
}
if（位图！=null）{
photoToLoad.imageView.setImageBitmap（位图）；
}否则{
photoToLoad.imageView.setImageResource（存根id）；
}
}
}
公共void clearCache（）{
memoryCache.clear（）；
fileCache.clear（）；
}
}

不幸的是，解决方案是重复检查传入的url，这是错误的，现在一切似乎都好了。对于其他有类似问题的人，请仔细检查您正在加载的内容，以及从您尝试加载的任何地方输入的文件

同样的问题对我来说，哪里需要检查？？？检查你的实际网址，并确保它们是正确的。是的，一切都是正确的，我不能加载https网址在我的android应用程序，除了一切正常。谢谢你的回复