Pokaż i ukryj widok z animacją przesuwania w górę / w dół


318

Mam coś LinearLayout, co chcę pokazać lub ukryć za pomocą przycisku, Animationktóry przesuwa układ w górę lub w dół za każdym razem, gdy zmieniam jego widoczność.

Widziałem kilka próbek, ale żadna z nich nie odpowiada moim potrzebom.

Utworzyłem dwa pliki XML dla animacji, ale nie wiem, jak je uruchomić, gdy zmienię widoczność pliku LinearLayout.

Odpowiedzi:


639

Dzięki nowemu interfejsowi API animacji, który został wprowadzony w systemie Android 3.0 (Honeycomb), tworzenie takich animacji jest bardzo proste.

Przesuwanie w Viewdół o odległość:

view.animate().translationY(distance);

Możesz później przesunąć Viewtył do pierwotnej pozycji, tak jak to:

view.animate().translationY(0);

Możesz także łatwo łączyć wiele animacji. Poniższa animacja przesunie w Viewdół o jego wysokość i jednocześnie pojawi się:

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

Następnie możesz wyciszyć Viewtył i przesunąć go z powrotem do pierwotnej pozycji. Ustawiamy również AnimatorListener, abyśmy mogli ustawić widoczność Viewtyłu GONEpo zakończeniu animacji:

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

1
dlaczego widok nie jest widoczny po jego zniknięciu?
Ram

1
Chcę animować widok, gdy jest widoczny i po jego zniknięciu. ale jeśli po raz pierwszy odejdę, widok nie jest widoczny, a miejsce widoku jest puste
Ram

3
@Ram Co próbujesz osiągnąć, animując, Viewkiedy ustawiona jest jego widoczność View.GONE? Jeśli ustawisz widoczność na cokolwiek poza View.VISIBLEtym, Viewikona nie będzie widoczna. Nie rozumiem o co pytasz. Jeśli chcesz, aby animacja być widoczne wtedy nie ustawić widoczność Viewdo View.GONE.
Xaver Kapeller,

2
w obliczu tego samego problemu, z jakim zmierzył się Ram, za pierwszym razem działa dobrze, ale od następnego razu, gdy sprawię, że ten widok zniknie i spróbuję sprawić, by ten widok był widoczny, nie pojawia się.
Pankaj kumar

12
@XaverKapeller Myślę, że wielu ma problem z tym, że słuchacz onAnimationEndjest wywoływany za każdym razem, aby uzyskać wielokrotnie występującą animację, co oznacza, że onAnimationEndjest wywoływany również wtedy, gdy widok zostanie wyświetlony, co ustawia jego widoczność na Gone itp.
oldgod

129

Miałem problemy ze zrozumieniem zastosowania zaakceptowanej odpowiedzi. Potrzebowałem trochę więcej kontekstu. Teraz, gdy to rozgryzłem, oto pełny przykład:

wprowadź opis zdjęcia tutaj

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>

Notatki

  • Dzięki temu artykułowi za skierowanie mnie we właściwym kierunku. To było bardziej pomocne niż inne odpowiedzi na tej stronie.
  • Jeśli chcesz zacząć od widoku na ekranie, nie inicjuj go jako INVISIBLE.
  • Ponieważ animujemy go całkowicie poza ekranem, nie ma potrzeby ustawiania go ponownie INVISIBLE. Jeśli jednak nie animujesz całkowicie poza ekranem, możesz dodać animację alfa i ustawić widoczność za pomocą AnimatorListenerAdapter.
  • Dokumenty dotyczące animacji właściwości

android: widoczność = „niewidoczny”, aby zainicjować animację widoku jako
ukrytą

2
Nie polecam używania animate.setFillAfter (true); jeśli masz klikalne widoki w widoku
slajdów,

2
Zauważ, że bez .setVisibility(View.INVISIBLE);funkcji przesuwania nie będzie działać zgodnie z oczekiwaniami wizualnymi.
Advait S

