Android फोन पर अभिविन्यास जांचें

415

अगर एंड्रॉइड फोन लैंडस्केप या पोर्ट्रेट में है तो मैं कैसे जांच सकता हूं?

java  android  orientation 
— मोहित देशपांडे
स्रोत
1
एक समान सूत्र पर इस उत्तर पर एक नज़र डालें: stackoverflow.com/a/26601009/3072449
— मैजिक हैंड्स पेलेग्रिन

जवाबों:

676

वर्तमान कॉन्फ़िगरेशन, जैसा कि यह निर्धारित करने के लिए उपयोग किया जाता है कि संसाधनों को प्राप्त करने के लिए कौन से संसाधन उपलब्ध हैं Configuration:

getResources().getConfiguration().orientation;

आप इसके मूल्य को देखकर अभिविन्यास के लिए जाँच कर सकते हैं:

int orientation = getResources().getConfiguration().orientation;
if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // In landscape
} else {
    // In portrait
}

अधिक जानकारी Android डेवलपर में पाई जा सकती है ।

— hackbod
स्रोत
2
माफ करना, मुझे गलत समझा गया, मुझे लगा कि आप कह रहे हैं कि अगर कॉन्फ़िगरेशन में बदलाव होता है तो सेवा कॉन्फ़िगरेशन को नहीं बदलेगी। आप जो वर्णन कर रहे हैं वह यह है ... ठीक है, यह कुछ भी नहीं देख रहा है, क्योंकि कुछ भी नहीं बदल रहा है, क्योंकि लॉन्चर ने स्क्रीन ओरिएंटेशन को लॉक कर दिया है और इसे बदलने की अनुमति नहीं देता है। तो यह सही है कि .orientation नहीं बदलता है, क्योंकि ओरिएंटेशन नहीं बदला है। स्क्रीन अभी भी पोर्ट्रेट है।
— हैकबॉड
निकटतम चीज जो मैं कर सकता हूं वह है सेंसर से ओरिएंटेशन को पढ़ना जिसमें गणित शामिल है कि मैं इस समय वास्तव में बहुत उत्सुक नहीं हूं।
— आर्किमिडीज ट्रेजानो
13
इसमें नाराज होने की कोई बात नहीं है। स्क्रीन घुमाया नहीं गया है, यह अभी भी पोर्ट्रेट में है, देखने के लिए कोई रोटेशन नहीं है। यदि आप मॉनिटर करना चाहते हैं कि स्क्रीन को घुमाए जाने के बावजूद उपयोगकर्ता अपने फोन को कैसे चला रहा है, तो हाँ आपको सीधे सेंसर को देखने की आवश्यकता है, और यह निर्णय लें कि आप किस तरह से डिवाइस को घुमा रहे हैं, इसके बारे में जानकारी प्राप्त करना चाहते हैं।
— हैकबॉड
4
यदि स्क्रीन ओरिएंटेशन ठीक किया गया है तो यह विफल हो जाएगा।
— AndroidDev
7
यदि गतिविधि प्रदर्शन को बंद कर देती है ( android:screenOrientation="portrait"), तो यह विधि उसी मान को लौटाएगी, भले ही उपयोगकर्ता डिवाइस को घुमाए या न करे। उस स्थिति में आप अभिविन्यास को ठीक से समझने के लिए एक्सेलेरोमीटर या ग्रेविटी सेंसर का उपयोग करेंगे।
— बिल्ली
169

यदि आप getResources () का उपयोग करते हैं। getConfiguration ()। कुछ डिवाइस पर ओरिएंटेशन आपको गलत मिलेगा। हमने उस दृष्टिकोण का प्रयोग शुरू में http://apphance.com में किया था । Apphance के रिमोट लॉगिंग के लिए धन्यवाद, हम इसे विभिन्न उपकरणों पर देख सकते हैं और हमने देखा कि विखंडन यहां अपनी भूमिका निभाता है। मैंने अजीब मामलों को देखा: उदाहरण के लिए एचटीसी डिजायर एचडी पर पोर्ट्रेट और स्क्वायर (?):

CONDITION[17:37:10.345] screen: rotation: 270 orientation: square
CONDITION[17:37:12.774] screen: rotation: 0 orientation: portrait
CONDITION[17:37:15.898] screen: rotation: 90
CONDITION[17:37:21.451] screen: rotation: 0
CONDITION[17:38:42.120] screen: rotation: 270 orientation: square

या अभिविन्यास को बिल्कुल नहीं बदलना:

CONDITION[11:34:41.134] screen: rotation: 0
CONDITION[11:35:04.533] screen: rotation: 90
CONDITION[11:35:06.312] screen: rotation: 0
CONDITION[11:35:07.938] screen: rotation: 90
CONDITION[11:35:09.336] screen: rotation: 0

दूसरी ओर, चौड़ाई () और ऊंचाई () हमेशा सही होती है (यह विंडो प्रबंधक द्वारा उपयोग किया जाता है, इसलिए यह बेहतर होना चाहिए)। मैं कहूंगा कि सबसे अच्छा विचार यह है कि चौड़ाई / ऊंचाई की जाँच हमेशा की जाए। यदि आप एक पल के बारे में सोचते हैं, तो यह वही है जो आप चाहते हैं - यह जानने के लिए कि चौड़ाई ऊंचाई (चित्र) से छोटी है, विपरीत (परिदृश्य) या यदि वे समान (वर्ग) हैं।

तो यह इस सरल कोड के लिए नीचे आता है:

public int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    int orientation = Configuration.ORIENTATION_UNDEFINED;
    if(getOrient.getWidth()==getOrient.getHeight()){
        orientation = Configuration.ORIENTATION_SQUARE;
    } else{ 
        if(getOrient.getWidth() < getOrient.getHeight()){
            orientation = Configuration.ORIENTATION_PORTRAIT;
        }else { 
             orientation = Configuration.ORIENTATION_LANDSCAPE;
        }
    }
    return orientation;
}
— जारेक पोटियुक
स्रोत
3
धन्यवाद! "ओरिएंटेशन" को प्रारंभ करना हालांकि बहुत ही कम है।
— 14 मई को MrMaffen
getWidthऔर getHeightपदावनत नहीं होते हैं।
— FindOut_Quran
3
@ user3441905, हाँ वे हैं। getSize(Point outSize)इसके बजाय उपयोग करें । मैं एपीआई 23 का उपयोग कर रहा हूं।
— विंडराइडर
@ jarek-potiuk यह पदावनत है।
— हेड्स
53

इस समस्या को हल करने का एक अन्य तरीका यह है कि प्रदर्शन से सही रिटर्न वैल्यू पर भरोसा नहीं किया जाता है, बल्कि एंड्रॉइड संसाधनों के समाधान पर भरोसा किया जाता है।

layouts.xmlफ़ोल्डर में res/values-landऔर res/values-portनिम्न सामग्री के साथ फ़ाइल बनाएँ :

res / values-भूमि / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">true</bool>
</resources>

res / values ​​बंदरगाह / layouts.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="is_landscape">false</bool>
</resources>

अपने स्रोत कोड में अब आप वर्तमान अभिविन्यास तक पहुँच सकते हैं:

context.getResources().getBoolean(R.bool.is_landscape)
— पॉल
स्रोत
1
मुझे यह पसंद है क्योंकि यह उस तरीके का उपयोग करता है जो सिस्टम पहले से ही अभिविन्यास का निर्धारण कर रहा है
— क्रस्टीगस्ट्रिंगिंग सिप
1
परिदृश्य / चित्र जांच के लिए सर्वश्रेष्ठ उत्तर!
— 19-28 बजे vtlinh
डिफ़ॉल्ट मान फ़ाइल में इसका मान क्या होगा?
— शशांक मिश्र
46

फोन के वर्तमान अभिविन्यास को निर्दिष्ट करने का एक पूर्ण तरीका:

    public String getRotation(Context context){
    final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();
           switch (rotation) {
            case Surface.ROTATION_0:
                return "portrait";
            case Surface.ROTATION_90:
                return "landscape";
            case Surface.ROTATION_180:
                return "reverse portrait";
            default:
                return "reverse landscape";
            }
        }

चीयर बिनह गुयेन

— गुयेन मिन्ह बिनह
स्रोत
6
आपकी पोस्ट में एक टाइपो है - इसे कहना चाहिए .getRotation () getOrientation नहीं
— कीथ
1
इसके लिए +1। मुझे सटीक अभिविन्यास जानने की जरूरत है, न कि केवल परिदृश्य बनाम चित्र। getOrientation () सही है जब तक कि आप SDK 8+ पर नहीं हैं, जिस स्थिति में आपको getRotation () का उपयोग करना चाहिए। एसडीके 9+ में 'रिवर्स' मोड का समर्थन किया गया है।
— पॉल
6
@Keith @Paul मुझे याद नहीं है कि कैसे getOrientation()काम करता है, लेकिन इसका उपयोग करते समय यह सही नहीं है getRotation()। रोटेशन "Returns the rotation of the screen from its "natural" orientation." स्रोत प्राप्त करें । इसलिए ROTATION_0 कहे जाने वाले फ़ोन पर पोर्ट्रेट की संभावना सही है, लेकिन एक टैबलेट पर इसके "प्राकृतिक" ओरिएंटेशन की संभावना परिदृश्य है और ROTATION_0 को पोर्ट्रेट के बजाय लैंडस्केप लौटना चाहिए।
— jp36
ऐसा लगता है कि पसंदीदा तरीका आगे बढ़ें: developer.android.com/reference/android/view/…
— jaysqrd
यह गलत उत्तर है। यह मतदान क्यों हुआ? getOrientation (फ्लोट [] आर, फ्लोट [] मान) रोटेशन मैट्रिक्स के आधार पर डिवाइस के अभिविन्यास की गणना करता है।
— user1914692
29

