Android पूरी तरह से पारदर्शी स्थिति पट्टी?

Question

मैंने प्रलेखन खोजा है, लेकिन केवल यही पाया गया: लिंक । बार को पारभासी बनाने के लिए किसका उपयोग किया जाता है ? मैं जो करने की कोशिश कर रहा हूं वह स्टेटस बार को पूरी तरह से पारदर्शी बनाने के लिए है (जैसा कि नीचे दी गई छवि में दिखाया गया है) और इसे एपीके 19 के लिए पीछे की ओर संगत बनाएं।

मेरी शैलियाँ। 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>

मैं क्या करने में सक्षम था:

Answer 1

आपको बस इन गुणों को अपनी थीम में सेट करना है:

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

आपकी गतिविधि / कंटेनर लेआउट जिसे आप चाहते हैं कि एक पारदर्शी स्थिति पट्टी की आवश्यकता हो, इस संपत्ति को सेट करें:

android:fitsSystemWindows="true"

पूर्व किटकैट पर यह सुनिश्चित करने के लिए आम तौर पर प्रदर्शन करना संभव नहीं है, ऐसा लगता है कि आप ऐसा कर सकते हैं लेकिन कुछ अजीब कोड इसे बनाते हैं ।

संपादित करें: मैं इस लिब की सिफारिश करूंगा: https://github.com/jgilfelt/SystemBarTint बहुत सारे प्री-लॉलीपॉप स्टेटस बार कलर कंट्रोल के लिए।

बहुत विचार-विमर्श के बाद मैंने सीखा है कि लॉलीपॉप के लिए स्टेटस बार और नेविगेशन बार पर पूरी तरह से ट्रांसलेंसी या किसी भी रंग को निष्क्रिय करने का जवाब इस झंडे को खिड़की पर सेट करना है:

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

कोई अन्य थीम-आईएनजी आवश्यक नहीं है, यह कुछ इस तरह का उत्पादन करता है:

Comments

मैंने कोड का उपयोग किया और फिर पृष्ठभूमि के रूप में एक छवि जोड़ी और फिर android:fitsSystemWindows="true"अपनी गतिविधि_मैं.एक्सएमएल में जोड़ी । सिस्टम बार पारभासी हैं और पारदर्शी नहीं हैं।

— मुहम्मद अली

वैसे मुझे विश्वास है कि आपको उस मामले में सभी की जरूरत है, फिर <item name="android:statusBarColor">@android:color/transparent</item>अपने विषय में जोड़ना है :)

— डैनियल विल्सन

हाँ, हम आपके धैर्य के लिए धन्यवाद करते हैं, मैं लगभग एक झुकाव पर हूं क्योंकि मैं पिछले कुछ घंटों के लिए एक्सडी करने की कोशिश कर रहा हूं। ऊपर दिया गया कोड काम नहीं करता है लेकिन मैंने android:windowTranslucentStatusझूठे को सेट कर दिया है और इसने स्टेटस बार को पारदर्शी बना दिया है। अब मैंने नेवीगटन बार के साथ भी यही किया और जोड़ा <item name="android:navigationBarColor">@android:color/transparent</item>लेकिन यह दोनों बार को ग्रे बनाता है। छी!

— मुहम्मद अली

इसके w.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);बजाय "समायोजनपैन" काम का उपयोग करने के लिए

— अरदा कारा

ध्यान दें: FLAG_LAYOUT_NO_LIMITS ध्वज का उपयोग करने से आपके लेआउट को नीचे की ओर वर्चुअल नेवी बार में रखा जाएगा। सामान्य तौर पर, आप ऐसा नहीं करना चाहते ... इसलिए

— डिट्टो

Answer 2

कोड की इस लाइन को अपनी मुख्य जावा फ़ाइल में जोड़ें:

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

Comments

यह नेविगेशन बार को भी प्रभावित करता है।

— Android डेवलपर

Answer 3

आप बाहरी लाइब्रेरी StatusBarUtil का उपयोग कर सकते हैं :

अपने मॉड्यूल स्तर में जोड़ें build.gradle:

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

तब आप स्थिति बार को पारदर्शी बनाने के लिए किसी गतिविधि के लिए निम्नलिखित उपयोग कर सकते हैं:

StatusBarUtil.setTransparent(Activity activity)

उदाहरण:

Comments

नेविगेशन ड्रॉअर के लिए यह कैसे करें?

— रीजेश पीके

एक lib एक आग फेंकने की तोप के साथ इस तरह अपने प्रकाश एक मोमबत्ती का समाधान सिर्फ

— फेलिप Castilhos

@FelipeCastilhos हाँ हो सकता है, लेकिन क्या होगा अगर आप स्टेटस बार के साथ बहुत सारे काम कर रहे हैं और आप खराब एपीआई से निपटना नहीं चाहते हैं तो Google आपको प्रदान करता है?

— डेविड रॉसन

@DavidRawson जो एक अलग परिदृश्य है। यहां हम केवल पारदर्शिता जोड़ने की बात कर रहे हैं। इसे संभालने के लिए अपने कोडबेस में बहुत अधिक थर्ड पार्टी कोड क्यों जोड़ें?

— फेलिप कास्टिलोस

Answer 4

एंड्रॉइड किटकैट और इसके बाद के संस्करण के लिए काम करता है (उन लोगों के लिए जो स्टेटस बार को पारदर्शी करना चाहते हैं और नेवीगेशनबार में हेरफेर नहीं करते हैं, क्योंकि इन सभी उत्तरों से नेविगेशनबार भी पारदर्शी होगा!)

इसे प्राप्त करने का सबसे आसान तरीका:

कोड की इन 3 पंक्तियों को styles.xml (v19)-> यदि आप नहीं जानते कि यह (v19) कैसे है, तो बस उन्हें अपने डिफ़ॉल्ट में लिखें styles.xmlऔर फिर इसे स्वचालित रूप से बनाने के लिए alt+ enterका उपयोग करें :

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

और अब, अपनी MainActivityकक्षा में जाएँ और इस विधि को कक्षा में रखें।

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

फिर इस कोड onCreateको गतिविधि की विधि में रखें:

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

बस!

Comments

