Android Barra de status completamente transparente?

184

Pesquisei a documentação, mas só encontrei o seguinte: Link . Qual é usado para tornar a barra translúcida ? O que estou tentando fazer é tornar a barra de status completamente transparente (como mostra a imagem abaixo) e torná-la compatível com versões anteriores do APK <19: insira a descrição da imagem aqui

Meus styles.xml:

<resources xmlns:tools="http://schemas.android.com/tools">

  <style name="AppTheme" parent="Theme.AppCompat.Light">
  <item name="android:actionBarStyle">@style/ThemeActionBar</item>
  <item name="android:windowActionBarOverlay">true</item>
  <!-- Support library compatibility -->
  <item name="actionBarStyle">@style/ThemeActionBar</item>
  <item name="windowActionBarOverlay">true</item>
  </style>

  <style name="ThemeActionBar" parent="Widget.AppCompat.Light.ActionBar.Solid">
  <item name="android:background"> @null </item>
  <!-- Support library compatibility -->
  <item name="background">@null</item>
  <item name="android:displayOptions"> showHome | useLogo</item>
  <item name="displayOptions">showHome|useLogo</item>

  </style>

</resources>

O que eu pude fazer:

insira a descrição da imagem aqui

Muhammad Ali
fonte

Respostas:

369

Tudo o que você precisa fazer é definir essas propriedades no seu tema:

<item name="android:windowTranslucentStatus">true</item>
<item name="android:windowTranslucentNavigation">true</item>

Seu layout de atividade / contêiner que você deseja ter uma barra de status transparente precisa deste conjunto de propriedades:

android:fitsSystemWindows="true"

Geralmente, não é possível fazer isso com certeza no pré-kitkat, parece que você pode fazer isso, mas algum código estranho o faz .

Edição: Eu recomendaria esta lib: https://github.com/jgilfelt/SystemBarTint para lotes de controle de cores da barra de status pré-pirulito.

Bem, depois de muita deliberação, aprendi que a resposta para desativar totalmente a translucidez ou qualquer cor colocada na barra de status e na barra de navegação do pirulito é definir esse sinalizador na janela:

// In Activity's onCreate() for instance
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    Window w = getWindow();
    w.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}

Nenhum outro tema é necessário, ele produz algo como isto:

insira a descrição da imagem aqui

