वेबव्यू में वेब ऐप्लिकेशन बनाएं

क्लाइंट ऐप्लिकेशन के हिस्से के तौर पर, वेब ऐप्लिकेशन या वेब पेज दिखाने के लिए WebView का इस्तेमाल करें. WebView क्लास, Android की View क्लास का एक्सटेंशन है. इसकी मदद से, वेब पेजों को अपने ऐक्टिविटी लेआउट के हिस्से के तौर पर दिखाया जा सकता है. इसमें पूरी तरह से तैयार किए गए वेब ब्राउज़र की सुविधाएं शामिल नहीं होती हैं. जैसे, नेविगेशन कंट्रोल या पता बार. डिफ़ॉल्ट रूप से, WebView सिर्फ़ वेब पेज दिखाता है.

WebView की मदद से, अपने ऐप्लिकेशन में ऐसी जानकारी दी जा सकती है जिसे अपडेट करने की ज़रूरत पड़ सकती है. जैसे, असली उपयोगकर्ता के साथ किया गया समझौता या उपयोगकर्ता गाइड. अपने Android ऐप्लिकेशन में, Activity वाली WebView बनाई जा सकती है. इसके बाद, इसका इस्तेमाल करके, ऑनलाइन होस्ट किए गए अपने दस्तावेज़ दिखाए जा सकते हैं.

WebView तब भी काम आ सकता है, जब आपका ऐप्लिकेशन उपयोगकर्ता को ऐसा डेटा दिखाता है जिसे पाने के लिए इंटरनेट कनेक्शन की ज़रूरत होती है. जैसे, ईमेल. इस मामले में, आपको लग सकता है कि Android ऐप्लिकेशन में WebView बनाना ज़्यादा आसान है. यह WebView, उपयोगकर्ता के पूरे डेटा के साथ एक वेब पेज दिखाता है. इसके लिए, नेटवर्क का अनुरोध करने, डेटा को पार्स करने, और उसे Android लेआउट में रेंडर करने की ज़रूरत नहीं होती. इसके बजाय, Android पर चलने वाले डिवाइसों के लिए, वेब पेज डिज़ाइन किया जा सकता है. इसके बाद, अपने Android ऐप्लिकेशन में WebView लागू किया जा सकता है, जो वेब पेज लोड करता है.

इस दस्तावेज़ में, WebView का इस्तेमाल शुरू करने, अपने Android ऐप्लिकेशन में क्लाइंट-साइड कोड से अपने वेब पेज से JavaScript को बाइंड करने, पेज नेविगेशन को हैंडल करने, और WebView का इस्तेमाल करते समय विंडो मैनेज करने का तरीका बताया गया है.

Android के पुराने वर्शन पर WebView का इस्तेमाल करना

अपने ऐप्लिकेशन को जिस डिवाइस पर चलाया जा रहा है उस पर WebView की नई सुविधाओं का सुरक्षित तरीके से इस्तेमाल करने के लिए, AndroidX Webkit लाइब्रेरी जोड़ें. यह एक स्टैटिक लाइब्रेरी है. इसे अपने ऐप्लिकेशन में जोड़ा जा सकता है, ताकि android.webkit के उन एपीआई का इस्तेमाल किया जा सके जो प्लैटफ़ॉर्म के पुराने वर्शन के लिए उपलब्ध नहीं हैं.

इसे अपनी build.gradle फ़ाइल में इस तरह जोड़ें:

Kotlin

dependencies {
    implementation("androidx.webkit:webkit:1.8.0")
}

शानदार

dependencies {
    implementation ("androidx.webkit:webkit:1.8.0")
}

ज़्यादा जानकारी के लिए, GitHub पर उदाहरण WebView देखें.

अपने ऐप्लिकेशन में WebView जोड़ना

अपने ऐप्लिकेशन में WebView जोड़ने के लिए, अपने ऐक्टिविटी लेआउट में <WebView> एलिमेंट शामिल किया जा सकता है. इसके अलावा, onCreate() में पूरी Activity विंडो को WebView के तौर पर सेट किया जा सकता है.

ऐक्टिविटी लेआउट में WebView जोड़ना

लेआउट में अपने ऐप्लिकेशन में WebView जोड़ने के लिए, अपनी ऐक्टिविटी के लेआउट की XML फ़ाइल में यह कोड जोड़ें:

<WebView
    android:id="@+id/webview"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
/>

WebView में वेब पेज लोड करने के लिए, loadUrl() का इस्तेमाल करें. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

val myWebView: WebView = findViewById(R.id.webview)
myWebView.loadUrl("http://www.example.com")

Java

WebView myWebView = (WebView) findViewById(R.id.webview);
myWebView.loadUrl("http://www.example.com");

onCreate() में WebView जोड़ना

इसके अलावा, किसी ऐक्टिविटी के onCreate() तरीके में अपने ऐप्लिकेशन में WebView जोड़ने के लिए, इस तरह की लॉजिक का इस्तेमाल करें:

Kotlin

val myWebView = WebView(activityContext)
setContentView(myWebView)

Java

WebView myWebView = new WebView(activityContext);
setContentView(myWebView);

इसके बाद, पेज लोड करें:

Kotlin

myWebView.loadUrl("http://www.example.com")

Java

myWebView.loadUrl("https://www.example.com");

इसके अलावा, एचटीएमएल स्ट्रिंग से यूआरएल लोड करें:

Kotlin

// Create an unencoded HTML string, then convert the unencoded HTML string into
// bytes. Encode it with base64 and load the data.
val unencodedHtml =
     "<html><body>'%23' is the percent code for ‘#‘ </body></html>";
val encodedHtml = Base64.encodeToString(unencodedHtml.toByteArray(), Base64.NO_PADDING)
myWebView.loadData(encodedHtml, "text/html", "base64")

Java

// Create an unencoded HTML string, then convert the unencoded HTML string into
// bytes. Encode it with base64 and load the data.
String unencodedHtml =
     "<html><body>'%23' is the percent code for ‘#‘ </body></html>";
String encodedHtml = Base64.encodeToString(unencodedHtml.getBytes(),
        Base64.NO_PADDING);
myWebView.loadData(encodedHtml, "text/html", "base64");

आपके ऐप्लिकेशन के पास इंटरनेट का ऐक्सेस होना चाहिए. इंटरनेट का ऐक्सेस पाने के लिए, अपनी मेनिफ़ेस्ट फ़ाइल में INTERNET की अनुमति का अनुरोध करें. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

<manifest ... >
    <uses-permission android:name="android.permission.INTERNET" />
    ...
</manifest>

WebView को अपनी पसंद के मुताबिक बनाने के लिए, इनमें से कोई भी काम किया जा सकता है:

  • WebChromeClient का इस्तेमाल करके, फ़ुलस्क्रीन मोड की सुविधा चालू करना. जब WebView को होस्ट ऐप्लिकेशन के यूज़र इंटरफ़ेस में बदलाव करने की अनुमति चाहिए होती है, तब भी इस क्लास को कॉल किया जाता है. जैसे, विंडो बनाना या बंद करना या उपयोगकर्ता को JavaScript के डायलॉग भेजना. इस संदर्भ में डीबग करने के बारे में ज़्यादा जानने के लिए, वेब ऐप्लिकेशन डीबग करना लेख पढ़ें.
  • कॉन्टेंट रेंडरिंग पर असर डालने वाले इवेंट को हैंडल करना. जैसे, फ़ॉर्म सबमिट करने में गड़बड़ियां या WebViewClient का इस्तेमाल करके नेविगेशन. यूआरएल लोड करने में रुकावट डालने के लिए, इस सबक्लास का भी इस्तेमाल किया जा सकता है.
  • WebSettings में बदलाव करके, JavaScript चालू करना.
  • JavaScript का इस्तेमाल करके, Android फ़्रेमवर्क के उन ऑब्जेक्ट को ऐक्सेस करना जिन्हें WebView में इंजेक्ट किया गया है.

WebView में JavaScript का इस्तेमाल करना

अगर आपके WebView में लोड किया जाने वाला वेब पेज JavaScript का इस्तेमाल करता है, तो आपको अपने WebView के लिए JavaScript चालू करना होगा. JavaScript चालू करने के बाद, अपने ऐप्लिकेशन कोड और JavaScript कोड के बीच इंटरफ़ेस बनाए जा सकते हैं.

JavaScript चालू करना

