java.lang.IllegalStateException: solo le attività opache a schermo intero possono richiedere l'orientamento

Sto affrontando il problema durante il recupero dei contatti dalla rubrica in Android 8.0 Oreo java.lang.IllegalStateException: solo le attività opache a schermo intero possono richiedere l'orientamento

Sto cercando di ottenere il contatto nella mia attività dalla rubrica del telefono e funziona perfettamente per Lollipop, Marshmallow, Nougat, ecc. Ma mi darà l'errore per Oreo come questo, per favore, aiutatemi. Il mio codice è qui sotto.

Codice demo: -

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

Registro errori: -

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

Il problema sembra verificarsi quando il tuo sdk di destinazione ha 28 anni. Quindi, dopo aver provato molte opzioni, alla fine ha funzionato.

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

stile:-

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

Nota: parent = "Theme.AppCompat.Light.NoActionBar" è necessario per api 28. Precedentemente aveva qualcos'altro su api 26. Funzionava alla grande ma ha iniziato a dare problemi a 28. Spero che aiuti qualcuno qui. EDIT: per alcuni solo impostando ha funzionato. <item name="android:windowIsTranslucent">false</item> and <item name="android:windowIsFloating">false</item> Potrebbe dipendere dal modo in cui implementa la soluzione. Nel mio caso ha funzionato impostandoli su true.

In Android Oreo (API 26) non è possibile modificare l'orientamento per attività che hanno stile nella riga inferiore

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

o

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

Hai diversi modi per risolvere questo:

1) Puoi semplicemente rimuovere le righe sopra (o trasformarle in false ) e la tua app funziona bene.

2) Oppure puoi prima rimuovere la riga sotto da manifest per quell'attività

android:screenOrientation="portrait"

Quindi devi aggiungere questa linea alla tua attività (in onCreate ())

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

3) Puoi crearne di nuovi styles.xmlnella values-v26cartella e aggiungerli al tuo style.xml. (Grazie al commento di AbdelHady )

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

In Android O e versioni successive questo errore si verifica quando si imposta

 android:screenOrientation="portrait"

in Manifest.

Rimuovi quella linea e usa

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

nella tua attività.

Questo risolverà il tuo problema.

Google lancia questa eccezione sul onCreatemetodo Activity dopo la v27, il loro significato è: se un'attività è traslucida o mobile, il suo orientamento dovrebbe essere affidato all'attività genitore (in background), non può prendere una decisione su se stesso.

Anche se rimuovi android:screenOrientation="portrait"dall'attività fluttuante o traslucida ma correggi l'orientamento sull'attività principale (in background), viene comunque corretto dal genitore, l'ho già testato.

Una situazione speciale: se rendi traslucido su un'attività di avvio, non ha un genitore (in background), quindi ruota sempre con il dispositivo. Vuoi risolverlo, devi prendere un altro modo per sostituire lo <item name="android:windowIsTranslucent">true</item>stile.

Se si utilizza un'attività trasparente a schermo intero, non è necessario specificare il blocco dell'orientamento sull'attività. Prenderanno le impostazioni di configurazione dell'attività principale. Quindi se l'attività del genitore ha nel manifest:

Android: screenOrientation = "ritratto"

la tua attività traslucida avrà lo stesso blocco dell'orientamento: ritratto.

Ho usato android:screenOrientation="behind"invece di android:screenOrientation="portrait". Fondamentalmente, hai creato una finestra di dialogo (in un'attività) e la finestra di dialogo non può richiedere l'orientamento da sola, per fare ciò è necessaria l'attività genitore (perché un genitore è visibile in background e ha il proprio layout).

"dietro" Lo stesso orientamento dell'attività immediatamente sottostante nello stack di attività.

L'unica soluzione che funziona davvero:

Modificare:

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

per:

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

in styles.xml

Ma questo potrebbe causare un problema con la tua schermata iniziale (schermata bianca all'avvio) ... In questo caso, aggiungi la seguente riga al tuo styles.xml:

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

appena sotto la finestra Linea trasparente.

Ultima possibilità se i suggerimenti precedenti non funzionano: scegli come target SDK 26 o 27.

Se devi usare setRequestedOrientation() , non c'è altro che sacrificare l'attributo windowIsTranslucent su Android 8.0

values\styles.xml per api livello 25- (<8.0)

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

values-v26\styles.xml per api livello 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 per api livello 27+ (> 8.0)

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

Molte persone hanno dato una soluzione, quindi parlerò della fonte del problema.

Secondo il registro delle eccezioni ：

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)

Il codice che ha attivato l'eccezione in 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;
        }

Secondo l'analisi del codice precedente, quando TargetSdkVersion> = 27, quando si utilizzano SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT e altri attributi correlati, l'uso degli attributi dell'argomento windowIsTranslucent, windowIsFloating e windowSwipeToDismiss attiverà un'eccezione.

Dopo aver riscontrato il problema, è possibile modificare TargetSdkVersion o rimuovere gli attributi correlati del tema in base alle proprie esigenze.

Non posso accettare la risposta più votata, perché

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

causa un errore

java.lang.IllegalStateException: solo le attività opache a schermo intero possono richiedere l'orientamento

ma questo fa funzionare per me

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

e utilizzalo per la tua attività, quando ti estendi

InterstitialActivity extends AppCompatActivity

in AndroidManifest.xml

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