यहाँ कोड स्निपेट डेमो है जिसे स्क्रीन ओरिएंटेशन प्राप्त करने के लिए हैकबॉड और मार्टिज़न द्वारा सिफारिश की गई थी :

अभिविन्यास बदलने पर ट्रिगर:

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
        int nCurrentOrientation = _getScreenOrientation();
    _doSomeThingWhenChangeOrientation(nCurrentOrientation);
}

Od हैकबोड अनुशंसा के रूप में वर्तमान अभिविन्यास प्राप्त करें :

private int _getScreenOrientation(){    
    return getResources().getConfiguration().orientation;
}

Screen वर्तमान स्क्रीन अभिविन्यास के लिए वैकल्पिक समाधान हैं n मार्टिज़न समाधान का पालन करें :

private int _getScreenOrientation(){
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        return display.getOrientation();
}

★ नोट : मैं दोनों ❷ & ❷ को लागू करने की कोशिश कर रहा था, लेकिन RealDevice (NexusOne SDK 2.3) अभिविन्यास पर यह गलत अभिविन्यास देता है।

★ इसलिए मैं स्क्रीन अभिविन्यास प्राप्त करने के लिए उपयोग किए गए समाधान orientation की सलाह देता हूं जिनके पास अधिक लाभ है: स्पष्ट रूप से, सरल और एक आकर्षण की तरह काम करना।

★ हमारी उम्मीद के अनुसार सही सुनिश्चित करने के लिए अभिविन्यास की सावधानीपूर्वक वापसी की जाँच करें (हो सकता है कि सीमित भौतिक उपकरणों विनिर्देश पर निर्भर हो)

आशा है कि यह मदद करेगा,

— NguyenDat
स्रोत
16 
int ot = getResources().getConfiguration().orientation;
switch(ot)
        {

        case  Configuration.ORIENTATION_LANDSCAPE:

            Log.d("my orient" ,"ORIENTATION_LANDSCAPE");
        break;
        case Configuration.ORIENTATION_PORTRAIT:
            Log.d("my orient" ,"ORIENTATION_PORTRAIT");
            break;

        case Configuration.ORIENTATION_SQUARE:
            Log.d("my orient" ,"ORIENTATION_SQUARE");
            break;
        case Configuration.ORIENTATION_UNDEFINED:
            Log.d("my orient" ,"ORIENTATION_UNDEFINED");
            break;
            default:
            Log.d("my orient", "default val");
            break;
        }
— अंशुल
स्रोत
13

getResources().getConfiguration().orientationइसका सही उपयोग करें ।

आपको बस विभिन्न प्रकार के परिदृश्यों के लिए बाहर देखना होगा, परिदृश्य जो डिवाइस आमतौर पर उपयोग करता है और अन्य।

फिर भी समझ में नहीं आता है कि इसे कैसे प्रबंधित किया जाए।

— neteinstein
स्रोत
12

इनमें से अधिकांश उत्तर पोस्ट किए जाने के बाद कुछ समय बीत चुका है और कुछ अब पदावनत विधियों और स्थिरांक का उपयोग करते हैं।

मैंने इन तरीकों और स्थिरांक का उपयोग नहीं करने के लिए जेरेक के कोड को अपडेट किया है :

protected int getScreenOrientation()
{
    Display getOrient = getWindowManager().getDefaultDisplay();
    Point size = new Point();

    getOrient.getSize(size);

    int orientation;
    if (size.x < size.y)
    {
        orientation = Configuration.ORIENTATION_PORTRAIT;
    }
    else
    {
        orientation = Configuration.ORIENTATION_LANDSCAPE;
    }
    return orientation;
}

ध्यान दें कि मोड Configuration.ORIENTATION_SQUAREअब समर्थित नहीं है।

