Lollipop: rysuj za paskiem statusu z kolorem ustawionym na przezroczysty

Ustawiłem kolor paska statusu na przezroczysty dla Lollipopa tylko z następującym wierszem w moim motywie:

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

Teraz muszę się za tym rysować, ale nie mogę uzyskać za tym żadnego widoku. Wiem, jak to zrobić z tą windowTranslucentStatuswłaściwością, ale nie chcę jej używać, ponieważ wtedy zignoruje ona kolor paska statusu ustawiony na przezroczysty.

Metoda nr 1:

Aby uzyskać całkowicie przezroczysty pasek stanu, musisz użyć statusBarColor, który jest dostępny tylko w API 21 i nowszych. windowTranslucentStatusjest dostępny w API 19 i nowszych, ale dodaje przyciemnione tło do paska stanu. Jednak ustawienie windowTranslucentStatusdaje jedną rzecz, statusBarColorktórej nie daje zmiana na przezroczystą: ustawia flagi SYSTEM_UI_FLAG_LAYOUT_STABLE i SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. Najłatwiejszym sposobem na uzyskanie tego samego efektu jest ręczne ustawienie tych flag, co skutecznie wyłącza wstawki narzucone przez system układu Androida i pozostawia samemu sobie.

W swojej onCreatemetodzie nazywasz tę linię :

getWindow().getDecorView().setSystemUiVisibility(
    View.SYSTEM_UI_FLAG_LAYOUT_STABLE
    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);

Pamiętaj, aby ustawić przezroczystość w /res/values-v21/styles.xml:

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

Lub ustaw przezroczystość programowo:

getWindow().setStatusBarColor(Color.TRANSPARENT);

Dobrą stroną tego podejścia jest to, że te same układy i projekty mogą być również używane w API 19, zamieniając przezroczysty pasek stanu na przyciemniany półprzezroczysty pasek stanu.

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

Metoda nr 2:

Jeśli potrzebujesz tylko pomalować obraz tła pod paskiem stanu, zamiast umieszczać widok za nim, możesz to zrobić, ustawiając tło motywu działania na żądany obraz i ustawiając przezroczystość paska stanu, jak pokazano w metodzie # 1. To była metoda, której użyłem do stworzenia zrzutów ekranu do artykułu Android Police z kilku miesięcy temu.

Metoda nr 3:

Jeśli musisz zignorować standardowe wstawki systemowe dla niektórych układów, zachowując je w innych, jedynym realnym sposobem na to jest praca z często połączoną ScrimInsetsFrameLayoutklasą. Oczywiście niektóre rzeczy wykonane na tych zajęciach nie są konieczne we wszystkich scenariuszach. Na przykład, jeśli nie planujesz używać syntetycznej nakładki paska stanu, po prostu init()zakomentuj wszystko w metodzie i nie przejmuj się dodawaniem niczego do pliku attrs.xml. Widziałem, jak to podejście działa, ale myślę, że przekonasz się, że ma ono inne implikacje, których obejście może wymagać dużo pracy.

Zauważyłem też, że sprzeciwiasz się owijaniu wielu układów. W przypadku zawijania jednego układu wewnątrz drugiego, gdzie oba mają match_parentwysokość i szerokość, wpływ na wydajność jest zbyt trywialny, aby się nim martwić. Niezależnie od tego możesz całkowicie uniknąć tej sytuacji, zmieniając klasę, z której się ona rozciąga, FrameLayoutna dowolną inną klasę układu, którą lubisz. Będzie działać dobrze.

To zadziałało w moim przypadku

// Create/Set toolbar as actionbar
toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

// Check if the version of Android is Lollipop or higher
if (Build.VERSION.SDK_INT >= 21) {

    // Set the status bar to dark-semi-transparentish
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS,
            WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);

    // Set paddingTop of toolbar to height of status bar.
    // Fixes statusbar covers toolbar issue
    toolbar.setPadding(0, getStatusBarHeight(), 0, 0);
}

// A method to find height of the status bar
public int getStatusBarHeight() {
    int result = 0;
    int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
    if (resourceId > 0) {
        result = getResources().getDimensionPixelSize(resourceId);
    }
    return result;
}

