स्लाइड अप / डाउन एनीमेशन के साथ एक दृश्य दिखाएं और छुपाएं

Question

मेरे पास एक LinearLayoutऐसा है जिसे मैं दिखाना चाहता हूं या उसके साथ छिपाना चाहता Animationहूं जब भी मैं अपनी दृश्यता को बदलता हूं तो लेआउट को ऊपर या नीचे की ओर धकेलता है।

मैंने कुछ नमूने देखे हैं, लेकिन उनमें से कोई भी मेरी आवश्यकताओं के अनुरूप नहीं है।

मैंने एनिमेशन के लिए दो xml फाइलें बनाई हैं, लेकिन मुझे नहीं पता है कि जब मैं एक की दृश्यता को बदलता हूं तो उन्हें कैसे शुरू किया जाए LinearLayout।

Answer 1

एंड्रॉइड 3.0 (हनीकॉम्ब) में पेश किए गए नए एनीमेशन एपीआई के साथ इस तरह के एनिमेशन बनाना बहुत सरल है।

एक स्लाइडिंग Viewएक दूरी से नीचे:

view.animate().translationY(distance);

आप बाद में Viewइस तरह अपनी मूल स्थिति में वापस स्लाइड कर सकते हैं :

view.animate().translationY(0);

---

आप आसानी से कई एनिमेशन भी जोड़ सकते हैं। निम्नलिखित एनीमेशन Viewअपनी ऊंचाई से नीचे स्लाइड करेगा और एक ही समय में इसे फीका करेगा:

// Prepare the View for the animation
view.setVisibility(View.VISIBLE);
view.setAlpha(0.0f);

// Start the animation
view.animate()
    .translationY(view.getHeight())
    .alpha(1.0f)
    .setListener(null);

फिर आप Viewबैक को फीका कर सकते हैं और उसे वापस उसकी मूल स्थिति में ले जा सकते हैं। हम एक बार सेट भी करते हैं AnimatorListenerताकि एनीमेशन समाप्त Viewहोने के GONEबाद हम बैक की दृश्यता सेट कर सकें :

view.animate()
    .translationY(0)
    .alpha(0.0f)
    .setListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            super.onAnimationEnd(animation);
            view.setVisibility(View.GONE);
        }
    });

Comments

एक बार देखने के बाद दिखाई क्यों नहीं दिया?

— राम

मैं दृश्यमान चेतन चाहता हूं जब दिखाई देता है और जब जाता है। लेकिन अगर मैं पहली बार देखने गया हूं तो यह दिखाई नहीं दे रहा है और देखने की जगह खाली है

— राम

@Ram Viewजब आप इसकी दृश्यता के लिए सेट हो जाते हैं, तो इसे एनिमेट करके आप क्या हासिल करना View.GONEचाहते हैं? यदि आप इसकी दृश्यता को इसके अलावा किसी भी चीज़ पर सेट View.VISIBLEकरते हैं तो Viewदिखाई नहीं देगी। मुझे समझ नहीं आ रहा है कि आप क्या पूछ रहे हैं। यदि आप चाहते हैं कि आपका एनीमेशन दृश्यमान हो, तो की दृश्यता निर्धारित न Viewकरें View.GONE।

— Xaver Kapeller

उसी मुद्दे का सामना करना पड़ रहा है जो राम का सामना कर रहा था, पहली बार में यह ठीक काम करता है लेकिन अगली बार जब मैं उस दृश्य को चला गया राज्य में बनाता हूं और उस दृश्य को फिर से दिखाई देने की कोशिश करता हूं तो यह दिखाई नहीं देता है।

— पंकज कुमार

@XaverKapeller मुझे लगता है कि समस्या कई लोगों की है कि श्रोता onAnimationEndको बहु-घटित एनीमेशन के लिए हर बार बुलाया जाता है, जिसका अर्थ है कि onAnimationEndयह भी कहा जाता है जब दृश्य दिखाया जाता है, जो कि इसकी दृश्यता को निर्धारित करता है, इत्यादि

— oldgod

Answer 2

मुझे स्वीकृत उत्तर को समझने में परेशानी हो रही थी। मुझे थोड़ा और संदर्भ चाहिए था। अब जब मैंने इसका पता लगा लिया है, तो इसका पूरा उदाहरण है:

MainActivity.java

public class MainActivity extends AppCompatActivity {

    Button myButton;
    View myView;
    boolean isUp;

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

        myView = findViewById(R.id.my_view);
        myButton = findViewById(R.id.my_button);

        // initialize as invisible (could also do in xml)
        myView.setVisibility(View.INVISIBLE);
        myButton.setText("Slide up");
        isUp = false;
    }

    // slide the view from below itself to the current position
    public void slideUp(View view){
        view.setVisibility(View.VISIBLE);
        TranslateAnimation animate = new TranslateAnimation(
                0,                 // fromXDelta
                0,                 // toXDelta
                view.getHeight(),  // fromYDelta
                0);                // toYDelta
        animate.setDuration(500);
        animate.setFillAfter(true);
        view.startAnimation(animate);
    }

    // slide the view from its current position to below itself
    public void slideDown(View view){
        TranslateAnimation animate = new TranslateAnimation(
                0,                 // fromXDelta
                0,                 // toXDelta
                0,                 // fromYDelta
                view.getHeight()); // toYDelta
        animate.setDuration(500);
        animate.setFillAfter(true);
        view.startAnimation(animate);
    }

    public void onSlideViewButtonClick(View view) {
        if (isUp) {
            slideDown(myView);
            myButton.setText("Slide up");
        } else {
            slideUp(myView);
            myButton.setText("Slide down");
        }
        isUp = !isUp;
    }
}

activity_mail.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.slideview.MainActivity">

    <Button
        android:id="@+id/my_button"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="100dp"
        android:onClick="onSlideViewButtonClick"
        android:layout_width="150dp"
        android:layout_height="wrap_content"/>

    <LinearLayout
        android:id="@+id/my_view"
        android:background="#a6e1aa"
        android:orientation="vertical"
        android:layout_alignParentBottom="true"
        android:layout_width="match_parent"
        android:layout_height="200dp">

    </LinearLayout>

</RelativeLayout>

टिप्पणियाँ

• मुझे सही दिशा में इंगित करने के लिए इस लेख के लिए धन्यवाद । यह इस पृष्ठ पर अन्य उत्तरों की तुलना में अधिक सहायक था।
• यदि आप स्क्रीन पर दृश्य के साथ शुरू करना चाहते हैं, तो इसे प्रारंभ न करें INVISIBLE।
• चूंकि हम इसे पूरी तरह से स्क्रीन से अलग कर रहे हैं, इसलिए इसे वापस सेट करने की कोई आवश्यकता नहीं है INVISIBLE । यदि आप स्क्रीन को पूरी तरह से बंद नहीं कर रहे हैं, तो आप अल्फा एनीमेशन जोड़ सकते हैं और दृश्यता को ए के साथ सेट कर सकते हैं AnimatorListenerAdapter।
• संपत्ति एनीमेशन डॉक्स

Comments

Android: दृश्यता = "अदृश्य" दृश्य एनीमेशन को छिपाने के लिए आरंभ करने के लिए

— Goodlife

मैं aimate.setFillAfter (true) के उपयोग की अनुशंसा नहीं करता; यदि आपके पास

— स्लेडेड

ध्यान दें कि .setVisibility(View.INVISIBLE);स्लाइड अप फ़ंक्शन के बिना नेत्रहीन अपेक्षा के अनुरूप काम नहीं करेगा।

— अद्वैत S

Translate Animationदृश्य ले जाता है। यदि आप इसके स्केलिंग की तरह ही चेतन देखना चाहते हैं तो उपयोग करेंScaleAnimation anim = new ScaleAnimation(1, 1, 0, 1)

— ज़ोहैब अली

Answer 3

अब दृश्यता परिवर्तन एनिमेशन को Transition APIसपोर्ट (androidx) पैकेज में उपलब्ध होना चाहिए । बस ट्रांज़िशनमैनएगर को कॉल करें। स्लाइड ट्रांज़ैक्शन के साथ एल्गिलडेलट्रांसशन विधि फिर दृश्य की दृश्यता बदलें।

import androidx.transition.Slide;
import androidx.transition.Transition;
import androidx.transition.TransitionManager;

