Java 如何检查上下文是否仍然可以在android中使用？

在我的android应用程序中，我有一个异步任务，它下载一个图像并将其保存到外部存储器，然后重复，直到所有图像都下载完毕。这可能需要一段时间，我引用了调用它的活动的上下文，在异步的每个下载的映像中引用了几次

在这个过程中，用户可能已经按下了后退或结束上下文的内容

如何检查我是否仍然可以在异步任务中使用它

这是我的异步任务代码：

package async;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;
import common.Common;
import common.FishCategory;
import http.Network;
import interfaces.ImageDownloader;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.os.AsyncTask;
import android.os.Environment;
import android.provider.MediaStore;

public class Async_getAllFishPics extends AsyncTask<FishCategory, Void, FishCategory> {

    String link;
    ImageDownloader callerContext;
    List<FishCategory> categoryList;

    public Async_getAllFishPics(ImageDownloader callerContext, List<FishCategory> categoryList) {
        this.callerContext = callerContext;
        this.categoryList = categoryList;

        for (FishCategory fish : categoryList) {
            link = fish.getLink();
            if (!link.equals("")) {
                String imgpath = Common.getImagePath(link);
                File file = new File(android.os.Environment.getExternalStorageDirectory(), imgpath);
                if (!file.exists() && Network.isNetworkAvailable((Context)callerContext)) {
                    execute(fish);
                    break;
                }
            }
        }
    }

    @Override
    protected FishCategory doInBackground(FishCategory... fishes) {
        Bitmap bitmap = Network.DownloadImage((Context) callerContext, link);

        try {
            saveImage(bitmap);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return fishes[0];
    }

    @Override
    protected void onPostExecute(FishCategory fish) {
        try {
            fish.setLink(link);
            new Async_getAllFishPics(callerContext, categoryList);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    private void saveImage(Bitmap bitmap) throws IOException {
        if (bitmap != null) {
            String path = Environment.getExternalStorageDirectory().toString();

            String imgpath = Common.getImagePath(link);

            File file = new File(path, imgpath);
            file.getParentFile().mkdirs();

            String abs = file.getAbsolutePath();

            OutputStream fOut = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, fOut);

            fOut.flush();
            fOut.close();

            MediaStore.Images.Media.insertImage(((Activity)callerContext).getContentResolver(),abs,file.getName(),file.getName());
        }   
    }
}

包异步；
导入java.io.File；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.OutputStream；
导入java.util.List；
进口普通。普通；
进口普通鱼类；
导入http.net；
导入interfaces.ImageDownloader；
导入android.app.Activity；
导入android.content.Context；
导入android.graphics.Bitmap；
导入android.os.AsyncTask；
导入android.os.Environment；
导入android.provider.MediaStore；
公共类异步\u getAllFishPics扩展异步任务{
串链；
ImageDownloader调用Context；
列表分类列表；
公共异步\u getAllFishPics（ImageDownloader callerContext，列表类别列表）{
this.callerContext=callerContext；
this.categoryList=categoryList；
对于（鱼类类别：分类列表）{
link=fish.getLink（）；
如果（！link.equals（“”）{
字符串imgpath=Common.getImagePath（链接）；
File File=新文件（android.os.Environment.getExternalStorageDirectory（），imgpath）；
如果（！file.exists（）&&Network.isNetworkAvailable（（上下文）callerContext））{
处决（鱼）；
打破
}
}
}
}
@凌驾
受保护的鱼类类别doInBackground（鱼类类别…鱼类）{
位图位图=Network.DownloadImage（（上下文）callerContext，link）；
试一试{
保存图像（位图）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
回归鱼类[0]；
}
@凌驾
PostExecute上受保护的void（鱼类类鱼类）{
试一试{
fish.setLink（link）；
新的Async_getAllFishPics（callerContext，categoryList）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
私有void saveImage（位图）引发IOException{
if（位图！=null）{
字符串路径=Environment.getExternalStorageDirectory（）.toString（）；
字符串imgpath=Common.getImagePath（链接）；
File File=新文件（路径，imgpath）；
文件.getParentFile（）.mkdirs（）；
字符串abs=file.getAbsolutePath（）；
OutputStream fOut=新文件OutputStream（文件）；
compress（bitmap.CompressFormat.PNG，100，fOut）；
fOut.flush（）；
fOut.close（）；
MediaStore.Images.Media.insertImage（（（活动）callerContext.getContentResolver（），abs，file.getName（），file.getName（））；
}   
}
}

为什么不改用ApplicationContext？至少在关闭应用程序之前，您可以确保上下文将一直存在

---

context.getApplicationContext（）

如果你正在做的事情可能需要很长时间，那么你应该使用一个

服务

，它有自己的

上下文

。或者，您可以签入

finish（）

并停止任务。如果活动关闭时我尝试访问

.getApplicationContext（）

的结果会发生什么？@omega我不确定您的意思。如果将应用程序上下文作为异步任务的上下文传递，则用于访问应用程序上下文的活动是否已关闭并不重要。例如，如果上下文活动中存在非静态的全局变量，则如果上下文已关闭，如果我尝试访问它会发生什么情况？我还在这里使用上下文

MediaStore.Images.Media.insertImage（（（活动）callerContext.getContentResolver（），abs，file.getName（），file.getName（）），然后会发生什么？活动上下文！=应用程序上下文。终止异步任务的唯一方法是关闭应用程序，而不是关闭活动。无论如何，您都无法访问异步任务，因为它位于另一个线程上。