Browser Android应用程序-使用AsyncTask-停止在WebView中打开URL，如果我调用另一个URL，它将由默认浏览器打开

我开始在android中使用来自的材料进行开发

我拿了他们的一个例子并修改了它，这样我的应用程序就可以连接到一个网页。打开时效果很好，但如果我单击一个actionBar项目，它将打开另一个页面，新页面不会在WebView中打开，但会启动默认浏览器

我尝试了很多方法来理解如何避免这种情况，但我的一点经验不允许我解决这个问题

你能帮我吗

非常感谢。 尼诺

公共类MainActivity扩展活动{
公共静态最终字符串WIFI=“Wi-Fi”；
公共静态最终字符串ANY=“ANY”；
公共静态字符串PAGINA=”http://www.kibao.org/simu/wap.php?lng=";    
公共静态字符串基=”http://www.kibao.org";
公共静态字符串ATTUALE=“”；
公共静态字符串lng=“”；
最终上下文=此；
私有静态布尔wifiConnected=false；
私有静态布尔值mobileConnected=false；
公共静态布尔刷新显示=true；
公共静态字符串sPref=null；
公共静态字符串pagina=“”；
专用NetworkReceiver=新NetworkReceiver（）；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
lng=getResources（）.getString（R.string.lng）；
IntentFilter筛选器=新的IntentFilter（ConnectionManager.CONNECTIVITY_操作）；
receiver=新的NetworkReceiver（）；
此注册表接收程序（接收器、过滤器）；
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
}
@凌驾
public void onStart（）{
super.onStart（）；
SharedPreferences SharedPrefers=PreferenceManager.getDefaultSharedPreferences（此）；
sPref=sharedPrefs.getString（“listPref”、“Wi-Fi”）；
UpdateConnectionFlags（）；
如果（刷新显示）{
ATTUALE=帕吉纳浓缩液（lng）；
加载页（附件）；
}
}
@凌驾
公共空间{
super.onStop（）；
String ciao=getResources（）.getString（R.String.ciao）；
敬酒（再见）；
如果（接收器！=null）{
本条：未注册接收人（接收人）；
}
}
私有void updateConnectionFlags（）{
连接管理器连接管理器=
（ConnectionManager）getSystemService（Context.CONNECTIVITY_服务）；
NetworkInfo-activeInfo=connMgr.getActiveNetworkInfo（）；
if（activeInfo！=null&&activeInfo.isConnected（））{
wifiConnected=activeInfo.getType（）==ConnectivityManager.TYPE\u WIFI；
MobileConnect=activeInfo.getType（）==ConnectivityManager.TYPE\u MOBILE；
}否则{
wifiConnected=false；
mobileConnected=false；
}
}
私有void加载页（字符串pgUrl）{
if（（（sPref.equals（ANY））和&（wifiConnected | | mobileConnect））
||（（sPref.equals（WIFI））&（wifiConnected）））{
新建下载WebPagetAsk（）.execute（pgUrl）；
}否则{
第页（）；
}
}
//如果应用程序无法加载内容，则显示错误。
私人网页（第页）{
.... 
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
super.onCreateOptions菜单（菜单）；
MenuInflater充气机=getMenuInflater（）；
充气机。充气（右菜单项，菜单）；
返回true；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
//处理项目选择
开关（item.getItemId（））{
案例R.id.menu1：
如果（刷新显示）{
ATTUALE=BASE.concat（“/partite.php？lng=”）；
ATTUALE=ATTUALE.concat（液化天然气）；
加载页（附件）；
}
返回true；
....
违约：
返回super.onOptionsItemSelected（项目）；
}
}
私有InputStream downloadUrl（字符串urlString）引发IOException{
URL=新URL（URL字符串）；
HttpURLConnection conn=（HttpURLConnection）url.openConnection（）；
conn.setReadTimeout（10000/*毫秒*/）；
conn.setConnectTimeout（15000/*毫秒*/）；
conn.setRequestMethod（“GET”）；
conn.setDoInput（真）；
连接（）；
InputStream=conn.getInputStream（）；
回流；
}
公共类NetworkReceiver扩展了BroadcastReceiver{
@凌驾
公共void onReceive（上下文、意图）{
连接管理器连接管理器=
（ConnectionManager）context.getSystemService（context.CONNECTIVITY_服务）；
NetworkInfo NetworkInfo=connMgr.getActiveNetworkInfo（）；
如果（WIFI.equals（sPref）&&networkInfo！=null
&&networkInfo.getType（）==ConnectivityManager.TYPE\u WIFI）{
刷新显示=真；
Toast.makeText（context，R.string.wifi_connected，Toast.LENGTH_SHORT）.show（）；
}else if（ANY.equals（sPref）&&networkInfo！=null）{
刷新显示=真；
}否则{
刷新显示=假；
Toast.makeText（context，R.string.lost_connection，Toast.LENGTH_SHORT）.show（）；
}
}
}
私有类下载WebPagetTask扩展异步任务{
@凌驾
受保护的字符串doInBackground（字符串…URL）{
试一试{
从网络返回loadWebpageFromNetwork（URL[0]）；
}捕获（IOE异常）{
返回getResources（）.getString（R.string.connection\u错误）；
}
}
@凌驾
受保护的void onPostExecute（字符串结果）{
setContentView（R.layout.main）；
WebView myWebView=（WebView）findviewbyd（R.id.WebView）；
myWebView.loadUrl（附件）；
}
}
私有字符串loadWebpageFromNetwork（字符串urlString）抛出IOEXEP
public class MainActivity extends Activity {
    public static final String WIFI = "Wi-Fi";
    public static final String ANY = "Any";
    public static String PAGINA ="http://www.kibao.org/simu/wap.php?lng=";    
    public static String BASE ="http://www.kibao.org";
    public static String ATTUALE ="";
    public static String lng = "";
    final Context context = this;