private void toggle(boolean show) {
    View redLayout = findViewById(R.id.redLayout);
    ViewGroup parent = findViewById(R.id.parent);

    Transition transition = new Slide(Gravity.BOTTOM);
    transition.setDuration(600);
    transition.addTarget(R.id.redLayout);

    TransitionManager.beginDelayedTransition(parent, transition);
    redLayout.setVisibility(show ? View.VISIBLE : View.GONE);
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/parent"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="play" />

    <LinearLayout
        android:id="@+id/redLayout"
        android:layout_width="match_parent"
        android:layout_height="400dp"
        android:background="#5f00"
        android:layout_alignParentBottom="true" />
</RelativeLayout>

इस उत्तर को दूसरे डिफ़ॉल्ट और कस्टम संक्रमण उदाहरणों के साथ जांचें ।

Comments

@akubi हाँ, यह होना चाहिए

— अबा

सबसे अच्छे और आसान उत्तरों में से एक! धन्यवाद!

— krisDrOid

बस ध्यान दें, इसके लिएminSdkVersion 21

— Lasec0203

@ lasec0203 नहीं, कक्षाएं androidxपैकेज से हैं। यह प्री 21 एपी पर ठीक काम करता है।

— आशिरोव

: thumbs_up: यह एक विधि अस्पष्टता से छुटकारा

— दिलाता है जो

Answer 4

सबसे आसान समाधान: android:animateLayoutChanges="true"अपने विचारों को रखने वाले कंटेनर पर सेट करें।

इसे कुछ संदर्भ में रखने के लिए: यदि आपके पास नीचे की तरह एक लेआउट है, तो इस कंटेनर में दृश्य के सभी दृश्यता परिवर्तन स्वचालित रूप से एनिमेटेड होंगे।

<LinearLayout android:id="@+id/container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:animateLayoutChanges="true"
    >

    <Views_which_change_visibility>

</LinearLayout>

आप इस बारे में अधिक जानकारी एनिमेटेड लेआउट परिवर्तन - Android डेवलपर पर पा सकते हैं

Comments

यह सबसे आसान है, लेकिन यह व्यवहार फोन निर्माता के कारण भिन्न है और वह कोड परिवर्तन है

— b2mob

यह अल्फा को एनिमेट करता है, पोजीशन को नहीं।

— सुरग

हां, लेकिन यह मूल प्रश्न था कि क्या मैं इसे सही तरीके से समझ पा रहा हूं। यदि आप पदों को चेतन करना चाहते हैं, तो आप RecyclerView का उपयोग कर सकते हैं जो स्थिर आईडी के साथ ViewHolders का उपयोग करता है।

— स्टीफन मेडैक

Answer 5

Animationजब आप LinearLayoutएक नया उपवर्ग बनाकर परिवर्तनों की दृश्यता शुरू कर सकते हैं LinearLayoutऔर setVisibility()शुरू करने के लिए ओवरराइड कर सकते हैं, तो आप सही शुरुआत कर सकते हैं Animations। कुछ इस तरह से विचार करें:

public class SimpleViewAnimator extends LinearLayout
{
    private Animation inAnimation;
    private Animation outAnimation;

    public SimpleViewAnimator(Context context)
    {
        super(context);
    }

    public void setInAnimation(Animation inAnimation)
    {
        this.inAnimation = inAnimation;
    }

    public void setOutAnimation(Animation outAnimation)
    {
        this.outAnimation = outAnimation;
    }

    @Override
    public void setVisibility(int visibility)
    {
        if (getVisibility() != visibility)
        {
            if (visibility == VISIBLE)
            {
                if (inAnimation != null) startAnimation(inAnimation);
            }
            else if ((visibility == INVISIBLE) || (visibility == GONE))
            {
                if (outAnimation != null) startAnimation(outAnimation);
            }
        }

        super.setVisibility(visibility);
    }
}

Comments

मुझे वास्तव में बेहतर उपवर्ग दृष्टिकोण पसंद है। आपका बहुत बहुत धन्यवाद।

— 11

यह एक भयानक समाधान है, जिसे मैं अपने BaseView में लागू करने वाला हूं। इसके लिए Thx!

— ब्रैम वंडेनब्यूश

जैसा कि यह दिखाते समय काम करता है, जब छुपाते हैं, तो एनीमेशन को देखने से पहले दृश्य गायब हो जाता है। किसी भी काम?

— बर्नार्डो

@BramVandenbussche यह एक भयानक समाधान है। यह Viewअपने स्वयं के एनिमेशन के लिए जिम्मेदार बनाता है जो कभी भी आप क्या चाहते हैं। कल्पना कीजिए कि आप Viewअपने ऐप के दूसरे हिस्से में अलग तरह से चेतन करना चाहते हैं । तब आप क्या करते हो? दृश्यता को स्वचालित रूप से चेतन नहीं करने के लिए एक ध्वज जोड़ें? एनीमेशन को हटाने के लिए उपवर्ग Viewऔर ओवरराइड setVisibility()? या इससे भी बदतर setVisibility()एक और एनीमेशन के साथ लागू ? यह बस वहाँ से बदसूरत और बदसूरत हो जाता है। इस "समाधान" का उपयोग न करें।

— Xaver कपेलर

बेहतर है इसे

— अनिमेटेडलाइयर लॉयआउट कहो

Answer 6

Kotlin

Suragch के उत्तर के आधार पर , यहाँ दृश्य विस्तार का उपयोग करके एक सुंदर तरीका दिया गया है:

fun View.slideUp(duration: Int = 500) {
    visibility = View.VISIBLE
    val animate = TranslateAnimation(0f, 0f, this.height.toFloat(), 0f)
    animate.duration = duration.toLong()
    animate.fillAfter = true
    this.startAnimation(animate)
}

fun View.slideDown(duration: Int = 500) {
    visibility = View.VISIBLE
    val animate = TranslateAnimation(0f, 0f, 0f, this.height.toFloat())
    animate.duration = duration.toLong()
    animate.fillAfter = true
    this.startAnimation(animate)
}

और फिर जहाँ भी आप इसका उपयोग करना चाहते हैं, आपको बस myView.slideUp()या आवश्यकता हैmyView.slideDown()

Comments

केवल बग है, इसे "fillAfter = true" की आवश्यकता नहीं है क्योंकि यह बच्चे के विचारों को क्लिक करने की पहुंच को अवरुद्ध करता है

— रंजन

इसके अलावा, आप शायद SlideDown एनीमेशन के लिए एक श्रोता को जोड़ने और onAnimationEnd पर देखने की आवश्यकता होगी।

— मनोहर रेड्डी

Answer 7

if (filter_section.getVisibility() == View.GONE) {
    filter_section.animate()
            .translationY(filter_section.getHeight()).alpha(1.0f)
            .setListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationStart(Animator animation) {
                    super.onAnimationStart(animation);
                    filter_section.setVisibility(View.VISIBLE);
                    filter_section.setAlpha(0.0f);
                }
            });
} else {
    filter_section.animate()
            .translationY(0).alpha(0.0f)
            .setListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    super.onAnimationEnd(animation);
                    filter_section.setVisibility(View.GONE);
                }
            });
}