WebView में JavaScript, डिफ़ॉल्ट रूप से बंद होता है. इसे अपने WebView से जुड़े WebSettings के ज़रिए चालू किया जा सकता है. getSettings() की मदद से WebSettings को वापस पाएं. इसके बाद, setJavaScriptEnabled() की मदद से JavaScript चालू करें.

यह उदाहरण देखें:

Kotlin

val myWebView: WebView = findViewById(R.id.webview)
myWebView.settings.javaScriptEnabled = true

Java

WebView myWebView = (WebView) findViewById(R.id.webview);
WebSettings webSettings = myWebView.getSettings();
webSettings.setJavaScriptEnabled(true);

WebSettings की मदद से, अन्य सेटिंग को भी ऐक्सेस किया जा सकता है. ये सेटिंग आपके काम आ सकती हैं. उदाहरण के लिए, अगर ऐसा वेब ऐप्लिकेशन बनाया जा रहा है जिसे खास तौर पर आपके Android ऐप्लिकेशन में मौजूद WebView के लिए डिज़ाइन किया गया है, तो setUserAgentString() की मदद से, उपयोगकर्ता एजेंट की कस्टम स्ट्रिंग तय की जा सकती है. इसके बाद, अपने वेब पेज में उपयोगकर्ता एजेंट की कस्टम स्ट्रिंग के बारे में क्वेरी करके, यह पुष्टि की जा सकती है कि आपके वेब पेज का अनुरोध करने वाला क्लाइंट, आपका Android ऐप्लिकेशन है.

JavaScript कोड को Android कोड से बाइंड करना

अगर ऐसा वेब ऐप्लिकेशन बनाया जा रहा है जिसे खास तौर पर आपके Android ऐप्लिकेशन में मौजूद WebView के लिए डिज़ाइन किया गया है, तो JavaScript कोड और क्लाइंट-साइड Android कोड के बीच इंटरफ़ेस बनाए जा सकते हैं. उदाहरण के लिए, JavaScript के alert() फ़ंक्शन का इस्तेमाल करने के बजाय, आपका JavaScript कोड, Dialog दिखाने के लिए आपके Android कोड में किसी तरीके को कॉल कर सकता है.

अपने JavaScript और Android कोड के बीच नया इंटरफ़ेस बाइंड करने के लिए, addJavascriptInterface() को कॉल करें. इसे अपने JavaScript से बाइंड करने के लिए, क्लास इंस्टेंस और इंटरफ़ेस का नाम पास करें. JavaScript, क्लास को ऐक्सेस करने के लिए इस नाम को कॉल कर सकता है.

JavaScript और नेटिव कोड के बीच कम्यूनिकेट करने के बारे में ज़्यादा जानने के लिए, ज़्यादा आधुनिक और सुरक्षित एपीआई के बारे में भी बताया गया है. JSBridge की मदद से नेटिव एपीआई ऐक्सेस करना लेख पढ़ें.

उदाहरण के लिए, अपने Android ऐप्लिकेशन में यह क्लास शामिल की जा सकती है:

Kotlin

/** Instantiate the interface and set the context.  */
class WebAppInterface(private val mContext: Context) {

    /** Show a toast from the web page.  */
    @JavascriptInterface
    fun showToast(toast: String) {
        Toast.makeText(mContext, toast, Toast.LENGTH_SHORT).show()
    }
}

Java

public class WebAppInterface {
    Context mContext;

    /** Instantiate the interface and set the context. */
    WebAppInterface(Context c) {
        mContext = c;
    }

    /** Show a toast from the web page. */
    @JavascriptInterface
    public void showToast(String toast) {
        Toast.makeText(mContext, toast, Toast.LENGTH_SHORT).show();
    }
}

इस उदाहरण में, WebAppInterface क्लास, showToast() तरीके का इस्तेमाल करके, वेब पेज को Toast मैसेज बनाने की अनुमति देती है.

addJavascriptInterface() की मदद से, इस क्लास को अपने WebView में चलने वाले JavaScript से बाइंड किया जा सकता है. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

Kotlin

val webView: WebView = findViewById(R.id.webview)
webView.addJavascriptInterface(WebAppInterface(this), "Android")

Java

WebView webView = (WebView) findViewById(R.id.webview);
webView.addJavascriptInterface(new WebAppInterface(this), "Android");

