Mostra e nascondi una vista con un'animazione della diapositiva su / giù


318

Ho un oggetto LinearLayoutche voglio mostrare o nascondere con uno Animationche spinge il layout verso l'alto o verso il basso ogni volta che cambio la sua visibilità.

Ho visto alcuni campioni là fuori, ma nessuno di loro soddisfa i miei bisogni.

Ho creato due file XML per le animazioni ma non so come avviarle quando cambio la visibilità di a LinearLayout.

Risposte:


640

Con la nuova API di animazione introdotta in Android 3.0 (Honeycomb) è molto semplice creare tali animazioni.

Scorrendo Viewverso il basso di una distanza:

view.animate().translationY(distance);

Successivamente puoi far scorrere la Viewschiena nella posizione originale in questo modo:

view.animate().translationY(0);

Puoi anche combinare facilmente più animazioni. La seguente animazione farà scorrere una Viewgiù per la sua altezza e la dissolverà contemporaneamente:

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

È quindi possibile sfumare il Viewretro e farlo scorrere nella posizione originale. Abbiamo anche impostato un AnimatorListenermodo per poter impostare la visibilità della Viewschiena GONEuna volta terminata l'animazione:

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

1
perché vista non visibile una volta sparito?
Ram

1
voglio animare la vista quando visibile e quando non c'è più. ma se per la prima volta sono andato a vedere .non è in grado di vedere e il punto di vista è vuoto
Ram

3
@Ram Cosa stai cercando di ottenere animando un Viewquando la sua visibilità è impostata su View.GONE? Se si imposta la sua visibilità a qualcosa oltre View.VISIBLEallora il Viewnon saranno visibili. Non capisco cosa stai chiedendo. Se vuoi che l'animazione sia visibile, non impostare la visibilità di Viewa View.GONE.
Xaver Kapeller,

2
affrontando lo stesso problema con quello che Ram stava affrontando, per la prima volta funziona benissimo ma dalla prossima volta quando rendo quella vista in stato sparito e provo a rendere quella vista di nuovo visibile non appare.
Pankaj kumar,

12
@XaverKapeller Penso che il problema che molti hanno è che l'ascoltatore onAnimationEndviene chiamato ogni volta per un'animazione multi-occorrenza, il che significa che onAnimationEndviene chiamato anche quando viene mostrata la vista, che imposta la sua visibilità su Andato, ecc.
oldergod

129

Avevo problemi a capire come applicare la risposta accettata. Avevo bisogno di un po 'più di contesto. Ora che l'ho capito, ecco un esempio completo:

inserisci qui la descrizione dell'immagine

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>

Appunti

  • Grazie a questo articolo per avermi indicato nella giusta direzione. È stato più utile delle altre risposte in questa pagina.
  • Se si desidera iniziare con la vista sullo schermo, non inizializzarla come INVISIBLE.
  • Dato che lo stiamo animando completamente fuori dallo schermo, non è necessario ripristinarlo INVISIBLE. Se non stai animando completamente fuori dallo schermo, tuttavia, puoi aggiungere un'animazione alfa e impostare la visibilità con un AnimatorListenerAdapter.
  • Documenti di animazione della proprietà

android: visible = "invisible" per inizializzare l'animazione della vista come un nascondiglio
Goodlife

2
Non consiglio l'uso di animate.setFillAfter (true); se hai viste cliccabili sotto la vista
scorrevole

2
Si noti che senza .setVisibility(View.INVISIBLE);la funzione di scorrimento verso l'alto non funzionerà come previsto visivamente.
Advait S

Translate Animationsposta la vista. Se vuoi animare la vista come il suo ridimensionamento stesso, usaScaleAnimation anim = new ScaleAnimation(1, 1, 0, 1)
Zohab Ali il

33

Ora le animazioni di modifica della visibilità dovrebbero essere eseguite tramite le Transition APIquali sono disponibili nel pacchetto di supporto (androidx). Basta chiamare il metodo TransitionManager.beginDelayedTransition con transizione Slide quindi cambiare la visibilità della vista.

inserisci qui la descrizione dell'immagine

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>

Controlla questa risposta con altri esempi di transizione predefiniti e personalizzati.


@akubi sì, dovrebbe essere
Aba,

1
Una delle risposte migliori e facili! Grazie!
krisDrOid

solo per notare, questo richiedeminSdkVersion 21
lasec0203

@ lasec0203 no, le classi provengono dal androidxpacchetto. Funziona bene su pre 21 api.
ashakirov,

: thumbs_up: questo si è sbarazzato di un errore di ambiguità del metodo che stavo ottenendo
lasec0203

30

La soluzione più semplice: posizionati android:animateLayoutChanges="true"sul contenitore con le tue viste.

Per inserirlo in un contesto: se si dispone di un layout come di seguito, tutte le modifiche alla visibilità delle viste in questo contenitore verranno animate automaticamente.

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

    <Views_which_change_visibility>

</LinearLayout>

Puoi trovare maggiori dettagli al riguardo su Modifiche al layout di animazione - Sviluppatore Android


È il più semplice ma il suo comportamento differisce a causa del produttore del telefono e lui cambia il codice
b2mob

Questo anima l'alfa, non la posizione.
Suragch,

Sì, ma è questa la domanda originale se l'ho capito correttamente. Se si desidera animare le posizioni, è possibile utilizzare un RecyclerView che utilizza ViewHolders con ID stabili.
Stefan Medack,