    private static boolean wifiConnected = false;
    private static boolean mobileConnected = false;
    public static boolean refreshDisplay = true;
    public static String sPref = null;

    public static String pagina = "";

    private NetworkReceiver receiver = new NetworkReceiver();
    @Override
    public void onCreate(Bundle savedInstanceState) {
        lng = getResources().getString(R.string.lng);
        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
        receiver = new NetworkReceiver();
        this.registerReceiver(receiver, filter);

        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    public void onStart() {
        super.onStart();

        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

        sPref = sharedPrefs.getString("listPref", "Wi-Fi");

        updateConnectedFlags();


        if (refreshDisplay) {
            ATTUALE=PAGINA.concat(lng);
            loadPage(ATTUALE);
        }
    }
    @Override
    public void onDestroy() {
        super.onStop();
        String ciao = getResources().getString(R.string.ciao);
        show_toast(ciao);
        if (receiver != null) {
           this.unregisterReceiver(receiver);
        }
    }
    private void updateConnectedFlags() {
        ConnectivityManager connMgr =
            (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
        if (activeInfo != null && activeInfo.isConnected()) {
            wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
            mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;
        } else {
            wifiConnected = false;
            mobileConnected = false;
        }
    }

    private void loadPage(String pgUrl) {
        if (((sPref.equals(ANY)) && (wifiConnected || mobileConnected))
            || ((sPref.equals(WIFI)) && (wifiConnected))) {
            new DownloadWebpageTask().execute(pgUrl);
        } else {
            showErrorPage();
        }
    }

   // Displays an error if the app is unable to load content.
   private void showErrorPage() {
        .... 
   }

   @Override
   public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.items, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {

    // Handle item selection
    switch (item.getItemId()) {
    case R.id.menu1:
        if (refreshDisplay) {

            ATTUALE=BASE.concat("/partite.php?lng=");
            ATTUALE=ATTUALE.concat(lng);
            loadPage(ATTUALE);
        }
        return true;
    ....
    default:
        return super.onOptionsItemSelected(item);
    }

    }
    private InputStream downloadUrl(String urlString) throws IOException {
        URL url = new URL(urlString);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(10000 /* milliseconds */);
        conn.setConnectTimeout(15000 /* milliseconds */);
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        conn.connect();
        InputStream stream = conn.getInputStream();
        return stream;
   }

    public class NetworkReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
           ConnectivityManager connMgr =
                (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
            if (WIFI.equals(sPref) && networkInfo != null
                && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
                refreshDisplay = true;
                Toast.makeText(context, R.string.wifi_connected, Toast.LENGTH_SHORT).show();
            } else if (ANY.equals(sPref) && networkInfo != null) {
                refreshDisplay = true;
            } else {
                refreshDisplay = false;
                Toast.makeText(context, R.string.lost_connection, Toast.LENGTH_SHORT).show();
            }
        }
    }

    private class DownloadWebpageTask extends AsyncTask<String, Void, String> {

        @Override
        protected String doInBackground(String... urls) {
            try {
            return loadWebpageFromNetwork(urls[0]);
            } catch (IOException e) {
                return getResources().getString(R.string.connection_error);
            }
        }

        @Override
        protected void onPostExecute(String result) {
            setContentView(R.layout.main);
            WebView myWebView = (WebView) findViewById(R.id.webview);
            myWebView.loadUrl(ATTUALE);            
        }
    }
    private String loadWebpageFromNetwork(String urlString) throws IOException {
        InputStream stream = null;
        try {
            stream = downloadUrl(urlString);
            pagina = getStringFromInputStream(stream);
        } finally {
            if (stream != null) {
                stream.close();
            }
        }
    return pagina;
    }
    private static String getStringFromInputStream(InputStream is) {
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();

        String line;
        try {

        br = new BufferedReader(new InputStreamReader(is));
        while ((line = br.readLine()) != null) {
            sb.append(line);
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    return sb.toString();

}        
........
}

 myWebView.setWebViewClient(new WebViewClient()); 

protected void onPostExecute(String result) {
        setContentView(R.layout.main);
        WebView myWebView = (WebView) findViewById(R.id.webview);
        myWebView.setWebViewClient(new WebViewClient());
        myWebView.loadUrl(ATTUALE);            
}