java - एंड्रॉइड फोन पर अभिविन्यास की जांच करें




android orientation (12)

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


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

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

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


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

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

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)

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

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

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

 if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) {
             // portrait mode
} else if (this.getWindow().getWindowManager().getDefaultDisplay()
                .getOrientation() == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
                      // landscape
        }

कोड स्निपेट डेमो और द्वारा स्क्रीन अभिविन्यास की सिफारिश कैसे की गई थी:

Ori ओरिएंटेशन बदलने पर ट्रिगर:

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

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

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

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

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

नोट : मैं ❷ और ​​❸ को लागू करने की कोशिश कर रहा था, लेकिन रीयलडिवाइस (नेक्ससऑन एसडीके 2.3) ओरिएंटेशन पर यह गलत अभिविन्यास देता है।

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

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

उम्मीद है कि यह मदद करता है,


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

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

    }

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


मुझे लगता है कि 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

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


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

Display getOrient = getWindowManager().getDefaultDisplay();

int orientation = getOrient.getOrientation();

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


यदि आप getResources () का उपयोग करते हैं। कुछ डिवाइसों पर कॉन्फ़िगरेशन () प्राप्त करें, आपको यह गलत लगेगा। हमने शुरुआत में उस दृष्टिकोण का उपयोग 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;
}

रनटाइम में स्क्रीन अभिविन्यास जांचें।

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

सरल और आसान :)

  1. 2 एक्सएमएल लेआउट बनाएं (यानी पोर्ट्रेट और लैंडस्केप)
  2. जावा फ़ाइल पर, लिखें:

    private int intOrientation;
    

    onCreate विधि पर और सेट से पहले सामग्री देखें लिखें:

    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.
    

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

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

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







orientation