फ़ोन पर ऐप्लिकेशन के ओरिएंटेशन पर पाबंदी लगाना, लेकिन बड़ी स्क्रीन वाले डिवाइसों पर नहीं

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

आपके पास दोनों विकल्प हैं. छोटी स्क्रीन पर ऐप्लिकेशन को पोर्ट्रेट ओरिएंटेशन में इस्तेमाल करने की सुविधा को सीमित किया जा सकता है. हालांकि, बड़ी स्क्रीन पर लैंडस्केप ओरिएंटेशन में इस्तेमाल करने की सुविधा चालू की जा सकती है.

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

नतीजे

डिवाइस को घुमाने पर भी, आपका ऐप्लिकेशन छोटी स्क्रीन पर पोर्ट्रेट ओरिएंटेशन में ही रहता है. बड़ी स्क्रीन पर, ऐप्लिकेशन लैंडस्केप और पोर्ट्रेट मोड में काम करता है.

वर्शन के साथ काम करने की सुविधा

यह तरीका, सभी एपीआई लेवल के साथ काम करता है.

डिपेंडेंसी

implementation("androidx.window:window:1.5.1")
implementation("androidx.window:window-core:1.5.1")

implementation "androidx.window:window:1.5.1"
implementation "androidx.window:window-core:1.5.1"

ऐप्लिकेशन का ओरिएंटेशन मैनेज करना

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

1. ऐप्लिकेशन मेनिफ़ेस्ट में ओरिएंटेशन सेटिंग तय करना

आपके पास ऐप्लिकेशन के मेनिफ़ेस्ट फ़ाइल के screenOrientation एलिमेंट को शामिल न करने का विकल्प होता है. ऐसा करने पर, ओरिएंटेशन डिफ़ॉल्ट रूप से unspecified पर सेट हो जाता है. इसके अलावा, स्क्रीन ओरिएंटेशन को fullUser पर सेट किया जा सकता है. अगर उपयोगकर्ता ने सेंसर के आधार पर स्क्रीन को घुमाने की सुविधा लॉक नहीं की है, तो आपका ऐप्लिकेशन डिवाइस के सभी ओरिएंटेशन के साथ काम करेगा.

<activity
    android:name=".MyActivity"
    android:screenOrientation="fullUser">

unspecified और fullUser के बीच का अंतर बहुत कम है, लेकिन ज़रूरी है. अगर आपने screenOrientation वैल्यू तय नहीं की है, तो सिस्टम ओरिएंटेशन चुनता है. साथ ही, सिस्टम जिस नीति का इस्तेमाल ओरिएंटेशन तय करने के लिए करता है वह डिवाइस के हिसाब से अलग-अलग हो सकती है. दूसरी ओर, fullUser तय करने पर, डिवाइस के लिए उपयोगकर्ता की तय की गई सेटिंग ज़्यादा सटीक तरीके से लागू होती है: अगर उपयोगकर्ता ने सेंसर के आधार पर स्क्रीन रोटेशन की सुविधा को लॉक किया है, तो ऐप्लिकेशन उपयोगकर्ता की प्राथमिकता के मुताबिक काम करेगा. अगर ऐसा नहीं है, तो सिस्टम स्क्रीन के ओरिएंटेशन के लिए उपलब्ध चार विकल्पों (पोर्ट्रेट, लैंडस्केप, रिवर्स पोर्ट्रेट या रिवर्स लैंडस्केप) में से किसी एक को चुनने की अनुमति देता है. screenOrientation देखें.

2. स्क्रीन का साइज़ तय करना

मेनिफ़ेस्ट को उपयोगकर्ता की अनुमति वाले सभी ओरिएंटेशन के साथ काम करने के लिए सेट किया जा सकता है. इससे, स्क्रीन के साइज़ के आधार पर ऐप्लिकेशन के ओरिएंटेशन को प्रोग्राम के हिसाब से तय किया जा सकता है.

मॉड्यूल की build.gradle या build.gradle.kts फ़ाइल में, Jetpack WindowManager लाइब्रेरी जोड़ें:

implementation("androidx.window:window:version")
implementation("androidx.window:window-core:version")

implementation 'androidx.window:window:version'
implementation 'androidx.window:window-core:version'

डिवाइस की स्क्रीन के साइज़ को WindowMetrics ऑब्जेक्ट के तौर पर पाने के लिए, Jetpack WindowManager WindowMetricsCalculator#computeMaximumWindowMetrics() तरीके का इस्तेमाल करें. विंडो मेट्रिक की तुलना, विंडो के साइज़ की क्लास से की जा सकती है. इससे यह तय किया जा सकता है कि ओरिएंटेशन को कब सीमित करना है.

विंडो साइज़ क्लास, छोटी और बड़ी स्क्रीन के बीच ब्रेकपॉइंट उपलब्ध कराती हैं.

स्क्रीन का साइज़ तय करने के लिए, WindowWidthSizeClass#COMPACT और WindowHeightSizeClass#COMPACT ब्रेकपॉइंट का इस्तेमाल करें:

/** Determines whether the device has a compact screen. **/
fun compactScreen() : Boolean {
    val metrics = WindowMetricsCalculator.getOrCreate().computeMaximumWindowMetrics(this)
    val width = metrics.bounds.width()
    val height = metrics.bounds.height()
    val density = resources.displayMetrics.density
    val windowSizeClass = WindowSizeClass.compute(width/density, height/density)
    return windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.COMPACT ||
           windowSizeClass.windowHeightSizeClass == WindowHeightSizeClass.COMPACT
}

