java.lang.IllegalStateException: solo las actividades opacas de pantalla completa pueden solicitar orientación

Estoy enfrentando el problema al recuperar los contactos de la libreta de contactos en Android 8.0 Oreo java.lang.IllegalStateException: solo las actividades opacas a pantalla completa pueden solicitar orientación

Estoy tratando de obtener el contacto en mi actividad de la guía telefónica y funciona perfecto para Lollipop, Marshmallow, Nougat, etc., pero me dará el error de Oreo como este, por favor, ayúdenme. Mi código está aquí abajo.

Código de demostración: -

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 de errores:-

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

El problema parece estar sucediendo cuando su SDK objetivo es 28. Entonces, después de probar muchas opciones, finalmente funcionó.

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

estilo:-

<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" es necesario para la API 28. Anteriormente tenía algo más en la API 26. Estaba funcionando muy bien pero comenzó a dar problemas a los 28. Espero que ayude a alguien aquí. EDITAR: para algunos solo estableciendo <item name="android:windowIsTranslucent">false</item> and <item name="android:windowIsFloating">false</item> trabajado . Puede depender de la forma en que implementa la solución funciona. En mi caso funcionó estableciéndolos en verdadero.

En Android Oreo (API 26) no puede cambiar la orientación de la actividad que tiene estilo debajo de la (s) línea (s)

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

o

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

Tienes varias formas de resolver esto:

1) Simplemente puede eliminar las líneas anteriores (o convertirlas en falsas ) y su aplicación funciona bien.

2) O puede eliminar primero la línea inferior del manifiesto para esa actividad

android:screenOrientation="portrait"

Luego debe agregar esta línea a su actividad (en onCreate ())

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

3) Puede crear nueva styles.xmlen la values-v26carpeta y agregar esto a su style.xml. (Gracias al comentario de AbdelHady )

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

En Android O y versiones posteriores, este error ocurre cuando configura

 android:screenOrientation="portrait"

en manifiesto.

Elimina esa línea y usa

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

en tu actividad

Esto solucionará tu problema.

Google lanza esta excepción en el onCreatemétodo de la Actividad después de la v27, su significado es: si una Actividad es translúcida o flotante, su orientación debe basarse en la Actividad principal (en segundo plano), no puede tomar una decisión sobre sí misma.

Incluso si elimina android:screenOrientation="portrait"de la Actividad flotante o translúcida, pero fija la orientación en su Actividad principal (de fondo), todavía está fijada por la principal, ya lo he probado.

Una situación especial: si hace que la actividad del iniciador sea translúcida, no tiene padre (fondo), así que siempre gire con el dispositivo. Si desea solucionarlo, debe tomar otra forma de reemplazar el <item name="android:windowIsTranslucent">true</item>estilo.

Si utiliza una actividad transparente a pantalla completa, no es necesario especificar el bloqueo de orientación de la actividad. Tomará la configuración de la actividad principal. Entonces, si la actividad principal tiene en el manifiesto:

android: screenOrientation = "retrato"

su actividad translúcida tendrá el mismo bloqueo de orientación: vertical.

Solía ​​en android:screenOrientation="behind"lugar de android:screenOrientation="portrait". Básicamente, creó un cuadro de diálogo (en una actividad) y el cuadro de diálogo no puede solicitar orientación por sí mismo, necesita actividad principal para hacerlo (porque un elemento primario es visible en el fondo y tiene su propio diseño).

"detrás" La misma orientación que la actividad que está inmediatamente debajo de ella en la pila de actividades.

La única solución que realmente funciona:

Cambio:

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

a:

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

en styles.xml

Pero esto podría provocar un problema con su pantalla de inicio (pantalla blanca al inicio) ... En este caso, agregue la siguiente línea a su styles.xml:

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

justo debajo de la ventana es una línea translúcida.

Última oportunidad si los consejos anteriores no funcionan: apunte SDK 26 en su lugar o 27.

Si tiene que usar setRequestedOrientation(), no hay otra forma que sacrificar el atributo windowIsTranslucent en Android 8.0

values\styles.xml para api nivel 25- (<8.0)

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

values-v26\styles.xml para el nivel 26 de la API (= 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 para el nivel de API 27+ (> 8.0)

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

Muchas personas han dado una solución, por lo que hablaré sobre la fuente del problema.

De acuerdo con el registro de excepciones:

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)

El código que activó la excepción en 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;
        }

De acuerdo con el análisis de código anterior, cuando TargetSdkVersion> = 27, cuando se usan SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT y otros atributos relacionados, el uso de los atributos de tema windowIsTranslucent, windowIsFloating y windowSwipeToDismiss desencadenará una excepción.

Una vez que se encuentra el problema, puede cambiar TargetSdkVersion o eliminar los atributos relacionados del tema según sus necesidades.

No puedo aceptar la respuesta más valorada, porque

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

causa un error

java.lang.IllegalStateException: solo las actividades opacas de pantalla completa pueden solicitar orientación

pero esto hace que funcione para mí

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

y úselo para su Actividad, cuando se extiende desde

InterstitialActivity extends AppCompatActivity