मैंने पाया कि यह उन सभी उपकरणों पर विश्वसनीय है, जिनके उपयोग के बारे में सुझाव देने के तरीके के विपरीत मैंने इसका परीक्षण किया है getResources().getConfiguration().orientation

— बाज
स्रोत
ध्यान दें कि getOrient.getSize (आकार) को 13 एपीआई स्तर की आवश्यकता होती है
— लेस्टर
6

रनटाइम में स्क्रीन ओरिएंटेशन की जाँच करें।

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);

    // Checks the orientation of the screen
    if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
        Toast.makeText(this, "landscape", Toast.LENGTH_SHORT).show();

    } else if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT){
        Toast.makeText(this, "portrait", Toast.LENGTH_SHORT).show();        
    }
}
— कुमार
स्रोत
5

इसे करने का एक और तरीका है:

public int getOrientation()
{
    if(getResources().getDisplayMetrics().widthPixels>getResources().getDisplayMetrics().heightPixels)
    { 
        Toast t = Toast.makeText(this,"LANDSCAPE",Toast.LENGTH_SHORT);
        t.show();
        return 1;
    }
    else
    {
        Toast t = Toast.makeText(this,"PORTRAIT",Toast.LENGTH_SHORT);
        t.show();
        return 2;
    }       
}
— मैक्सिमस
स्रोत
4

एपीआई 28 पर 2019 में परीक्षण किया गया, भले ही उपयोगकर्ता ने पोर्ट्रेट ओरिएंटेशन सेट किया हो या नहीं, और दूसरे, आउटडेटेड उत्तर की तुलना में न्यूनतम कोड के साथ , निम्नलिखित सही ओरिएंटेशन देता है:

/** @return The {@link Configuration#ORIENTATION_SQUARE}, {@link Configuration#ORIENTATION_PORTRAIT}, {@link Configuration#ORIENTATION_LANDSCAPE} constants based on the current phone screen pixel relations. */
private int getScreenOrientation()
{
    DisplayMetrics dm = context.getResources().getDisplayMetrics(); // Screen rotation effected

    if(dm.widthPixels == dm.heightPixels)
        return Configuration.ORIENTATION_SQUARE;
    else
        return dm.widthPixels < dm.heightPixels ? Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
}
— ManuelTS
स्रोत
2

मुझे लगता है कि उन्मुखीकरण परिवर्तन के प्रभावी होने के बाद यह कोड काम कर सकता है

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

यदि आप setContentView को कॉल करने से पहले नए अभिविन्यास के बारे में सूचित करना चाहते हैं, तो ओवरराइड activity.onConfigurationChanged (कॉन्फ़िगरेशन newConfig) फ़ंक्शन और newConfig का उपयोग करें।

— डैनियल
स्रोत
2

मुझे लगता है कि getRotationv का उपयोग करना () मदद नहीं करता है क्योंकि http://developer.android.com/reference/android/view/Display.html#getRotation%28%29 getRotation () स्क्रीन के रोटेशन को उसके "प्राकृतिक" से लौटाता है उन्मुखीकरण।

इसलिए जब तक आप "प्राकृतिक" अभिविन्यास को नहीं जानते, रोटेशन अर्थहीन है।

मुझे एक आसान तरीका मिला, 

  Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  Point size = new Point();
  display.getSize(size);
  int width = size.x;
  int height = size.y;
  if(width>height)
    // its landscape

कृपया मुझे बताएं कि क्या इसमें किसी के साथ कोई समस्या है?

— steveh
स्रोत
2

यह वनप्लस 3 जैसे सभी फोन को ओवरले करता है

public static boolean isScreenOriatationPortrait(Context context) {
         return context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
         }

सही कोड निम्नानुसार है:

public static int getRotation(Context context){
        final int rotation = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();

        if(rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180){
            return Configuration.ORIENTATION_PORTRAIT;
        }

        if(rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270){
            return Configuration.ORIENTATION_LANDSCAPE;
        }

        return -1;
    }
— yueyue_projects
स्रोत
1

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

   private void initActivityScreenOrientPortrait()
    {
        // Avoid screen rotations (use the manifests android:screenOrientation setting)
        // Set this to nosensor or potrait

        // Set window fullscreen
        this.activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

        DisplayMetrics metrics = new DisplayMetrics();
        this.activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

         // Test if it is VISUAL in portrait mode by simply checking it's size
        boolean bIsVisualPortrait = ( metrics.heightPixels >= metrics.widthPixels ); 

        if( !bIsVisualPortrait )
        { 
            // Swap the orientation to match the VISUAL portrait mode
            if( this.activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT )
             { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); }
            else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT ); }
        }
        else { this.activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR); }

    }