इससे WebView में चलने वाले JavaScript के लिए, Android नाम का इंटरफ़ेस बनता है. इस समय, आपके वेब ऐप्लिकेशन के पास WebAppInterface क्लास का ऐक्सेस होता है. उदाहरण के लिए, यहां कुछ एचटीएमएल और JavaScript दिया गया है. इससे, उपयोगकर्ता के किसी बटन पर टैप करने पर, नए इंटरफ़ेस का इस्तेमाल करके, टोस्ट मैसेज बनता है:

<input type="button" value="Say hello" onClick="showAndroidToast('Hello Android!')" />

<script type="text/javascript">
    function showAndroidToast(toast) {
        Android.showToast(toast);
    }
</script>

JavaScript से Android इंटरफ़ेस को शुरू करने की ज़रूरत नहीं होती. WebView इसे आपके वेब पेज के लिए अपने-आप उपलब्ध कराता है. इसलिए, जब कोई उपयोगकर्ता बटन पर टैप करता है, तो showAndroidToast() फ़ंक्शन, WebAppInterface.showToast() तरीके को कॉल करने के लिए, Android इंटरफ़ेस का इस्तेमाल करता है.

पेज नेविगेशन को हैंडल करना

जब उपयोगकर्ता आपके WebView में किसी वेब पेज के लिंक पर टैप करता है, तो डिफ़ॉल्ट रूप से, Android ऐसा ऐप्लिकेशन लॉन्च करता है जो यूआरएल को हैंडल करता है. आम तौर पर, डिफ़ॉल्ट वेब ब्राउज़र खुलता है और डेस्टिनेशन यूआरएल लोड करता है. हालांकि, अपने WebView के लिए इस व्यवहार को बदला जा सकता है, ताकि लिंक आपके WebView में खुलें. इसके बाद, उपयोगकर्ता को अपने WebView से मैनेज किए जाने वाले वेब पेज के इतिहास में, पीछे और आगे की ओर नेविगेट करने की अनुमति दी जा सकती है.

उपयोगकर्ता के टैप किए गए लिंक खोलने के लिए, अपने WebView के लिए WebViewClient उपलब्ध कराएं. setWebViewClient()का इस्तेमाल करके. उपयोगकर्ता के टैप किए गए सभी लिंक, आपके WebView में लोड होते हैं. अगर आपको यह तय करने के लिए ज़्यादा कंट्रोल चाहिए कि क्लिक किया गया लिंक कहां लोड होता है, तो अपना WebViewClient बनाएं. यह shouldOverrideUrlLoading() तरीके को ओवरराइड करता है. यहां दिए गए उदाहरण में, यह माना गया है कि MyWebViewClient, Activity की इनर क्लास है.

Kotlin

private class MyWebViewClient : WebViewClient() {

    override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
        if (Uri.parse(url).host == "www.example.com") {
            // This is your website, so don't override. Let your WebView load
            // the page.
            return false
        }
        // Otherwise, the link isn't for a page on your site, so launch another
        // Activity that handles URLs.
        Intent(Intent.ACTION_VIEW, Uri.parse(url)).apply {
            startActivity(this)
        }
        return true
    }
}

Java

private class MyWebViewClient extends WebViewClient {
    @Override
    public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
        if ("www.example.com".equals(request.getUrl().getHost())) {
      // This is your website, so don't override. Let your WebView load the
      // page.
      return false;
    }
    // Otherwise, the link isn't for a page on your site, so launch another
    // Activity that handles URLs.
    Intent intent = new Intent(Intent.ACTION_VIEW, request.getUrl());
    startActivity(intent);
    return true;
  }
}

इसके बाद, WebView के लिए, इस नए WebViewClient का इंस्टेंस बनाएं:

Kotlin

val myWebView: WebView = findViewById(R.id.webview)
myWebView.webViewClient = MyWebViewClient()

Java

WebView myWebView = (WebView) findViewById(R.id.webview);
myWebView.setWebViewClient(new MyWebViewClient());