रिएक्ट नेटिव में मेरे अनुभव के रूप में ... ऊपर दिए गए कोड कीबोर्ड दिखाने के साथ संघर्ष है (समायोजित करें)। इसलिए, मैं अभी थोड़े बदलाव करता हूं: `` if (Build.VERSION.SDK_INT> = 19) {getWindow ()। GetDecorView ()। SetSystemUiVisibility (View.SYSTEM -UI_FLAG_LAYOUT_STABLE); } `` `और घटक में` `<StatusBar पारभासी = {सत्य} पृष्ठभूमि का रंग =" पारदर्शी "/>` `` और AppManisfes में - MainActivity `` Android: windowSoftInputMet = "समायोजन" `` `और बाकी कोड हैं वही। फ़ि: `` `प्रतिक्रिया-मूलक”: “0.61.5”, `` `शुक्रिया @ दारसा दादरा

— रुडी विजया

Answer 5

पूरी तरह से ट्रांसपेरेंट स्टेटसबार और नेवीगेशनबार

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

Comments

केवल समाधान जो वास्तव में मेरे लिए कियोस्क मोड (स्क्रीन पिनिंग) के साथ काम करता है।

— Brontes

Answer 6

स्टेटसबार के तहत अपना लेआउट बनाने के लिए:

मान / styles.xml

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

मान-V21 / styles.xml

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

CoordinatorLayout / DrawerLayout का उपयोग करें जो पहले से ही FitSystemWindows पैरामीटर का ध्यान रखता है या इस तरह से अपना खुद का लेआउट बनाता है:

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>

परिणाम:

स्क्रीनशॉट:

Answer 7

आप स्थिति को पारदर्शी बनाने के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं। लाल हाइलाइट के साथ चित्र देखें जो आपको नीचे दिए गए कोड के उपयोग की पहचान करने में मदद करता है

अपने Android एप्लिकेशन के लिए कोटलिन कोड स्निपेट

स्टेप: 1 क्रिएट मेक इन कोड को लिखिए

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
}

Step2: आपको सेटविंडोफ्लैग विधि की आवश्यकता है जो नीचे दिए गए कोड में वर्णित है।

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
}

आपके एंड्रॉइड ऐप के लिए जावा कोड स्निपेट:

Step1: मुख्य गतिविधि कोड

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

Step2: 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);
}

Comments

मैं सिर्फ मदद करने के लिए हमारे डेवलपर समुदाय के साथ अपना कोड साझा करता हूं। 😊

— CodeInsideCofee

Answer 8

android:fitsSystemWindows="false"अपने शीर्ष लेआउट में उपयोग करें

Comments

यह नेविगेशन बार को भी प्रभावित करता है

— इब्राहिम करीम

Answer 9

यहाँ kotlin में एक एक्सटेंशन दिया गया है जो इस चाल को करता है:

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

Answer 10

अपने XML में इस कोड का उपयोग करके, आप अपनी गतिविधि में समय पट्टी देख पाएंगे:

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

Answer 11

तीन चरण हैं:

1) इस कोड सेगमेंट को अपने @OnCreate मेथड में उपयोग करें

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

यदि आप Fragment पर काम कर रहे हैं, तो आपको अपनी गतिविधि के @OnCreate पद्धति में इस कोड सेगमेंट को रखना चाहिए।

2) /res/values-v21/styles.xml में पारदर्शिता भी सेट करना सुनिश्चित करें:

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

या आप प्रोग्रामेटिक रूप से पारदर्शिता सेट कर सकते हैं:

getWindow().setStatusBarColor(Color.TRANSPARENT);

3) वैसे भी आपको style.xml में कोड सेगमेंट जोड़ना चाहिए

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

नोट: यह विधि सिर्फ एपीआई 21 और इसके बाद के संस्करण पर काम करती है।

Answer 12

आप मेरे उदाहरण को एनिमेटेड अवतार और एनिमेटेड पाठ के साथ भी देख सकते हैं

CollapsingAvatarToolbarSample

मेरी पोस्ट को मीडियम पर पढ़ें

तो मुझे यह पता लगाने देता है कि यह कैसे काम करता है। मैंने कस्टम व्यू कार्यान्वित AppBarLayout.OnOffsetChangedListener बनाया । हेडकॉलैपिंग कस्टम व्यू के अंदर मैंने 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)
     }
}

फिर गणना प्रतिशत के माध्यम से विचार बदलें। उदाहरण के लिए, पाठ दृश्य कैसे बदलते हैं:

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

यह पता लगाने के लिए कि कब जरूरत पड़ने वाली छवि चेतन वस्तु को बनाए

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

राज्यों के साथ: 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
    }

अवतार swith राज्य के लिए फिर cretaed एनीमेशन:

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

Answer 13

आप कोशिश कर सकते हैं कि

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

Answer 14

जबकि ऊपर दिए गए सभी उत्तर एक ही मौलिक विचार के आसपास घूमते हैं और आप इसे ऊपर दिए गए उदाहरणों का उपयोग करके सरल लेआउट के साथ काम करने के लिए प्राप्त कर सकते हैं। हालाँकि मैं 'फुल स्क्रीन' (टैब बार एक तरफ) खंडन नेविगेशन का उपयोग करते हुए पृष्ठभूमि का रंग बदलना चाहता था और नियमित नेविगेशन, टैब और एक्शन बार बनाए रखता था।

एंटोन हडुतस्की के एक लेख को ध्यान से पढ़ने के बाद मुझे बेहतर समझ थी कि क्या चल रहा है।

मैं DrawerLayoutके साथ ConstraintLayout(यानी कंटेनर) जो है Toolbar, मुख्य टुकड़ा और के लिए शामिल हैं BottomNavigationView।

स्थापना DrawerLayoutहोने fitsSystemWindowsसच करने के लिए पर्याप्त नहीं है, तो आप दोनों निर्धारित करने की आवश्यकता DrawerLayoutहै और ConstraintLayout। पारदर्शी स्थिति पट्टी मानकर, स्थिति पट्टी रंग अब पृष्ठभूमि रंग के समान है ConstraintLayout।

हालाँकि, शामिल किए गए टुकड़े में अभी भी स्टेटस बार इनसेट है, इसलिए टॉप के साथ एक और 'फुल स्क्रीन' टुकड़े को एनिमेट करना स्टेटस बार का रंग नहीं बदलता है।

में संदर्भित किया जाता है लेख से एक छोटा सा कोड Activityकी onCreate:

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

और सब अच्छा है, सिवाय इसके Toolbarकि स्थिति पट्टी की ऊँचाई को संबोधित नहीं करता है। कुछ और लेख का जिक्र है और हमारे पास पूरी तरह से काम करने का हल है:

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

Main_activity.xml (कृपया ध्यान दें कि Toolbarपूर्वावलोकन उद्देश्यों के लिए इसमें मार्जिन है, यह कोड द्वारा प्रतिस्थापित किया जाएगा):

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

Answer 15

मुझे बहुत अधिक बोझिल होने के लिए स्टाइल.एक्सएमएल और एक्टिविटी में फ़िदालिंग लगा, इसलिए एक आम यूटिलिटी मेथड बनाया, जिसमें नीचे दिए गए विकल्प हैं

जावा

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

कोटलिन डी.एस.एल.

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
}

और यह सब पारदर्शी स्थिति पट्टी को प्राप्त करने के लिए किया गया है। उम्मीद है की यह मदद करेगा।

Answer 16

android:fitsSystemWindows="true"केवल v21 पर काम करते हैं। हम इसे थीम xml या माता-पिता के लेआउट में जैसे LinearLayoutया में सेट कर सकते हैं CoordinateLayout। नीचे v21 के लिए, हम इस ध्वज को नहीं जोड़ सकते। कृपया style.xmlअपनी आवश्यकता के अनुसार अलग-अलग फ़ाइल के साथ अलग-अलग मान फ़ोल्डर बनाएँ ।

Answer 17

यह मेरे लिए काम किया:

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

Answer 18

सभी को इसमें जाने की जरूरत है 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);

    }

Comments

हालाँकि मुझे कुछ डरावने कीड़े मिलते हैं जब मैं नीचे स्क्रॉल करना शुरू करता हूं।

Answer 19

मेरे मामले में जैसा कि मैंने एक नीचे टूल बार किया है मुझे पिछले समाधानों का परीक्षण करते समय एक समस्या थी, एंड्रॉइड सिस्टम बटन मेरे निचले मेनू के साथ कवर किए गए हैं मेरा समाधान गतिविधि के भीतर जोड़ना है:

संरक्षित शून्य onCreate (बंडल सहेजी गई InstanceState) {super.onCreate (saveInstanceState);

    // 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);

Answer 20

आप इस नीचे दिए गए कोड का उपयोग कर सकते हैं।

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

अपने मुख्य लेआउट में इस लेआउट को शामिल करें।

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>

नोट: आप एसडीपी और एसएसपी को क्रमशः डीपी और एसपी से बदल सकते हैं।

Answer 21

मेरे मामले में, मैं सभी "onCreate" पर कॉल नहीं करता हूं (इसकी एक प्रतिक्रिया देशी ऐप है और यह प्रतिक्रिया-देशी StatusBar घटक का उपयोग करके भी फिक्स किया जा सकता है) एक भी इसका उपयोग कर सकता है:

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
}

Answer 22

यह काम करना चाहिए

उदाहरण के लिए एक्टिविटी ऑनक्रिएट () में

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

Answer 23

इस लाइब्रेरी की जाँच के दौरान मुझे इसका उत्तर मिला: https://github.com/laobie/StatusBarUtil

इसलिए आपको अपनी गतिविधि में निम्नलिखित कोड जोड़ने होंगे

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

Answer 24

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

इन 2 पंक्तियों को अपने AppTheme में जोड़ें

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

और आखिरी बात आपके minSdkVersion को 19 होना चाहिए

minSdkVersion 19

Answer 25

 <item name="android:statusBarColor" tools:targetApi="lollipop">@android:color/transparent</item>
            <!--<item name="android:windowLightStatusBar" tools:targetApi="m">true</item>-->

windowLightStatusBarइसके बजाय उपयोग का उपयोग न करेंstatusBarColor = @android:color/transparent

Answer 26

यह केवल एपीआई स्तर> = 21 के लिए है। यह मेरे लिए काम करता है। यहाँ मेरा कोड है (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
}