Więcej informacji na temat pracy z paskami stanu: youtube.com/watch?v=_mGDMVRO3iE

Wypróbuj ten motyw

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- Customize your theme here. -->
    <item name="windowActionBar">false</item>
    <item name="windowNoTitle">true</item>
    <item name="colorPrimaryDark">@android:color/transparent</item>
    <item name="colorPrimary">@color/md_blue_200</item>
    <item name="android:windowDrawsSystemBarBackgrounds">true</item>
    <item name="android:statusBarColor">@android:color/transparent</item>
    <item name="android:windowTranslucentStatus">true</item>
</style>

Upewnij się, że twój zestaw układów

android:fitsSystemWindows="false"

Zamiast

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

Użyj następujących:

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

I pamiętaj, aby usunąć górne wypełnienie (które jest dodawane domyślnie) w układzie „MainActivity”.

Zwróć uwagę, że nie czyni to paska stanu w pełni przezroczystym, a na pasku stanu nadal będzie widoczna „wyblakła czarna” nakładka.

Rozwiązanie od Cody Toombs prawie załatwiło sprawę . Nie jestem pewien, czy jest to związane z platformą Xamarin, czy nie, ale mam teraz akceptowalne rozwiązanie:

To jest moja konfiguracja:

Mam projekt systemu Android, w którym odwołałem się do pakietów Android.Support v4 i v7. Mam zdefiniowane dwa style:

values ​​/ styles.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<resources>
    <style name="MyStyle" parent="@style/Theme.AppCompat.Light.NoActionBar">
        <item name="android:windowTranslucentStatus">true</item>
    </style>
</resources>

values-v21 / styles.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<resources>
    <style name="MyStyle" parent="@style/Theme.AppCompat.Light.NoActionBar">
        <item name="android:statusBarColor">@android:color/transparent</item>
    </style>
</resources>

AndroidManifest jest kierowany na „MyStyle”:

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="com.agn.test.test">
    <uses-sdk android:minSdkVersion="10" />
    <application android:allowBackup="true" android:icon="@mipmap/icon" android:label="@string/app_name" android:theme="@style/MyStyle">
    </application>
</manifest>

I na koniec kod w głównym działaniu:

[Activity (Label = "Test", MainLauncher = true, Icon = "@mipmap/icon")]
public class MainActivity : Activity
{
    protected override void OnCreate (Bundle savedInstanceState)
    {
        base.OnCreate (savedInstanceState);

        SetContentView (Resource.Layout.Main);
        //Resource.Layout.Main is just a regular layout, no additional flags. Make sure there is something in there like an imageView, so that you can see the overlay.

        var uiOptions = (int)Window.DecorView.SystemUiVisibility;
        uiOptions ^= (int)SystemUiFlags.LayoutStable;
        uiOptions ^= (int)SystemUiFlags.LayoutFullscreen;
        Window.DecorView.SystemUiVisibility = (StatusBarVisibility)uiOptions;

        Window.AddFlags (WindowManagerFlags.DrawsSystemBarBackgrounds);
    }
}

Zauważ, że ustawiłem flagę DrawsSystemBarBackgrounds, to robi różnicę

Window.AddFlags (WindowManagerFlags.DrawsSystemBarBackgrounds); 

Spędziłem dużo czasu, aby to naprawić, w rzeczywistości zbyt wiele. Mam nadzieję, że ta odpowiedź pomoże każdemu, kto próbuje osiągnąć to samo.

Odpowiedź @Cody Toombs prowadzi do problemu, który powoduje układ za paskiem nawigacyjnym. Więc to, co znalazłem, używa tego rozwiązania podane przez @Kriti

tutaj jest fragment kodu Kotlin dla tego samego:

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) {
    window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
}

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

private fun setWindowFlag(activity: Activity, bits: Int, on: Boolean) {

    val win: Window = activity.getWindow()

    val winParams: WindowManager.LayoutParams = win.getAttributes()
    if (on) {
        winParams.flags = winParams.flags or bits
    } else {
        winParams.flags = winParams.flags and bits.inv()
    }
    win.setAttributes(winParams)
}

