Android: किसी गतिविधि में उन्मुखीकरण परिवर्तनों को अस्थायी रूप से अक्षम करें

116

मेरी मुख्य गतिविधि में कुछ कोड हैं जो कुछ डेटाबेस में बदलाव करते हैं जिन्हें बाधित नहीं किया जाना चाहिए। मैं एक और धागे में भारी लिफ्टिंग कर रहा हूं, और एक प्रगति संवाद का उपयोग कर रहा हूं जिसे मैंने गैर-रद्द करने के रूप में सेट किया है। हालाँकि, मैंने देखा कि अगर मैं अपने फोन को घुमाता हूँ तो यह उस गतिविधि को पुनः आरंभ करता है जो वास्तव में चल रही प्रक्रिया के लिए बुरा है, और मुझे एक फोर्स क्लोज मिलता है।

जब मैं अपनी प्रक्रिया पूरी होने तक स्क्रीन अभिविन्यास परिवर्तन अक्षम करता हूं, तो उस समय उन्मुखीकरण परिवर्तन सक्षम होते हैं।

android  screen-orientation  android-orientation 
— क्रिस्टोफर पेरी
स्रोत
चूँकि कोई भी इस हिस्से का उल्लेख नहीं करता है, आप ActivInfo पहचानकर्ता का उपयोग करने के लिए android.content.pm.ActivityInfo को आयात करना चाहते हैं।
— zsalwasser
1
— diyism
1
देखें: सबसे अच्छा समाधान के लिए stackoverflow.com/a/32885911/2673792
— सुधीर सिन्हा

जवाबों:

165

जैसा कि क्रिस ने अपने आत्म-उत्तर , कॉलिंग में बताया है

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);

और फिर

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);

वास्तव में आकर्षण की तरह काम करता है ... असली उपकरणों पर!

ऐसा मत सोचो कि एमुलेटर पर परीक्षण करते समय यह टूट गया है, ctrl + F11 शॉर्टकट हमेशा स्क्रीन अभिविन्यास को बदलते हैं, बिना सेंसर चालें।

EDIT: यह सबसे अच्छा संभव जवाब नहीं था। जैसा कि टिप्पणियों में बताया गया है, इस पद्धति के साथ समस्याएं हैं। असली जवाब यहाँ है ।

— केविन गौडिन
स्रोत
मैं उन स्थिरांक का पता नहीं लगा सका। उसके लिए धन्यवाद।
— क्रिस्टोफर पेरी
41
इन विधियों के साथ एक समस्या है ... ऐसा लगता है कि यदि आप setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_NOSENSOR) कहते हैं; जब डिवाइस अपने डिफ़ॉल्ट अभिविन्यास उपयोग में नहीं होता है, तो गतिविधि अभिविन्यास तुरंत डिवाइस डिफ़ॉल्ट अभिविन्यास में बदल जाता है (नष्ट हो जाता है और फिर से बनाया जाता है)। उदाहरण के लिए, एक फोन पर, यदि आप इसे लैंडस्केप ओरिएंटेशन में रखते हैं, तो सेंसर को फिर से सक्रिय करने पर यह गतिविधि पोर्ट्रेट और लैंडस्केप पर वापस आ जाती है। Archos A5 IT के साथ एक ही विपरीत मुद्दा: पोर्ट्रेट में इसका उपयोग करने से गतिविधि को लैंडस्केप और पोर्ट्रेट पर वापस ले जाने का कारण बनता है।
— केविन गौडिन
1
मूल प्रश्न का वास्तविक उत्तर है: stackoverflow.com/questions/3821423/…
— केविन गौडिन
2
इसने मेरे लिए काम नहीं किया। हालांकि यह एक काम किया: stackoverflow.com/a/10488012/1369016 मुझे setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) को कॉल करना पड़ा; or setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT); getResources ()। getConfiguration () ओरिएंटेशन से प्राप्त वर्तमान ओरिएंटेशन के आधार पर।
— टिआगो
ActivityInfo.SCREEN_ORIENTATION_SENSORAndroid के मूल अभिविन्यास लॉक का सम्मान नहीं करता है। करने के लिए अभिविन्यास रीसेट करना ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED।
— TVkanters
43

