java.lang.IllegalStateException: Somente atividades opacas em tela cheia podem solicitar orientação

Estou enfrentando o problema ao recuperar os contatos do catálogo de contatos no Android 8.0 Oreo java.lang.IllegalStateException: Somente atividades opacas de tela cheia podem solicitar orientação

Estou tentando obter o contato da minha atividade na lista de contatos telefônicos e funciona perfeitamente para pirulito, marshmallow, nougat, etc. Meu código está aqui abaixo.

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

Log de erro: -

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

O problema parece estar acontecendo quando seu sdk de destino é 28. Então, depois de experimentar muitas opções, finalmente funcionou.

<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" é necessário para a API 28. Anteriormente, havia outra coisa na API 26. Estava funcionando muito bem, mas começou a dar problemas aos 28. Espero que ajude alguém aqui. EDIT: Para alguns, apenas configurando o trabalho. <item name="android:windowIsTranslucent">false</item> and <item name="android:windowIsFloating">false</item> Pode depender da maneira como você implementa a solução. No meu caso, funcionou definindo-os como true.

No Android Oreo (API 26), você não pode alterar a orientação da Atividade que possui linhas abaixo do estilo

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

ou

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

Você tem várias maneiras de resolver isso:

1) Você pode simplesmente remover as linhas acima (ou transformá-lo em falso ) e seu aplicativo funciona bem.

2) Ou você pode primeiro remover a linha abaixo do manifesto para essa atividade

android:screenOrientation="portrait"

Então você deve adicionar esta linha à sua atividade (em onCreate ())

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

3) Você pode criar um novo styles.xmlna values-v26pasta e adicioná-lo ao seu style.xml. (Obrigado ao comentário de AbdelHady )

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

No Android O e posterior, esse erro ocorre quando você define

 android:screenOrientation="portrait"

no manifesto.

Remova essa linha e use

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

em sua atividade.

Isso resolverá o seu problema.

O Google lança essa exceção no onCreatemétodo Activity após a v27, o significado é: se uma Activity é translúcida ou flutuante, sua orientação deve ser baseada na Atividade pai (em segundo plano), não pode tomar uma decisão.

Mesmo se você remover android:screenOrientation="portrait"da Atividade flutuante ou translúcida, mas fixar a orientação na Atividade pai (em segundo plano), ela ainda será corrigida pelo pai, eu já testei.

Uma situação especial: se você tornar translúcido em uma Atividade do iniciador, ela não tem pai (plano de fundo); portanto, sempre gire com o dispositivo. Deseja corrigi-lo, você precisa seguir outra maneira de substituir o <item name="android:windowIsTranslucent">true</item>estilo.

Se você usar uma atividade transparente em tela cheia, não será necessário especificar o bloqueio de orientação na atividade. Serão necessárias as definições de configuração da atividade pai. Portanto, se a atividade pai tiver no manifesto:

android: screenOrientation = "portrait"

sua atividade translúcida terá o mesmo bloqueio de orientação: retrato.

Eu usei em android:screenOrientation="behind"vez de android:screenOrientation="portrait". Basicamente, você criou um diálogo (em uma atividade) e o diálogo não pode solicitar orientação por si só; ele precisa da atividade pai para fazer isso (porque um pai é visível em segundo plano e possui layout próprio).

"behind" A mesma orientação que a atividade imediatamente abaixo dela na pilha de atividades.

A única solução que realmente funciona:

Mudança:

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

para:

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

em styles.xml

Mas isso pode induzir um problema na tela inicial (tela branca na inicialização) ... Nesse caso, adicione a seguinte linha ao seu styles.xml:

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

logo abaixo da linha windowIsTranslucent.

Última chance, se as dicas anteriores não funcionarem: segmente o SDK 26 em vez de 27.

Se você precisar usar setRequestedOrientation(), não há como sacrificar o atributo windowIsTranslucent no Android 8.0

values\styles.xml para API nível 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 API nível 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 para api nível 27+ (> 8.0)

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

Muitas pessoas deram uma correção, então eu vou falar sobre a fonte do problema.

De acordo com o log de exceção:

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)

O código que acionou a exceção no 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 acordo com a análise de código acima, quando TargetSdkVersion> = 27, ao usar SCREEN_ORIENTATION_LANDSCAPE, SCREEN_ORIENTATION_PORTRAIT e outros atributos relacionados, o uso dos atributos de tópico windowIsTranslucent, windowIsFloating e windowSwipeToDismiss acionará uma exceção.

Depois que o problema for encontrado, você poderá alterar a TargetSdkVersion ou remover os atributos relacionados do tema de acordo com suas necessidades.

Não posso concordar com a resposta mais classificada, porque

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

causa um erro

java.lang.IllegalStateException: Somente atividades opacas em tela cheia podem solicitar orientação

mas isso faz funcionar para mim

<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 use-o para sua Atividade, quando você se estende de

InterstitialActivity extends AppCompatActivity

no AndroidManifest.xml

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