Musisz także dodać

android:fitsSystemWindows="false"

widok główny układu.

Miałem ten sam problem, więc tworzę ImageView, który rysuje za paskiem stanu API 19+

Ustaw niestandardowy obraz za paskiem stanu gist.github.com

public static void setTransparent(Activity activity, int imageRes) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
        return;
    }
    // set flags
    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);
    }

    // get root content of system window
    //ViewGroup rootView = (ViewGroup) ((ViewGroup) activity.findViewById(android.R.id.content)).getChildAt(0);
    // rootView.setFitsSystemWindows(true);
    // rootView.setClipToPadding(true);

    ViewGroup contentView = (ViewGroup) activity.findViewById(android.R.id.content);
    if (contentView.getChildCount() > 1) {
        contentView.removeViewAt(1);
    }

    // get status bar height
    int res = activity.getResources().getIdentifier("status_bar_height", "dimen", "android");
    int height = 0;
    if (res != 0)
        height = activity.getResources().getDimensionPixelSize(res);

    // create new imageview and set resource id
    ImageView image = new ImageView(activity);
    LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, height);
    image.setLayoutParams(params);
    image.setImageResource(imageRes);
    image.setScaleType(ScaleType.MATRIX);

    // add image view to content view
    contentView.addView(image);
    // rootView.setFitsSystemWindows(true);

}

Możesz użyć ScrimInsetFrameLayout

https://github.com/google/iosched/blob/master/android/src/main/java/com/google/samples/apps/iosched/ui/widget/ScrimInsetsFrameLayout.java

android: fitSystemWindows = "true" powinno być ustawione na układzie scrim!

Podobnie jak w przypadku niektórych opublikowanych rozwiązań, ale w moim przypadku pasek stanu był przezroczysty i naprawiałem pozycję paska akcji z pewnym ujemnym marginesem

if (Build.VERSION.SDK_INT >= 21) {
    getWindow().setStatusBarColor(Color.TRANSPARENT);
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) toolbar.getLayoutParams();
    lp.setMargins(0, -getStatusBarHeight(), 0, 0);
}

I użyłem na pasku narzędzi i widoku głównym

android:fitsSystemWindows="true"

Istnieje dobra biblioteka StatusBarUtil z @laobie która pomaga w łatwym rysowaniu obrazu w StatusBar.

Po prostu dodaj swoje build.gradle:

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

Następnie w zestawie Activity

StatusBarUtil.setTranslucentForImageView(Activity activity, int statusBarAlpha, View viewNeedOffset)

W układzie

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 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:background="@color/white"
    android:orientation="vertical">

    <ImageView
        android:layout_alignParentTop="true"
        android:layout_width="match_parent"
        android:adjustViewBounds="true"
        android:layout_height="wrap_content"
        android:src="@drawable/toolbar_bg"/>

    <android.support.design.widget.CoordinatorLayout
        android:id="@+id/view_need_offset"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <android.support.v7.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="@android:color/transparent"
            app:popupTheme="@style/ThemeOverlay.AppCompat.Light"
            app:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"/>

        <!-- Your layout code -->
    </android.support.design.widget.CoordinatorLayout>
</RelativeLayout>

Aby uzyskać więcej informacji, pobierz demo lub sklonuj ze strony github i baw się wszystkimi funkcjami.

Uwaga: Wsparcie KitKat i nowszych.

Mam nadzieję, że to pomoże komuś innemu!

W Android Studio 1.4 projekt szablonu z kodem płyty kotłowej ustawia Overlaymotyw na AppbarLayout i / lub pasku narzędzi. Są również ustawione tak, aby były renderowane za paskiem stanu przez fitSystemWindowatrybut = true. Spowoduje to, że tylko pasek narzędzi będzie renderowany bezpośrednio pod paskiem stanu, a wszystko inne będzie renderowane pod paskiem narzędzi. Dlatego powyższe rozwiązania nie będą działać samodzielnie. Będziesz musiał wprowadzić następujące zmiany.

• Usuń motyw nakładki lub zmień go na motyw bez nakładki dla paska narzędzi.