12

È possibile avviare la corretta Animationquando la visibilità delle LinearLayoutmodifiche creando una nuova sottoclasse LinearLayoute sostituendo setVisibility()per avviare il Animations. Prendi in considerazione qualcosa del genere:

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
In realtà mi piace meglio l'approccio della sottoclasse. Grazie mille.
MichelReap,

1
Questa è una soluzione fantastica che implementerò nel mio BaseView. Grazie per questo!
Bram Vandenbussche,

1
Dato che funziona quando si mostra, quando si nasconde, la vista scompare prima che l'animazione possa essere vista. Qualche soluzione alternativa?
Bernardo,

12
@BramVandenbussche Questa è una soluzione terribile. Rende Viewresponsabile le proprie animazioni che non è MAI quello che vuoi. Immagina di voler animare Viewdiversamente in un'altra parte della tua app. Cosa fai allora? Aggiungi un flag per non animare automaticamente la visibilità? Sottoclassare Viewe sovrascrivere setVisibility()per rimuovere l'animazione? O peggio ancora implementare setVisibility()con un'altra animazione? Da qui diventa sempre più brutto. Non usare questa "soluzione".
Xaver Kapeller,

3
Meglio chiamarlo AnimatedLinearLayout
Roel

12

Kotlin

Sulla base di Suragch 's risposta , qui è un modo elegante con vista l'estensione:

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

E poi ovunque tu voglia usarlo, hai solo bisogno myView.slideUp()omyView.slideDown()


L'unico bug è che non ha bisogno di "fillAfter = true" poiché blocca l'accessibilità ai clic sulle visualizzazioni figlio
Ranjan,

Inoltre, probabilmente dovrai aggiungere un listener per l'animazione slideDown e rendere la vista attivaAnimationEnd.
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
Problemi con questa risposta: 1) Formattazione del codice terribile. 2) Si utilizza uno snippet di codice per pubblicare codice che in realtà non può essere eseguito nel browser. Questo non solo aggiunge due pulsanti inutili, ma distrugge anche l'evidenziazione della sintassi. 3) È solo un dump di codice casuale senza alcuna spiegazione o scopo. 4) Stai modificando la visibilità durante l'esecuzione di un'animazione. A parte il fatto che questo è evidente odore di codice, anche questo non funzionerà correttamente. La modifica della visibilità avvia un nuovo processo di layout, solo dopo che l'animazione ha effettivamente dei valori su cui lavorare. L'elenco
potrebbe continuare all'infinito

Ho già modificato la tua risposta per correggere la formattazione e ho trasformato lo snippet di codice in un blocco di codice reale. Ma devi compilare il resto ...
Xaver Kapeller

Mi dispiace, amico mio, ho inventato il tuo codice perché non funziona bene per me, questo mio codice funziona. Ma sono necessarie modifiche nel modo di pubblicare.
Ameen Maheen,

@AmeenMaheen A cosa serve setAlpha?
IgorGanapolsky,

@ Igor Ganapolsky è usato per la trasparenza, cioè per dare un effetto sbiadito
Ameen Maheen,

4

puoi scorrere su e giù su qualsiasi vista o layout utilizzando il codice seguente nell'app Android

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

che cosa è 120? e che cosa è 0? qual è l'unità per setDuration se voglio codificare questo?
Stanley Santoso,

1
qui 120 e 0 è la distanza correlata all'asse Y se si inserisce codice fisso piuttosto che ottenere problemi su schermo di grandi dimensioni o tablet, quindi, è necessario inserire il valore dal valore string.xml per tutti i diversi dispositivi. e durata è il tempo in cui vuoi mostrare l'animazione del layout .... !!! scusa per il mio pessimo inglese...!
varotariya vajsi,

@varotariyavajsi In realtà non mostra / nasconde la visibilità di una vista.
IgorGanapolsky,

ciao igor ganapolsky li conosco ... è solo tradurre la vista in direzione y, se l'utente ha bisogno di mostrarsi su e giù come un cursore in basso funzionerà bene.
varotariya vajsi,

4

Usa questa classe:

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

Utilizzando 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
Piccoli miglioramenti: possiamo usare View.TRANSLATION_Y costante invece di "translationY" e anche nella slide up ObjectAnimation possiamo fare .apply {doOnEnd {view.visibility = View.GONE} .......}. Start ()
tashi

0.toFloat()può anche essere0f
styler1972

2

Avevo un caso angolare in cui l'altezza della mia vista era ancora zerocosì ...

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

Ecco la mia soluzione Basta avere un riferimento alla tua vista e chiamare questo metodo:

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

Non c'è bisogno di fare altro =)


1
Perché avresti bisogno di un GlobalLayoutListener per fare questo? Perché stai impostando la visibilità in un modo così strano? Perché includi cose come un ritardo di avvio che è irrilevante da mettere in discussione nella tua risposta?
Xaver Kapeller,

1

La risposta di Suragch a Kotlin. Questo ha funzionato per me.

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

Puoi usare le tre semplici righe di codice per mostrare l'animazione ...

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

Con le estensioni di Kotlin puoi usare questo:

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

Esempio per l'estensione:

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

Uno dei modi semplici:

containerView.setLayoutTransition(LayoutTransition())
containerView.layoutTransition.enableTransitionType(LayoutTransition.CHANGING)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.