अब जब उपयोगकर्ता किसी लिंक पर टैप करता है, तो सिस्टम shouldOverrideUrlLoading() तरीके को कॉल करता है. यह तरीका, यह जांचता है कि यूआरएल का होस्ट, पहले दिए गए उदाहरण में तय किए गए किसी खास डोमेन से मेल खाता है या नहीं. अगर यह मेल खाता है, तो यह तरीका 'गलत' वैल्यू दिखाता है और यूआरएल लोड करने की प्रोसेस को ओवरराइड नहीं करता. इससे WebView, यूआरएल को सामान्य तरीके से लोड कर पाता है. अगर यूआरएल का होस्ट मेल नहीं खाता है, तो यूआरएल को हैंडल करने के लिए, डिफ़ॉल्ट Activity लॉन्च करने के लिए Intent बनाया जाता है. यह उपयोगकर्ता के डिफ़ॉल्ट वेब ब्राउज़र पर रिज़ॉल्व होता है.

कस्टम यूआरएल हैंडल करना

संसाधनों का अनुरोध करते समय और कस्टम यूआरएल स्कीम का इस्तेमाल करने वाले लिंक को रिज़ॉल्व करते समय, WebView पाबंदियां लागू करता है. उदाहरण के लिए, अगर shouldOverrideUrlLoading() या shouldInterceptRequest() जैसे कॉलबैक लागू किए जाते हैं, तो WebView इन्हें सिर्फ़ मान्य यूआरएल के लिए लागू करता है.

उदाहरण के लिए, WebView ऐसे लिंक के लिए, shouldOverrideUrlLoading() तरीके को कॉल नहीं कर सकता:

<a href="showProfile">Show Profile</a>

अमान्य यूआरएल को WebView में अलग-अलग तरीके से हैंडल किया जाता है. जैसे, पहले दिए गए उदाहरण में दिखाया गया है. इसलिए, हमारा सुझाव है कि इसके बजाय, सही फ़ॉर्मैट वाले यूआरएल का इस्तेमाल करें. आपके संगठन के कंट्रोल वाले डोमेन के लिए, कस्टम स्कीम या एचटीटीपीएस यूआरएल का इस्तेमाल किया जा सकता है.

पिछले उदाहरण की तरह, लिंक में सामान्य स्ट्रिंग का इस्तेमाल करने के बजाय, कस्टम स्कीम का इस्तेमाल किया जा सकता है. जैसे:

<a href="example-app:showProfile">Show Profile</a>

इसके बाद, shouldOverrideUrlLoading() तरीके में इस यूआरएल को इस तरह हैंडल किया जा सकता है:

Kotlin

// The URL scheme must be non-hierarchical, meaning no trailing slashes.
const val APP_SCHEME = "example-app:"

override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
    return if (url?.startsWith(APP_SCHEME) == true) {
        urlData = URLDecoder.decode(url.substring(APP_SCHEME.length), "UTF-8")
        respondToData(urlData)
        true
    } else {
        false
    }
}

Java

// The URL scheme must be non-hierarchical, meaning no trailing slashes.
private static final String APP_SCHEME = "example-app:";

@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
    if (url.startsWith(APP_SCHEME)) {
        urlData = URLDecoder.decode(url.substring(APP_SCHEME.length()), "UTF-8");
        respondToData(urlData);
        return true;
    }
    return false;
}

shouldOverrideUrlLoading() एपीआई का मुख्य मकसद, खास यूआरएल के लिए इंटेंट लॉन्च करना है. इसे लागू करते समय, पक्का करें कि WebView से हैंडल किए जाने वाले यूआरएल के लिए, false वैल्यू दिखाई जाए. हालांकि, सिर्फ़ इंटेंट लॉन्च करने की पाबंदी नहीं है. पहले दिए गए कोड के उदाहरणों में, इंटेंट लॉन्च करने की जगह, पसंद के मुताबिक कोई भी व्यवहार लागू किया जा सकता है.

जब आपका WebView, यूआरएल लोड करने की प्रोसेस को ओवरराइड करता है, तो यह अपने-आप देखे गए वेब पेजों का इतिहास इकट्ठा करता है. आप इतिहास में पीछे और आगे की ओर नेविगेट कर सकते हैं, goBack() और goForward() की मदद से.

उदाहरण के लिए, यहां दिखाया गया है कि आपकी Activity, पीछे की ओर नेविगेट करने के लिए, डिवाइस के 'बैक' बटन का इस्तेमाल कैसे कर सकती है:

Kotlin

