检查Android中的internet连接，如果活动不可用，请重新加载该活动

我开发了一个Android RSS阅读器。我创建了一个选项卡布局，并为每种类型的新闻创建了每个选项卡（如标题、国家、国际等）

然后我在tablayout的第一页的CustomListView中列出了RSS标题及其图像。 见下图

现在，当用户单击新闻标题时，另一个活动（页面）将打开，其中包含新闻描述

我的问题是，当用户单击选项卡并加载时，如果internet连接不可用，我想显示一个带有两个按钮的对话框，请重试并退出

当用户单击“重试”时，应该重新加载活动。我使用了一种方法（if（International.Title==null））。但我认为这不是一种正确的方法。我想知道是否有更好的解决方案来检查网络是否可用

这是我的密码

 public class International extends Activity {
    static final String URL = "http://www.abcd.com/en/taxonomy/term/3/0/feed";
    static final String KEY_HEAD = "item";
    static final String KEY_DATE = "pubDate";
    ListView list;
    InternationalAdapter adapter;

    public static String[] Title;
    public static String[] Description;
    public static String[] image;
    public static String[] Date;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.headlines);

        Bundle mybundle = new Bundle();
        mybundle.putString("number", "0");
        new DoInBackground().execute();
    }
    public void do_update() 
        {
            internationalparser.parse();//this is the function to parse RSS feeds

        }


    public void populate_listview()
     {

        ArrayList<HashMap<String, String>> newsList = new ArrayList<HashMap<String, String>>();

        XMLParser parser = new XMLParser();
        String xml = parser.getXmlFromUrl(URL); // getting XML from URL
        Document doc = parser.getDomElement(xml); // getting DOM element

        NodeList nl = doc.getElementsByTagName(KEY_HEAD);
        // looping through all song nodes <song>
        NodeList itemLst = doc.getElementsByTagName("item");


        for (int i = 0; i < nl.getLength(); i++) {
            // creating new HashMap
            HashMap<String, String> map = new HashMap<String, String>();
            Element e = (Element) nl.item(i);

            //map.put(KEY_DATE, parser.getValue(e, KEY_DATE));

            newsList.add(map);
        }


        list=(ListView)findViewById(R.id.list);

        // Getting adapter by passing xml data ArrayList
        adapter=new InternationalAdapter(this, newsList);        
        list.setAdapter(adapter);


        // Click event for single list row
        list.setOnItemClickListener(new OnItemClickListener() {


            public void onItemClick(AdapterView<?> parent, View view,
                int position, long id) {
                Intent myintent = new Intent("com.abcd.rssreaderinternationalpodcast.PODCAST");
                Bundle mybundle = new Bundle();
                mybundle.putInt("number", position);
                myintent.putExtras(mybundle);

                startActivity(myintent);

            }

        }); 

    }


     private class DoInBackground extends AsyncTask<Void, Void, Void>
     implements DialogInterface.OnCancelListener
{   
private ProgressDialog dialog;
private Intent intent;
private Intent intent2;

public void onPreExecute() 
{

    dialog = ProgressDialog.show(International.this, "", "Loading", true);

}

protected Void doInBackground(Void... unused) 
{ 


do_update(); 
return null; 
}

public void retry()
{

    internationalparser.parse();
}

protected void onPostExecute(Void unused) 
{ 


    if(International.Title!=null)
    {

        dialog.dismiss();
        populate_listview();

    }
    if(International.Title==null) ///this is what I tried.
    {
        dialog.dismiss();
         AlertDialog.Builder alertbox = new AlertDialog.Builder(International.this);

          alertbox.setMessage("Error in connection!");
          alertbox.setPositiveButton("Retry", new DialogInterface.OnClickListener() {

             public void onClick(DialogInterface arg0, int arg1) {

               retry();             //here i want to reload  activity

             }

         });

         alertbox.setNegativeButton("Exit", new DialogInterface.OnClickListener() {


             public void onClick(DialogInterface arg0, int arg1) {

                 finish();

             }

         });

         alertbox.show();

    }

}

public void onCancel(DialogInterface dialog) 
{ 
cancel(true); 
dialog.dismiss(); 
  }
 }
}