Basta remover esta linha android:screenOrientation="portrait"de atividade no Manifiest.xml

Essa atividade receberá orientação de sua atividade anterior, portanto, não é necessário aplicar a orientação necessária <item name="android:windowIsTranslucent">true</item>.

parece que o destino sdk é torta (api nível 28.0) e windowIsTranslucent é true

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

e você tenta acessar a orientação. problema vem com o Android oreo 8.0 (api nível 26), existem duas maneiras de resolver isso

1. remova a orientação
2. ou defina windowIsTranslucent como false

se você estiver definindo uma orientação em manifesto como este

android:screenOrientation="portrait"

ou em classe de atividade como esta

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

remova o formulário dos dois lugares.

e observado quando você define windowIsTranslucent como true, ele recebe orientação da atividade pai.

no arquivo de manifesto, defina a segunda atividade parentActivityName como primeira atividade e remova o parâmetro screenOrientation para a segunda atividade. isso significa que sua primeira atividade é a mãe e decide uma orientação para sua segunda atividade.

<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 definir a orientação da atividade no Manifiest.xml

android:screenOrientation="unspecified"

OU para restrito à orientação retrato

Você também pode usar a onCreatechamada de método Activity, In antes, super.onCreate(...)por exemplo,

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

Eu tive o mesmo problema e minha solução foi eliminar a linha

android:screenOrientation="portrait"

e adicione isso na atividade:

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

Depois de fazer algumas pesquisas, parece que esse problema pode ser devido a um bug do google. Para mim, consegui deixar essa linha no meu método Activities onCreate:

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

E mudei minha targetSdkVersion para 26. Tendo essa linha no meu onCreate ainda resultou em uma falha enquanto minha targetSdkVersion ainda estava definida em 27. Como a solução de ninguém mais funcionou para mim até agora, achei que isso funcionava como uma correção temporária para agora.

É um conflito (bug) entre os Temas dentro do arquivo style.xml nas versões Android 7 (níveis de API 24,25) e 8 (níveis de API 26,27), quando você tiver

android:screenOrientation="portrait" : dentro da atividade específica (que trava) no AndroidManifest.xml

&

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

no tema aplicado a essa atividade em style.xml

Pode ser resolvido por estas maneiras de acordo com sua necessidade:

1- Remova as propriedades acima mencionadas que causam conflito

2- Altere a orientação da atividade para um desses valores conforme necessário: unspecifiedou behindassim por diante, que pode ser encontrado aqui: Referência do Google para android: screenOrientation `

3- Defina a orientação programaticamente em tempo de execução

Recentemente, enfrentei o problema e aqui está a solução.

Não é necessário alterar o parâmetro de orientação da tela definido no arquivo de manifesto do Android.

Basta adicionar duas pastas no

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

Em seguida, copie seu arquivo styles.xml e themes.xml para lá.

e altere os seguintes parâmetros de TRUE para FALSE.

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

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

Vai funcionar.

Um erro comum do Android 8.0

Eu enfrentei esse problema apenas no SDK 26 (8.0.0) se estiver usando windowIsTranslucent 'true' e forçando a orientação com força:

Aqui está a solução:

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

Eu estava recebendo esse erro ao tentar capturar uma imagem ou tirar uma foto da galeria. O que funciona para mim é remover os dois

 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

e

android:screenOrientation="portrait"

agora minha atividade 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>

somente 8.0.0 lança a exceção, acima de 8.0 removeu a exceção

A única coisa que funcionou para mim foi mudar

android:screenOrientation="portrait"

para

android:screenOrientation="unspecified"

no manifesto para todas as atividades translúcidas.

Dessa forma, é compatível com todas as versões da API, pois a atividade translúcida parece herdar sua orientação da atividade pai a partir de targetApi: 28.

O estilo pode ser deixado como está incluindo <item name="android:windowIsTranslucent">true</item>.

Usar

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>

Eu não sei se isso é um bug do Google ou um comportamento pretendido, mas eu (pelo menos momentaneamente) o resolvi alterando compileSdkVersion e targetSdkVersion de volta para 26 em Gradle ...

Se você não resolveu o problema, registre a atividade do anúncio no manifesto da seguinte maneira:

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

Você também precisa atualizar para a versão mais recente do sdk.

Provavelmente, você está mostrando Activity como Diálogo (não em tela cheia), então remova screenOrientation do Manifest ou do código. Isso resolverá o problema.

isso aconteceu depois de 27, use targetSdkVersion 26 replace, aguarde o google corrigi-lo

Acabei de remover as tags "retrato" dos elementos que não são de tela cheia e tudo correu bem.

android:screenOrientation="portrait"

Verifique o estilo da sua atividade e verifique se, se você não estiver usando nada relacionado ao Translúcido, altere o estilo para alternar. Para que possamos resolver esse problema.

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

Resolvi esse problema removendo android:screenOrientation="portrait"e adicionando o código abaixo ao meu onCreate

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

enquanto minhas propriedades do tema são

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