Jak wyłączyć tryb krajobrazowy w Androidzie?

Jak mogę wyłączyć tryb poziomy dla niektórych widoków w mojej aplikacji na Androida?

Dodaj android:screenOrientation="portrait"do działania w pliku AndroidManifest.xml. Na przykład:

<activity android:name=".SomeActivity"
    android:label="@string/app_name"
    android:screenOrientation="portrait" />

EDYCJA: Ponieważ stało się to bardzo popularną odpowiedzią, czuję się bardzo winny, ponieważ zmuszanie do portretowania rzadko jest właściwym rozwiązaniem problemów, do których często się stosuje.
Główne zastrzeżenia dotyczące wymuszonego portretu:

• Nie zwalnia Cię to z konieczności myślenia o zdarzeniach w cyklu życia aktywności lub prawidłowego zapisywania / przywracania stanu. Oprócz rotacji aplikacji istnieje wiele rzeczy, które mogą spowodować zniszczenie / odtwarzanie aktywności, w tym nieuniknione rzeczy, takie jak wielozadaniowość. Nie ma skrótów; naucz się korzystać z pakietów i retainInstancefragmentów.
• Należy pamiętać, że w przeciwieństwie do dość jednolitego sposobu korzystania z iPhone'a, istnieje kilka urządzeń, w których portret nie jest wyraźnie popularną orientacją. Gdy użytkownicy są na urządzeniach ze sprzętową klawiaturą lub konsolą do gier, a także Nvidia Shield, na Chromebookach , na urządzeniach składanych lub na Samsung DeX , wymuszenie portretu może sprawić, że korzystanie z aplikacji będzie ograniczone lub będzie ogromnym problemem w zakresie użyteczności. Jeśli Twoja aplikacja nie ma silnego argumentu UX, który prowadziłby do negatywnych doświadczeń w zakresie obsługi innych orientacji, prawdopodobnie nie powinieneś wymuszać krajobrazu. Mówię o takich rzeczach, jak: „jest to aplikacja kasy fiskalnej dla jednego określonego modelu tabletu, zawsze używana w stałej stacji dokującej”.

Dlatego większość aplikacji powinna pozwalać czujnikom telefonu, oprogramowaniu i fizycznej konfiguracji na podejmowanie własnych decyzji dotyczących sposobu interakcji użytkownika z aplikacją. Kilka przypadków, o których warto pomyśleć, jeśli nie jesteś zadowolony z domyślnego zachowania sensororientacji w twoim przypadku użycia:

• Jeśli Twoim głównym problemem są przypadkowe zmiany orientacji w połowie aktywności, która Twoim zdaniem czujniki i oprogramowanie urządzenia nie poradzą sobie dobrze (na przykład w grze opartej na przechylaniu), rozważ obsługę krajobrazu i portretu, ale użyj nosensororientacji. Wymusza to orientację poziomą na większości tabletów i portret na większości telefonów, ale nadal nie zalecałbym tego w przypadku większości „normalnych” aplikacji (niektórzy użytkownicy lubią pisać na klawiaturze programowej w orientacji poziomej na swoich telefonach, a wielu użytkowników tabletów czyta w trybie pionowym - i powinieneś im pozwolić).
• Jeśli z jakiegoś powodu nadal musisz wymusić portret, sensorPortraitmoże być lepszy niż w portraitprzypadku Androida 2.3+; pozwala to na odwrócenie portretu, co jest dość powszechne w przypadku używania tabletu.

AndroidManifest.xmlDopóki nie przeczytałem tego posta, nie wiedziałem o zmianie pliku, więc w moich aplikacjach użyłem tego:

setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);     //  Fixed Portrait orientation

Dodaj to android:screenOrientation="portrait"do pliku manifestu, w którym deklarujesz swoją aktywność w ten sposób

<activity android:name=".yourActivity"
    ....
    android:screenOrientation="portrait" />

Jeśli chcesz to zrobić za pomocą kodu Java, spróbuj

setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 

przed wywołaniem setContentViewmetody dla swojej aktywności w onCreate().

Mam nadzieję, że ta pomoc będzie zrozumiała dla wszystkich ...