अन्य उत्तरों में से किसी ने भी मेरे लिए पूरी तरह से चाल नहीं चली, लेकिन यहाँ जो मैंने पाया वह करता है।

वर्तमान के लिए ओरिएंटेशन लॉक करें ...

if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
} else setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

जब बदलते अभिविन्यास को फिर से अनुमति दी जानी चाहिए, तो डिफ़ॉल्ट पर वापस सेट करें ...

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
— Pilot_51
स्रोत
9
इसके साथ समस्या यह है कि Configuration.ORIENTATION_PORTRAITदोनों परिदृश्य मोड (यानी 'सामान्य', और उलट) में वापस आ जाएंगे। इसलिए अगर फोन उल्टा लैंडस्केप ओरिएंटेशन में है और आप इसे सेट करते हैं तो ActivityInfo.SCREEN_ORIENTATION_LANDSCAPEयह उल्टा हो जाएगा। एपीआई 9 में, एक्टिविटीइंफो SCREEN_ORIENTATION_REVERSE_LANDSCAPEनिरंतर का परिचय देता है, लेकिन मुझे Configurationकक्षा के माध्यम से इस तरह के अभिविन्यास का पता लगाने का कोई तरीका नहीं दिखता है ।
— बलोएज Czapp
1
यह काम किया। उपरोक्त चिंता का उत्तर इस उत्तर में स्थित है। stackoverflow.com/a/10453034/1223436
— Zack
मेरी जरूरतों के लिए भी एक आकर्षण की तरह काम किया, शानदार धन्यवाद
— 13:20 पर user2029541
39

यहां एक अधिक पूर्ण और अद्यतित समाधान है जो एपीआई 8+ के लिए काम करता है, रिवर्स पोर्ट्रेट और लैंडस्केप के लिए काम करता है, और एक गैलेक्सी टैब पर काम करता है, जहां "प्राकृतिक" अभिविन्यास परिदृश्य है ( activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)ओरिएंटेशन अनलॉक करने के लिए कॉल )

@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
public static void lockActivityOrientation(Activity activity) {
    Display display = activity.getWindowManager().getDefaultDisplay();
    int rotation = display.getRotation();
    int height;
    int width;
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
        height = display.getHeight();
        width = display.getWidth();
    } else {
        Point size = new Point();
        display.getSize(size);
        height = size.y;
        width = size.x;
    }
    switch (rotation) {
    case Surface.ROTATION_90:
        if (width > height)
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        else
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
        break;
    case Surface.ROTATION_180:
        if (height > width)
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
        else
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
        break;          
    case Surface.ROTATION_270:
        if (width > height)
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
        else
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        break;
    default :
        if (height > width)
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        else
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
    }
}
— रॉय
स्रोत
टैबलेट और फोन के साथ मेरे लिए बहुत अच्छा काम किया।
— स्क्रूफीफॉक्स
एकमात्र सही उत्तर जो मेरे लिए सभी प्रकार के डिवाइस पर काम करता है।
— अमरदेव
निश्चित रूप से सबसे अच्छा जवाब! आप इस विधि को बना सकते हैं staticऔर Activity activityएक पैरामीटर के रूप में जोड़ सकते हैं ।
— कांव-कांव
18

रिवर्स ओरिएंटेशन मोड को भी प्रबंधित करने के लिए, मैंने उस कोड का उपयोग गतिविधि उन्मुखीकरण को ठीक करने के लिए किया है:

int rotation = getWindowManager().getDefaultDisplay().getRotation();

    switch(rotation) {
    case Surface.ROTATION_180:
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
        break;
    case Surface.ROTATION_270:
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);         
        break;
    case  Surface.ROTATION_0:
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        break;
    case Surface.ROTATION_90:
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        break;
    }

और फिर से उन्मुखीकरण की अनुमति देने के लिए:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
— इवान बासार्ट
स्रोत
17

उपयोग setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);वर्तमान उन्मुखीकरण को लॉक करने के लिए चाहे वह परिदृश्य या चित्र हो।

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);अभिविन्यास अनलॉक करने के लिए उपयोग करें ।

