Android: Deaktivieren Sie vorübergehend Orientierungsänderungen in einer Aktivität

116

Meine Hauptaktivität enthält Code, der einige Datenbankänderungen vornimmt, die nicht unterbrochen werden sollten. Ich mache das schwere Heben in einem anderen Thread und verwende einen Fortschrittsdialog, den ich als nicht stornierbar festgelegt habe. Ich habe jedoch festgestellt, dass beim Drehen meines Telefons die Aktivität neu gestartet wird, die für den ausgeführten Prozess WIRKLICH schlecht ist, und ich erhalte ein Force Close.

Ich möchte Änderungen der Bildschirmausrichtung programmgesteuert deaktivieren, bis mein Prozess abgeschlossen ist. Zu diesem Zeitpunkt werden Änderungen der Ausrichtung aktiviert.

Christopher Perry
quelle
Da niemand diesen Teil zu erwähnen scheint, möchten Sie android.content.pm.ActivityInfo importieren, um die ActivityInfo-ID zu verwenden.
Zsalwasser
1
Siehe: stackoverflow.com/a/32885911/2673792 für die beste Lösung
Sudhir Sinha

Antworten:

165

Wie von Chris in seiner Selbstantwort erklärt , ruft er an

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);

und dann

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);

funktioniert wirklich wie Charme ... auf echten Geräten!

Denken Sie nicht, dass es beim Testen auf dem Emulator kaputt ist. Die Tastenkombination Strg + F11 ändert IMMER die Bildschirmausrichtung, ohne dass sich die Sensoren emulieren.

EDIT: Dies war nicht die bestmögliche Antwort. Wie in den Kommentaren erläutert, gibt es Probleme mit dieser Methode. Die wirkliche Antwort ist hier .

Kevin Gaudin
quelle
Ich konnte diese Konstanten nicht finden. Dank dafür.
Christopher Perry
41
Es gibt ein Problem mit diesen Methoden ... Es sieht so aus, als würden Sie setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_NOSENSOR) aufrufen. Wenn das Gerät nicht in seiner Standardausrichtung verwendet wird, wird die Aktivitätsausrichtung sofort in die Standardausrichtung des Geräts geändert (zerstört und neu erstellt). Wenn Sie es beispielsweise auf einem Telefon im Querformat halten, wird die Aktivität beim Reaktivieren von Sensoren auf Hochformat und wieder auf Querformat umgeschaltet. Das gleiche Gegenteil bei einem Archos A5 IT: Wenn Sie es im Hochformat verwenden, wird die Aktivität auf Querformat und wieder auf Hochformat umgeschaltet.
Kevin Gaudin
1
Die eigentliche Antwort auf die ursprüngliche Frage ist da: stackoverflow.com/questions/3821423/…
Kevin Gaudin
2
Das hat bei mir nicht funktioniert. Dies funktionierte jedoch: stackoverflow.com/a/10488012/1369016 Ich musste setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) aufrufen; oder setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT); basierend auf der aktuellen Ausrichtung, die aus getResources () abgerufen wurde. getConfiguration (). Ausrichtung.
Tiago
ActivityInfo.SCREEN_ORIENTATION_SENSORrespektiert nicht die native Orientierungssperre von Android. Zurücksetzen der Ausrichtung auf ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIEDtut.
tvkanters
43

Keine der anderen Antworten hat den Trick perfekt für mich gemacht, aber hier ist, was ich gefunden habe.

Ausrichtung auf Strom sperren ...

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

Wenn das Ändern der Ausrichtung erneut zulässig sein soll, setzen Sie den Standardwert auf ...

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Pilot_51
quelle
9
Das Problem dabei ist, dass Configuration.ORIENTATION_PORTRAITin beiden Querformatmodi (dh "normal" und umgekehrt) zurückgegeben wird. Wenn sich das Telefon also im umgekehrten Querformat befindet und Sie es darauf einstellen, wird es auf den ActivityInfo.SCREEN_ORIENTATION_LANDSCAPEKopf gestellt. In API 9 führt ActivityInfo eine SCREEN_ORIENTATION_REVERSE_LANDSCAPEKonstante ein, aber ich sehe keine Möglichkeit, eine solche Ausrichtung durch die ConfigurationKlasse zu erkennen .
Błażej Czapp
1
Das hat funktioniert. Die Antwort auf das oben genannte Problem befindet sich in dieser Antwort. stackoverflow.com/a/10453034/1223436
Zack
Arbeitete wie ein Zauber für meine Bedürfnisse, brillanter Dank
user2029541
39

Hier ist eine vollständigere und aktuellere Lösung, die für API 8+, für umgekehrtes Hoch- und Querformat sowie für eine Galaxy-Registerkarte funktioniert, auf der die "natürliche" Ausrichtung Querformat ist (Aufruf activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)zum Entsperren der Ausrichtung):

@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);
    }
}
Roy
quelle
Funktionierte hervorragend für mich mit Tablet und Handys.
ScruffyFox
Die einzig richtige Antwort, die für mich auf allen Arten von Geräten funktioniert.
Amdev
Auf jeden Fall die beste Antwort! Sie können diese Methode staticerstellen und Activity activityals Parameter hinzufügen .
Caw
18

Um auch die Modi für die umgekehrte Ausrichtung zu verwalten, habe ich diesen Code verwendet, um die Aktivitätsorientierung zu korrigieren:

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