Translate Animationprzesuwa widok. Jeśli chcesz animować widok tak, jak samo skalowanie, użyjScaleAnimation anim = new ScaleAnimation(1, 1, 0, 1)
Zohab Ali,

33

Teraz należy wykonać animacje zmiany widoczności, za pośrednictwem Transition APIktórych dostępne są w pakiecie wsparcia (androidx). Wystarczy wywołać metodę TransitionManager.beginDelayedTransition z przejściem slajdów, a następnie zmienić widoczność widoku.

wprowadź opis zdjęcia tutaj

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>

Sprawdź tę odpowiedź, używając innych domyślnych i niestandardowych przykładów przejścia.


@akubi tak, powinno być
Aba

1
Jedna z najlepszych i łatwych odpowiedzi! Dzięki!
krisDrOid

dla przypomnienia, wymaga tominSdkVersion 21
lasec0203

@ lasec0203 nie, klasy pochodzą z androidxpakietu. Działa dobrze na interfejsach API w wersji wcześniejszej niż 21.
ashakirov

: thumbs_up: pozbyłem się błędu niejednoznaczności metody, który otrzymywałem
lasec0203

30

Najłatwiejsze rozwiązanie: ustaw android:animateLayoutChanges="true"na pojemniku z widokami.

Aby umieścić go w pewnym kontekście: Jeśli masz układ taki jak poniżej, wszystkie zmiany widoczności widoków w tym kontenerze będą animowane automatycznie.

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

    <Views_which_change_visibility>

</LinearLayout>

Więcej informacji na ten temat można znaleźć w temacie Animowanie zmian układu - programista Androida


Jest to najłatwiejsze, ale jego zachowanie różni się ze względu na producenta telefonu i zmiany kodu
b2mob

To animuje alfę, a nie pozycję.
Suragch,

Tak, ale o to chodziło w pierwotnym pytaniu, czy dobrze to zrozumiałem. Jeśli chcesz animować pozycje, możesz użyć RecyclerView, który używa ViewHolders ze stabilnymi identyfikatorami.
Stefan Medack

12

Możesz rozpocząć poprawne Animationwyświetlanie widoczności LinearLayoutzmian, tworząc nową podklasę LinearLayouti zastępując, setVisibility()aby rozpocząć Animations. Rozważ coś takiego:

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

1
Właściwie bardziej podoba mi się podejście do podklasy. Dziękuję Ci bardzo.
MichelReap

1
To niesamowite rozwiązanie, które zaimplementuję w moim BaseView. Dzięki za to!
Bram Vandenbussche

1
Ponieważ działa to podczas pokazywania, podczas ukrywania widok znika, zanim będzie można zobaczyć animację. Jakieś obejścia?
Bernardo

12
@BramVandenbussche To okropne rozwiązanie. To sprawia, że ​​jest Viewodpowiedzialny za swoje własne animacje, które NIGDY nie są potrzebne. Wyobraź sobie, że chcesz Viewinaczej animować w innej części swojej aplikacji. Co wtedy robisz Dodać flagę, aby nie animować automatycznie widoczności? Podklasować Viewi zastępować, setVisibility()aby usunąć animację? A może jeszcze gorzej setVisibility()z inną animacją? Z tego miejsca robi się coraz gorzej. Nie używaj tego „rozwiązania”.
Xaver Kapeller

3
Lepiej nazwij to AnimatedLinearLayout
Roel

12

Kotlin

Na podstawie Suragch „s odpowiedź , tutaj jest elegancki sposób za pomocą Zobacz rozszerzenie:

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

A potem, gdziekolwiek chcesz go użyć, potrzebujesz tylko myView.slideUp()lubmyView.slideDown()


Tylko błąd jest, że nie potrzebuje „fillAfter = true”, jak zablokować widoki dziecko kliknij dostępności
Ranjan

Prawdopodobnie będziesz musiał dodać detektor do animacji slideDown i sprawić, że widok zniknie naAnimationEnd.
Manohar Reddy

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