— सुधीर सिन्हा
स्रोत
एक छोटे अस्थायी ताला के लिए सबसे अच्छा समाधान। वर्तमान उन्मुखीकरण सेंसर के साथ कोई खिलवाड़ नहीं।
— अविश्वसनीय जान
2
Build.VERSION.SDK_INT> = 18 पर काम करता है, इस पृष्ठ में tdjprog द्वारा अधिक पूर्ण उत्तर दिया गया है stackoverflow.com/a/41812971/5235263
— bastami82
14

मुझे जवाब मिल गया। ऐसा करने के लिए, एक गतिविधि में आप setRequestedOrientation(int)यहां निर्दिष्ट मूल्यों में से एक के साथ कॉल कर सकते हैं: http://developer.android.com/reference/android/R.attr.html#screenOrientation

इससे पहले कि मैं अपने थ्रेड को बंद करता, मुझे setRequestedOrientation(OFF)(OFF = nosensor) बुलाया जाता था और जब थ्रेड किया जाता था तो मुझे setRequestedOrientation(ON)(ON = सेंसर) बुलाया जाता था । एक जादू की तरह काम करता है।

— क्रिस्टोफर पेरी
स्रोत
11

सबको शुक्रीया। मैंने Pilot_51 के समाधान को संशोधित किया, यह सुनिश्चित करने के लिए कि मैंने पिछली स्थिति में पुनर्स्थापित किया था। मैंने गैर-परिदृश्य और गैर-पोर्ट्रेट स्क्रीन का समर्थन करने के लिए एक बदलाव में फेंक दिया (लेकिन इस तरह की स्क्रीन पर इसका परीक्षण नहीं किया है)।

prevOrientation = getRequestedOrientation();
if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
} else if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
} else {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
}

फिर इसे बहाल करने के लिए

setRequestedOrientation(prevOrientation);
— ProjectJourneyman
स्रोत
अच्छा सामान - सुनिश्चित नहीं है कि आपने switchहालांकि उपयोग क्यों नहीं किया ।
तीसरा विकल्प जोड़ने के बाद मैं सफाई करना और स्विच में बदलना भूल गया।
— प्रोजेक्टजॉर्नीमैन
मैं वर्तमान कॉन्फ़िगरेशन प्राप्त करने के लिए आप गतिविधि वस्तु लेकिन केवल संदर्भ ActivityInfo.SCREEN_ORIENTATION_NOSENSOR के लिए उपयोग नहीं है, तो बिना इस काम करता पाया | ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
— max4ever
8 
protected void setLockScreenOrientation(boolean lock) {
    if (Build.VERSION.SDK_INT >= 18) {
        setRequestedOrientation(lock?ActivityInfo.SCREEN_ORIENTATION_LOCKED:ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR);
        return;
    }

    if (lock) {
        switch (getWindowManager().getDefaultDisplay().getRotation()) {
            case 0: setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); break; // value 1
            case 2: setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT); break; // value 9
            case 1: setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); break; // value 0
            case 3: setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE); break; // value 8
        }
    } else
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR); // value 10
}
— tdjprog
स्रोत
क्या आप अपने उत्तर में कुछ स्पष्टीकरण जोड़ सकते हैं?
— slfan
जब आपके पास बैकग्राउंड में कुछ काम हों, तो बस ओरिएंटेशन लॉक करने के लिए setLockScreenOrientation (true) पर कॉल करें और इसे फिर से बनाने के लिए वर्तमान गतिविधि को नष्ट करने से रोकें। जब आप यह सुनिश्चित करते हैं कि ये कार्य समाप्त हो गए हैं, तो setLockScreenOrientation (false) पर कॉल करें।
— tdjprog
2
यह सबसे अच्छा जवाब है!
— फखर
7

यहां एक समाधान है जो हर बार काम करता है और वर्तमान अभिविन्यास को संरक्षित करता है ( Activity.Info.SCREEN_ORIENTATION_PORTRAITउदाहरण के लिए 0 डिग्री पर सेट का उपयोग करता है, लेकिन उपयोगकर्ता के पास वर्तमान के रूप में 180 ° अभिविन्यास हो सकता है)।

// Scope: Activity

private void _lockOrientation() {
    if (super.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
        super.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT);
    } else {
        super.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE);
    }
}