override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
    // Check whether the key event is the Back button and if there's history.
    if (keyCode == KeyEvent.KEYCODE_BACK && myWebView.canGoBack()) {
        myWebView.goBack()
        return true
    }
    // If it isn't the Back button or there isn't web page history, bubble up to
    // the default system behavior. Probably exit the activity.
    return super.onKeyDown(keyCode, event)
}

Java

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    // Check whether the key event is the Back button and if there's history.
    if ((keyCode == KeyEvent.KEYCODE_BACK) && myWebView.canGoBack()) {
        myWebView.goBack();
        return true;
    }
    // If it isn't the Back button or there's no web page history, bubble up to
    // the default system behavior. Probably exit the activity.
    return super.onKeyDown(keyCode, event);
}

अगर आपका ऐप्लिकेशन, AndroidX AppCompat 1.6.0 या इसके बाद वाले वर्शन का इस्तेमाल करता है, तो पहले दिए गए स्निपेट को और भी आसान बनाया जा सकता है:

Kotlin

onBackPressedDispatcher.addCallback {
    // Check whether there's history.
    if (myWebView.canGoBack()) {
        myWebView.goBack()
    }
}

Java

onBackPressedDispatcher.addCallback {
    // Check whether there's history.
    if (myWebView.canGoBack()) {
        myWebView.goBack();
    }
}

The canGoBack() तरीका, 'सही' वैल्यू तब दिखाता है, जब उपयोगकर्ता के लिए वेब पेज का इतिहास मौजूद हो. इसी तरह, आगे का इतिहास मौजूद है या नहीं, यह देखने के लिए canGoForward() का इस्तेमाल किया जा सकता है. अगर यह जांच नहीं की जाती है, तो उपयोगकर्ता के इतिहास के आखिर तक पहुंचने के बाद, goBack() और goForward() कुछ नहीं करते.

डिवाइस के कॉन्फ़िगरेशन में होने वाले बदलावों को हैंडल करना

रनटाइम के दौरान, डिवाइस के कॉन्फ़िगरेशन में बदलाव होने पर, ऐक्टिविटी की स्थिति में बदलाव होते हैं. जैसे, जब उपयोगकर्ता डिवाइस को घुमाते हैं या इनपुट मेथड एडिटर (आईएमई) को बंद करते हैं. इन बदलावों की वजह से, WebView ऑब्जेक्ट की ऐक्टिविटी खत्म हो जाती है और नई ऐक्टिविटी बनती है. इससे नया WebView ऑब्जेक्ट भी बनता है, जो खत्म हुए ऑब्जेक्ट का यूआरएल लोड करता है. अपनी ऐक्टिविटी के डिफ़ॉल्ट व्यवहार में बदलाव करने के लिए, मेनिफ़ेस्ट में यह बदला जा सकता है कि वह orientation में होने वाले बदलावों को कैसे हैंडल करती है. रनटाइम के दौरान, कॉन्फ़िगरेशन में होने वाले बदलावों को हैंडल करने के बारे में ज़्यादा जानने के लिए, कॉन्फ़िगरेशन में होने वाले बदलावों को हैंडल करना लेख पढ़ें.

विंडो मैनेज करना

डिफ़ॉल्ट रूप से, नई विंडो खोलने के अनुरोधों को अनदेखा किया जाता है. ऐसा तब भी होता है, जब इन्हें JavaScript या लिंक में मौजूद टारगेट एट्रिब्यूट से खोला जाता है. एक से ज़्यादा विंडो खोलने के लिए, अपना व्यवहार तय करने के लिए, WebChromeClient को अपनी पसंद के मुताबिक बनाया जा सकता है.

अपने ऐप्लिकेशन को ज़्यादा सुरक्षित रखने के लिए, पॉप-अप और नई विंडो को खुलने से रोकना बेहतर है. इस व्यवहार को लागू करने का सबसे सुरक्षित तरीका यह है कि "true" वैल्यू पास की जाए setSupportMultipleWindows(). हालांकि, onCreateWindow() तरीके को ओवरराइड न किया जाए. setSupportMultipleWindows() इसी पर निर्भर करता है. इस लॉजिक से, लिंक में target="_blank" का इस्तेमाल करने वाला कोई भी पेज लोड नहीं होता.