Wiele odpowiedzi tutaj sugeruje się użyć "portrait"w pliku AndroidManifest.xml. To może wydawać się dobrym rozwiązaniem - ale jak zauważono w dokumentacji, wyróżniasz urządzenia, które mogą mieć tylko krajobraz. Zmuszasz także niektóre urządzenia (najlepiej działające w krajobrazie) do przejścia w pionie, nie uzyskując właściwej orientacji.

Moją propozycją jest użycie "nosensor"zamiast tego. Spowoduje to, że urządzenie będzie korzystało z domyślnej preferowanej orientacji, nie zablokuje żadnych zakupów / pobrań w Google Play i zapewni, że czujnik nie zepsuje twojej (NDK, w moim przypadku) gry.

Po prostu dodaj Like this Line in Your Manifest

android: screenOrientation = "portret"

<manifest
    package="com.example.speedtest"
    android:versionCode="1"
    android:versionName="1.0" >

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >


        <activity
            android:name="ComparisionActivity"
            android:label="@string/app_name"
            android:screenOrientation="portrait" >
        </activity>

    </application>

</manifest>   

Jeśli chcesz ustawienia użytkownika,

to polecam setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Możesz zmienić ustawienia z menu ustawień.

Wymagam tego, ponieważ moje zegary muszą odpowiadać temu, co jest na ekranie, a obracanie ekranu zniszczy bieżącą aktywność.

Możesz to zrobić dla całej aplikacji bez konieczności przekształcania wszystkich działań w wspólną klasę bazową.

Sztuczka polega na tym, aby upewnić się, że do projektu dołączono podklasę aplikacji. W funkcji onCreate (), wywoływanej przy pierwszym uruchomieniu aplikacji, rejestrujesz obiekt ActivityLifecycleCallbacks (poziom API 14+), aby otrzymywać powiadomienia o zdarzeniach cyklu życia aktywności.

Daje to możliwość wykonywania własnego kodu za każdym razem, gdy dowolne działanie w aplikacji zostanie uruchomione (zatrzymane, wznowione lub cokolwiek innego). W tym momencie możesz wywołać setRequestedOrientation () na nowo utworzonym działaniu.

I nie zapomnij dodać aplikacji: name = ". MyApp" w pliku manifestu.

class MyApp extends Application {

    @Override
    public void onCreate() {
        super.onCreate();  

        // register to be informed of activities starting up
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {

            @Override
            public void onActivityCreated(Activity activity, 
                                          Bundle savedInstanceState) {

                // new activity created; force its orientation to portrait
                activity.setRequestedOrientation(
                    ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            }
            ....
        });
    }
}

Użyj tego w onCreate () działania

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Powinieneś zmienić android:screenOrientation="sensorPortrait"w AndroidManifest.xml

Po prostu dodaj ten atrybut do tagu aktywności.

 android:screenOrientation="portrait"

Jeśli nie chcesz lepiej męczyć się z dodawaniem orientacji w każdym przejawie pozycji działania, utwórz klasę BaseActivity (dziedziczy „Activity” lub „AppCompatActivity”), która będzie dziedziczona przez każdą aktywność aplikacji zamiast „Activity ”lub„ AppCompatActivity ”i wystarczy dodać następujący fragment kodu do BaseActivity:

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    // rest of your code......
}

Dodaj android:screenOrientation="portrait"do działania, które chcesz wyłączyć tryb krajobrazu.

Jeśli chcesz wyłączyć Landscape mode for your android app(lub pojedyncze działanie), wszystko co musisz zrobić, to dodać,

android:screenOrientation="portrait"do znacznika aktywności w AndroidManifest.xmlpliku.

Lubić:

<activity android:name="YourActivityName" 
    android:icon="@drawable/ic_launcher" 
    android:label="Your App Name" 
    android:screenOrientation="portrait">

Inna droga, podejście programowe.

Jeśli chcesz to zrobić programowo, tj. za pomocą kodu Java. Możesz to zrobić, dodając poniższy kod do klasy Java działania, którego nie chcesz wyświetlać w trybie poziomym.

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Mam nadzieję, że ci to pomoże. Aby uzyskać więcej informacji, odwiedź tutaj, wprowadź opis linku tutaj

