Android: Vorübergehend deaktivieren Sie die Ausrichtung in einer Aktivität

Meine Haupttätigkeit hat einige code, der macht einige Datenbank-änderungen, die sollte nicht unterbrochen werden. Ich bin tun, die schweres heben in einem anderen thread, und mit einer Fortschrittsanzeige, die ich als nicht erlassen werden. Allerdings ist mir aufgefallen, dass wenn ich wechsle mein Handy startet die Aktivität, die ist WIRKLICH schlecht für den Prozess, der ausgeführt wurde, und bekomme ich einen Force Close.

Was ich tun möchte, ist programmgesteuert deaktivieren Sie änderungen der Bildschirmausrichtung bis mein Prozess abgeschlossen ist, an die Zeit, Orientierung, änderungen sind aktiviert.

InformationsquelleAutor der Frage Christopher Perry | 2010-08-31

150

Als erklärt von Chris in seinem selbst-Antwortruft
```
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_NOSENSOR);
```
dann
```
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
```
wirklich funktioniert wie Charme... auf echten Geräten !

Glaube nicht, dass es kaputt ist, beim Test auf dem emulator, die Tastenkombination Strg+F11 Verknüpfung jederzeit ändern der Ausrichtung des Bildschirms, ohne Emulation-sensoren bewegt.

EDIT: das war nicht die beste mögliche Antwort. Wie bereits in den Kommentaren gibt es Probleme mit dieser Methode. Die richtige Antwort ist hier.

InformationsquelleAutor der Antwort Kevin Gaudin

Keiner der anderen Antworten hat den trick perfekt für mich, aber hier ist was ich gefunden habe, die funktioniert.

Sperren der Ausrichtung auf die aktuellen...

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

Als Orientierung ändern sollte wieder erlaubt werden, wieder auf die default...

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);

InformationsquelleAutor der Antwort Pilot_51

Hier ist eine vollständige und up-to-date-Lösung, die funktioniert für API 8+, funktioniert die umgekehrte hoch-und Querformat, und funktioniert auf einem Galaxy-tab, wo die "Natürliche" Orientierung der Landschaft (nennen activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) zum entsperren der Orientierung):

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

InformationsquelleAutor der Antwort Roy

Zu verwalten, um auch die umgekehrte Orientierung Modi, die ich verwendet habe, die code zu beheben, die Handlungsorientierung:

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

Zuzulassen und wieder die Orientierung:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);

InformationsquelleAutor der Antwort Ivan BASART

14

Fand ich die Antwort. Um dies zu tun, in einer Tätigkeit, die Sie anrufen können setRequestedOrientation(int) mit einem der hier angegebenen Werte: http://developer.android.com/reference/android/R.attr.html#screenOrientation

Bevor ich gekickt aus meinem thread, ich rief setRequestedOrientation(OFF) (OFF = nosensor) und wenn der thread fertig war rief ich setRequestedOrientation(ON) (=sensor). Funktioniert wie ein Charme.

InformationsquelleAutor der Antwort Christopher Perry
12

Verwenden setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LOCKED); für
Verriegelung aktuellen Ausrichtung sein, ob es im hoch-oder Querformat.

Verwenden setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR); für das entsperren Orientierung.

InformationsquelleAutor der Antwort Sudhir Sinha

Danke an alle. Ich veränderte Pilot_51 Lösung, um sicherzustellen, dass ich im vorherigen Zustand wiederhergestellt. Ich warf auch in einer Veränderung der für die Unterstützung von nicht-Querformat und nicht hochformat-Bildschirme (aber noch nicht getestet, es auf einem solchen Bildschirm).

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 wiederherstellen

setRequestedOrientation(prevOrientation);

InformationsquelleAutor der Antwort ProjectJourneyman

Hier ist eine Lösung, die funktioniert zu jeder Zeit und bewahrt aktuellen Ausrichtung (mit Activity.Info.SCREEN_ORIENTATION_PORTRAIT setzt auf 0° zum Beispiel, aber Benutzer kann eine 180° - Orientierung als aktuellen).

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

InformationsquelleAutor der Antwort Adrien Cadet

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
}

InformationsquelleAutor der Antwort tdjprog

Funktioniert dies perfekt für mich. Es löst problem mit verschiedenen "Natürliche Orientierung" von tablet/Telefon 😉

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

InformationsquelleAutor der Antwort Naxos

0

verwenden ActivityInfo.SCREEN_ORIENTATION_USER wenn Sie wollen, drehen Sie den Bildschirm nur zu, wenn seine aktivierten Gerät.

InformationsquelleAutor der Antwort Pawan M

Habe ich mit einer Lösung kommen, die abhängig von der display-rotation und dann entscheidet die Ausrichtung des Geräts. Aus der Kenntnis der Orientierung, wir können die Ausrichtung sperren, und geben Sie es später, wenn nötig. Diese Lösung kann auch feststellen, ob das Gerät in reverse-Landschaft - Modus.

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

Dann später, wenn wir müssen, lassen Sie die Ausrichtung können wir diese Methode aufrufen:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);

InformationsquelleAutor der Antwort Mansour Fahad

Ich denke dieser code ist einfacher 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);
            }
    }
}

InformationsquelleAutor der Antwort nor_miya

Fand ich dann eine Kombination der bestehenden rotation/Orientierung-Werte sind erforderlich, um die vier Möglichkeiten; es gibt die hochformat/Querformat-Werte und der natürlichen Ausrichtung des Geräts. Lassen Sie uns sagen, dass die Geräte " Natürliche Orientierung wird ein Wert für Drehung von 0 Grad, wenn der Bildschirm ist in seiner "natürlichen" Ausrichtung hochformat oder Querformat. Ähnlich, es wird ein Wert für Drehung von 90 Grad, wenn es im landscape-oder portrait (beachte, dass es gegenüber von der orientation bei 0 Grad). Also die rotation Werte, die nicht 0 oder 90 Grad bedeutet, dass "Reverse" - Orientierung. Ok, hier einige 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 );
}

InformationsquelleAutor der Antwort Magic Hands Pellegrin

Ich wusste nicht, wie die meisten Antworten hier, da in der unlock setzen Sie es weder als Gegensatz zu dem vorherigen Zustand. ProjectJourneyman hast, nehmen Sie es in Betracht, das war toll, aber ich bevorzugte den Sperrcode von Roy. Also, meine Empfehlung wäre eine Mischung aus den beiden:

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

InformationsquelleAutor der Antwort Gadzair

Können Sie

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

InformationsquelleAutor der Antwort moviehay0032

-1

verwenden, die code-Zeile
```
this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  
```
in ur activity oncreate-Methode

InformationsquelleAutor der Antwort Zeeshan Akhter

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.