Android: Expand/collapse animation

I see that this question became popular so I post my actual solution. The main advantage is that you don't have to know the expanded height to apply the animation and once the view is expanded, it adapts height if content changes. It works great for me.

public static void expand(final View v) {    int matchParentMeasureSpec = View.MeasureSpec.makeMeasureSpec(((View) v.getParent()).getWidth(), View.MeasureSpec.EXACTLY);    int wrapContentMeasureSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);    v.measure(matchParentMeasureSpec, wrapContentMeasureSpec);    final int targetHeight = v.getMeasuredHeight();    // Older versions of android (pre API 21) cancel animations for views with a height of 0.    v.getLayoutParams().height = 1;    v.setVisibility(View.VISIBLE);    Animation a = new Animation()    {        @Override        protected void applyTransformation(float interpolatedTime, Transformation t) {            v.getLayoutParams().height = interpolatedTime == 1                    ? LayoutParams.WRAP_CONTENT                    : (int)(targetHeight * interpolatedTime);            v.requestLayout();        }        @Override        public boolean willChangeBounds() {            return true;        }    };    // Expansion speed of 1dp/ms    a.setDuration((int)(targetHeight / v.getContext().getResources().getDisplayMetrics().density));    v.startAnimation(a);}public static void collapse(final View v) {    final int initialHeight = v.getMeasuredHeight();    Animation a = new Animation()    {        @Override        protected void applyTransformation(float interpolatedTime, Transformation t) {            if(interpolatedTime == 1){                v.setVisibility(View.GONE);            }else{                v.getLayoutParams().height = initialHeight - (int)(initialHeight * interpolatedTime);                v.requestLayout();            }        }        @Override        public boolean willChangeBounds() {            return true;        }    };    // Collapse speed of 1dp/ms    a.setDuration((int)(initialHeight / v.getContext().getResources().getDisplayMetrics().density));    v.startAnimation(a);}

As mentioned by @Jefferson in the comments, you can obtain a smoother animation by changing the duration (and hence the speed) of the animation. Currently, it has been set at a speed of 1dp/ms

I stumbled over the same problem today and I guess the real solution to this question is this

<LinearLayout android:id="@+id/container"android:animateLayoutChanges="true"... />

You will have to set this property for all topmost layouts, which are involved in the shift. If you now set the visibility of one layout to GONE, the other will take the space as the disappearing one is releasing it. There will be a default animation which is some kind of "fading out", but I think you can change this - but the last one I have not tested, for now.

If using this in a RecyclerView item, set the visibility of the view to expand/collapse in onBindViewHolder and call notifyItemChanged(position) to trigger the transformation.

    override fun onBindViewHolder(holder: ItemViewHolder, position: Int) {        ...        holder.list.visibility = data[position].listVisibility        holder.expandCollapse.setOnClickListener {            data[position].listVisibility = if (data[position].listVisibility == View.GONE) View.VISIBLE else View.GONE            notifyItemChanged(position)        }    }

If you perform expensive operations in onBindViewHolder you can optimize for partial changes using notifyItemChanged(position, payload)

    private const val UPDATE_LIST_VISIBILITY = 1    override fun onBindViewHolder(holder: ItemViewHolder, position: Int, payloads: MutableList<Any>) {        if (payloads.contains(UPDATE_LIST_VISIBILITY)) {            holder.list.visibility = data[position].listVisibility        } else {            onBindViewHolder(holder, position)        }    }    override fun onBindViewHolder(holder: ItemViewHolder, position: Int) {        ...        holder.list.visibility = data[position].listVisibility        holder.expandCollapse.setOnClickListener {            data[position].listVisibility = if (data[position].listVisibility == View.GONE) View.VISIBLE else View.GONE            notifyItemChanged(position, UPDATE_LIST_VISIBILITY)        }    }

I was trying to do what I believe was a very similar animation and found an elegant solution. This code assumes that you are always going from 0->h or h->0 (h being the maximum height). The three constructor parameters are view = the view to be animated (in my case, a webview), targetHeight = the maximum height of the view, and down = a boolean which specifies the direction (true = expanding, false = collapsing).

public class DropDownAnim extends Animation {    private final int targetHeight;    private final View view;    private final boolean down;    public DropDownAnim(View view, int targetHeight, boolean down) {        this.view = view;        this.targetHeight = targetHeight;        this.down = down;    }    @Override    protected void applyTransformation(float interpolatedTime, Transformation t) {        int newHeight;        if (down) {            newHeight = (int) (targetHeight * interpolatedTime);        } else {            newHeight = (int) (targetHeight * (1 - interpolatedTime));        }        view.getLayoutParams().height = newHeight;        view.requestLayout();    }    @Override    public void initialize(int width, int height, int parentWidth,            int parentHeight) {        super.initialize(width, height, parentWidth, parentHeight);    }    @Override    public boolean willChangeBounds() {        return true;    }}