java.lang.IllegalStateException: Tylko nieprzejrzyste działania na pełnym ekranie mogą żądać orientacji

Mam problem z odzyskiwaniem kontaktów z książki kontaktów w systemie Android 8.0 Oreo java.lang.IllegalStateException: Tylko nieprzejrzyste działania na pełnym ekranie mogą prosić o orientację

Próbuję uzyskać kontakt w mojej działalności z książki telefonicznej i działa idealnie dla Lollipop, Marshmallow, Nougat itp., Ale daje mi błąd dla Oreo w ten sposób, proszę, pomóż mi. Mój kod jest tutaj poniżej.

Kod demonstracyjny: -

private void loadContacts() {
            contactAsync = new ContactLoaderAsync();
            contactAsync.execute();
        }

        private class ContactLoaderAsync extends AsyncTask<Void, Void, Void> {
            private Cursor numCursor;

            @Override
            protected void onPreExecute() {
                super.onPreExecute();
                Uri numContacts = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;
                String[] numProjection = new String[]{ContactsContract.CommonDataKinds.Phone.CONTACT_ID, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME, ContactsContract.CommonDataKinds.Phone.NUMBER, ContactsContract.CommonDataKinds.Phone.TYPE};
                if (android.os.Build.VERSION.SDK_INT < 11) {
                    numCursor = InviteByContactActivity.this.managedQuery(numContacts, numProjection, null, null, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " COLLATE NOCASE ASC");
                } else {
                    CursorLoader cursorLoader = new CursorLoader(InviteByContactActivity.this, numContacts, numProjection, null, null, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " COLLATE NOCASE ASC");
                    numCursor = cursorLoader.loadInBackground();
                }

            }

            @Override
            protected Void doInBackground(Void... params) {
                if (numCursor.moveToFirst()) {
                    try {
                        final int contactIdIndex = numCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.CONTACT_ID);
                        final int displayNameIndex = numCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME);
                        final int numberIndex = numCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
                        final int typeIndex = numCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.TYPE);
                        String displayName, number, type;
                        do {
                            displayName = numCursor.getString(displayNameIndex);
                            number = numCursor.getString(numberIndex);
                            type = getContactTypeString(numCursor.getString(typeIndex), true);
                            final ContactModel contact = new ContactModel(displayName, type, number);
                            phoneNumber = number.replaceAll(" ", "").replaceAll("\\(", "").replaceAll("\\)", "").replaceAll("-", "");

                            if (phoneNumber != null || displayName != null) {
                                contacts.add(phoneNumber);
                                contactsName.add(displayName);
                                contactsChecked.add(false);

                                filterdNames.add(phoneNumber);
                                filterdContactNames.add(displayName);
                                filterdCheckedNames.add(false);
                            }
                        } while (numCursor.moveToNext());
                    } finally {
                        numCursor.close();
                    }
                }


                Collections.sort(contacts, new Comparator<String>() {
                    @Override
                    public int compare(String lhs, String rhs) {
                        return lhs.compareToIgnoreCase(rhs);
                    }
                });

                InviteByContactActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        mContactAdapter.notifyDataSetChanged();
                    }
                });

                return null;
            }
        }

        private String getContactTypeString(String typeNum, boolean isPhone) {
            String type = PHONE_TYPES.get(typeNum);
            if (type == null)
                return "other";
            return type;
        }

        static HashMap<String, String> PHONE_TYPES = new HashMap<String, String>();

        static {
            PHONE_TYPES.put(ContactsContract.CommonDataKinds.Phone.TYPE_HOME + "", "home");
            PHONE_TYPES.put(ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE + "", "mobile");
            PHONE_TYPES.put(ContactsContract.CommonDataKinds.Phone.TYPE_WORK + "", "work");
        }
}

Dziennik błędów: -