Comments

इस उत्तर के साथ मुद्दे: 1) भयानक कोड स्वरूपण। 2) आप कोड को पोस्ट करने के लिए एक कोड स्निपेट का उपयोग करते हैं जो वास्तव में ब्राउज़र में नहीं चलाया जा सकता है। यह सिर्फ दो बेकार बटन नहीं जोड़ता है, लेकिन यह सिंटैक्स हाइलाइटिंग को भी नष्ट कर देता है। 3) यह किसी भी स्पष्टीकरण या उद्देश्य के बिना बस कुछ यादृच्छिक कोड डंप है। 4) आप एक एनीमेशन का प्रदर्शन करते हुए दृश्यता बदल रहे हैं। इस तथ्य के अलावा कि यह स्पष्ट कोड गंध है यह भी ठीक से काम नहीं करेगा। दृश्यता बदलने से एक नई लेआउटिंग प्रक्रिया शुरू होती है, उसके बाद ही एनीमेशन समाप्त होने के बाद वास्तव में काम करने के लिए मूल्य होते हैं। सूची आगे और आगे

— बढ़ती है

मैंने फॉर्मेटिंग को ठीक करने के लिए आपके उत्तर को पहले ही संपादित कर दिया है और कोड स्निपेट को वास्तविक कोड ब्लॉक में बदल दिया है। लेकिन आपको बाकी

— चीजों

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

— अमीन महेन