en AndroidManifest.xml

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

Simplemente elimine esta línea android:screenOrientation="portrait"de actividad en Manifiest.xml

Esa actividad obtendrá orientación de su actividad anterior, por lo que no es necesario aplicar la orientación que tiene <item name="android:windowIsTranslucent">true</item>.

parece que cuando el sdk objetivo es circular (nivel de API 28.0) y windowIsTranslucent es verdadero

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

e intentas acceder a la orientación. El problema viene con Android Oreo 8.0 (API nivel 26) Hay dos formas de resolver esto

1. eliminar la orientación
2. o establecer windowIsTranslucent en false

si está configurando orientación en manifiesto como este

android:screenOrientation="portrait"

o en una clase de actividad como esta

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

eliminar de ambos lugares.

y observado cuando configuras windowIsTranslucent en true, toma orientación de la actividad principal.

en el archivo de manifiesto, configure la segunda actividad parentActivityName como primera actividad y elimine el parámetro screenOrientation de la segunda actividad. significa que su primera actividad es el padre y decide una orientación de su segunda actividad.

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

Simplemente configure la orientación de la actividad en Manifiest.xml

android:screenOrientation="unspecified"

O para restringido a orientación vertical

También puede usar en Actividad, onCreateLlamada al método antes, super.onCreate(...)p. Ej.

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

Tuve el mismo problema y mi solución fue eliminar la línea.

android:screenOrientation="portrait"

y luego agregue esto en la actividad:

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

Después de investigar un poco, parece que este problema puede deberse a un error de Google. Para mí, pude dejar esta línea en mi método de Actividades en Crear:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Y cambié mi targetSdkVersion a 26. Tener esa línea en mi onCreate todavía resultó en un bloqueo mientras mi targetSdkVersion todavía estaba configurado en 27. Dado que la solución de nadie más me ha funcionado hasta ahora, descubrí que esto funciona como una solución temporal para ahora.

Es un conflicto (error) entre Temas dentro del archivo style.xml en las versiones de Android 7 (niveles de API 24,25) y 8 (niveles de API 26,27), cuando tiene

android:screenOrientation="portrait" : actividad específica interna (que se bloquea) en AndroidManifest.xml

Y

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

en el tema que se aplica a esa actividad dentro de style.xml

Se puede resolver de esta manera según su necesidad:

1- Eliminar una de las propiedades mencionadas anteriormente que hacen conflicto

2- Cambie la orientación de la actividad a uno de estos valores según lo necesite: unspecifiedo behindasí sucesivamente, que puede encontrar aquí: referencia de Google para Android: screenOrientation `

3- Establecer la orientación mediante programación en tiempo de ejecución

Recientemente me enfrenté al problema y aquí está la solución.

No es necesario cambiar el parámetro de orientación de la pantalla que configuró en el archivo de manifiesto de Android.

Simplemente agregue dos carpetas en

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

Luego copie su archivo styles.xml y themes.xml allí.

y cambie los siguientes parámetros de VERDADERO a FALSO.

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

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

Funcionará.

Un error común de Android 8.0

Enfrenté este problema solo en el SDK 26 (8.0.0) si utilicé windowIsTranslucent 'true' y establecí la orientación con fuerza:

Aquí está la solución:

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

Recibí este error cuando intento capturar una imagen o tomar una imagen de la galería, lo que funciona para mí es eliminar ambas

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

y

android:screenOrientation="portrait"

ahora mi actividad está usando este 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 arroja la excepción, por encima de 8.0 ha eliminado la excepción

Lo único que funcionó para mí fue cambiar

android:screenOrientation="portrait"

a

android:screenOrientation="unspecified"

en el manifiesto para todas las actividades translúcidas.

De esa manera, es compatible con todas las versiones de API, ya que la actividad translúcida parece heredar su orientación de la actividad principal a partir de targetApi: 28.

El estilo se puede dejar como está incluido <item name="android:windowIsTranslucent">true</item>.

Utilizar

android:screenOrientation="behind"

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

No sé si esto es un error de Google o un comportamiento previsto, pero (al menos momentáneamente) lo resolví cambiando compileSdkVersion y targetSdkVersion de nuevo a 26 en Gradle ...

Si no ha resuelto su problema, simplemente registre la actividad publicitaria en el manifiesto de esta manera:

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

También necesita actualizar a la última versión del SDK.

Probablemente esté mostrando la actividad como un cuadro de diálogo (no a pantalla completa), por lo tanto, elimine screenOrientation del manifiesto o del código. Esto solucionará el problema.

esto sucedió después del 27, use targetSdkVersion 26 replace, espere a que Google lo arregle

Acabo de eliminar las etiquetas "retrato" de los elementos que no son de pantalla completa y todo salió bien.

android:screenOrientation="portrait"

Verifique el estilo de su Actividad y asegúrese de que si no está usando ningún elemento relacionado con Translucent, cambie el estilo para alternar. Para que podamos solucionar este problema.

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

android:screenOrientation="portrait"Resolví este problema eliminando y agregué el siguiente código en mi onCreate

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

mientras que mis propiedades de tema son

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