E/AndroidRuntime: FATAL EXCEPTION: main Process: com.example, PID: 6573
                                                             java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example/com.example.Activity.InviteByContactActivity}: java.lang.IllegalStateException: Only fullscreen opaque activities can request orientation
                                                              Caused by: java.lang.IllegalStateException: Only fullscreen opaque activities can request orientation

Problem wydaje się występować, gdy docelowy sdk ma 28 lat. Więc po wypróbowaniu wielu opcji w końcu to zadziałało.

<activity
            android:name=".activities.FilterActivity"
            android:theme="@style/Transparent"
            android:windowSoftInputMode="stateHidden|adjustResize" />

styl:-

<style name="Transparent" parent="Theme.AppCompat.Light.NoActionBar">
     <item name="android:windowIsTranslucent">true</item>
     <item name="android:windowBackground">@android:color/transparent</item>
     <item name="android:windowIsFloating">true</item>
     <item name="android:windowContentOverlay">@null</item>
     <item name="android:windowNoTitle">true</item>
     <item name="android:backgroundDimEnabled">false</item>
 </style>

Uwaga: rodzic = "Theme.AppCompat.Light.NoActionBar" jest potrzebny dla interfejsu API 28. Wcześniej miałem coś innego w interfejsie API 26. Działało świetnie, ale zaczęło dawać problemy w wieku 28 lat. Mam nadzieję, że to pomaga komuś tutaj. EDYCJA: W przypadku niektórych tylko ustawienie <item name="android:windowIsTranslucent">false</item> and <item name="android:windowIsFloating">false</item> działało. Może zależeć od sposobu wdrożenia rozwiązania. W moim przypadku działało, ustawiając je na true.

W Androidzie Oreo (API 26) nie można zmienić orientacji dla działania, które ma styl poniżej linii

 <item name="android:windowIsTranslucent">true</item>

lub

 <item name="android:windowIsFloating">true</item>

Istnieje kilka sposobów rozwiązania tego:

1) Możesz po prostu usunąć powyższe linie (lub zmienić je na false ), a aplikacja będzie działać poprawnie.

2) Lub możesz najpierw usunąć poniżej manifestu z manifestu dla tego działania

android:screenOrientation="portrait"

Następnie musisz dodać ten wiersz do swojej aktywności (w onCreate ())

    //android O fix bug orientation
    if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    }

3) Możesz utworzyć nowy styles.xmlw values-v26folderze i dodać go do swojego style.xml. (Dzięki komentarzowi AbdelHady )

 <item name="android:windowIsTranslucent">false</item>
 <item name="android:windowIsFloating">false</item>

W Androidzie O i później ten błąd występuje po ustawieniu

 android:screenOrientation="portrait"

w Manifeście.

Usuń tę linię i użyj

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

w twojej działalności.

To rozwiąże problem.

Google zgłasza ten wyjątek od onCreatemetody działania po wersji 27, ich znaczenie to: jeśli działanie jest półprzezroczyste lub zmiennoprzecinkowe, jego orientacja powinna opierać się na działaniu nadrzędnym (w tle), nie może samodzielnie podjąć decyzji.

Nawet jeśli usuniesz android:screenOrientation="portrait"z pływającego lub półprzezroczystego działania, ale naprawisz orientację na jego działaniu nadrzędnym (w tle), nadal jest to ustalone przez rodzica, co już przetestowałem.

Jedna szczególna sytuacja: jeśli uczynisz półprzezroczystym działaniem programu uruchamiającego, nie będzie ono nadrzędne (w tle), więc zawsze obracaj z urządzeniem. Chcesz to naprawić, musisz wziąć inny sposób na zastąpienie <item name="android:windowIsTranslucent">true</item>stylu.

Jeśli używasz przezroczystego działania na pełnym ekranie, nie ma potrzeby określania blokady orientacji dla działania. To zajmie ustawienia konfiguracji działania nadrzędnego. Więc jeśli aktywność rodzica ma w manifeście:

android: screenOrientation = "portret"

twoja przezroczysta aktywność będzie miała tę samą blokadę orientacji: portret.

Użyłem android:screenOrientation="behind"zamiast android:screenOrientation="portrait". Zasadniczo utworzyłeś okno dialogowe (w działaniu) i okno dialogowe nie może samodzielnie zażądać orientacji, aby to zrobić, wymaga działania rodzica (ponieważ rodzic jest widoczny w tle i ma własny układ).

„z tyłu” Taka sama orientacja, jak aktywność bezpośrednio pod nią w stosie aktywności.

Jedyne rozwiązanie, które naprawdę działa:

Zmiana:

<item name="android:windowIsTranslucent">true</item>

do:

<item name="android:windowIsTranslucent">false</item>

w styles.xml

Może to jednak powodować problem z ekranem powitalnym (biały ekran podczas uruchamiania) ... W takim przypadku dodaj następujący wiersz do pliku styles.xml:

 <item name="android:windowDisablePreview">true</item> 

tuż pod linią windowIsTranslucent.

Ostatnia szansa, jeśli poprzednie wskazówki nie działają: docelowy zestaw SDK 26 zamiast o 27.

Jeśli musisz użyć setRequestedOrientation(), nie ma innej możliwości, niż poświęcić atrybut windowIsTranslucent na Androidzie 8.0

values\styles.xml dla poziomu API 25- (<8,0)

<style name="Base.Theme.DesignDemo" parent="Base.Theme.AppCompat.Light">
        ...
        <item name="android:windowIsTranslucent">true</item>
        ...
    </style>

values-v26\styles.xml dla interfejsu API poziomu 26 (= 8,0)

<style name="Base.Theme.DesignDemo" parent="Base.Theme.AppCompat.Light">
    ...
    <!-- android 8.0(api26)，Only fullscreen opaque activities can request orientation -->
    <item name="android:windowIsTranslucent">false</item>
    ...
</style>

values-v27\styles.xml dla interfejsu API na poziomie 27+ (> 8,0)

<style name="Base.Theme.DesignDemo" parent="Base.Theme.AppCompat.Light">
    ...
    <item name="android:windowIsTranslucent">true</item>
    ...
</style>

Wiele osób naprawiło problem, więc opowiem o źródle problemu.

Zgodnie z logiem wyjątków ：

Caused by: java.lang.IllegalStateException: Only fullscreen opaque activities can request orientation
    at android.app.Activity.onCreate(Activity.java:1081)
    at android.support.v4.app.SupportActivity.onCreate(SupportActivity.java:66)
    at android.support.v4.app.FragmentActivity.onCreate(FragmentActivity.java:297)
    at android.support.v7.app.AppCompatActivity.onCreate(AppCompatActivity.java:84)
    at com.nut.blehunter.ui.DialogContainerActivity.onCreate(DialogContainerActivity.java:43)
    at android.app.Activity.performCreate(Activity.java:7372)
    at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1218)
    at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:3147)
    at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:3302) 
    at android.app.ActivityThread.-wrap12(Unknown Source:0) 
    at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1891) 
    at android.os.Handler.dispatchMessage(Handler.java:108) 
    at android.os.Looper.loop(Looper.java:166)

Kod, który wywołał wyjątek w Activity.java

    //Need to pay attention mActivityInfo.isFixedOrientation() and ActivityInfo.isTranslucentOrFloating(ta)
    if (getApplicationInfo().targetSdkVersion >= O_MR1 && mActivityInfo.isFixedOrientation()) {
        final TypedArray ta = obtainStyledAttributes(com.android.internal.R.styleable.Window);
        final boolean isTranslucentOrFloating = ActivityInfo.isTranslucentOrFloating(ta);
        ta.recycle();

        //Exception occurred
        if (isTranslucentOrFloating) {
            throw new IllegalStateException(
                    "Only fullscreen opaque activities can request orientation");
        }
    }