10
Problemy z tą odpowiedzią: 1) Okropne formatowanie kodu. 2) Używasz fragmentu kodu, aby opublikować kod, którego w rzeczywistości nie można uruchomić w przeglądarce. To nie tylko dodaje dwa niepotrzebne przyciski, ale także niszczy podświetlanie składni. 3) To tylko losowy zrzut kodu bez żadnego wyjaśnienia ani celu. 4) Zmieniasz widoczność podczas wykonywania animacji. Oprócz tego, że jest to oczywisty zapach kodu, to również nie będzie działać poprawnie. Zmiana widoczności rozpoczyna nowy proces układania, dopiero po zakończeniu animacja faktycznie ma wartości do pracy. Lista jest długa i długa ...
Xaver Kapeller

Zredagowałem już twoją odpowiedź, aby naprawić formatowanie, i przekształciłem fragment kodu w rzeczywisty blok kodu. Ale musisz wypełnić resztę ...
Xaver Kapeller

Przepraszam, kolego, stworzyłem twój kod, ponieważ nie działa dla mnie dobrze, ten mój kod działa. Ale zmiany w sposobie publikowania zgadzam się.
Ameen Maheen,

@AmeenMaheen Do czego służy setAlpha?
IgorGanapolsky

@ Igor Ganapolsky służy do przezroczystości, tzn. Do uzyskania efektu zanikania
Ameen Maheen

4

możesz przesuwać w górę i w dół dowolnego widoku lub układu za pomocą poniższego kodu w aplikacji na Androida

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

co to jest 120? a co to jest 0? jaka jest jednostka setDuration, jeśli chcę to kodować na stałe?
Stanley Santoso

1
tutaj 120 i 0 to odległość związana z osią Y, jeśli umieścisz twardy kod niż problem na dużym ekranie lub tablecie, więc musisz wstawić wartość z wartości string.xml dla różnych urządzeń. a czas trwania to czas, w którym chcesz pokazać animację układu .... !!! Przepraszam za mój słaby angielski...!
varotariya vajsi

@varotariyavajsi To nie pokazuje / nie ukrywa widoczności widoku.
IgorGanapolsky

cześć Igor Ganapolsky, znam to ... To jest po prostu przetłumacz widok w kierunku Y, jeśli użytkownik będzie musiał się wyświetlać w górę iw dół jak dolny suwak, będzie działał dobrze.
varotariya vajsi

4

Użyj tej klasy:

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

3

Korzystanie z 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()
    }
}

2
Niewielkie udoskonalenia: Możemy użyć stałej View.TRANSLATION_Y zamiast „translationY”, a także w suwaku ObjectAnimation możemy zrobić .apply {doOnEnd {view.visibility = View.GONE} .......}. Start ()
tashi

0.toFloat()może też być0f
styler1972

2

Miałem skrzynkę narożną, w której wysokość mojego widoku była wciąż zerotaka ...

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

}

1

Oto moje rozwiązanie. Po prostu uzyskaj odniesienie do swojego widoku i wywołaj tę metodę:

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

Nie musisz nic więcej robić =)


1
Dlaczego potrzebujesz GlobalLayoutListener, aby to zrobić? Dlaczego ustawiasz widoczność w tak dziwny sposób? Dlaczego w odpowiedzi podajesz opóźnienie rozpoczęcia, które nie ma znaczenia?
Xaver Kapeller,

1

Odpowiedź Suragcha w Kotlinie. To zadziałało dla mnie.

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
}

}


0

Możesz użyć prostych trzech wierszy kodu, aby wyświetlić animację ...

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

            }

0

Z rozszerzeniami Kotlin możesz użyć tego:

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

Przykład rozszerzenia:

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

0

Jeden z prostych sposobów:

containerView.setLayoutTransition(LayoutTransition())
containerView.layoutTransition.enableTransitionType(LayoutTransition.CHANGING)
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.