公共类国际扩展活动{
静态最终字符串URL=”http://www.abcd.com/en/taxonomy/term/3/0/feed";
静态最终字符串键\u HEAD=“item”；
静态最终字符串键\u DATE=“pubDate”；
列表视图列表；
国际适配器；
公共静态字符串[]标题；
公共静态字符串[]说明；
公共静态字符串[]图像；
公共静态字符串[]日期；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.headlines）；
Bundle mybundle=新Bundle（）；
mybundle.putString（“数字”、“0”）；
新建DoInBackground（）.execute（）；
}
public void do_update（）
{
internationalparser.parse（）；//这是解析RSS源的函数
}
public void populate_listview（）
{
ArrayList newsList=新建ArrayList（）；
XMLParser=新的XMLParser（）；
字符串xml=parser.getXmlFromUrl（URL）；//从URL获取xml
Document doc=parser.getDomeElement（xml）；//获取DOM元素
NodeList nl=doc.getElementsByTagName（键头）；
//循环通过所有歌曲节点
nodelistitemlst=doc.getElementsByTagName（“项”）；
对于（int i=0；i

更新：：

new DoInBackground().execute();

按如下所示替换此行，然后重试

if(isNetworkAvailable(YourActivity.this))
    new DoInBackground().execute();
else{
    makeAndShowDialogBox();
}

更新：：

new DoInBackground().execute();

按如下所示替换此行，然后重试

if(isNetworkAvailable(YourActivity.this))
    new DoInBackground().execute();
else{
    makeAndShowDialogBox();
}

---

这是我使用重试/退出进行internet连接的类

用法：

URLContent httpContent = new URLContent(this);
String test =  httpContent.getContent("http://www.hotmail.com/");

类别：

import java.io.BufferedReader;

import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;


import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

public class URLContent {

    MainActivity mMainActivity;
    String returnData;
    String address;

    public URLContent(MainActivity mMainActivity)  
    {
        this.mMainActivity = mMainActivity;
    }


    public String getContent(String address)
    {
        this.address = address;
        processContent(address);
        return returnData;
    }

    private void processContent(String address)
    {

        try {

            if (!isNetworkAvailable(mMainActivity))
            {
                throw new Exception("No internet connectivity.");
            }

            HttpClient client = new DefaultHttpClient();
            HttpGet request = new HttpGet();
            request.setURI(new URI(address));
            HttpResponse response = client.execute(request);

                if (response.getStatusLine().getStatusCode() == 200)
                {
                    InputStream ips  = response.getEntity().getContent();
                    BufferedReader buf = new BufferedReader(new InputStreamReader(ips,"UTF-8"));

                    StringBuilder sb = new StringBuilder();
                    String s;
                    while(true)
                    {
                        s = buf.readLine();
                        if(s==null || s.length()==0)
                            break;
                        sb.append(s);

                    }
                    buf.close();
                    ips.close();

                    returnData = sb.toString();
                }
                else
                {
                    throw new Exception();
                }

        } catch (Exception e) {

             makeAndShowDialogBox(e.getMessage()).show();
        }

    }

    private static boolean isNetworkAvailable(Context context) 
    {
       ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
       if (connectivity == null) 
       {
           return false;
       } else 
       {
          NetworkInfo[] info = connectivity.getAllNetworkInfo();
          if (info != null) 
          {
             for (int i = 0; i < info.length; i++) 
             {
                if (info[i].getState() == NetworkInfo.State.CONNECTED) 
                {
                   return true;
                }
             }
          }
       }
       return false;
    }

    private AlertDialog makeAndShowDialogBox(String msg)
    {
        AlertDialog myQuittingDialogBox =  new AlertDialog.Builder(mMainActivity) 

            .setCancelable(false)
            .setTitle(R.string.connectionerr) 
            .setMessage(msg) 

            .setPositiveButton("Retry", new DialogInterface.OnClickListener() { 
                public void onClick(DialogInterface dialog, int whichButton) { 
                 //whatever should be done when answering "YES" goes here
                    getContent(address);
                }              
            })//setPositiveButton
            .setNegativeButton("Exit", new DialogInterface.OnClickListener() { 
                public void onClick(DialogInterface dialog, int whichButton) { 
                 //whatever should be done when answering "NO" goes here
                    mMainActivity.finish();
             } 
            })//setNegativeButton

            .create();

            return myQuittingDialogBox;
    }

}

导入java.io.BufferedReader；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.net.URI；
导入org.apache.http.HttpResponse；
导入org.apache.http.client.HttpClient；
导入org.apache.http.client.methods.HttpGet；
导入org.apache.http.impl.client.DefaultHttpClient；
导入android.app.AlertDialog；
导入android.content.Context；
导入android.content.DialogInterface；
导入android.net.ConnectivityManager；
导入android.net.NetworkInfo；
公共类URL内容{
主要活动和不活动；
字符串返回数据；
字符串地址；
公共URL内容（主活动和非活动）
{
this.mMainActivity=mMainActivity；
}
公共字符串getContent（字符串地址）
{
this.address=地址；
处理内容（地址）；
返回数据；
}
私有void processContent（字符串地址）
{
试一试{
如果（！isNetworkAvailable（不活动））
{
抛出新异常（“无internet连接”）；
}
HttpClient=new DefaultHttpClient（）；
HttpGet请求=新建HttpGet（）；
请求.setURI（ne）