private void _unlockOrientation() {
    super.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
}
— एड्रियन कैडेट
स्रोत
2
उल्लेख के लायक: एपीआई 18+ केवल
— दिमित्री ज़ेत्सेव
1

उपयोग करें ActivityInfo.SCREEN_ORIENTATION_USERयदि आप स्क्रीन को केवल तभी घुमाना चाहते हैं जब डिवाइस पर इसकी सक्षमता हो।

— पवन माहेश्वरी
स्रोत
1

यह मेरे लिए प्रीफेक्ट का काम करता है। यह टैबलेट / फोन के विभिन्न "प्राकृतिक अभिविन्यास" के साथ समस्या को हल करता है;)

int rotation = getWindowManager().getDefaultDisplay().getRotation();

        Configuration config = getResources().getConfiguration();
        int naturalOrientation;

        if (((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) &&
                config.orientation == Configuration.ORIENTATION_LANDSCAPE)
                || ((rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) &&
                config.orientation == Configuration.ORIENTATION_PORTRAIT)) {
            naturalOrientation = Configuration.ORIENTATION_LANDSCAPE;
        } else {
            naturalOrientation = Configuration.ORIENTATION_PORTRAIT;
        }

        // because getRotation() gives "rotation from natural orientation" of device (different on phone and tablet)
        // we need to update rotation variable if natural orienation isn't 0 (mainly tablets)
        if (naturalOrientation == Configuration.ORIENTATION_LANDSCAPE)
            rotation = ++rotation % 4;

        switch (rotation) {
            case Surface.ROTATION_0: //0
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
                break;
            case Surface.ROTATION_90: //1
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
                break;
            case Surface.ROTATION_180: //2
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
                break;
            case Surface.ROTATION_270: //3
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
                break;
        }
    } else {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
    }
— Naxos
स्रोत
0

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

private void lockOrientation(){
    switch (((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRotation()) {


        // Portrait
        case Surface.ROTATION_0:
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            break;


        //Landscape     
        case Surface.ROTATION_90: 
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            break;


        // Reversed landscape
        case Surface.ROTATION_270:
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);             
            break;
    }
}

फिर बाद में अगर हमें अभिविन्यास जारी करने की आवश्यकता है तो हम इस विधि को कॉल कर सकते हैं:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
— मंसूर फहद
स्रोत
0

मुझे लगता है कि यह कोड पढ़ना आसान है।

private void keepOrientation() {

    int orientation = getResources().getConfiguration().orientation;
    int rotation = getWindowManager().getDefaultDisplay().getRotation();

    switch (rotation) {
        case Surface.ROTATION_0:
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            }
            break;
        case Surface.ROTATION_90:
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            }
            break;
        case Surface.ROTATION_180:
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
            }
            break;
        default:
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            } else {
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
            }
    }
}
— nor_miya
स्रोत
0

मैंने पाया है कि मौजूदा घूर्णन / अभिविन्यास मूल्यों का एक संयोजन चार संभावनाओं को कवर करने के लिए आवश्यक है; वहाँ चित्र / परिदृश्य मूल्यों और डिवाइस की प्राकृतिक अभिविन्यास है। मान लीजिए कि उपकरणों के प्राकृतिक अभिविन्यास का रोटेशन मान 0 डिग्री होगा जब स्क्रीन "प्राकृतिक" पोर्ट्रेट या लैंडस्केप ओरिएंटेशन में होगी। इसी तरह, लैंडस्केप या पोर्ट्रेट में 90 डिग्री का रोटेशन वैल्यू होगा (ध्यान दें कि यह ओरिएंटेशन @ 0 डिग्री के विपरीत है)। तो रोटेशन मान जो 0 या 90 डिग्री नहीं है, वह "रिवर्स" ओरिएंटेशन का अर्थ होगा। ठीक है, यहाँ कुछ कोड है:

public enum eScreenOrientation 
{
PORTRAIT (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),
LANDSCAPE (ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE),
PORTRAIT_REVERSE (ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT),
LANDSCAPE_REVERSE (ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE),
UNSPECIFIED_ORIENTATION (ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);

    public final int activityInfoValue;