Daniel Wilson
fonte
21
Usei o código e, em seguida, adicionei uma imagem como plano de fundo e, em seguida, adicionei android:fitsSystemWindows="true"ao meu activity_main.xml. As barras do sistema são translúcidas e não transparentes.
Muhammad Ali
9
Bem, eu acredito que tudo que você precisa, nesse caso, então é adicionar <item name="android:statusBarColor">@android:color/transparent</item>ao seu tema :)
Daniel Wilson
7
Sim, obrigado pela sua paciência, estou quase em estado de choque desde que venho tentando fazer isso nas últimas horas xD. O código acima não funciona, no entanto, defino android:windowTranslucentStatuscomo false e tornou a barra de status transparente. Agora eu fiz a mesma coisa com a barra de navegação e adicionei, <item name="android:navigationBarColor">@android:color/transparent</item>mas deixa as duas barras cinza. UGH!
Muhammad Ali
4
Para fazer "adjustPan" uso de trabalho w.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);em vez
Arda Kara
4
NOTA: o uso do sinalizador FLAG_LAYOUT_NO_LIMITS também colocará seu layout na barra de navegação virtual na parte inferior. Em geral, você não quer fazer isso ... então ditto que outras pessoas têm dito :-(
kenyee
23

Basta adicionar esta linha de código ao seu arquivo java principal:

getWindow().setFlags(
    WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
    WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
);
Abhijeet Farakate
fonte
45
Isso afeta a barra de navegação também.
desenvolvedor Android
16

Você pode usar a biblioteca externa StatusBarUtil :

Adicione ao seu nível de módulo build.gradle:

compile 'com.jaeger.statusbarutil:library:1.4.0'

Em seguida, você pode usar o seguinte utilitário para uma Atividade para tornar a barra de status transparente:

StatusBarUtil.setTransparent(Activity activity)

Exemplo:

barra de status transparente no Lollipop e KitKat

David Rawson
fonte
Como fazer isso para a gaveta de navegação?
Reejesh PK 11/01/19
24
um lib apenas para resolver este é como a luz de uma vela com um lança-chamas
Felipe Castilhos
@FelipeCastilhos sim, talvez, mas e se você estiver fazendo muitas coisas diferentes com a barra de status e não quiser lidar com a API ruim que o Google fornece?
David Rawson
@DavidRawson que é um cenário diferente. Aqui estamos falando apenas de adicionar transparência. Por que adicionar muito mais código de terceiros à sua base de código apenas para lidar com isso?
Felipe Castilhos
14

Funciona para Android KitKat e superior (para aqueles que desejam transparente na barra de status e não manipulam a NavigationBar, porque todas essas respostas também transparecem a NavigationBar!)

A maneira mais fácil de conseguir isso:

Coloque essas 3 linhas de código no styles.xml (v19)-> se você não souber como obtê-lo (v19), basta escrevê-las no seu padrão styles.xmle usar alt+ enterpara criar automaticamente:

<item name="android:windowFullscreen">false</item>
<item name="android:windowContentOverlay">@null</item>
<item name="android:fitsSystemWindows">false</item>

E agora, vá para sua MainActivityclasse e coloque este método fora de onCreate na classe:

public static void setWindowFlag(Activity activity, final int bits, boolean on) {

    Window win = activity.getWindow();
    WindowManager.LayoutParams winParams = win.getAttributes();
    if (on) {
        winParams.flags |= bits;
    } else {
        winParams.flags &= ~bits;
    }
    win.setAttributes(winParams);
}

Em seguida, coloque este código no onCreatemétodo da atividade:

if (Build.VERSION.SDK_INT >= 19 && Build.VERSION.SDK_INT < 21) {
        setWindowFlag(this, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, true);
    }
    if (Build.VERSION.SDK_INT >= 19) {
        getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
    }
    //make fully Android Transparent Status bar
    if (Build.VERSION.SDK_INT >= 21) {
        setWindowFlag(this, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, false);
        getWindow().setStatusBarColor(Color.TRANSPARENT);
    }

É isso aí!

parsa dadras
fonte
1
Como minha experiência em React Native ... Os códigos acima estão em conflito com a exibição do teclado (AdjustResize). Então, eu apenas faço pequenas alterações: `` if (Build.VERSION.SDK_INT> = 19) {getWindow (). GetDecorView (). SetSystemUiVisibility (View.SYSTEM_UI_FLAG_LAYOUT_STABLE); } `` `e no Componente` `<StatusBar translúcido = {true} backgroundColor =" transparent "/>` `` e em AppManisfes - MainActivity `` `android: windowSoftInputMode =" AdjustResize "` `` e os demais códigos são mesmo. fyi: `` `" react-native ":" 0.61.5 ",` `` obrigado @parsa dadras
Rudi Wijaya
12

Completamente transparente StatusBar e NavigationBar

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

    transparentStatusAndNavigation();
}


private void transparentStatusAndNavigation() {
    //make full transparent statusBar
    if (Build.VERSION.SDK_INT >= 19 && Build.VERSION.SDK_INT < 21) {
        setWindowFlag(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
                | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, true);
    }
    if (Build.VERSION.SDK_INT >= 19) {
        getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
        );
    }
    if (Build.VERSION.SDK_INT >= 21) {
        setWindowFlag(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
                | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, false);
        getWindow().setStatusBarColor(Color.TRANSPARENT);
        getWindow().setNavigationBarColor(Color.TRANSPARENT);
    }
}

private void setWindowFlag(final int bits, boolean on) {
    Window win = getWindow();
    WindowManager.LayoutParams winParams = win.getAttributes();
    if (on) {
        winParams.flags |= bits;
    } else {
        winParams.flags &= ~bits;
    }
    win.setAttributes(winParams);
}
Ahamadullah Saikat
fonte
Única solução que realmente funcionou para mim junto com o modo quiosque (fixação da tela).
Brontes
11

