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

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

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

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

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

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

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

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

Kotlin

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

Groovy

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

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

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

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

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

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

<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 की सुविधा चालू करना.
  • WebView में इंजेक्ट किए गए Android फ़्रेमवर्क ऑब्जेक्ट को ऐक्सेस करने के लिए, JavaScript का इस्तेमाल करना.

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);
}

अगर आपका ऐप्लिकेशन, Jetpack 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();
    }
}

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

ऐक्टिविटी को फिर से बनाने या बैकग्राउंड प्रोसेस को वापस पाने के दौरान, नेविगेशन इतिहास को सुरक्षित रखने के लिए, saveState का इस्तेमाल करके, WebView के नेविगेशन इतिहास को Bundle में क्रम से लगाएं. इसके बाद, इसे वापस पाने के लिए restoreState का इस्तेमाल करें. सेव किए गए स्टेट के साइज़ की सीमाओं को सुरक्षित तरीके से मैनेज करने और TransactionTooLargeException से बचने के बारे में जानने के लिए, WebView के स्टेट को बेहतर तरीके से मैनेज करना लेख पढ़ें.

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

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

अपनी ऐक्टिविटी के डिफ़ॉल्ट व्यवहार में बदलाव करने के लिए, मेनिफ़ेस्ट में orientation में होने वाले बदलावों को हैंडल करने का तरीका बदला जा सकता है. रनटाइम के दौरान, कॉन्फ़िगरेशन में होने वाले बदलावों को हैंडल करने के बारे में ज़्यादा जानने के लिए, कॉन्फ़िगरेशन में होने वाले बदलावों को हैंडल करना लेख पढ़ें.

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

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

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

मेमोरी और परफ़ॉर्मेंस मैनेज करना

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

वेब कॉन्टेंट का इस्तेमाल करते समय, अपने ऐप्लिकेशन की मेमोरी फ़ुटप्रिंट की समस्या को हल करने और उसे ऑप्टिमाइज़ करने के बारे में ज़्यादा जानने के लिए, WebView की मेमोरी मैनेज करना और उसकी समस्या हल करना लेख पढ़ें.