Jak zmienić orientację w niektórych widokach

Zamiast blokować orientację całej aktywności, możesz użyć tej klasy, aby dynamicznie zablokować orientację z dowolnego widoku w sposób pragmatyczny: -

Zrób swój widok Krajobraz

OrientationUtils.lockOrientationLandscape(mActivity);

Zrób swój widok Portret

OrientationUtils.lockOrientationPortrait(mActivity);

Odblokuj orientację

OrientationUtils.unlockOrientation(mActivity);

Orientacja Util Class

import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.os.Build;
import android.view.Surface;
import android.view.WindowManager;

/*  * This class is used to lock orientation of android app in nay android devices 
 */

public class OrientationUtils {
    private OrientationUtils() {
    }

    /** Locks the device window in landscape mode. */
    public static void lockOrientationLandscape(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
    }

    /** Locks the device window in portrait mode. */
    public static void lockOrientationPortrait(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }

    /** Locks the device window in actual screen mode. */
    public static void lockOrientation(Activity activity) {
        final int orientation = activity.getResources().getConfiguration().orientation;
        final int rotation = ((WindowManager) activity.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay()
                .getRotation();

        // Copied from Android docs, since we don't have these values in Froyo
        // 2.2
        int SCREEN_ORIENTATION_REVERSE_LANDSCAPE = 8;
        int SCREEN_ORIENTATION_REVERSE_PORTRAIT = 9;

        // Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO
        if (!(Build.VERSION.SDK_INT <= Build.VERSION_CODES.FROYO)) {
            SCREEN_ORIENTATION_REVERSE_LANDSCAPE = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            SCREEN_ORIENTATION_REVERSE_PORTRAIT = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        }

        if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_90) {
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            }
        } else if (rotation == Surface.ROTATION_180 || rotation == Surface.ROTATION_270) {
            if (orientation == Configuration.ORIENTATION_PORTRAIT) {
                activity.setRequestedOrientation(SCREEN_ORIENTATION_REVERSE_PORTRAIT);
            } else if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                activity.setRequestedOrientation(SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
            }
        }
    }

    /** Unlocks the device window in user defined screen mode. */
    public static void unlockOrientation(Activity activity) {
        activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_USER);
    }

}

posługiwać się

android:configChanges="keyboardHidden|orientation"
android:screenOrientation="portrait" 

Musisz ustawić orientację każdego działania.

<activity
                android:name="com.example.SplashScreen2"
                android:label="@string/app_name"
                android:screenOrientation="portrait"
                android:theme="@android:style/Theme.Black.NoTitleBar" >
            </activity>
            <activity
                android:name="com.example.Registration"
                android:label="@string/app_name"
                android:screenOrientation="portrait"
                android:theme="@android:style/Theme.Black.NoTitleBar" >
            </activity>
            <activity
                android:name="com.example.Verification"
                android:label="@string/app_name"
                android:screenOrientation="portrait"
                android:theme="@android:style/Theme.Black.NoTitleBar" >
            </activity>
            <activity
                android:name="com.example.WelcomeAlmostDone"
                android:label="@string/app_name"
                android:screenOrientation="portrait"
                android:theme="@android:style/Theme.Black.NoTitleBar" >
            </activity>
            <activity
                android:name="com.example.PasswordRegistration"
                android:label="@string/app_name"
                android:screenOrientation="portrait"
                android:theme="@android:style/Theme.Black.NoTitleBar" >
            </activity>

dodaj klasę do metody oncreate ()

 setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Jeśli używasz Xamarin C #, niektóre z tych rozwiązań nie będą działać. Oto rozwiązanie, które według mnie działa.

[Activity(MainLauncher = true, Icon = "@drawable/icon", ScreenOrientation = ScreenOrientation.Portrait)]

Powyżej klasy działa dobrze, podobnie jak inne rozwiązania, również nie ma zastosowania na całym świecie i należy ją umieścić w każdym nagłówku działania.

