java.lang.IllegalStateException: seules les activités opaques en plein écran peuvent demander une orientation

Je suis confronté au problème lors de la récupération des contacts du carnet de contacts dans Android 8.0 Oreo java.lang.IllegalStateException: seules les activités opaques en plein écran peuvent demander une orientation

J'essaie d'obtenir le contact dans mon activité à partir du répertoire téléphonique et cela fonctionne parfaitement pour Lollipop, Marshmallow, Nougat, etc. mais cela me donnera l'erreur pour Oreo comme ça, aidez-moi. Mon code est ci-dessous.

Code démo: -

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

Journal des erreurs: -

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

Le problème semble se produire lorsque votre SDK cible est de 28. Donc, après avoir essayé de nombreuses options, cela a finalement fonctionné.

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

style:-

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

Remarque: parent = "Theme.AppCompat.Light.NoActionBar" est nécessaire pour l'api 28. Auparavant, il y avait autre chose à api 26. Cela fonctionnait très bien mais a commencé à poser problème à 28. J'espère que cela aide quelqu'un ici. EDIT: Pour certains seulement en définissant <item name="android:windowIsTranslucent">false</item> and <item name="android:windowIsFloating">false</item> travaillé.Peut-être dépend de la façon dont vous implémentez la solution fonctionne.Dans mon cas, cela a fonctionné en les mettant à true

Dans Android Oreo (API 26), vous ne pouvez pas changer l'orientation des activités qui ont une ou plusieurs lignes en dessous de style

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

ou

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

Vous avez plusieurs façons de résoudre ce problème:

1) Vous pouvez simplement supprimer la (les) ligne (s) ci-dessus (ou la définir sur false ) et votre application fonctionne correctement.

2) Ou vous pouvez d'abord supprimer la ligne ci-dessous du manifeste pour cette activité

android:screenOrientation="portrait"

Ensuite, vous devez ajouter cette ligne à votre activité (dans onCreate ())

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

3) Vous pouvez créer styles.xmldans le values-v26dossier et l' ajouter à votre style.xml. (Merci au commentaire d' AbdelHady )

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

Dans Android O et versions ultérieures, cette erreur se produit lorsque vous définissez

 android:screenOrientation="portrait"

dans Manifest.

Supprimez cette ligne et utilisez

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

dans votre activité.

Cela résoudra votre problème.

Google lève cette exception sur la onCreateméthode Activity après la version 27, leur signification est: si une activité est translucide ou flottante, son orientation doit être basée sur l'activité parent (arrière-plan), ne peut pas prendre de décision sur elle-même.

Même si vous supprimez android:screenOrientation="portrait"de l'activité flottante ou translucide mais que vous fixez l'orientation sur son activité parent (arrière-plan), elle est toujours fixée par le parent, j'ai déjà testé.

Une situation particulière: si vous rendez translucide sur une activité de lanceur, elle n'a pas de parent (arrière-plan), alors faites toujours pivoter avec l'appareil. Vous voulez le réparer, vous devez prendre une autre façon de remplacer le <item name="android:windowIsTranslucent">true</item>style.

Si vous utilisez une activité transparente plein écran, il n'est pas nécessaire de spécifier le verrou d'orientation sur l'activité. Il prendra les paramètres de configuration de l'activité parent. Donc, si l'activité parent a dans le manifeste:

android: screenOrientation = "portrait"

votre activité translucide aura le même verrou d'orientation: portrait.

J'ai utilisé à la android:screenOrientation="behind"place de android:screenOrientation="portrait". Fondamentalement, vous avez créé une boîte de dialogue (dans une activité) et la boîte de dialogue ne peut pas demander l'orientation par elle-même, elle a besoin d'une activité parent pour le faire (car un parent est visible en arrière-plan et a sa propre mise en page).

"derrière" La même orientation que l'activité qui se trouve immédiatement en dessous dans la pile d'activités.

La seule solution qui fonctionne vraiment:

Changement:

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

à:

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

dans styles.xml

Mais cela peut induire un problème avec votre écran de démarrage (écran blanc au démarrage) ... Dans ce cas, ajoutez la ligne suivante à votre styles.xml:

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

juste en dessous de la ligne windowIsTranslucent.

Dernière chance si les astuces précédentes ne fonctionnent pas: ciblez SDK 26 à la place o 27.

Si vous devez utiliser setRequestedOrientation(), il n'y a pas d'autre moyen que de sacrifier l'attribut windowIsTranslucent sur Android 8.0

values\styles.xml pour le niveau 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 pour api niveau 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 pour api niveau 27+ (> 8,0)

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

Beaucoup de gens ont donné une solution, je vais donc parler de la source du problème.

Selon le journal des exceptions ：

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)

Le code qui a déclenché l'exception dans 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;
        }

Selon l'analyse de code ci-dessus, lorsque TargetSdkVersion> = 27, lors de l'utilisation des attributs de rubrique SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT et d'autres attributs associés, l'utilisation des attributs de rubrique windowIsTranslucent, windowIsFloating et windowSwipeToDismiss déclenchera une exception.

Une fois le problème détecté, vous pouvez modifier TargetSdkVersion ou supprimer les attributs associés du thème en fonction de vos besoins.

Je ne peux pas accepter la réponse la plus notée, car

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

provoque une erreur

java.lang.IllegalStateException: seules les activités opaques en plein écran peuvent demander une orientation

mais cela fonctionne pour moi

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

et utilisez-le pour votre activité, lorsque vous

InterstitialActivity extends AppCompatActivity

dans AndroidManifest.xml

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