• Umieść następujący kod w swoim pliku styles-21.xml .

  @android: kolor / przezroczysty

• Przypisz ten motyw do działania zawierającego szufladę nawigacji w pliku AndroidManifest.xml .

Spowoduje to, że szuflada nawigacji będzie renderowana za przezroczystym paskiem stanu.

Wszystko, co musisz zrobić, to ustawić te właściwości w swoim motywie

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

Zaakceptowana odpowiedź zadziałała dla mnie przy użyciu CollapsingToolbarLayout. Należy jednak pamiętać, że setSytstemUiVisibility()przesłania to wszelkie wcześniejsze wywołania tej funkcji. Więc jeśli używasz tej funkcji gdzie indziej dla tego samego widoku, musisz dołączyć View.SYSTEM_UI_FLAG_LAYOUT_STABLEiView.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN flagi , w przeciwnym razie zostaną one nadpisane przez nowe wywołanie.

Tak było w moim przypadku, a kiedy dodałem dwie flagi do innego miejsca, do którego dzwoniłem setSystemUiVisibility(), zaakceptowana odpowiedź działała idealnie.

Dodam tutaj więcej informacji. Najnowsze osiągnięcia Androida ułatwiły obsługę wielu przypadków na pasku stanu. Poniżej znajdują się moje obserwacje zstyles.xml

1. Kolor tła : w przypadku SDK 21+, jak wspomniano w wielu odpowiedziach, <item name="android:windowTranslucentStatus">true</item> pasek stanu będzie przezroczysty i będzie widoczny przed interfejsem użytkownika. Twoja aktywność zajmie całą przestrzeń na górze.

2. Kolor tła : ponownie, w przypadku SDK 21+, <item name="android:statusBarColor">@color/your_color</item>po prostu nada kolor Twojemu paskowi stanu, nie wpływając na nic innego.

3. Jednak w nowszych urządzeniach (Android M / +) ikony zaczęły pojawiać się w różnych odcieniach. System operacyjny może nadać ikonom SDK 23 / + ciemniejszy odcień szarości, jeśli zastąpisz styles.xmlplik w values-23folderze i dodasz <item name="android:windowLightStatusBar">true</item>.
   W ten sposób zapewnisz użytkownikowi bardziej widoczny pasek stanu, jeśli pasek stanu ma jasny kolor (pomyśl, jak wiele aplikacji Google ma jasne tło, a ikony są tam widoczne w kolorze szarym).
   Sugeruję, abyś skorzystał z tego, jeśli nadajesz kolor swojemu paskowi stanu za pośrednictwem punktu # 2

4. W najnowszych urządzeniach SDK 29 / + jest wyposażony w systemowy, jasny i ciemny motyw, kontrolowany przez użytkownika. Jako programiści mamy również zastąpić nasz plik stylu w nowym values-nightfolderze, aby dać użytkownikowi 2 różne doświadczenia.
   Tutaj ponownie stwierdziłem, że punkt # 2 jest skuteczny w zapewnianiu „koloru tła paska stanu”. Ale system nie zmieniał koloru ikon paska stanu dla mojej aplikacji. ponieważ moja dzienna wersja stylu składała się z jaśniejszego motywu, oznacza to, że użytkownicy będą cierpieć z powodu słabej widoczności (białe ikony na jaśniejszym tle)
   Ten problem można rozwiązać, stosując podejście z punktu # 3 lub zastępując plik stylu w values-29folderze i używając nowszego api <item name="android:enforceStatusBarContrast">true</item>. Spowoduje to automatyczne wymuszenie szarawego odcienia ikon, jeśli kolor tła jest zbyt jasny.

Oto motyw, którego używam, aby to osiągnąć:

<style name="AppTheme" parent="@android:style/Theme.NoTitleBar">

    <!-- Default Background Screen -->
    <item name="android:background">@color/default_blue</item>
    <item name="android:windowTranslucentStatus">true</item>

</style>

Właściwym rozwiązaniem jest zmiana właściwości w XML pod tagiem Activity na poniższy styl. Po prostu działa

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