Para desenhar seu layout na barra de status:

values ​​/ styles.xml

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

values-v21 / styles.xml

<item name="android:windowDrawsSystemBarBackgrounds">true</item>
<item name="android:statusBarColor">@color/colorPrimaryDark</item>

Use o CoordinatorLayout / DrawerLayout que já cuida do parâmetro fitsSystemWindows ou crie seu próprio layout para:

public class FitsSystemWindowConstraintLayout extends ConstraintLayout {

    private Drawable mStatusBarBackground;
    private boolean mDrawStatusBarBackground;

    private WindowInsetsCompat mLastInsets;

    private Map<View, int[]> childsMargins = new HashMap<>();

    public FitsSystemWindowConstraintLayout(Context context) {
        this(context, null);
    }

    public FitsSystemWindowConstraintLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public FitsSystemWindowConstraintLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        if (ViewCompat.getFitsSystemWindows(this)) {
            ViewCompat.setOnApplyWindowInsetsListener(this, new android.support.v4.view.OnApplyWindowInsetsListener() {
                @Override
                public WindowInsetsCompat onApplyWindowInsets(View view, WindowInsetsCompat insets) {
                    FitsSystemWindowConstraintLayout layout = (FitsSystemWindowConstraintLayout) view;
                    layout.setChildInsets(insets, insets.getSystemWindowInsetTop() > 0);
                    return insets.consumeSystemWindowInsets();
                }
            });
            setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
            TypedArray typedArray = context.obtainStyledAttributes(new int[]{android.R.attr.colorPrimaryDark});
            try {
                mStatusBarBackground = typedArray.getDrawable(0);
            } finally {
                typedArray.recycle();
            }
        } else {
            mStatusBarBackground = null;
        }
    }

    public void setChildInsets(WindowInsetsCompat insets, boolean draw) {
        mLastInsets = insets;
        mDrawStatusBarBackground = draw;
        setWillNotDraw(!draw && getBackground() == null);

        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                if (ViewCompat.getFitsSystemWindows(this)) {
                    ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) child.getLayoutParams();

                    if (ViewCompat.getFitsSystemWindows(child)) {
                        ViewCompat.dispatchApplyWindowInsets(child, insets);
                    } else {
                        int[] childMargins = childsMargins.get(child);
                        if (childMargins == null) {
                            childMargins = new int[]{layoutParams.leftMargin, layoutParams.topMargin, layoutParams.rightMargin, layoutParams.bottomMargin};
                            childsMargins.put(child, childMargins);
                        }
                        if (layoutParams.leftToLeft == LayoutParams.PARENT_ID) {
                            layoutParams.leftMargin = childMargins[0] + insets.getSystemWindowInsetLeft();
                        }
                        if (layoutParams.topToTop == LayoutParams.PARENT_ID) {
                            layoutParams.topMargin = childMargins[1] + insets.getSystemWindowInsetTop();
                        }
                        if (layoutParams.rightToRight == LayoutParams.PARENT_ID) {
                            layoutParams.rightMargin = childMargins[2] + insets.getSystemWindowInsetRight();
                        }
                        if (layoutParams.bottomToBottom == LayoutParams.PARENT_ID) {
                            layoutParams.bottomMargin = childMargins[3] + insets.getSystemWindowInsetBottom();
                        }
                    }
                }
            }
        }

        requestLayout();
    }

    public void setStatusBarBackground(Drawable bg) {
        mStatusBarBackground = bg;
        invalidate();
    }

    public Drawable getStatusBarBackgroundDrawable() {
        return mStatusBarBackground;
    }

    public void setStatusBarBackground(int resId) {
        mStatusBarBackground = resId != 0 ? ContextCompat.getDrawable(getContext(), resId) : null;
        invalidate();
    }

    public void setStatusBarBackgroundColor(@ColorInt int color) {
        mStatusBarBackground = new ColorDrawable(color);
        invalidate();
    }

    @Override
    public void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (mDrawStatusBarBackground && mStatusBarBackground != null) {
            int inset = mLastInsets != null ? mLastInsets.getSystemWindowInsetTop() : 0;
            if (inset > 0) {
                mStatusBarBackground.setBounds(0, 0, getWidth(), inset);
                mStatusBarBackground.draw(canvas);
            }
        }
    }
}