Und um noch einmal die Orientierung zu ermöglichen:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Ivan BASART
quelle
17

Verwenden setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED);zum Arretieren aktuelle Orientierung ob Quer- oder Hochformat sein.

Verwendung setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);zur Entriegelung Orientierung.

Sudhir Sinha
quelle
Beste Lösung für eine kurze temporäre Sperre. Kein Durcheinander mit der aktuellen Ausrichtung des Sensors.
Der unglaubliche
2
funktioniert auf Build.VERSION.SDK_INT> = 18, eine vollständigere Antwort gibt tdjprog auf dieser Seite stackoverflow.com/a/41812971/5235263
bastami82
14

Ich habe die Antwort gefunden. Zu diesem Zweck können Sie in einer Aktivität setRequestedOrientation(int)einen der hier angegebenen Werte aufrufen : http://developer.android.com/reference/android/R.attr.html#screenOrientation

Bevor ich meinen Thread startete, rief ich an setRequestedOrientation(OFF)(OFF = Nosensor) und als der Thread fertig war, rief ich an setRequestedOrientation(ON)(ON = Sensor). Klappt wunderbar.

Christopher Perry
quelle
11

Vielen Dank an alle. Ich habe die Lösung von Pilot_51 geändert, um sicherzustellen, dass ich den vorherigen Status wiederhergestellt habe. Ich habe auch eine Änderung vorgenommen, um Bildschirme ohne Querformat und ohne Hochformat zu unterstützen (habe sie jedoch nicht auf einem solchen Bildschirm getestet).

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

Dann, um es wiederherzustellen

setRequestedOrientation(prevOrientation);
Projektgeselle
quelle
Gutes Zeug - ich bin mir nicht sicher, warum du es nicht benutzt hast switch.
Ich habe vergessen aufzuräumen und zu einem Schalter zu wechseln, nachdem ich die dritte Option hinzugefügt habe.
ProjectJourneyman
Ich fand, dass dies funktioniert, ohne die aktuelle Konfiguration
abrufen
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
quelle
Könnten Sie bitte Ihrer Antwort eine Erklärung hinzufügen?
Slfan
Wenn Sie einige Jobs im Hintergrund haben, rufen Sie einfach setLockScreenOrientation (true) auf, um die Ausrichtung zu sperren und zu verhindern, dass die aktuelle Aktivität zerstört wird, um sie neu zu erstellen. Wenn Sie sicherstellen, dass diese Jobs abgeschlossen sind, rufen Sie setLockScreenOrientation (false) auf.
tdjprog
2
Das ist die beste Antwort!
Fakher
7

Hier ist eine Lösung, die jedes Mal funktioniert und die aktuelle Ausrichtung beibehält ( Activity.Info.SCREEN_ORIENTATION_PORTRAITz. B. mit Sätzen auf 0 °, aber der Benutzer kann eine aktuelle Ausrichtung von 180 ° haben).

// 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);
}
Adrien Cadet
quelle
2
Erwähnenswert: nur API 18+
Dmitry Zaytsev
1

Verwenden ActivityInfo.SCREEN_ORIENTATION_USERSie diese Option, wenn Sie den Bildschirm nur drehen möchten, wenn er auf dem Gerät aktiviert ist.

Pawan Maheshwari
quelle
1

Das funktioniert Präfekt für mich. Es löst das Problem mit der unterschiedlichen "natürlichen Ausrichtung" des Tablets / Telefons;)

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
quelle
0

Ich habe eine Lösung gefunden, die von der Drehung des Displays abhängt und dann die Ausrichtung des Geräts festlegt. Wenn wir die Ausrichtung kennen, können wir die Ausrichtung sperren und später bei Bedarf freigeben. Diese Lösung kann auch feststellen, ob sich das Gerät im umgekehrten Querformatmodus befindet.

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

Wenn wir später die Orientierung freigeben müssen, können wir diese Methode aufrufen:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
Mansour Fahad
quelle
0

Ich denke, dieser Code ist leichter zu lesen.

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
quelle
0

Ich habe festgestellt, dass eine Kombination vorhandener Rotations- / Orientierungswerte erforderlich ist, um die vier Möglichkeiten abzudecken. Es gibt die Hoch- / Querformatwerte und die natürliche Ausrichtung des Geräts. Angenommen, die natürliche Ausrichtung der Geräte hat einen Rotationswert von 0 Grad, wenn sich der Bildschirm im "natürlichen" Hoch- oder Querformat befindet. In ähnlicher Weise gibt es einen Rotationswert von 90 Grad im Quer- oder Hochformat (beachten Sie, dass er der Ausrichtung bei 0 Grad entgegengesetzt ist). Die Rotationswerte, die nicht 0 oder 90 Grad sind, implizieren also eine "umgekehrte" Ausrichtung. Ok, hier ist ein Code:

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 );
}
Magische Hände Pellegrin
quelle
0

Die meisten Antworten hier haben mir nicht gefallen, da sie beim Entsperren im Gegensatz zum vorherigen Status auf UNSPECIFIED gesetzt wurden. ProjectJourneyman hat das berücksichtigt, was großartig war, aber ich habe den Sperrcode von Roy vorgezogen. Meine Empfehlung wäre also eine Mischung aus beidem:

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
quelle
0

Sie können verwenden

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
quelle
-1

Verwenden Sie diese Codezeile

this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  

in Ihrer Aktivität oncreate Methode

Zeeshan Akhter
quelle