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

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

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

WebView तब भी मदद कर सकता है, जब आपका ऐप्लिकेशन उपयोगकर्ता को ऐसा डेटा उपलब्ध कराता है जिसे वापस पाने के लिए इंटरनेट कनेक्शन की ज़रूरत होती है. जैसे, ईमेल. ऐसे में, आपको अपने Android ऐप्लिकेशन में WebView बनाना ज़्यादा आसान लग सकता है. यह एक ऐसा वेब पेज दिखाता है जिसमें उपयोगकर्ता का पूरा डेटा होता है. इसके लिए, नेटवर्क का अनुरोध करने, डेटा को पार्स करने, और उसे Android लेआउट में रेंडर करने की ज़रूरत नहीं होती. इसके बजाय, 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> एलिमेंट को शामिल किया जा सकता है. इसके अलावा, onCreate में पूरी Activity विंडो को 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");

ध्यान दें: हमारा सुझाव है कि Jetpack Webkit में loadUrl के बजाय WebViewCompat.navigate का इस्तेमाल करें. इससे इतिहास की एंट्री को बेहतर तरीके से बदला जा सकता है, लाइफ़साइकल कॉलबैक को ट्रैक किया जा सकता है, और सेव की गई स्थिति के हेडर को बेहतर तरीके से मैनेज किया जा सकता है. ज़्यादा जानकारी के लिए, WebViewCompat.navigate की मदद से बेहतर पेज नेविगेशन देखें.

onCreate() में वेबव्यू जोड़ना

इसके बजाय, किसी गतिविधि के 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");

ध्यान दें: इस एचटीएमएल के इस्तेमाल पर कुछ पाबंदियां हैं. एन्कोडिंग के विकल्पों के बारे में ज़्यादा जानने के लिए, loadData और loadDataWithBaseURL देखें.

आपके ऐप्लिकेशन के पास इंटरनेट का ऐक्सेस होना चाहिए. इंटरनेट का ऐक्सेस पाने के लिए, अपनी मेनिफ़ेस्ट फ़ाइल में 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 कोड, JavaScript के alert() फ़ंक्शन का इस्तेमाल करने के बजाय, Dialog दिखाने के लिए आपके Android कोड में मौजूद किसी तरीके को कॉल कर सकता है.

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

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

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

चेतावनी: अगर आपने targetSdkVersion को 17 या उसके बाद के वर्शन पर सेट किया है, तो उस तरीके में @JavascriptInterface एनोटेशन जोड़ें जिसे आपको JavaScript के लिए उपलब्ध कराना है. यह तरीका सार्वजनिक होना चाहिए. अगर आपने यह एनोटेशन नहीं दिया है, तो आपके वेब पेज से इस तरीके को ऐक्सेस नहीं किया जा सकता.

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

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

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() फ़ंक्शन, Android इंटरफ़ेस का इस्तेमाल करके WebAppInterface.showToast() तरीके को कॉल करता है.

ध्यान दें: आपके JavaScript से जुड़ा ऑब्जेक्ट, किसी दूसरे थ्रेड में चलता है, न कि उस थ्रेड में जिसमें इसे बनाया गया है.

पेज नेविगेशन को मैनेज करना

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

ध्यान दें: सुरक्षा की वजहों से, सिस्टम का ब्राउज़र ऐप्लिकेशन, आपके ऐप्लिकेशन के साथ अपना डेटा शेयर नहीं करता.

उपयोगकर्ता ने जिस लिंक पर टैप किया है उसे खोलने के लिए, setWebViewClient का इस्तेमाल करके, अपने WebView के लिए WebViewClient उपलब्ध कराएं. उपयोगकर्ता जिन लिंक पर टैप करता है वे सभी आपके 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 तरीके को कॉल करता है. इससे यह जांच की जाती है कि यूआरएल होस्ट, किसी खास डोमेन से मेल खाता है या नहीं. इसके बारे में पिछले उदाहरण में बताया गया है. अगर यह मैच करता है, तो यह तरीका false दिखाता है और यूआरएल लोड होने की प्रोसेस को ओवरराइड नहीं करता. इससे 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 को रिटर्न किया जाए. हालांकि, आपके पास इंटेंट लॉन्च करने के अलावा और भी विकल्प हैं. पिछले कोड सैंपल में, लॉन्च करने वाले इंटेंट को किसी भी कस्टम व्यवहार से बदला जा सकता है.

चेतावनी: shouldOverrideUrlLoading से WebViewCompat.navigate, loadUrl, reload या मिलते-जुलते तरीकों को कॉल न करें. इससे ऐप्लिकेशन ठीक से काम नहीं करते. false को वापस करना ज़्यादा असरदार है, ताकि WebView को उसके डिफ़ॉल्ट तरीके से यूआरएल लोड करना जारी रखने की अनुमति दी जा सके.

वेब पेज का इतिहास देखना

जब आपका 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 इंस्टेंस, लेआउट से व्यू हटाए जाने के बाद भी मेमोरी बनाए रखते हैं. Activity मेमोरी लीक और आउट-ऑफ़-मेमोरी (ओओएम) क्रैश से बचने के लिए, आपको WebView को उसके पैरंट ViewGroup से साफ़ तौर पर हटाना होगा. साथ ही, व्यू की ज़रूरत न होने पर, destroy() को शुरू करना होगा.

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