main_activity.xml

<FitsSystemWindowConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <ImageView
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:fitsSystemWindows="true"
        android:scaleType="centerCrop"
        android:src="@drawable/toolbar_background"
        app:layout_constraintBottom_toBottomOf="@id/toolbar"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <android.support.v7.widget.Toolbar
        android:id="@+id/toolbar"
        android:layout_width="0dp"
        android:layout_height="?attr/actionBarSize"
        android:background="@android:color/transparent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <LinearLayout
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:gravity="center"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toBottomOf="@id/toolbar">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="Content"
            android:textSize="48sp" />
    </LinearLayout>
</FitsSystemWindowConstraintLayout>

Resultado:

Captura de tela:
Captura de tela

Decam Developer
fonte
10

Você pode usar o código abaixo para tornar a barra de status transparente. Veja as imagens Com destaque vermelho que ajuda a identificar o uso do código Abaixo

1]

Snippet de código Kotlin para seu aplicativo Android

Etapa: 1 Anote o código no método On create

if (Build.VERSION.SDK_INT >= 19 && Build.VERSION.SDK_INT < 21) {
    setWindowFlag(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, true)
}
if (Build.VERSION.SDK_INT >= 19) {
    window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
}
if (Build.VERSION.SDK_INT >= 21) {
    setWindowFlag(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, false)
    window.statusBarColor = Color.TRANSPARENT
}

Etapa 2: você precisa do método SetWindowFlag que descreve no código Abaixo.

private fun setWindowFlag(bits: Int, on: Boolean) {
    val win = window
    val winParams = win.attributes
    if (on) {
        winParams.flags = winParams.flags or bits
    } else {
        winParams.flags = winParams.flags and bits.inv()
    }
    win.attributes = winParams
}

Snippet de código Java para seu aplicativo Android:

Etapa 1: Código da Atividade Principal

if (Build.VERSION.SDK_INT >= 19 && Build.VERSION.SDK_INT < 21) {
    setWindowFlag(this, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, true);
}
if (Build.VERSION.SDK_INT >= 19) {
    getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
}

if (Build.VERSION.SDK_INT >= 21) {
    setWindowFlag(this, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, false);
    getWindow().setStatusBarColor(Color.TRANSPARENT);
}

Etapa 2: Método SetWindowFlag

public static void setWindowFlag(Activity activity, final int bits, boolean on) {
    Window win = activity.getWindow();
    WindowManager.LayoutParams winParams = win.getAttributes();
    if (on) {
        winParams.flags |= bits;
    } else {
        winParams.flags &= ~bits;
    }
    win.setAttributes(winParams);
}
CodeInsideCofee
fonte
1
Acabei de compartilhar meu código com nossa comunidade de desenvolvedores para ajudar. 😊
CodeInsideCofee
6

Use android:fitsSystemWindows="false"no seu layout superior

Miguel
fonte
6
isso afeta barra de navegação também
Ebrahim Karimi
5

Aqui está uma extensão no kotlin que faz o truque:

fun Activity.setTransparentStatusBar() {
    window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        window.statusBarColor = Color.TRANSPARENT
    }
}
Felipe Castilhos
fonte
4

Usando este código em seu XML, você poderá ver a barra de tempo em sua atividade:

<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">
Irfan Ali
fonte
3

Existem três etapas:

1) Basta usar esse segmento de código no seu método @OnCreate

@OnCreate{
  // FullScreen
  getWindow().setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, 
  WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}

se você estiver trabalhando no Fragment, coloque esse segmento de código no método @OnCreate da sua atividade.

2) Defina também a transparência em /res/values-v21/styles.xml:

<item name="android:statusBarColor">@android:color/transparent</item>

Ou você pode definir a transparência programaticamente:

getWindow().setStatusBarColor(Color.TRANSPARENT);

3) De qualquer forma, você deve adicionar o segmento de código em styles.xml

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

NOTA: Este método funciona apenas na API 21 e acima.

Annas Bin Waheed
fonte
2

Você também pode ver meu exemplo com avatar animado e texto animado

CollapsingAvatarToolbarSample

Leia minha postagem no Medium

Então, deixe-me explicar como funciona. Criei o modo de exibição personalizado implementado AppBarLayout.OnOffsetChangedListener . Por dentro do HeadCollapsing Custom View, fundei a exibição de texto e imagem no AppBarLayout.

class HeadCollapsing(context: Context, attrs: AttributeSet?) : 
 FrameLayout(context, attrs), AppBarLayout.OnOffsetChangedListener {

  private fun findViews() {
            appBarLayout = findParentAppBarLayout()

            avatarContainerView = findViewById(R.id.imgb_avatar_wrap)

            titleToolbarText =  findViewById<AppCompatTextView>(id)

        }

  private fun findParentAppBarLayout(): AppBarLayout {
    val parent = this.parent
    return parent as? AppBarLayout ?: if (parent.parent is AppBarLayout) {
        parent.parent as AppBarLayout
    } else {
        throw IllegalStateException("Must be inside an AppBarLayout")
    }
}

  ...

     override fun onOffsetChanged(appBarLayout: AppBarLayout, offset:Int) {
           ...
           //Calculate expanded percentage
           val expandedPercentage = 1 - -offset / maxOffset
           updateViews(expandedPercentage)
     }
}

Em seguida, altere as visualizações por porcentagem calculada. Por exemplo, como a exibição de texto é alterada:

         when {
                inversePercentage < ABROAD -> {
                    titleToolbarText?.visibility = View.VISIBLE
                    titleTolbarTextSingle?.visibility = View.INVISIBLE
                }

                inversePercentage > ABROAD -> {
                    titleToolbarText?.visibility = View.INVISIBLE
                    titleTolbarTextSingle?.visibility = View.VISIBLE
                    titleTolbarTextSingle?.let {
                        animateShowText(it)
                    }
                }
            }

Para detectar quando é necessário recolher a imagem animar o objeto Pair criado

private var cashCollapseState: kotlin.Pair<Int, Int>? = null

com estados: TO_EXPANDED_STATE, TO_COLLAPSED_STATE, WAIT_FOR_SWITCH, SWITCHED

  companion object {
        const val ABROAD = 0.95f
        const val TO_EXPANDED_STATE = 0
        const val TO_COLLAPSED_STATE = 1
        const val WAIT_FOR_SWITCH = 0
        const val SWITCHED = 1
    }