mActivityInfo.isFixedOrientation () ：

        /**
        * Returns true if the activity's orientation is fixed.
        * @hide
        */
        public boolean isFixedOrientation() {
            return isFixedOrientationLandscape() || isFixedOrientationPortrait()
                    || screenOrientation == SCREEN_ORIENTATION_LOCKED;
        }
        /**
        * Returns true if the activity's orientation is fixed to portrait.
        * @hide
        */
        boolean isFixedOrientationPortrait() {
            return isFixedOrientationPortrait(screenOrientation);
        }

        /**
        * Returns true if the activity's orientation is fixed to portrait.
        * @hide
        */
        public static boolean isFixedOrientationPortrait(@ScreenOrientation int orientation) {
            return orientation == SCREEN_ORIENTATION_PORTRAIT
                    || orientation == SCREEN_ORIENTATION_SENSOR_PORTRAIT
                    || orientation == SCREEN_ORIENTATION_REVERSE_PORTRAIT
                    || orientation == SCREEN_ORIENTATION_USER_PORTRAIT;
        }

        /**
        * Determines whether the {@link Activity} is considered translucent or floating.
        * @hide
        */
        public static boolean isTranslucentOrFloating(TypedArray attributes) {
            final boolean isTranslucent = attributes.getBoolean(com.android.internal.R.styleable.Window_windowIsTranslucent, false);
            final boolean isSwipeToDismiss = !attributes.hasValue(com.android.internal.R.styleable.Window_windowIsTranslucent)
                                            && attributes.getBoolean(com.android.internal.R.styleable.Window_windowSwipeToDismiss, false);
            final boolean isFloating = attributes.getBoolean(com.android.internal.R.styleable.Window_windowIsFloating, false);
            return isFloating || isTranslucent || isSwipeToDismiss;
        }

Zgodnie z powyższą analizą kodu, gdy TargetSdkVersion> = 27, przy użyciu SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT i innych powiązanych atrybutów, użycie atrybutów tematu windowIsTranslucent, windowIsFloating i windowSwipeToDismiss spowoduje wyjątek.

Po znalezieniu problemu możesz zmienić TargetSdkVersion lub usunąć powiązane atrybuty kompozycji zgodnie z własnymi potrzebami.

Nie mogę zgodzić się na najbardziej ocenianą odpowiedź, ponieważ

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

powoduje błąd

java.lang.IllegalStateException: Tylko nieprzejrzyste działania na pełnym ekranie mogą żądać orientacji

ale to sprawia, że ​​to działa dla mnie

<style name="TranslucentTheme" parent="@style/Theme.AppCompat.Light.NoActionBar">
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowActionBar">false</item>
    <item name="android:windowFullscreen">true</item>
    <item name="android:windowContentOverlay">@null</item>
</style>

i używaj go do swojej Aktywności, kiedy się rozwijasz

InterstitialActivity extends AppCompatActivity

w AndroidManifest.xml

    <activity
        android:name=".InterstitialActivity"
        ...
        android:screenOrientation="portrait"
        android:theme="@style/TranslucentTheme" />

Po prostu usuń tę linię android:screenOrientation="portrait"aktywności z Manifiest.xml

Ta aktywność uzyska orientację na podstawie poprzedniej aktywności, więc nie ma potrzeby stosowania orientacji, która ma <item name="android:windowIsTranslucent">true</item>.

wydaje się, gdy docelowym SDK jest pie (poziom interfejsu API 28.0), a parametr WindowIsTranslucent ma wartość true

<item name="android:windowIsTranslucent">true</item>

i próbujesz uzyskać dostęp do orientacji. problem pochodzi z Androida oreo 8.0 (api poziom 26) istnieją dwa sposoby na rozwiązanie tego

1. usuń orientację
2. lub ustaw windowIsTranslucent na false

jeśli ustawiasz orientację w taki sposób