Supprimez simplement cette ligne android:screenOrientation="portrait"d'activité dans Manifiest.xml

Cette activité obtiendra une orientation de son activité précédente, donc pas besoin d'appliquer l'orientation qui a <item name="android:windowIsTranslucent">true</item>.

il semble que le sdk cible est à tarte (niveau de l'API 28.0) et que windowIsTranslucent est vrai

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

et vous essayez d'accéder à l'orientation. problème vient avec android oreo 8.0 (api niveau 26) il y a deux façons de résoudre ce problème

1. supprimer l'orientation
2. ou définissez windowIsTranslucent sur false

si vous définissez l'orientation dans un manifeste comme celui-ci

android:screenOrientation="portrait"

ou en classe d'activités comme celle-ci

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

supprimer des deux endroits.

et observé lorsque vous définissez windowIsTranslucent sur true, il prend l'orientation de l'activité parent.

dans le fichier manifeste, définissez la deuxième activité parentActivityName comme première activité et supprimez le paramètre screenOrientation de la deuxième activité. cela signifie que votre première activité est le parent et décidez d'une orientation de votre deuxième activité.

<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" />

Définissez simplement l'orientation de l'activité dans Manifiest.xml

android:screenOrientation="unspecified"

OU pour restreint à l'orientation portrait

Vous pouvez également utiliser dans Activity, In onCreatemethod call avant super.onCreate(...)eg

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

J'ai eu le même problème, et ma solution était d'éliminer la ligne

android:screenOrientation="portrait"

puis ajoutez ceci dans l'activité:

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

Après quelques recherches, il semble que ce problème soit dû à un bug de Google. Pour moi, j'ai pu laisser cette ligne dans ma méthode Activities onCreate:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

ET j'ai changé ma targetSdkVersion à 26. Avoir cette ligne dans mon onCreate entraînait toujours un plantage alors que ma targetSdkVersion était toujours définie à 27. Puisque la solution de personne d'autre n'a fonctionné pour moi jusqu'à présent, j'ai trouvé que cela fonctionne comme une solution temporaire pour maintenant.

Il s'agit d'un conflit (bogue) entre les thèmes à l'intérieur du fichier style.xml dans les versions Android 7 (niveaux Api 24,25) et 8 (niveaux api 26,27), lorsque vous avez

android:screenOrientation="portrait" : à l'intérieur d'une activité spécifique (qui plante) dans AndroidManifest.xml

&

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

dans le thème qui s'appliquait à cette activité dans style.xml

Il peut être résolu de ces manières en fonction de vos besoins:

1- Supprimer l'une des propriétés mentionnées ci-dessus qui créent des conflits

2- Changez l'orientation de l'activité sur l'une de ces valeurs selon vos besoins: unspecifiedou behindet ainsi de suite que vous pouvez trouver ici: référence Google pour Android: screenOrientation `

3- Définir l'orientation par programmation en temps d'exécution

Utilisation

android:screenOrientation="behind"

Et thème

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

J'ai récemment fait face au problème et voici la solution.

Pas besoin de modifier le paramètre d'orientation de l'écran que vous définissez dans le fichier manifeste Android.

Ajoutez simplement deux dossiers dans

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

Copiez ensuite votre fichier styles.xml et themes.xml ici.

et modifiez les paramètres suivants de TRUE à FALSE.

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

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

Ça va marcher.

Un bogue commun d'Android 8.0

J'ai rencontré ce problème uniquement dans le SDK 26 (8.0.0) si vous utilisez windowIsTranslucent `` true '' et définissez l'orientation avec force:

Voici la solution:

    @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>

J'obtenais cette erreur lorsque j'essayais de capturer une image ou de prendre une image de la galerie, ce qui fonctionne pour moi est de supprimer les deux

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

et

android:screenOrientation="portrait"

maintenant mon activité utilise ce thème:

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

seulement 8.0.0 lance l'exception, au-dessus de 8.0 a supprimé l'exception

La seule chose qui a fonctionné pour moi a été de changer

android:screenOrientation="portrait"

à

android:screenOrientation="unspecified"

dans le manifeste pour toutes les activités translucides.

De cette façon, il est compatible avec toutes les versions d'API puisque l'activité translucide semble hériter de son orientation de l'activité parente à partir du targetApi: 28.

Le style peut être laissé tel quel <item name="android:windowIsTranslucent">true</item>.

Je ne sais pas s'il s'agit d'un bogue de Google ou d'un comportement prévu mais je l'ai (au moins momentanément) résolu en remettant compileSdkVersion et targetSdkVersion à 26 dans Gradle ...

Si vous n'avez pas résolu votre problème, enregistrez simplement l'activité publicitaire dans le manifeste comme suit:

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

Vous devez également mettre à jour la dernière version du sdk.

Vous affichez probablement une activité ressemblant à une boîte de dialogue (non plein écran), supprimez donc screenOrientation du manifeste ou du code. Cela résoudra le problème.

cela s'est produit après 27, utilisez targetSdkVersion 26 remplacer, attendez que Google le corrige

Je viens de supprimer les balises "portrait" des éléments non plein écran et tout s'est bien passé.

android:screenOrientation="portrait"

Veuillez vérifier le style de votre activité et assurez-vous que si vous n'utilisez pas d'éléments liés à Translucent, changez le style pour alterner. Afin que nous puissions résoudre ce problème.

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

J'ai résolu ce problème en supprimant android:screenOrientation="portrait"et en ajoutant le code ci-dessous dans mon onCreate

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

tandis que mes propriétés de thème sont

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