Em seguida, criei uma animação para o avatar swith state:

 when {
                cashCollapseState != null && cashCollapseState != state -> {
                    when (state.first) {
                        TO_EXPANDED_STATE -> {
                          // do calculates
                        }
                        TO_COLLAPSED_STATE -> {

                    ValueAnimator.ofFloat(avatarContainerView.translationX, translationX).apply {
                        addUpdateListener {
                            avatarContainerView.translationX = it.animatedValue as Float
                        }

                        duration = 350
                        (state.first == TO_COLLAPSED_STATE).apply {
                            if (this) interpolator = LinearInterpolator()
                        }
                        start()
                    }
                //SWITCH STATE CASE
                cashCollapseState = kotlin.Pair(state.first, SWITCHED)
            }

            else -> {
                cashCollapseState = kotlin.Pair(state.first, WAIT_FOR_SWITCH)
            }
Serg Burlaka
fonte
2

Você pode tentar isso.

private static void setStatusBarTransparent(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
        activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
        activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
        activity.getWindow(). setStatusBarColor(Color.TRANSPARENT);
    } else {
        activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    }
}
Faisal Naseer
fonte
1

Embora todas as respostas acima circulem em torno da mesma idéia fundamental, você pode trabalhar com layouts simples usando um dos exemplos acima. No entanto, eu queria mudar a cor do plano de fundo enquanto usava a navegação em fragmentos deslizante 'tela cheia' (barra de guias à parte) e manter a navegação regular, as guias e as barras de ação.

Depois de ler atentamente um artigo de Anton Hadutski, entendi melhor o que está acontecendo.

Eu tenho DrawerLayoutcom ConstraintLayout(ou seja, contêiner) que tem Toolbar, incluir para o fragmento principal e BottomNavigationView.

Definir DrawerLayoutter fitsSystemWindowsque ser verdadeiro não é suficiente, você precisa definir ambos DrawerLayoute ConstraintLayout. Supondo uma barra de status transparente, a cor da barra de status agora é igual à cor de segundo plano ConstraintLayout.

No entanto, o fragmento incluído ainda possui a barra de status inserida, portanto, animar outro fragmento de 'tela cheia' não altera a cor da barra de status.

Um pouco de código do artigo referido em Activity's onCreate:

ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.container)) { view, insets ->
        insets.replaceSystemWindowInsets(
                insets.systemWindowInsetLeft,
                0,
                insets.systemWindowInsetRight,
                insets.systemWindowInsetBottom
        )
    }

E tudo está bem, exceto agora o Toolbarnão aborda a altura da barra de status. Mais algumas referências ao artigo e temos uma solução totalmente funcional:

val toolbar = findViewById<Toolbar>(R.id.my_toolbar)
    ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.container)) { view, insets ->
        val params = toolbar.layoutParams as ViewGroup.MarginLayoutParams
        params.topMargin = insets.systemWindowInsetTop
        toolbar.layoutParams = params
        insets.replaceSystemWindowInsets(
                insets.systemWindowInsetLeft,
                0,
                insets.systemWindowInsetRight,
                insets.systemWindowInsetBottom
        )
    }

O main_activity.xml (observe que marginTop in Toolbaré para fins de visualização, ele será substituído pelo código):

<?xml version="1.0" encoding="utf-8"?>
    <androidx.drawerlayout.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:id="@+id/drawer_layout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:fitsSystemWindows="true"
        >

    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/green"
        android:fitsSystemWindows="true"
        tools:context=".MainActivity">

        <androidx.appcompat.widget.Toolbar
            android:id="@+id/my_toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            app:layout_constraintTop_toTopOf="@id/container"
            android:layout_marginTop="26dp" 
            android:background="@android:color/transparent"
            ...>
            ...
        </androidx.appcompat.widget.Toolbar>

        <include layout="@layout/content_main" />
        ...
    </androidx.constraintlayout.widget.ConstraintLayout>
    ...
</androidx.drawerlayout.widget.DrawerLayout>
hohteri
fonte
1

Eu achei que brincar com styles.xml e atividade era muito complicado, portanto, criei um método de utilitário comum que possui as opções abaixo definidas

Java

Window window = getWindow();
window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
window.setStatusBarColor(Color.TRANSPARENT);

Kotlin DSL

activity.window.apply {
    clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
    addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
    decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    statusBarColor = Color.TRANSPARENT
}

E isso foi o suficiente para alcançar uma barra de status transparente. Espero que isto ajude.

Sumit Sahoo
fonte
0

android:fitsSystemWindows="true"só funciona na v21. Podemos configurá-lo no tema xml ou no layout pai, como LinearLayoutem CoordinateLayout. Abaixo da v21, não foi possível adicionar este sinalizador. Por favor, crie uma pasta de valores diferentes com um style.xmlarquivo diferente conforme sua necessidade.

Ashish Saini
fonte
0

Isso funcionou para mim:

<item name="android:statusBarColor">@android:color/transparent</item>
<item name="android:navigationBarColor">@android:color/transparent</item>
<item name="android:windowTranslucentStatus">false</item>
<item name="android:windowTranslucentNavigation">false</item>
greif.matthias
fonte
0