एक जादू की तरह काम करता है!

— Codebeat
स्रोत
1

इस तरह से उपयोग करें, 

    int orientation = getResources().getConfiguration().orientation;
    String Orintaion = "";
    switch (orientation)
    {
        case Configuration.ORIENTATION_UNDEFINED: Orintaion = "Undefined"; break;
        case Configuration.ORIENTATION_LANDSCAPE: Orintaion = "Landscrape"; break;
        case Configuration.ORIENTATION_PORTRAIT:  Orintaion = "Portrait"; break;
        default: Orintaion = "Square";break;
    }

स्ट्रिंग में आप ओरिएंटियन है

1

ऐसा करने के कई तरीके हैं, कोड का यह टुकड़ा मेरे लिए काम करता है 

 if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }
— महरोज मुनीर
स्रोत
1

मुझे लगता है कि यह समाधान आसान है

if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
  user_todat_latout = true;
} else {
  user_todat_latout = false;
}
— इस्साक नबील
स्रोत
आम तौर पर, उत्तर बहुत अधिक सहायक होते हैं यदि वे एक स्पष्टीकरण शामिल करते हैं कि कोड क्या करने का इरादा है, और क्यों वह दूसरों को पेश किए बिना समस्या को हल करता है।
— टॉम अरंडा
इसके लिए हाँ खेद है कि मुझे लगता था कि इसे समान रूप से कोड चेक ओरिएंटेशन के इस ब्लॉक की व्याख्या करने की आवश्यकता नहीं है अगर बराबर कॉन्फ़िगरेशन। पोर्टफ़ॉर्मेशन का मतलब है कि पोर्ट्रेट में ऐप का मतलब :)
— Issac Nabil
1

बस सरल दो लाइन कोड

if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
    // do something in landscape
} else {
    //do in potrait
}
— रेजाउल करीम
स्रोत
0

सरल और आसान :)

  1. 2 xml लेआउट बनाएं (यानी पोर्ट्रेट और लैंडस्केप)

  2. जावा फ़ाइल में, लिखें:

    private int intOrientation;

    पर onCreateविधि और इससे पहले कि setContentViewलिखने:

    intOrientation = getResources().getConfiguration().orientation;
if (intOrientation == Configuration.ORIENTATION_PORTRAIT)
    setContentView(R.layout.activity_main);
else
    setContentView(R.layout.layout_land);   // I tested it and it works fine.
— केरलोस
स्रोत
0

यह भी ध्यान देने योग्य है कि आजकल, getResources().getConfiguration().orientationलेआउट के लिए ऐसा करने के कारण स्पष्ट अभिविन्यास की जांच करने के लिए कम अच्छा कारण नहीं है , क्योंकि एंड्रॉइड 7 / एपीआई 24+ में पेश किया गया मल्टी-विंडो सपोर्ट आपके लेआउट के साथ गड़बड़ कर सकता है उन्मुखीकरण। उपयोग करने पर विचार करने के लिए बेहतर है <ConstraintLayout>, और वैकल्पिक लेआउट उपलब्ध चौड़ाई या ऊंचाई पर निर्भर करते हैं , साथ ही साथ यह निर्धारित करने के लिए कि कौन सी लेआउट का उपयोग किया जा रहा है, उदाहरण के लिए, आपकी गतिविधि से जुड़ी कुछ फ्रेगमेंट की उपस्थिति या नहीं।

— हड़बड़िया
स्रोत
0

आप इसका उपयोग कर सकते हैं ( यहाँ पर आधारित ):

public static boolean isPortrait(Activity activity) {
    final int currentOrientation = getCurrentOrientation(activity);
    return currentOrientation == ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT || currentOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
}

public static int getCurrentOrientation(Activity activity) {
    //code based on https://www.captechconsulting.com/blog/eric-miles/programmatically-locking-android-screen-orientation
    final Display display = activity.getWindowManager().getDefaultDisplay();
    final int rotation = display.getRotation();
    final Point size = new Point();
    display.getSize(size);
    int result;
    if (rotation == Surface.ROTATION_0
            || rotation == Surface.ROTATION_180) {
        // if rotation is 0 or 180 and width is greater than height, we have
        // a tablet
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a phone
            if (rotation == Surface.ROTATION_0) {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            }
        }
    } else {
        // if rotation is 90 or 270 and width is greater than height, we
        // have a phone
        if (size.x > size.y) {
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
            }
        } else {
            // we have a tablet
            if (rotation == Surface.ROTATION_90) {
                result = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
            } else {
                result = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
            }
        }
    }
    return result;
}
— Android डेवलपर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.