In the end, I created my own layout based on AbsoluteLayout, added a Matrix to my LayoutParams, leveraged getChildStaticTransformation, and overrode dispatchTouchEvent in order for my child to respond to the correct bounds when rotated. A lot more difficult than I anticipated.

public class UIViewLayout extends ViewGroup {

@Override
protected boolean getChildStaticTransformation(View child, Transformation t) {
    if(child instanceof UIViewLayout) {
        t.getMatrix().reset();
        UIViewLayout.LayoutParams params = (UIViewLayout.LayoutParams)child.getLayoutParams();
        t.setTransformationType(Transformation.TYPE_MATRIX);
        t.getMatrix().set(params.matrix);
    }
    return true;
}

public UIViewLayout(android.content.Context context) {
    super(context);
    this.setClipChildren(false);
    this.setClipToPadding(false);
    this.setChildrenDrawingOrderEnabled(true);
    this.setStaticTransformationsEnabled(true);
}

public UIViewLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
}

public UIViewLayout(Context context, AttributeSet attrs,
                      int defStyle) {
    super(context, attrs, defStyle);
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int count = getChildCount();

    int maxHeight = 0;
    int maxWidth = 0;

    // Find out how big everyone wants to be
    measureChildren(widthMeasureSpec, heightMeasureSpec);

    // Find rightmost and bottom-most child
    for (int i = 0; i < count; i++) {
        View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            int childRight;
            int childBottom;

            UIViewLayout.LayoutParams lp
                    = (UIViewLayout.LayoutParams) child.getLayoutParams();

            childRight = lp.x + child.getMeasuredWidth();
            childBottom = lp.y + child.getMeasuredHeight();

            maxWidth = Math.max(maxWidth, childRight);
            maxHeight = Math.max(maxHeight, childBottom);
        }
    }

    // Account for padding too
    //maxWidth += mPaddingLeft + mPaddingRight;
    //maxHeight += mPaddingTop + mPaddingBottom;

    // Check against minimum height and width
    maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
    maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, 0),
            resolveSizeAndState(maxHeight, heightMeasureSpec, 0));
}

@Override
protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
    return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, 0, 0);
}

@Override
protected void onLayout(boolean changed, int l, int t,
                        int r, int b) {
    int count = getChildCount();

    for (int i = 0; i < count; i++) {
        View child = getChildAt(i);
        if (child.getVisibility() != GONE) {

            UIViewLayout.LayoutParams lp =
                    (UIViewLayout.LayoutParams) child.getLayoutParams();

            int childLeft = lp.x;
            int childTop = lp.y;
            child.layout(childLeft, childTop,
                    childLeft + child.getMeasuredWidth(),
                    childTop + child.getMeasuredHeight());

        }
    }
}

@Override
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
    return new UIViewLayout.LayoutParams(getContext(), attrs);
}

// Override to allow type-checking of LayoutParams.
@Override
protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
    return p instanceof UIViewLayout.LayoutParams;
}

@Override
protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
    return new LayoutParams(p);
}

@Override
public boolean shouldDelayChildPressedState() {
    return false;
}

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    for(int i = 0; i < this.getChildCount(); i++) {
        View child = getChildAt(i);
        if(child instanceof UIViewLayout) {
            UIViewLayout.LayoutParams params = (UIViewLayout.LayoutParams)child.getLayoutParams();
            if(!params.matrix.isIdentity()) {
                MotionEvent ev2 = MotionEvent.obtain(ev);

                ev2.setLocation(ev2.getX() - params.x, ev2.getY() - params.y);

                Matrix m = new Matrix();
                params.matrix.invert(m);
                ev2.transform(m);
                if(child.dispatchTouchEvent(ev2)) {
                    return true;
                }
                ev2.recycle();
            }
        }
    }
    return super.dispatchTouchEvent(ev);
}

public static class LayoutParams extends ViewGroup.LayoutParams {
    public int x;
    public int y;
    public Matrix matrix;

    public LayoutParams(int width, int height, int x, int y) {
        super(width, height);
        this.x = x;
        this.y = y;
        this.matrix = new Matrix();
    }

    public LayoutParams(Context c, AttributeSet attrs) {
        super(c, attrs);
    }

    public LayoutParams(ViewGroup.LayoutParams source) {
        super(source);
    }
}

}

Read More

I ended up writing my own custom Animation that basically does 4 scale animations in a row:

public class BounceAnimation extends Animation {
    private final List<Float> expansionValuesX;
    private final List<Float> expansionValuesY;
    private final List<Float> timing;

    private int currentTimingIndex;
    private float currentTimingSum;

    private float pivotX;
    private float pivotY;

    public BounceAnimation(List<Float> expansionValuesX, List<Float> expansionValuesY, List<Float> timing, int duration) {
        this.expansionValuesX = expansionValuesX;
        this.expansionValuesY = expansionValuesY;
        this.timing = timing;

        setDuration(duration);
    }