@AmeenMaheen क्या है setAlpha?

— इगोरगानापोलस्की

@ इगोर गानापोलस्की का उपयोग पारदर्शिता के लिए किया जाता है यानी लुप्त होती प्रभाव देने के लिए

— अमीन महेन

Answer 8

आप एंड्रॉइड ऐप में bellow कोड का उपयोग करके किसी भी दृश्य या लेआउट को ऊपर और नीचे स्लाइड कर सकते हैं

boolean isClicked=false;
LinearLayout mLayoutTab = (LinearLayout)findViewById(R.id.linearlayout);

        if(isClicked){
                    isClicked = false;
                    mLayoutTab.animate()
                    .translationYBy(120)
                    .translationY(0)     
                    .setDuration(getResources().getInteger(android.R.integer.config_mediumAnimTime));

        }else{
                isClicked = true;
                mLayoutTab.animate()
                .translationYBy(0)
                .translationY(120)
                .setDuration(getResources().getInteger(android.R.integer.config_mediumAnimTime));
                }

Comments

120 क्या है? और 0 क्या है? अगर मैं इसे हार्डकोड करना चाहता / चाहती हूं तो setDuration के लिए यूनिट क्या है?

— स्टेनली santoso

यहां 120 और 0 वाई अक्ष से संबंधित दूरी है यदि आप बड़ी स्क्रीन या टैबलेट में समस्या होने की तुलना में हार्ड कोड डालते हैं, तो आपको सभी अलग-अलग डिवाइसों के लिए अपने string.xml मूल्य से मूल्य डालने की आवश्यकता है। और अवधि वह समय है जब आप लेआउट का एनीमेशन दिखाना चाहते हैं .... !!! मेरी खराब अंग्रेजी के लिए माफी चाहूंगा...!

— varotariya vajsi

@varotariyavajsi यह वास्तव में किसी दृश्य की दृश्यता को नहीं दिखाता / छिपाता है।

— इगोरगानापोलस्की

हैलो igor ganapolsky मुझे ये पता है ... यह सिर्फ y दिशा में अनुवाद दृश्य है, अगर उपयोगकर्ता को नीचे स्लाइडर की तरह ऊपर और नीचे दिखाना होगा तो यह ठीक काम करेगा।

— वरोत्रिया वाजसी

Answer 9

इस वर्ग का उपयोग करें:

public class ExpandCollapseExtention {

 public static void expand(View view) {
    view.setVisibility(View.VISIBLE);

    final int widthSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
    final int heightSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
    view.measure(widthSpec, heightSpec);

    ValueAnimator mAnimator = slideAnimator(view, 0, view.getMeasuredHeight());
    mAnimator.start();
}


public static void collapse(final View view) {
    int finalHeight = view.getHeight();

    ValueAnimator mAnimator = slideAnimator(view, finalHeight, 0);

    mAnimator.addListener(new Animator.AnimatorListener() {

        @Override
        public void onAnimationEnd(Animator animator) {               
            view.setVisibility(View.GONE);
        }


        @Override
        public void onAnimationStart(Animator animation) {

        }


        @Override
        public void onAnimationCancel(Animator animation) {

        }


        @Override
        public void onAnimationRepeat(Animator animation) {

        }
    });
    mAnimator.start();
}


private static ValueAnimator slideAnimator(final View v, int start, int end) {

    ValueAnimator animator = ValueAnimator.ofInt(start, end);

    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {

            int value = (Integer) valueAnimator.getAnimatedValue();
            ViewGroup.LayoutParams layoutParams = v.getLayoutParams();
            layoutParams.height = value;
            v.setLayoutParams(layoutParams);
        }
    });
    return animator;
}
}

Answer 10

ObjectAnimator का उपयोग करना

private fun slideDown(view: View) {
    val height = view.height
    ObjectAnimator.ofFloat(view, "translationY", 0.toFloat(), height.toFloat()).apply {
        duration = 1000
        start()
    }
}

private fun slideUp(view: View) {
    val height = view.height
    ObjectAnimator.ofFloat(view, "translationY", height.toFloat(),0.toFloat()).apply {
        duration = 1000
        start()
    }
}

Comments