Tudo o que precisamos é entrar em MainActivity.java


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

        Window g = getWindow();
        g.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);

        setContentView(R.layout.activity_main);

    }
DINA TAKLIT
fonte
No entanto, recebo alguns bugs assustadores quando começo a rolar para baixo.
0

no meu caso, como eu tenho uma barra de ferramentas inferior, tive um problema ao testar as soluções anteriores, os botões do sistema Android são cobertos pelo meu menu inferior, minha solução é adicionar à atividade:

void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState);

    // force full screen mode
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);


    setContentView(R.layout.main_activity_container);
aymenhs
fonte
0

Você pode usar este código abaixo.

getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN); 
getWindow().setStatusBarColor(Color.TRANSPARENT);

Inclua esse layout no seu layout principal.

toolbar.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.appcompat.widget.Toolbar xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/toolbarNav"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@android:color/transparent"
        app:contentInsetEnd="0dp"
        app:contentInsetLeft="0dp"
        app:contentInsetRight="0dp"
        app:contentInsetStart="0dp">

        <RelativeLayout
            android:id="@+id/rlBackImageLayout"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:background="@drawable/main_background2">  //add your color here

            <LinearLayout
                android:layout_width="match_parent"
                android:layout_height="@dimen/_40sdp"
                android:layout_marginTop="@dimen/_16sdp"
                android:orientation="horizontal">

                <ImageView
                    android:id="@+id/toolbarIcon"
                    android:layout_width="@dimen/_30sdp"
                    android:layout_height="@dimen/_30sdp"
                    android:layout_gravity="center"
                    android:layout_marginStart="@dimen/_10sdp"
                    android:padding="@dimen/_5sdp"
                    android:src="@drawable/nav_icon" />

                <TextView
                    android:id="@+id/txtTitle"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:layout_gravity="center"
                    android:layout_marginEnd="@dimen/_30sdp"
                    android:fontFamily="@font/muli_semibold"
                    android:gravity="center"
                    android:textColor="#fff"
                    android:textSize="@dimen/_14ssp"
                    android:textStyle="bold"
                    tools:text="test Data" />

            </LinearLayout>

        </RelativeLayout>

    </androidx.appcompat.widget.Toolbar>

Nota: Você pode substituir o SDP e o SSP por dp e sp, respectivamente.

Vivek Makwana
fonte
0

no meu caso, eu não chamo nada de "onCreate" (é um aplicativo nativo react e isso pode ser corrigido também usando o componente StatusBar react-native) também pode ser usado:

override fun onStart() {
        super.onStart()
        window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
        window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
        window.statusBarColor = Color.TRANSPARENT
}
gor
fonte
0

Isso deve funcionar

// Em Activity onCreate (), por exemplo

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    Window w = getWindow();
    w.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}
Favor okechukwu
fonte
0

Encontrei a resposta enquanto investigava esta biblioteca: https://github.com/laobie/StatusBarUtil

então você precisa adicionar os seguintes códigos à sua atividade

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS)
    window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
    window.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
    window.statusBarColor = Color.TRANSPARENT
} else {
    window.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
}
Ali Gürelli
fonte
0

adicione essas linhas em sua atividade antes do setContentView ()

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    Window w = getWindow();
    w.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
}

adicione estas 2 linhas ao seu AppTheme

<item name="android:windowTranslucentStatus">true</item>
<item name="android:windowTranslucentNavigation">true</item>

e a última coisa que sua minSdkVersion deve ser 19

minSdkVersion 19
Null Pointer Exception
fonte
-1
 <item name="android:statusBarColor" tools:targetApi="lollipop">@android:color/transparent</item>
            <!--<item name="android:windowLightStatusBar" tools:targetApi="m">true</item>-->

Não use o windowLightStatusBarusostatusBarColor = @android:color/transparent

NickUnuchek
fonte
-1

Isso é apenas para o nível da API> = 21. Funciona para mim. Aqui está o meu código (Kotlin)

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        findViewById<View>(android.R.id.content).systemUiVisibility =
                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
}
Capotasto
fonte