Możesz zmusić określoną aktywność do pozostawania w trybie portretowym, pisząc to w pliku manifest.xml

 <activity android:name=".MainActivity"
        android:screenOrientation="portrait"></activity>

Możesz także zmusić swoją aktywność do pozostania w trybie postrait, pisząc następujący wiersz w metodzie onCreate () twojej aktywności

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.your_layout);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

}

<android . . . >
    . . .
    <manifest . . . >
        . . .
        <application>
            <activity android:name=".MyActivity" 
                android:screenOrientation="portrait" 
                android:configChanges="keyboardHidden|orientation">
            </activity>
        </application>
    </manifest>
</android>

Dodaj poniżej wyróżnienie swojego projektu,

instalacja npm

npm i reaguje na natywną blokadę orientacji

następnie używasz klasy manifestu, takiej jak React_Native (Your Project Folder) / android / app / src / main / AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

<application
  android:name=".MainApplication"
  android:label="@string/app_name"
  android:icon="@mipmap/ic_launcher"
  android:allowBackup="false"
  android:theme="@style/AppTheme">
  <activity
    android:name=".MainActivity"
    android:label="@string/app_name"
    android:screenOrientation="landscape"
    android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
    android:windowSoftInputMode="adjustResize">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
  </activity>
  <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
</application>

Dziękuję Ci!

W <apphome>/platform/androidutworzonym katalogu AndroidManifest.xml(kopiowanie go z wygenerowanego). Następnie dodaj android:screenOrientation=„ portrait” do WSZYSTKICH elementów działania.

 <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="in.co.nurture.bajajfinserv">
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>


    <application

        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity" android:screenOrientation="portrait">

            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

możemy ograniczyć Aktywność w trybie pionowym lub poziomym za pomocą atrybutu lub Androida: screenOrientation.

jeśli w moim programie jest więcej niż jedna aktywność, masz swobodę ograniczenia dowolnej aktywności w dowolnym trybie i nigdy nie wpływa to na inne, których nie chcesz.

Albo w oczywistej klasie.

<activity android:name=".yourActivity"
    ....
    android:screenOrientation="portrait" />

lub programowo

setRequestedOrientation (ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 

Uwaga: powinieneś to nazwać przed setContentViewmetodą dla swojej aktywności w onCreate().

Dodaj android:screenOrientation="portrait"w AndroidManifest.xml pliku .

Na przykład :

<activity android:name=".MapScreen" 
 android:screenOrientation="portrait"></activity>

Aby pomóc komuś innemu, wystarczy następujący atrybut w AKTYWNOŚCI w AndroidManifest.xml:

android: configChanges = "orientacja"

Zatem pełny węzeł aktywności:

<activity android:name="Activity1" 
    android:icon="@drawable/icon" 
    android:label="App Name" 
    android:configChanges="orientation">

W kotlin to samo można osiągnąć programowo za pomocą poniżej

requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT

To działało dla mnie. Spróbuj dodać ten kod w pliku AndroidManifest

<application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:screenOrientation="portrait"
        android:theme="@style/AppTheme">
        ....
        ....
        </application>

Umieść to w swoim manifeście.

<activity
        android:name=".MainActivity"
        android:label="@string/app_name"
        android:screenOrientation="sensorPortrait" />

Orientacja będzie pionowa, ale jeśli telefon użytkownika jest odwrócony, pokazuje również prawidłową drogę. (Twój ekran będzie się obracał o 180 stopni).

System ignoruje ten atrybut, jeśli działanie działa w trybie wielu okien .

jeśli Twoja aktywność związana jest z pierwszym stanem orientacji urządzenia, uzyskaj bieżącą orientację urządzenia w onCreatemetodzie, a następnie napraw ją na zawsze:

        int deviceRotation = ((WindowManager) getBaseContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getOrientation();

        if(deviceRotation == Surface.ROTATION_0) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        }
        else if(deviceRotation == Surface.ROTATION_180)
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
        }
        else if(deviceRotation == Surface.ROTATION_90)
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        }
        else if(deviceRotation == Surface.ROTATION_270)
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
        }