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

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

दोनों तरह से कैसे सेट किया जा सकता है—छोटी स्क्रीन पर ऐप्लिकेशन को पोर्ट्रेट ओरिएंटेशन पर सेट करना, लेकिन बड़ी स्क्रीन पर लैंडस्केप ओरिएंटेशन चालू करना?

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

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

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

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 WindowManagerWindowMetricsCalculator#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;
}

ध्यान दें:
• उदाहरणों को किसी गतिविधि के तरीके के तौर पर लागू किया जाता है. इसलिए, computeMaximumWindowMetrics() के आर्ग्युमेंट में गतिविधि को this के तौर पर डीरेफ़रंस किया जाता है.
• 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 डिवाइसों पर ऑप्टिमाइज़ किया गया उपयोगकर्ता अनुभव देने के लिए चालू करें.

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

क्या आपका कोई सवाल है या सुझाव/राय देनी है

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

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