Como ocultar a barra de ação antes da atividade ser criada e mostrá-la novamente?

Preciso implementar a tela inicial no meu aplicativo do favo de mel. Eu uso esse código no onCreate da atividade para mostrar o splash:

setContentView(R.layout.splash);
getActionBar().hide();

e este código para mostrar a interface principal depois de algum tempo:

setContentView(R.layout.main);
getActionBar().show();

Porém, antes que onCreate seja chamado e o splash apareça, há uma pequena quantidade de tempo quando a barra de ação é exibida.

Como posso tornar a barra de ação invisível?

Tentei aplicar o tema à atividade sem barra de ação:

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

mas nesse caso, getActionBar () sempre retorna nulo e não encontrei maneira de mostrá-lo novamente.

A configuração android:windowActionBar="false"realmente desativa a ActionBar, mas, como você diz, getActionBar();retorna nulo. Isso é resolvido por:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
    getActionBar().hide();

    setContentView(R.layout.splash); // be sure you call this AFTER requestFeature

Isso cria a ActionBar e a oculta imediatamente antes que ela tenha a chance de ser exibida.

Mas agora há outro problema. Depois de colocar windowActionBar="false"o tema, a Atividade desenha seu Título de Janela normal em vez de uma ActionBar.
Se tentarmos evitar isso usando alguns dos *.NoTitleBartemas de estoque ou tentarmos incluir <item name="android:windowNoTitle">true</item>nosso próprio tema, ele não funcionará.
O motivo é que o ActionBar depende do título da janela para se exibir - ou seja, o ActionBar é um título da janela transformado.
Portanto, o truque que pode nos ajudar é adicionar mais uma coisa ao nosso xml do tema Atividade:

<item name="android:windowActionBar">false</item>
<item name="android:windowTitleSize">0dp</item>

Isso tornará o título da janela com altura zero, praticamente invisível.

No seu caso, depois de terminar de exibir a tela inicial, você pode simplesmente chamar

setContentView(R.layout.main);
getActionBar().show();

e você terminou. A atividade começará com nenhuma cintilação da ActionBar, nem o título da janela sendo exibido.

ADDON: Se você mostrar e ocultar a ActionBar várias vezes, talvez tenha notado que a primeira exibição não é animada. A partir de então, mostrar e ocultar são animados. Se você quiser ter animação na primeira exibição também, use:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_ACTION_BAR);

    // delaying the hiding of the ActionBar
    Handler h = new Handler();
    h.post(new Runnable() {     
        @Override
        public void run() {
            getActionBar().hide();
        }
    });

O mesmo pode ser alcançado com:

protected void onPostResume() {
    super.onPostResume();
    getActionBar().hide();

mas pode ser necessário um pouco de lógica extra para verificar se esta é a primeira exibição da atividade.

A idéia é atrasar um pouco a ocultação da ActionBar. De certa forma, deixamos o ActionBar ser mostrado, mas depois o ocultamos imediatamente. Assim, vamos além da primeira exibição não animada e a próxima exibição será considerada a segunda, assim será animada.

Como você deve ter adivinhado, há uma chance de que o ActionBar possa ser visto antes de ser oculto pela operação atrasada. Este é realmente o caso. Na maioria das vezes, nada é visto, mas, de vez em quando, é possível ver o ActionBar piscar por uma fração de segundo.

De qualquer forma, essa não é uma solução bonita, por isso agradeço sugestões.

Além do usuário da barra de ação do suporte v7, o código será:

getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
getSupportActionBar().hide();

Usando este código simples no seu arquivo .class para ocultar a barra de ação

getSupportActionBar().hide();

Se você estiver usando o ActionBarSherlock, use o Tema Theme.Sherlock.NoActionBar em sua Atividade

<activity 
    android:name=".SplashScreenActivity"
    android:theme="@style/Theme.Sherlock.NoActionBar">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Crie dois estilos:

<style name="AppThemeNoBar" parent="Theme.AppCompat.Light">
     <item name="android:windowNoTitle">true</item>
</style>

<style name="AppThemeBar" parent="Theme.AppCompat.Light">
    <item name="android:windowNoTitle">false</item>
</style>

Defina AppThemeNoBar como tema do aplicativo e AppThemeBar para a atividade em que você deseja mostrar a ActionBar. Usando dois estilos, você não verá a barra de Ação enquanto as visualizações estão carregando.

Verifique este link Android: ocultar barra de ação enquanto visualiza o carregamento

Oi eu tenho uma solução simples usando 2 temas

1. Tema da tela inicial (adicione-o ao manifesto):

   <style name="SplashTheme" parent="@android:style/Theme.Holo.NoActionBar"> <item name="android:windowBackground">@color/red</item> </style>

2. tema normal (adicione-o em sua atividade por setTheme (R.style.Theme)):

   <style name="Theme" parent="@style/Theme.Holo"> <item name="android:windowBackground">@color/blue</item> </style>

Para oferecer suporte ao SDK 10:

@Override    
public void onCreate(Bundle savedInstanceState) {

    setTheme(R.style.Theme);      
    super.onCreate(savedInstanceState);

      ...........
      ...........
}

Eu também estava tentando ocultar a Action Bar no Android 2.2, mas nenhuma dessas soluções funcionou. Tudo termina com um acidente. Eu verifiquei o DDMS LOg, ele estava me dizendo para usar 'Theme.AppCompat'. Por fim, resolvi o problema alterando a android:theme="@android:style/Theme.Holo.Light.NoActionBar"linha

em android:theme="@style/Theme.AppCompat.NoActionBar"e funcionou, mas o da Interface estava escuro.

então eu tentei android:theme="@style/Theme.AppCompat.Light.NoActionBar"e finalmente consegui o que queria.

Depois disso, quando pesquisei sobre 'AppCompat' no site do desenvolvedor, obtive este.

Então eu acho que a solução para o Android 2.2 é

<activity
    android:name=".MainActivity"
    android:theme="@style/Theme.AppCompat.Light.NoActionBar" >
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

E desculpe pelo meu inglês ruim como sempre.

O melhor resultado para mim foi criar uma atividade com ThemeNoTitleBar e sem conteúdo como iniciador. Então essa atividade chama diretamente para a outra.

Claro que, se você quiser, pode adicionar conteúdo à Atividade Splash, mas no meu caso, eu só queria mostrar o aplicativo diretamente.

Manifesto:

<activity
        android:name="com.package.SplashActivity"
        android:theme="@android:style/Theme.Black.NoTitleBar" >
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

Atividade:

public class SplashActivity extends Activity{

@Override
protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);

    //start StartActivity
    Intent intent = new Intent(this, StartActivity.class);
    startActivity(intent);
    finish();
}

}