    eScreenOrientation ( int orientation )
    {
        activityInfoValue = orientation;
    }
}



public eScreenOrientation currentScreenOrientation ( )
{
    final int rotation = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRotation();

    final int orientation = getResources().getConfiguration().orientation;
    switch ( orientation ) 
    {
    case Configuration.ORIENTATION_PORTRAIT:
        if ( rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90 )
            return eScreenOrientation.PORTRAIT;
        else
            return eScreenOrientation.PORTRAIT_REVERSE;
    case Configuration.ORIENTATION_LANDSCAPE:
        if ( rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90 )
            return eScreenOrientation.LANDSCAPE;
        else
            return eScreenOrientation.LANDSCAPE_REVERSE;
    default:
        return eScreenOrientation.UNSPECIFIED_ORIENTATION;
    }
}

public void lockScreenOrientation ( )
    throws UnsupportedDisplayException
{
    eScreenOrientation currentOrientation = currentScreenOrientation( );
    if ( currentOrientation == eScreenOrientation.UNSPECIFIED_ORIENTATION )
        throw new UnsupportedDisplayException("Unable to lock screen - unspecified orientation");
    else
        setRequestedOrientation( currentOrientation.activityInfoValue );
}

public void unlockScreenOrientation (  )
{
    setRequestedOrientation( ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED );
}
— मैजिक हैंड्स पेलेग्रिन
स्रोत
0

मुझे यहाँ अधिकांश उत्तर पसंद नहीं आए, क्योंकि अनलॉक में उन्होंने इसे पिछली स्थिति के विपरीत UNSPECIFIED में सेट कर दिया था। ProjectJourneyman ने इसे ध्यान में रखा, जो बहुत अच्छा था, लेकिन मैंने रॉय द्वारा लॉकिंग कोड को प्राथमिकता दी। तो, मेरी सिफारिश दो का मिश्रण होगी:

private int prevOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;

private void unlockOrientation() {
    setRequestedOrientation(prevOrientation);
}

@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
private void lockOrientation() {
    prevOrientation = getRequestedOrientation();
    Display display = getWindowManager().getDefaultDisplay();
    int rotation = display.getRotation();
    int height;
    int width;
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
        height = display.getHeight();
        width = display.getWidth();
    } else {
        Point size = new Point();
        display.getSize(size);
        height = size.y;
        width = size.x;
    }
    switch (rotation) {
        case Surface.ROTATION_90:
            if (width > height)
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            else
                setRequestedOrientation(9/* reversePortait */);
            break;
        case Surface.ROTATION_180:
            if (height > width)
                setRequestedOrientation(9/* reversePortait */);
            else
                setRequestedOrientation(8/* reverseLandscape */);
            break;
        case Surface.ROTATION_270:
            if (width > height)
                setRequestedOrientation(8/* reverseLandscape */);
            else
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            break;
        default :
            if (height > width)
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            else
                setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
    }
}
— Gadzair
स्रोत
0

आप उपयोग कर सकते हैं 

public void swapOrientaionLockState(){
    try{
        if (Settings.System.getInt(mContext.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION) == 1) {
            Display defaultDisplay = ((WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
            Settings.System.putInt(mContext.getContentResolver(), Settings.System.USER_ROTATION, defaultDisplay.getRotation());
            Settings.System.putInt(mContext.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION, 0);
        } else {
            Settings.System.putInt(mContext.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION, 1);
        }

        Settings.System.putInt(mContext.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION, !orientationIsLocked() ? 1 : 0);

    } catch (Settings.SettingNotFoundException e){
        e.printStackTrace();
    }
}

public boolean orientationIsLocked(){
    if(canModifiSetting(mContext)){
        try {
            return Settings.System.getInt(mContext.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION) == 0;
        } catch (Settings.SettingNotFoundException e) {
            e.printStackTrace();
        }
    }
    return false;
}

public static boolean canModifiSetting(Context context){
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        return Settings.System.canWrite(context);
    } else {
        return true;
    }
}
— moviehay0032
स्रोत
-1

कोड की उस लाइन का उपयोग करें 

this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

उर गतिविधि oncreate विधि में

— जीशान अख्तर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.