Rimuovi questa riga android:screenOrientation="portrait" di attività in Manifiest.xml

Quell'attività otterrà l'orientamento dalla sua attività precedente, quindi non è necessario applicare l'orientamento che ha <item name="android:windowIsTranslucent">true</item>.

sembra quando target sdk è pie (api livello 28.0) e windowIsTranslucent è vero

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

e provi ad accedere all'orientamento. il problema arriva con Android oreo 8.0 (api livello 26) ci sono due modi per risolverlo

1. rimuovere l'orientamento
2. o imposta windowIsTranslucent su false

se stai impostando l'orientamento in manifest in questo modo

android:screenOrientation="portrait"

o in una classe di attività come questa

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

rimuovere la forma da entrambi i luoghi.

e osservato quando imposti windowIsTranslucent su true, prende l'orientamento dall'attività principale.

nel file manifest impostare la seconda attività parentActivityName come prima attività e rimuovere il parametro screenOrientation sulla seconda attività. significa che la tua prima attività è il genitore e decide di orientare la tua seconda attività.

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

Basta impostare l'orientamento dell'attività in Manifiest.xml

android:screenOrientation="unspecified"

O per limitato all'orientamento verticale

È inoltre possibile utilizzare in Attività, In onCreatemetodo chiamare prima super.onCreate(...)ad es

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

Ho avuto lo stesso problema e la mia soluzione era eliminare la linea

android:screenOrientation="portrait"

e quindi aggiungilo all'attività:

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

Dopo aver fatto qualche ricerca, sembra che questo problema possa essere dovuto a un bug di Google. Per me, sono stato in grado di lasciare questa riga nel mio metodo Attività onCreate:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

E ho cambiato il mio targetSdkVersion a 26. Avere quella linea nel mio onCreate ha comunque provocato un crash mentre il mio targetSdkVersion era ancora impostato su 27. Dal momento che nessun'altra soluzione ha funzionato per me finora, ho scoperto che questo funziona come una soluzione temporanea per adesso.

È un conflitto (bug) tra i temi all'interno del file style.xml nelle versioni Android 7 (livelli Api 24,25) e 8 (livelli api 26,27), quando hai

android:screenOrientation="portrait" : all'interno di un'attività specifica (che si arresta in modo anomalo) in AndroidManifest.xml

&

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

nel tema applicato a quell'attività all'interno di style.xml

Può essere risolto in questi modi in base alle tue necessità:

1- Rimuovere le proprietà sopra menzionate che creano conflitto

2- Cambia l'orientamento dell'attività in uno di questi valori di cui hai bisogno: unspecifiedo behindcosì via che puoi trovare qui: Riferimento Google per Android: screenOrientation `

3- Impostare l'orientamento a livello di codice in fase di esecuzione

Di recente ho affrontato il problema ed ecco la soluzione.

Non è necessario modificare il parametro di orientamento dello schermo impostato nel file manifest di Android.

Basta aggiungere due cartelle in

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

Quindi copia lì il tuo styles.xml e il file themes.xml.

e modifica i seguenti parametri da TRUE a FALSE.

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

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

Funzionerà.

Un bug comune di Android 8.0

Ho riscontrato questo problema solo nell'SDK 26 (8.0.0) se si utilizza windowIsTranslucent 'true' e si imposta con forza l'orientamento:

Ecco la soluzione:

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

Stavo ricevendo questo errore quando provavo a catturare un'immagine o a catturare un'immagine dalla galleria, ciò che funziona per me è rimuovere entrambi

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

e

android:screenOrientation="portrait"

ora la mia attività sta usando questo tema:

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

solo 8.0.0 genera l'eccezione, sopra 8.0 è stata rimossa l'eccezione

L'unica cosa che ha funzionato per me stava cambiando

android:screenOrientation="portrait"

per

android:screenOrientation="unspecified"

nel manifest per tutte le attività traslucide.

In questo modo è compatibile con tutte le versioni dell'API poiché l'attività traslucida sembra ereditare il suo orientamento dall'attività padre a partire da targetApi: 28.

Lo stile può essere lasciato com'è incluso <item name="android:windowIsTranslucent">true</item>.

Uso

android:screenOrientation="behind"

E tema

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

Non so se si tratta di un bug di Google o di un comportamento previsto, ma l'ho risolto (almeno momentaneamente) cambiando compileSkkVersion e targetSdkVersion di nuovo a 26 in Gradle ...

Se non hai risolto il tuo problema, registra l'attività dell'annuncio nel manifest in questo modo:

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

È inoltre necessario aggiornare all'ultima versione di sdk.

Probabilmente stai mostrando Attività simile a una finestra di dialogo (non a schermo intero), quindi rimuovi screenOrientation da Manifest o da codice. Questo risolverà il problema.

questo è successo dopo il 27, usa targetSdkVersion 26 sostituisci, attendi che google lo risolva

Ho appena rimosso i tag "ritratto" dagli elementi non a schermo intero e tutto è andato bene.

android:screenOrientation="portrait"

Controlla lo stile della tua attività e assicurati che se non stai utilizzando alcun elemento correlato a Translucent, modifica lo stile in alternato. In modo che possiamo risolvere questo problema.

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

Ho risolto questo problema rimuovendo android:screenOrientation="portrait"e aggiungendo il codice seguente nel mio onCreate

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

mentre le mie proprietà del tema sono

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