android:screenOrientation="portrait"

lub w klasie aktywności takiej jak ta

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

usuń z obu miejsc.

i obserwowane, gdy ustawisz windowIsTranslucent na true, pobiera orientację od aktywności rodzica.

w pliku manifestu ustaw drugie działanie parentActivityName jako pierwsze działanie i usuń parametr screenOrientation do drugiego działania. oznacza to, że twoja pierwsza aktywność jest rodzicem i decydujesz o orientacji drugiej aktywności.

<activity
        android:name=".view.FirstActiviy"
        android:screenOrientation="portrait"
        android:theme="@style/AppTheme" />

<activity
        android:name=".view.SecondActivity"
        android:parentActivityName=".view.FirstActiviy"
        android:theme="@style/AppTheme.Transparent" />

Wystarczy ustawić orientację aktywności w pliku Manifiest.xml

android:screenOrientation="unspecified"

LUB dla ograniczonego do orientacji pionowej

Możesz także użyć w działaniu, w onCreatewywołaniu metody przed super.onCreate(...)np

@Override
    protected void onCreate(Bundle savedInstanceState) {
        setOrientation(this);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.your_xml_layout);
        //...
        //...
}

// Method 
public static void setOrientation(Activity context) {
   if (android.os.Build.VERSION.SDK_INT == Build.VERSION_CODES.O)
        context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
      else
        context.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

Miałem ten sam problem, a moim rozwiązaniem było wyeliminowanie linii

android:screenOrientation="portrait"

a następnie dodaj to do działania:

if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

Po przeprowadzeniu niektórych badań wydaje się, że ten problem może wynikać z błędu Google. Dla mnie udało mi się zostawić ten wiersz w metodzie działań w funkcji OnCreate:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

ORAZ zmieniłem celSdkVersion na 26. Posiadanie tej linii w moim onCreate wciąż powodowało awarię, podczas gdy mój obiekt targetSdkVersion wciąż był ustawiony na 27. Ponieważ jak dotąd żadne rozwiązanie dla mnie nie działało, stwierdziłem, że działa to jako tymczasowa poprawka dla teraz.

Jest to konflikt (błąd) między motywami w pliku style.xml w wersjach Androida 7 (poziomy API 24,25) i 8 (poziomy API 26, 27), gdy masz

android:screenOrientation="portrait" : wewnątrz określonej aktywności (która ulega awarii) w AndroidManifest.xml

I

<item name="android:windowIsTranslucent">true</item> 

w motywie zastosowanym do tej aktywności w style.xml

Można go rozwiązać w następujący sposób, w zależności od potrzeb:

1- Usuń z wyżej wymienionych właściwości, które powodują konflikt

2- orientacja aktywność Zmiana jednej z tych wartości, jak trzeba: unspecifiedalbo behindi tak dalej, które można znaleźć tutaj: odniesienie Google dla Androida: screenOrientation `

3- Ustaw programowo orientację w czasie wykonywania

Ostatnio stanąłem przed problemem i oto rozwiązanie.

Nie trzeba zmieniać parametru orientacji ekranu ustawionego w pliku manifestu Androida.

Po prostu dodaj dwa foldery

res>values
as  res>values-v26 
and res>values-v27

Następnie skopiuj tam plik styles.xml i themes.xml.

i zmień następujące parametry z PRAWDA na FAŁSZ.

<item name="android:windowIsTranslucent">true</item>

<item name="android:windowIsTranslucent">false</item>

To będzie działać.

Typowy błąd Androida 8.0

Problem ten napotkałem tylko w zestawie SDK 26 (8.0.0), jeśli korzystam z WindowIsTranslucent „true” i wymuszam ustawienie orientacji:

Oto rozwiązanie:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_splash);   

        // fixing portrait mode problem for SDK 26 if using windowIsTranslucent = true
        if (Build.VERSION.SDK_INT == 26) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
        } else {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        }        
    }



       <style name="SplashActivty" parent="AppTheme">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowNoTitle">true</item>
    </style>



<!-- Splash screen -->
        <activity
            android:name="edu.aku.family_hifazat.activities.SplashActivity"
            android:label="@string/app_name"
            android:screenOrientation="unspecified"
            android:theme="@style/SplashActivty">

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

        </activity>

Ten błąd pojawiał się podczas próby przechwycenia obrazu lub zrobienia zdjęcia z galerii. Dla mnie najlepszym rozwiązaniem jest usunięcie obu

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

i

android:screenOrientation="portrait"

teraz moja aktywność korzysta z tego motywu:

  <style name="Transparent" parent="Theme.AppCompat.Light.NoActionBar">
        <item name="android:windowNoTitle">true</item>
        <item name="android:windowBackground">@android:color/transparent</item>
        <item name="android:colorBackgroundCacheHint">@null</item>
        <item name="android:windowAnimationStyle">@android:style/Animation</item>
        <item name="android:windowIsTranslucent">false</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowIsFloating">true</item>
        <item name="android:backgroundDimEnabled">false</item>
    </style>

tylko 8.0.0 zgłasza wyjątek, powyżej 8.0 usunął wyjątek

Jedyną rzeczą, która działała dla mnie, była zmiana

android:screenOrientation="portrait"

do

android:screenOrientation="unspecified"

w manifeście dla wszystkich półprzezroczystych czynności.

W ten sposób jest kompatybilny ze wszystkimi wersjami API, ponieważ przezroczyste działanie zdaje się dziedziczyć swoją orientację od działania nadrzędnego z dnia targetApi: 28.

Styl można pozostawić bez zmian <item name="android:windowIsTranslucent">true</item>.

Posługiwać się

android:screenOrientation="behind"

I motyw

<style name="translucent" parent="Theme.AppCompat.Light.NoActionBar">
    <item name="android:windowBackground">#beaaaaaa</item>
    <item name="android:windowIsTranslucent">true</item>
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowAnimationStyle">@android:style/Animation</item>
    <item name="android:typeface">normal</item>
    <item name="android:windowSoftInputMode">adjustPan</item>
    <item name="windowActionBar">false</item>
</style>

Nie wiem, czy jest to błąd Google, czy zamierzone zachowanie, ale (przynajmniej chwilowo) rozwiązałem go, zmieniając compileSdkVersion i targetSdkVersion z powrotem na 26 w gradle ...

Jeśli problem nie został rozwiązany, po prostu zarejestruj aktywność reklamy w manifeście w następujący sposób:

<activity
android:name="com.google.android.gms.ads.AdActivity"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
tools:replace="android:theme"
 />

Musisz także zaktualizować do najnowszej wersji SDK.

Prawdopodobnie wyświetlasz Aktywność przypominającą okno dialogowe (nie na pełnym ekranie), więc usuń screenOrientation z Manifestu lub z kodu. To rozwiąże problem.

stało się to po 27, użyj targetSdkVersion 26 zamień, poczekaj, aż go naprawi

Właśnie usunąłem tagi „portret” z elementów pełnoekranowych i wszystko poszło dobrze.

android:screenOrientation="portrait"

Sprawdź styl swojej działalności i upewnij się, że nie używasz żadnych rzeczy związanych z przezroczystością, zmień styl na alternatywny. Abyśmy mogli rozwiązać ten problem.

android:theme="@android:style/Theme.Translucent.NoTitleBar.Fullscreen"
android:theme="@android:style/Theme.NoTitleBar.Fullscreen"

Rozwiązałem ten problem, usuwając android:screenOrientation="portrait"i dodając poniższy kod do mojego onCreate

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
}

podczas gdy moje właściwości motywu są

<item name="android:windowIsTranslucent">true</item>
<item name="android:windowDisablePreview">true</item>