Se você usar um Activityincluído uma tela inicial, poderá fazer isso se usarSherlockActionBar

getSupportActionBar().hide();

Após a tela inicial, você pode mostrá-lo novamente com ...

getSupportActionBar().show();

Deve ser o mesmo com o nativo ActionBardo Android.

A solução @Clerics funciona. Mas isso também parece ser um problema em alguns aplicativos nativos do Google: Google, Play Store, Conversar. Também outros grandes aplicativos como o skype.

O problema é que o problema não está no tamanho do arquivo, mas sim no tamanho do arquivo que você instalou no arquivo.

Adicione no seu manifesto as seguintes tags de aplicativo ou atividade:

android:theme="@style/Theme.NoActionBar"

E então em sua atividade principal:

    // Set theme
    setTheme(R.style.YOUR_THEME);
    getSupportActionBar().setTitle(R.string.title);

    // Start regular onCreate()
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

melhor e simples

requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

2015, usando a biblioteca do suporte v7 com o tema AppCompat, defina esse tema para sua atividade.

<style name="AppTheme.AppStyled" parent="Theme.AppCompat.Light.DarkActionBar">
    <item name="colorPrimaryDark">@color/md_indigo_100</item>
    <item name="colorPrimary">@color/md_indigo_500</item>
    <item name="colorAccent">@color/md_red_500</item>
    <item name="android:textColorPrimary">@color/md_white_1000</item>
    <item name="android:textColor">@color/md_purple_500</item>
    <item name="android:textStyle">bold</item>
    <item name="windowNoTitle">true</item>
    <item name="windowActionBar">false</item>
</style>

Pois Splashscreenvocê deve usar esta linha manifeste não usargetActionBar()

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

e uma vez quando o Splash Activityterminar no Activityuso principal abaixo ou nada

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

Tente isso, funciona para mim:

Abaixo se livra da barra de título da atividade

 requestWindowFeature(Window.FEATURE_NO_TITLE);

Abaixo, elimina a barra de notificação para tornar a atividade em tela cheia

 getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
        WindowManager.LayoutParams.FLAG_FULLSCREEN);

(Exemplo completo abaixo) Observe: esses métodos foram chamados antes de definir a exibição do conteúdo de nossa atividade

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Sets Application to full screen by removing action bar
        requestWindowFeature(Window.FEATURE_NO_TITLE);    
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, 
        WindowManager.LayoutParams.FLAG_FULLSCREEN);

        setContentView(R.layout.activity_main); 

        // without this check, we would create a new fragment at each orientation change!
        if (null == savedInstanceState)
            createFragment();
    }

isso pode ser útil,
adicione isso ao seu manifesto

 android:theme="@android:style/Theme.Light.NoTitleBar" 

Felicidades

A melhor maneira de encontrar depois de ler todas as opções disponíveis é definir o tema principal sem o ActionBar e, em seguida, configurar o MyTheme no código no pai de todas as atividades.

Manifesto:

<application
...
        android:theme="@android:style/Theme.Holo.Light.NoActionBar"
...>

BaseActivity:

public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setTheme(R.style.GreenHoloTheme);
}

Dessa forma, ajuda-me a evitar o ActionBar ao iniciar o aplicativo!

As soluções já postadas vieram com o efeito colateral, que a primeira chamada .show () não animava o ActionBar para mim. Eu tenho outra solução legal, que corrigia isso:

Crie um drawable transparente - algo assim:

<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid
       android:color="#00000000" />
</shape>

Defina o plano de fundo real da barra de ação como uma exibição personalizada invisível que você define na barra de ação:

getSupportActionBar().setCustomView(R.layout.actionbar_custom_layout);
      getSupportActionBar().setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM,
              ActionBar.DISPLAY_SHOW_CUSTOM | ActionBar.DISPLAY_SHOW_HOME | ActionBar.DISPLAY_SHOW_TITLE);

Defina o plano de fundo transparente para a barra de ação no onCreate:

getSupportActionBar().setBackgroundDrawable(getResources().getDrawable(R.drawable.background_transparent));

Imortante: não oculte a barra de ação imediatamente no onCreate, mas com um pouco de atraso depois - por exemplo, quando o layout terminar com a criação:

getWindow().getDecorView().getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
                @Override
                public void onGlobalLayout() {
                    getSupportActionBar().hide();
                }
            });

Antes de sua primeira chamada .show (), defina a exibição personalizada como visível:

_actionbarRoot.setVisibility(View.VISIBLE);
getSupportActionBar().show();

Caso você tenha nulo porque está usando a biblioteca de suporte , em vez de getActionBar()precisar ligar getSupportActionBar().

Basta adicionar isso à sua MainActivity na função onCreate.

val actionBar = supportActionBar?.apply { hide() }

Coloque sua tela inicial em uma atividade separada e use startActivityForResulto onCreatemétodo da sua atividade principal para exibi-la. Isso funciona porque, de acordo com os documentos:

Como um caso especial, se você chamar startActivityForResult () com um requestCode> = 0 durante o onCreate inicial (Bundle savedInstanceState) / onResume () de sua atividade, sua janela não será exibida até que um resultado seja retornado da atividade iniciada . Isso evita oscilações visíveis ao redirecionar para outra atividade.

Provavelmente, você deve fazer isso apenas se o argumento onCreatefor null(indicando um novo lançamento de sua atividade, em vez de uma reinicialização devido a uma alteração na configuração).

Eu ainda tinha erro com o ponteiro nulo e, finalmente, ajudou quando chamei primeiro getWindow (). RequestFeature () e depois super.onCreate ()

public void onCreate(Bundle savedInstanceState) {
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
super.onCreate(savedInstanceState);
getActionBar().show();

Basta adicionar isso no seu styles.xml

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

Na verdade, você poderia simplesmente definir respingo Activitycom NoActionBar e definir o seu principal activitycom barra de ação.

A melhor maneira de fazer isso é fazer a primeira atividade como atividade em branco e o conteúdo que você deseja colocar e depois de algum tempo acionar outra atividade. Seguindo esse caminho, você pode fazer a primeira atividade como sua tela inicial sem barra de ação ou qualquer coisa. Heres minha primeira atividade

package com.superoriginal.rootashadnasim.syllabus;

import android.content.Intent;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class first_screen extends AppCompatActivity {



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


    final Handler h=new Handler();
    h.postDelayed(new Runnable() {
        @Override
        public void run() {
            Intent intent=new     Intent(getApplicationContext(),DrawerChooseBranchMainActivity.class);
            startActivity(intent);
        }
    },2000);

}
}

Depois disso, você poderá colocar sua atividade como primeira atividade. Se você não quiser barra de ação em nenhuma tela, adicione-a aos seus estilos.

    <item name="windowActionBar">false</item>
    <item name="windowNoTitle">true</item>

O Android studio fornece um modelo de compilação para tela cheia. Se você usa o Android studio, pode seguir a etapa abaixo para implementar a atividade em tela cheia.

Feito. O Android studio fez seu trabalho, agora você pode verificar o código em tela cheia.

esta é a melhor maneira que usei Ir para o arquivo java, depois de onCreate:

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

        // Take instance of Action Bar 
        // using getSupportActionBar and 
        // if it is not Null 
        // then call hide function 
        if (getSupportActionBar() != null) { 
            getSupportActionBar().hide(); 
        } 
    }

Sei que os links de postagem não são a melhor maneira de fazer as coisas, mas recomendo que você leia a documentação a seguir do próprio Google. Este é o documento oficial do Android sobre como controlar a interface do usuário do sistema (coisas como barra de ação, barra de navegação etc.). Infelizmente, as informações são demais para serem postadas diretamente, mas depois de ler isso, você entenderá exatamente como mostrar e ocultar recursos, independentemente da versão em que está desenvolvendo, é tão simples!

Incase o link nunca muda, ele pode ser encontrado sob a documentação android oficial sob treinamento -> começando -> Melhores práticas para a interface de usuário -> gestão do ui sistema

https://developer.android.com/training/system-ui/index.html

você pode usar isso:

getSupportActionBar().hide(); se não funcionar, tente este:

getActionBar().hide();

se acima não funcionar, tente assim:

em seu diretório = res / values ​​/ style.xml, abra style.xml -> há parentalteração de atributo emparent="Theme.AppCompat.Light.DarkActionBar"

se tudo isso não funcionar também. eu não sei mais. mas para mim funciona.