    @Override
    protected void applyTransformation(float interpolatedTime, Transformation t) {
        float sx = 1.0f;
        float sy = 1.0f;

        if (currentTimingIndex < timing.size() - 1 && interpolatedTime >= currentTimingSum + timing.get(currentTimingIndex)) {
            currentTimingSum += timing.get(currentTimingIndex);
            currentTimingIndex++;
        }

        float currentFromX = expansionValuesX.get(currentTimingIndex);
        float currentFromY = expansionValuesY.get(currentTimingIndex);
        float currentToX = expansionValuesX.get(currentTimingIndex + 1);
        float currentToY = expansionValuesY.get(currentTimingIndex + 1);

        float currentInterpolatedTime = (interpolatedTime - currentTimingSum) / timing.get(currentTimingIndex);

        if (currentFromX != 1.0f || currentToX != 1.0f) {
            sx = currentFromX + ((currentToX - currentFromX) * currentInterpolatedTime);
        }
        if (currentFromY != 1.0f || currentToY != 1.0f) {
            sy = currentFromY + ((currentToY - currentFromY) * currentInterpolatedTime);
        }

        if (pivotX == 0 && pivotY == 0) {
            t.getMatrix().setScale(sx, sy);
        } else {
            t.getMatrix().setScale(sx, sy, pivotX, pivotY);
        }
    }

    @Override
    public void initialize(int width, int height, int parentWidth, int parentHeight) {
        super.initialize(width, height, parentWidth, parentHeight);

        pivotX = resolveSize(Animation.RELATIVE_TO_SELF, 0.5f, width, parentWidth);
        pivotY = resolveSize(Animation.RELATIVE_TO_SELF, 1.0f, height, parentHeight);

        currentTimingIndex = 0;
        currentTimingSum = 0;
    }

}

Read More

If you'd click on the package above that code you linked to,

you'd see that it shows more files.

AnimateDrawable:

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.bakhtiyor.android.snowfall;

import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.animation.Transformation;

public class AnimateDrawable extends ProxyDrawable {

    private Animation mAnimation;
    private Transformation mTransformation = new Transformation();

    public AnimateDrawable(Drawable target) {
        super(target);
    }

    public AnimateDrawable(Drawable target, Animation animation) {
        super(target);
        mAnimation = animation;
    }

    public Animation getAnimation() {
        return mAnimation;
    }

    public void setAnimation(Animation anim) {
        mAnimation = anim;
    }

    public boolean hasStarted() {
        return mAnimation != null && mAnimation.hasStarted();
    }

    public boolean hasEnded() {
        return mAnimation == null || mAnimation.hasEnded();
    }

    @Override
    public void draw(Canvas canvas) {
        Drawable dr = getProxy();
        if (dr != null) {
            int sc = canvas.save();
            Animation anim = mAnimation;
            if (anim != null) {
                anim.getTransformation(
                                    AnimationUtils.currentAnimationTimeMillis(),
                                    mTransformation);
                canvas.concat(mTransformation.getMatrix());
            }
            dr.draw(canvas);
            canvas.restoreToCount(sc);
        }
    }
}

Read More

Regarding the flicker issue:

I have encountered this issue before, and it stems from the possibility of the onAnimationEnd() call not syncing up with the next layout pass. Animation works by applying a transformation to a View, drawing it relative to its current position.

However, it is possible for a View to be rendered after you have moved it in your onAnimationEnd() method. In this case, the Animation's transformation is still being applied correctly, but the Animation thinks the View has not changed its original position, which means it will be drawn relative to its ENDING position instead of its STARTING position.

My solution was to create a custom subclass of Animation and add a method, changeYOffset(int change), which modifies the y translation that is applied during the Animation's applyTransformation method. I call this new method in my View's onLayout() method, and pass the new y-offset.

Here is some of my code from my Animation, MenuAnimation:

/**
* Signal to this animation that a layout pass has caused the View on which this animation is
* running to have its "top" coordinate changed.
*
* @param change
* the difference in pixels
*/
public void changeYOffset(int change) {
    fromY -= change;
    toY -= change;
}

@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
    float reverseTime = 1f - interpolatedTime;

    float dy = (interpolatedTime * toY) + (reverseTime * fromY);
    float alpha = (interpolatedTime * toAlpha) + (reverseTime * fromAlpha);

    if (alpha > 1f) {
        alpha = 1f;
    }
    else if (alpha < 0f) {
        alpha = 0f;
    }

    t.setAlpha(alpha);
    t.getMatrix().setTranslate(0f, dy);
}

And from the View class:

private int lastTop;

// ...

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    // the animation is expecting that its View will not be moved by the container
    // during its time period. if this does happen, we need to inform it of the change.
    Animation anim = getAnimation();
    if (anim != null && anim instanceof MenuAnimation) {
        MenuAnimation animation = (MenuAnimation) anim;
        animation.changeYOffset(top - lastTop);
    }

    // ...

    lastTop = top;

    super.onLayout(changed, left, top, right, bottom);
}

Read More