मामूली सुधार: हम "ट्रांसवाई" के बजाय निरंतर View.TRANSLATION_Y का उपयोग कर सकते हैं और स्लाइड अप ऑब्जेक्ट में भी कर सकते हैं। हम कर सकते हैं। do doEnd {view.visibility = View.Gone/ .......} () प्रारंभ करें ()।

— ताशी

0.toFloat()बस भी हो सकता है0f

— styler1972

Answer 11

मेरे पास एक कोने का मामला था जहां मेरे विचार की ऊंचाई अभी भी थी zero...

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.view.View;

public final class AnimationUtils {

  public static void slideDown(final View view) {
        view.animate()
                .translationY(view.getHeight())
                .alpha(0.f)
                .setListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        // superfluous restoration
                        view.setVisibility(View.GONE);
                        view.setAlpha(1.f);
                        view.setTranslationY(0.f);
                    }
                });
    }

    public static void slideUp(final View view) {
        view.setVisibility(View.VISIBLE);
        view.setAlpha(0.f);

        if (view.getHeight() > 0) {
            slideUpNow(view);
        } else {
            // wait till height is measured
            view.post(new Runnable() {
                @Override
                public void run() {
                    slideUpNow(view);
                }
            });
        }
    }

    private static void slideUpNow(final View view) {
        view.setTranslationY(view.getHeight());
        view.animate()
                .translationY(0)
                .alpha(1.f)
                .setListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        view.setVisibility(View.VISIBLE);
                        view.setAlpha(1.f);
                    }
                });
    }

}

Answer 12

यहाँ मेरा समाधान है। बस अपने दृष्टिकोण का संदर्भ लें और इस विधि को कॉल करें:

public static void animateViewFromBottomToTop(final View view){

    view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

        @Override
        public void onGlobalLayout() {

            view.getViewTreeObserver().removeOnGlobalLayoutListener(this);

            final int TRANSLATION_Y = view.getHeight();
            view.setTranslationY(TRANSLATION_Y);
            view.setVisibility(View.GONE);
            view.animate()
                .translationYBy(-TRANSLATION_Y)
                .setDuration(500)
                .setStartDelay(200)
                .setListener(new AnimatorListenerAdapter() {

                    @Override
                    public void onAnimationStart(final Animator animation) {

                        view.setVisibility(View.VISIBLE);
                    }
                })
                .start();
        }
    });
}

कुछ और करने की ज़रूरत नहीं =)

Comments

ऐसा करने के लिए आपको GlobalLayoutListener की आवश्यकता क्यों होगी? आप इतने अजीब तरीके से दृश्यता क्यों निर्धारित कर रहे हैं? आप उन चीजों को क्यों शामिल कर रहे हैं जो एक शुरुआत में देरी की तरह हैं जो आपके उत्तर में सवाल करने के लिए अप्रासंगिक हैं?

— Xaver Kapeller

Answer 13

कोटलिन में सुरगच का जवाब। इसने मेरे लिए काम किया।

class MainActivity : AppCompatActivity() {

var isUp: Boolean = false

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    var myView: View = findViewById(R.id.my_view)
    var myButton: Button = findViewById(R.id.my_button)

    //Initialize as invisible
    myView.visibility = View.INVISIBLE
    myButton.setText("Slide up")

    isUp = false

}


fun View.slideUp(duration: Int = 500){
    visibility = View.VISIBLE
    val animate = TranslateAnimation(0f, 0f, this.height.toFloat(), 0f)
    animate.duration = duration.toLong()
    animate.fillAfter = true
    this.startAnimation(animate)
}

fun View.slideDown(duration: Int = 500) {
    visibility = View.VISIBLE
    val animate = TranslateAnimation(0f, 0f, 0f, this.height.toFloat())
    animate.duration = duration.toLong()
    animate.fillAfter = true
    this.startAnimation(animate)
}

fun onSlideViewButtonClick(view: View){
    if(isUp){
        my_view.slideDown()
        my_button.setText("Slide Up")

    }
    else{
        my_view.slideUp()
        my_button.setText("Slide Down")
    }
    isUp = !isUp
}

}

Answer 14

आप एनीमेशन दिखाने के लिए कोड की सरल तीन लाइनों का उपयोग कर सकते हैं ...