/** Determines whether the device has a compact screen. **/
private boolean compactScreen() {
    WindowMetrics metrics = WindowMetricsCalculator.getOrCreate().computeMaximumWindowMetrics(this);
    int width = metrics.getBounds().width();
    int height = metrics.getBounds().height();
    float density = getResources().getDisplayMetrics().density;
    WindowSizeClass windowSizeClass = WindowSizeClass.compute(width/density, height/density);
    return windowSizeClass.getWindowWidthSizeClass() == WindowWidthSizeClass.COMPACT ||
           windowSizeClass.getWindowHeightSizeClass() == WindowHeightSizeClass.COMPACT;
}

ध्यान दें:
• उदाहरणों को किसी गतिविधि के तरीकों के तौर पर लागू किया जाता है. इसलिए, गतिविधि को this के आर्ग्युमेंट में computeMaximumWindowMetrics() के तौर पर डीरेफ़रंस किया जाता है.
• computeCurrentWindowMetrics() के बजाय computeMaximumWindowMetrics() तरीके का इस्तेमाल किया जाता है, क्योंकि ऐप्लिकेशन को मल्टी-विंडो मोड में लॉन्च किया जा सकता है. इससे स्क्रीन ओरिएंटेशन की सेटिंग को अनदेखा किया जाता है. जब तक ऐप्लिकेशन विंडो पूरे डिवाइस की स्क्रीन पर न हो, तब तक ऐप्लिकेशन विंडो के साइज़ का पता लगाने और ओरिएंटेशन सेटिंग को बदलने का कोई मतलब नहीं है.

अपने ऐप्लिकेशन में computeMaximumWindowMetrics() तरीके को उपलब्ध कराने के लिए, डिपेंडेंसी का एलान करने के निर्देश जानने के लिए, WindowManager देखें.

3. ऐप्लिकेशन मेनिफ़ेस्ट की सेटिंग बदलना

अगर आपको लगता है कि डिवाइस की स्क्रीन का साइज़ छोटा है, तो मेनिफ़ेस्ट की screenOrientation सेटिंग को बदलने के लिए, Activity#setRequestedOrientation() को कॉल करें:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    requestedOrientation = if (compactScreen())
        ActivityInfo.SCREEN_ORIENTATION_PORTRAIT else
        ActivityInfo.SCREEN_ORIENTATION_FULL_USER
    ...
    // Replace with a known container that you can safely add a
    // view to where the view won't affect the layout and the view
    // won't be replaced.
    val container: ViewGroup = binding.container

    // Add a utility view to the container to hook into
    // View.onConfigurationChanged. This is required for all
    // activities, even those that don't handle configuration
    // changes. You can't use Activity.onConfigurationChanged,
    // since there are situations where that won't be called when
    // the configuration changes. View.onConfigurationChanged is
    // called in those scenarios.
    container.addView(object : View(this) {
        override fun onConfigurationChanged(newConfig: Configuration?) {
            super.onConfigurationChanged(newConfig)
            requestedOrientation = if (compactScreen())
                ActivityInfo.SCREEN_ORIENTATION_PORTRAIT else
                ActivityInfo.SCREEN_ORIENTATION_FULL_USER
        }
    })
}

@Override
protected void onCreate(Bundle savedInstance) {
    super.onCreate(savedInstanceState);
    if (compactScreen()) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    } else {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_USER);
    }
    ...
    // Replace with a known container that you can safely add a
    // view to where the view won't affect the layout and the view
    // won't be replaced.
    ViewGroup container = binding.container;

    // Add a utility view to the container to hook into
    // View.onConfigurationChanged. This is required for all
    // activities, even those that don't handle configuration
    // changes. You can't use Activity.onConfigurationChanged,
    // since there are situations where that won't be called when
    // the configuration changes. View.onConfigurationChanged is
    // called in those scenarios.
    container.addView(new View(this) {
        @Override
        protected void onConfigurationChanged(Configuration newConfig) {
            super.onConfigurationChanged(newConfig);
            if (compactScreen()) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_USER);
            }
        }
    });
}

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

प्रमुख बिंदु

• screenOrientation: ऐप्लिकेशन मेनिफ़ेस्ट सेटिंग. इसकी मदद से यह तय किया जा सकता है कि डिवाइस को घुमाने पर आपका ऐप्लिकेशन कैसे काम करेगा
• Jetpack WindowManager: यह लाइब्रेरी का एक सेट है. इसकी मदद से, ऐप्लिकेशन विंडो का साइज़ और आसपेक्ट रेशियो तय किया जा सकता है. यह एपीआई लेवल 14 के साथ काम करता है
• Activity#setRequestedOrientation(): यह एक ऐसा तरीका है जिससे रनटाइम के दौरान ऐप्लिकेशन का ओरिएंटेशन बदला जा सकता है

ऐसे कलेक्शन जिनमें यह गाइड शामिल है

यह गाइड, चुनी गई क्विक गाइड के इन कलेक्शन का हिस्सा है. इनमें Android डेवलपमेंट के ज़्यादातर लक्ष्यों के बारे में बताया गया है:

बड़ी स्क्रीन के लिए ऑप्टिमाइज़ करना

अपने ऐप्लिकेशन को टैबलेट, फ़ोल्ड किए जा सकने वाले डिवाइसों, और ChromeOS डिवाइसों पर ऑप्टिमाइज़ किए गए उपयोगकर्ता अनुभव के साथ काम करने की सुविधा दें.

क्विक गाइड का कलेक्शन

कोई सवाल पूछना या सुझाव/राय देना है

अक्सर पूछे जाने वाले सवालों वाले पेज पर जाएं और क्विक गाइड के बारे में जानें. इसके अलावा, हमसे संपर्क करें और हमें अपने सुझाव/राय दें या शिकायत करें.

अक्सर पूछे जाने वाले सवालों पर जाएं सुझाव/राय दें या शिकायत करें