//getting the hiding view by animation

 mbinding.butn.setOnClickListener {

                val SlideOutLeft = AnimationUtils.loadAnimation(this, R.anim.slide_out_left)
                simplelayout.visibility = View.INVISIBLE
                simplelayout.startAnimation(SlideOutLeft)


                val SlideInRight = AnimationUtils.loadAnimation(applicationContext, R.anim.slide_in_right)
                animation1.visibility = View.VISIBLE
                animation1.startAnimation(SlideInRight)

            }
            //again unhide the view animation
            mbinding.buttn.setOnClickListener {


               val SlideInLeft=AnimationUtils.loadAnimation(this,R.anim.slide_in_left)
                //set the layout
               simplelayout.visibility=View.VISIBLE
               simplelayout.startAnimation(SlideInLeft)

               val SlideOutRight=AnimationUtils.loadAnimation(this,R.anim.slide_out_right)
               animation1.visibility=View.INVISIBLE
               animation1.startAnimation(SlideOutRight)

            }

Answer 15

कोटलिन एक्सटेंशन के साथ आप इसका उपयोग कर सकते हैं:

enum class SlideDirection{
    UP,
    DOWN,
    LEFT,
    RIGHT
}

enum class SlideType{
    SHOW,
    HIDE
}

fun View.slideAnimation(direction: SlideDirection, type: SlideType, duration: Long = 250){
    val fromX: Float
    val toX: Float
    val fromY: Float
    val toY: Float
    val array = IntArray(2)
    getLocationInWindow(array)
    if((type == SlideType.HIDE && (direction == SlideDirection.RIGHT || direction == SlideDirection.DOWN)) ||
        (type == SlideType.SHOW && (direction == SlideDirection.LEFT || direction == SlideDirection.UP))   ){
        val displayMetrics = DisplayMetrics()
        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
        windowManager.defaultDisplay.getMetrics(displayMetrics)
        val deviceWidth = displayMetrics.widthPixels
        val deviceHeight = displayMetrics.heightPixels
        array[0] = deviceWidth
        array[1] = deviceHeight
    }
    when (direction) {
        SlideDirection.UP -> {
            fromX = 0f
            toX = 0f
            fromY = if(type == SlideType.HIDE) 0f else (array[1] + height).toFloat()
            toY = if(type == SlideType.HIDE) -1f * (array[1] + height)  else 0f
        }
        SlideDirection.DOWN -> {
            fromX = 0f
            toX = 0f
            fromY = if(type == SlideType.HIDE) 0f else -1f * (array[1] + height)
            toY = if(type == SlideType.HIDE) 1f * (array[1] + height)  else 0f
        }
        SlideDirection.LEFT -> {
            fromX = if(type == SlideType.HIDE) 0f else 1f * (array[0] + width)
            toX = if(type == SlideType.HIDE) -1f * (array[0] + width) else 0f
            fromY = 0f
            toY = 0f
        }
        SlideDirection.RIGHT -> {
            fromX = if(type == SlideType.HIDE) 0f else -1f * (array[0] + width)
            toX = if(type == SlideType.HIDE) 1f * (array[0] + width) else 0f
            fromY = 0f
            toY = 0f
        }
    }
    val animate = TranslateAnimation(
        fromX,
        toX,
        fromY,
        toY
    )
    animate.duration = duration
    animate.setAnimationListener(object: Animation.AnimationListener{
        override fun onAnimationRepeat(animation: Animation?) {

        }

        override fun onAnimationEnd(animation: Animation?) {
            if(type == SlideType.HIDE){
                visibility = View.INVISIBLE
            }
        }

        override fun onAnimationStart(animation: Animation?) {
            visibility = View.VISIBLE
        }

    })
    startAnimation(animate)
}

विस्तार के लिए उदाहरण:

view.slideAnimation(SlideDirection.UP, SlideType.HIDE)//to make it disappear through top of the screen
view.slideAnimation(SlideDirection.DOWN, SlideType.SHOW)//to make it reappear from top of the screen

view.slideAnimation(SlideDirection.DOWN, SlideType.HIDE)//to make it disappear through bottom of the screen
view.slideAnimation(SlideDirection.UP, SlideType.SHOW)//to make it reappear from bottom of the screen

Answer 16

सरल तरीकों में से एक:

containerView.setLayoutTransition(LayoutTransition())
containerView.layoutTransition.enableTransitionType(LayoutTransition.CHANGING)