Implement new assist gesture and motion

Change-Id: Ic8ba18c200058062f4d38ac4226d3516af3d3df0

3 files changed, 732 insertions, 0 deletions

diff --git a/packages/SystemUI/src/com/android/systemui/assist/AssistGestureManager.java b/packages/SystemUI/src/com/android/systemui/assist/AssistGestureManager.java
new file mode 100644
index 0000000..36be355
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/assist/AssistGestureManager.java
@@ -0,0 +1,292 @@
+package com.android.systemui.assist;
+
+import android.app.ActivityManager;
+import android.app.ActivityOptions;
+import android.app.SearchManager;
+import android.content.ActivityNotFoundException;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.PixelFormat;
+import android.media.AudioAttributes;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.UserHandle;
+import android.os.Vibrator;
+import android.provider.Settings;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.ImageView;
+
+import com.android.internal.app.IVoiceInteractionManagerService;
+import com.android.internal.app.IVoiceInteractionSessionShowCallback;
+import com.android.systemui.R;
+import com.android.systemui.statusbar.CommandQueue;
+import com.android.systemui.statusbar.phone.PhoneStatusBar;
+
+/**
+ * Class to manage everything around the assist gesture.
+ */
+public class AssistGestureManager {
+
+    private static final String TAG = "AssistGestureManager";
+    private static final String ASSIST_ICON_METADATA_NAME =
+            "com.android.systemui.action_assist_icon";
+
+    private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
+            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+            .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION)
+            .build();
+
+    private static final long TIMEOUT_SERVICE = 2500;
+    private static final long TIMEOUT_ACTIVITY = 1000;
+
+    private final Context mContext;
+    private final WindowManager mWindowManager;
+    private AssistOrbContainer mView;
+    private final PhoneStatusBar mBar;
+    private final IVoiceInteractionManagerService mVoiceInteractionManagerService;
+
+    private IVoiceInteractionSessionShowCallback mShowCallback =
+            new IVoiceInteractionSessionShowCallback.Stub() {
+
+        @Override
+        public void onFailed() throws RemoteException {
+            mView.post(mHideRunnable);
+        }
+
+        @Override
+        public void onShown() throws RemoteException {
+            mView.post(mHideRunnable);
+        }
+    };
+
+    private Runnable mHideRunnable = new Runnable() {
+        @Override
+        public void run() {
+            mView.removeCallbacks(this);
+            mView.show(false /* show */, true /* animate */);
+        }
+    };
+
+    public AssistGestureManager(PhoneStatusBar bar, Context context) {
+        mContext = context;
+        mBar = bar;
+        mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
+        mVoiceInteractionManagerService = IVoiceInteractionManagerService.Stub.asInterface(
+                ServiceManager.getService(Context.VOICE_INTERACTION_MANAGER_SERVICE));
+    }
+
+    public void onConfigurationChanged() {
+        boolean visible = false;
+        if (mView != null) {
+            visible = mView.isShowing();
+            mWindowManager.removeView(mView);
+        }
+
+        mView = (AssistOrbContainer) LayoutInflater.from(mContext).inflate(
+                R.layout.assist_orb, null);
+        mView.setVisibility(View.GONE);
+        mView.setSystemUiVisibility(
+                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
+        WindowManager.LayoutParams lp = getLayoutParams();
+        mWindowManager.addView(mView, lp);
+        mBar.getNavigationBarView().setDelegateView(mView);
+        if (visible) {
+            mView.show(true /* show */, false /* animate */);
+        }
+    }
+
+    public void onGestureInvoked(boolean vibrate) {
+        boolean isVoiceInteractorActive = getVoiceInteractorSupportsAssistGesture();
+        if (!isVoiceInteractorActive && !isAssistantIntentAvailable()) {
+            return;
+        }
+        if (vibrate) {
+            vibrate();
+        }
+        if (!isVoiceInteractorActive || !isVoiceSessionRunning()) {
+            showOrb();
+            mView.postDelayed(mHideRunnable, isVoiceInteractorActive
+                    ? TIMEOUT_SERVICE
+                    : TIMEOUT_ACTIVITY);
+        }
+        startAssist();
+    }
+
+    private WindowManager.LayoutParams getLayoutParams() {
+        WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                mContext.getResources().getDimensionPixelSize(R.dimen.assist_orb_scrim_height),
+                WindowManager.LayoutParams.TYPE_VOICE_INTERACTION_STARTING,
+                WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+                        | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
+                        | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+                PixelFormat.TRANSLUCENT);
+        if (ActivityManager.isHighEndGfx()) {
+            lp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
+        }
+        lp.gravity = Gravity.BOTTOM | Gravity.START;
+        lp.setTitle("AssistPreviewPanel");
+        lp.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED
+                | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING;
+        return lp;
+    }
+
+    private void showOrb() {
+        maybeSwapSearchIcon();
+        mView.show(true /* show */, true /* animate */);
+    }
+
+    private void startAssist() {
+        if (getVoiceInteractorSupportsAssistGesture()) {
+            startVoiceInteractor();
+        } else {
+            startAssistActivity();
+        }
+    }
+
+    private void startAssistActivity() {
+        if (!mBar.isDeviceProvisioned()) {
+            return;
+        }
+
+        // Close Recent Apps if needed
+        mBar.animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_SEARCH_PANEL |
+                CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL);
+
+        final Intent intent = ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
+                .getAssistIntent(mContext, true, UserHandle.USER_CURRENT);
+        if (intent == null) {
+            return;
+        }
+
+        try {
+            final ActivityOptions opts = ActivityOptions.makeCustomAnimation(mContext,
+                    R.anim.search_launch_enter, R.anim.search_launch_exit);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            AsyncTask.execute(new Runnable() {
+                @Override
+                public void run() {
+                    mContext.startActivityAsUser(intent, opts.toBundle(),
+                            new UserHandle(UserHandle.USER_CURRENT));
+                }
+            });
+        } catch (ActivityNotFoundException e) {
+            Log.w(TAG, "Activity not found for " + intent.getAction());
+        }
+    }
+
+    private void startVoiceInteractor() {
+        try {
+            mVoiceInteractionManagerService.showSessionForActiveService(mShowCallback);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to call showSessionForActiveService", e);
+        }
+    }
+
+    private boolean getVoiceInteractorSupportsAssistGesture() {
+        try {
+            return mVoiceInteractionManagerService.activeServiceSupportsAssistGesture();
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to call activeServiceSupportsAssistGesture", e);
+            return false;
+        }
+    }
+
+    private ComponentName getVoiceInteractorComponentName() {
+        try {
+            return mVoiceInteractionManagerService.getActiveServiceComponentName();
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to call getActiveServiceComponentName", e);
+            return null;
+        }
+    }
+
+    private boolean isVoiceSessionRunning() {
+        try {
+            return mVoiceInteractionManagerService.isSessionRunning();
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to call isSessionRunning", e);
+            return false;
+        }
+    }
+
+    public void destroy() {
+        mWindowManager.removeViewImmediate(mView);
+    }
+
+    private void maybeSwapSearchIcon() {
+        Intent intent = ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
+                .getAssistIntent(mContext, false, UserHandle.USER_CURRENT);
+        ComponentName component = null;
+        boolean isService = false;
+        if (getVoiceInteractorSupportsAssistGesture()) {
+            component = getVoiceInteractorComponentName();
+            isService = true;
+        } else if (intent != null) {
+            component = intent.getComponent();
+        }
+        if (component != null) {
+            replaceDrawable(mView.getOrb().getLogo(), component, ASSIST_ICON_METADATA_NAME,
+                    isService);
+        } else {
+            mView.getOrb().getLogo().setImageDrawable(null);
+        }
+    }
+
+    public void replaceDrawable(ImageView v, ComponentName component, String name,
+            boolean isService) {
+        if (component != null) {
+            try {
+                PackageManager packageManager = mContext.getPackageManager();
+                // Look for the search icon specified in the activity meta-data
+                Bundle metaData = isService
+                        ? packageManager.getServiceInfo(
+                                component, PackageManager.GET_META_DATA).metaData
+                        : packageManager.getActivityInfo(
+                                component, PackageManager.GET_META_DATA).metaData;
+                if (metaData != null) {
+                    int iconResId = metaData.getInt(name);
+                    if (iconResId != 0) {
+                        Resources res = packageManager.getResourcesForApplication(
+                                component.getPackageName());
+                        v.setImageDrawable(res.getDrawable(iconResId));
+                        return;
+                    }
+                }
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.w(TAG, "Failed to swap drawable; "
+                        + component.flattenToShortString() + " not found", e);
+            } catch (Resources.NotFoundException nfe) {
+                Log.w(TAG, "Failed to swap drawable from "
+                        + component.flattenToShortString(), nfe);
+            }
+        }
+        v.setImageDrawable(null);
+    }
+
+    private void vibrate() {
+        if (Settings.System.getIntForUser(mContext.getContentResolver(),
+                Settings.System.HAPTIC_FEEDBACK_ENABLED, 1, UserHandle.USER_CURRENT) != 0) {
+            Resources res = mContext.getResources();
+            Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
+            vibrator.vibrate(res.getInteger(R.integer.config_search_panel_view_vibration_duration),
+                    VIBRATION_ATTRIBUTES);
+        }
+    }
+
+    public boolean isAssistantIntentAvailable() {
+        return ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
+                .getAssistIntent(mContext, false, UserHandle.USER_CURRENT) != null;
+    }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/assist/AssistOrbContainer.java b/packages/SystemUI/src/com/android/systemui/assist/AssistOrbContainer.java
new file mode 100644
index 0000000..67017db
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/assist/AssistOrbContainer.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2015 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.android.systemui.assist;
+
+import android.annotation.Nullable;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+import android.widget.FrameLayout;
+
+import com.android.systemui.R;
+
+public class AssistOrbContainer extends FrameLayout {
+
+    private static final long EXIT_START_DELAY = 150;
+
+    private final Interpolator mLinearOutSlowInInterpolator;
+    private final Interpolator mFastOutLinearInInterpolator;
+
+    private View mScrim;
+    private View mNavbarScrim;
+    private AssistOrbView mOrb;
+
+    private boolean mAnimatingOut;
+
+    public AssistOrbContainer(Context context) {
+        this(context, null);
+    }
+
+    public AssistOrbContainer(Context context, @Nullable AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public AssistOrbContainer(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        mLinearOutSlowInInterpolator = AnimationUtils.loadInterpolator(context,
+                android.R.interpolator.linear_out_slow_in);
+        mFastOutLinearInInterpolator = AnimationUtils.loadInterpolator(context,
+                android.R.interpolator.fast_out_slow_in);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+        mScrim = findViewById(R.id.assist_orb_scrim);
+        mNavbarScrim = findViewById(R.id.assist_orb_navbar_scrim);
+        mOrb = (AssistOrbView) findViewById(R.id.assist_orb);
+    }
+
+    public void show(final boolean show, boolean animate) {
+        if (show) {
+            if (getVisibility() != View.VISIBLE) {
+                setVisibility(View.VISIBLE);
+                if (animate) {
+                    startEnterAnimation();
+                } else {
+                    reset();
+                }
+            }
+        } else {
+            if (animate) {
+                startExitAnimation(new Runnable() {
+                    @Override
+                    public void run() {
+                        mAnimatingOut = false;
+                        setVisibility(View.GONE);
+                    }
+                });
+            } else {
+                setVisibility(View.GONE);
+            }
+        }
+    }
+
+    private void reset() {
+        mAnimatingOut = false;
+        mOrb.reset();
+        mScrim.setAlpha(1f);
+        mNavbarScrim.setAlpha(1f);
+    }
+
+    private void startEnterAnimation() {
+        if (mAnimatingOut) {
+            return;
+        }
+        mOrb.startEnterAnimation();
+        mScrim.setAlpha(0f);
+        mNavbarScrim.setAlpha(0f);
+        post(new Runnable() {
+            @Override
+            public void run() {
+                mScrim.animate()
+                        .alpha(1f)
+                        .setDuration(300)
+                        .setStartDelay(0)
+                        .setInterpolator(mLinearOutSlowInInterpolator);
+                mNavbarScrim.animate()
+                        .alpha(1f)
+                        .setDuration(300)
+                        .setStartDelay(0)
+                        .setInterpolator(mLinearOutSlowInInterpolator);
+            }
+        });
+    }
+
+    private void startExitAnimation(final Runnable endRunnable) {
+        if (mAnimatingOut) {
+            if (endRunnable != null) {
+                endRunnable.run();
+            }
+            return;
+        }
+        mAnimatingOut = true;
+        mOrb.startExitAnimation(EXIT_START_DELAY);
+        mScrim.animate()
+                .alpha(0f)
+                .setDuration(250)
+                .setStartDelay(EXIT_START_DELAY)
+                .setInterpolator(mFastOutLinearInInterpolator);
+        mNavbarScrim.animate()
+                .alpha(0f)
+                .setDuration(250)
+                .setStartDelay(EXIT_START_DELAY)
+                .setInterpolator(mFastOutLinearInInterpolator)
+                .withEndAction(endRunnable);
+    }
+
+    /**
+     * Whether the panel is showing, or, if it's animating, whether it will be
+     * when the animation is done.
+     */
+    public boolean isShowing() {
+        return getVisibility() == View.VISIBLE && !mAnimatingOut;
+    }
+
+    public AssistOrbView getOrb() {
+        return mOrb;
+    }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/assist/AssistOrbView.java b/packages/SystemUI/src/com/android/systemui/assist/AssistOrbView.java
new file mode 100644
index 0000000..a3372a8
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/assist/AssistOrbView.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2014 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.android.systemui.assist;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Outline;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewOutlineProvider;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+import android.view.animation.OvershootInterpolator;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import com.android.systemui.R;
+
+public class AssistOrbView extends FrameLayout {
+
+    private final int mCircleMinSize;
+    private final int mBaseMargin;
+    private final int mStaticOffset;
+    private final Paint mBackgroundPaint = new Paint();
+    private final Rect mCircleRect = new Rect();
+    private final Rect mStaticRect = new Rect();
+    private final Interpolator mAppearInterpolator;
+    private final Interpolator mDisappearInterpolator;
+    private final Interpolator mOvershootInterpolator = new OvershootInterpolator();
+
+    private boolean mClipToOutline;
+    private final int mMaxElevation;
+    private float mOutlineAlpha;
+    private float mOffset;
+    private float mCircleSize;
+    private ImageView mLogo;
+    private float mCircleAnimationEndValue;
+
+    private ValueAnimator mOffsetAnimator;
+    private ValueAnimator mCircleAnimator;
+
+    private ValueAnimator.AnimatorUpdateListener mCircleUpdateListener
+            = new ValueAnimator.AnimatorUpdateListener() {
+        @Override
+        public void onAnimationUpdate(ValueAnimator animation) {
+            applyCircleSize((float) animation.getAnimatedValue());
+            updateElevation();
+        }
+    };
+    private AnimatorListenerAdapter mClearAnimatorListener = new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            mCircleAnimator = null;
+        }
+    };
+    private ValueAnimator.AnimatorUpdateListener mOffsetUpdateListener
+            = new ValueAnimator.AnimatorUpdateListener() {
+        @Override
+        public void onAnimationUpdate(ValueAnimator animation) {
+            mOffset = (float) animation.getAnimatedValue();
+            updateLayout();
+        }
+    };
+
+
+    public AssistOrbView(Context context) {
+        this(context, null);
+    }
+
+    public AssistOrbView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public AssistOrbView(Context context, AttributeSet attrs, int defStyleAttr) {
+        this(context, attrs, defStyleAttr, 0);
+    }
+
+    public AssistOrbView(Context context, AttributeSet attrs, int defStyleAttr,
+            int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+        setOutlineProvider(new ViewOutlineProvider() {
+            @Override
+            public void getOutline(View view, Outline outline) {
+                if (mCircleSize > 0.0f) {
+                    outline.setOval(mCircleRect);
+                } else {
+                    outline.setEmpty();
+                }
+                outline.setAlpha(mOutlineAlpha);
+            }
+        });
+        setWillNotDraw(false);
+        mCircleMinSize = context.getResources().getDimensionPixelSize(
+                R.dimen.assist_orb_size);
+        mBaseMargin = context.getResources().getDimensionPixelSize(
+                R.dimen.assist_orb_base_margin);
+        mStaticOffset = context.getResources().getDimensionPixelSize(
+                R.dimen.assist_orb_travel_distance);
+        mMaxElevation = context.getResources().getDimensionPixelSize(
+                R.dimen.assist_orb_elevation);
+        mAppearInterpolator = AnimationUtils.loadInterpolator(mContext,
+                android.R.interpolator.linear_out_slow_in);
+        mDisappearInterpolator = AnimationUtils.loadInterpolator(mContext,
+                android.R.interpolator.fast_out_linear_in);
+        mBackgroundPaint.setAntiAlias(true);
+        mBackgroundPaint.setColor(getResources().getColor(R.color.assist_orb_color));
+    }
+
+    public ImageView getLogo() {
+        return mLogo;
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        drawBackground(canvas);
+    }
+
+    private void drawBackground(Canvas canvas) {
+        canvas.drawCircle(mCircleRect.centerX(), mCircleRect.centerY(), mCircleSize / 2,
+                mBackgroundPaint);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+        mLogo = (ImageView) findViewById(R.id.search_logo);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        mLogo.layout(0, 0, mLogo.getMeasuredWidth(), mLogo.getMeasuredHeight());
+        if (changed) {
+            updateCircleRect(mStaticRect, mStaticOffset, true);
+        }
+    }
+
+    public void animateCircleSize(float circleSize, long duration,
+            long startDelay, Interpolator interpolator) {
+        if (circleSize == mCircleAnimationEndValue) {
+            return;
+        }
+        if (mCircleAnimator != null) {
+            mCircleAnimator.cancel();
+        }
+        mCircleAnimator = ValueAnimator.ofFloat(mCircleSize, circleSize);
+        mCircleAnimator.addUpdateListener(mCircleUpdateListener);
+        mCircleAnimator.addListener(mClearAnimatorListener);
+        mCircleAnimator.setInterpolator(interpolator);
+        mCircleAnimator.setDuration(duration);
+        mCircleAnimator.setStartDelay(startDelay);
+        mCircleAnimator.start();
+        mCircleAnimationEndValue = circleSize;
+    }
+
+    private void applyCircleSize(float circleSize) {
+        mCircleSize = circleSize;
+        updateLayout();
+    }
+
+    private void updateElevation() {
+        float t = (mStaticOffset - mOffset) / (float) mStaticOffset;
+        t = 1.0f - Math.max(t, 0.0f);
+        float offset = t * mMaxElevation;
+        setElevation(offset);
+    }
+
+    /**
+     * Animates the offset to the edge of the screen.
+     *
+     * @param offset The offset to apply.
+     * @param startDelay The desired start delay if animated.
+     *
+     * @param interpolator The desired interpolator if animated. If null,
+     *                     a default interpolator will be taken designed for appearing or
+     *                     disappearing.
+     */
+    private void animateOffset(float offset, long duration, long startDelay,
+            Interpolator interpolator) {
+        if (mOffsetAnimator != null) {
+            mOffsetAnimator.removeAllListeners();
+            mOffsetAnimator.cancel();
+        }
+        mOffsetAnimator = ValueAnimator.ofFloat(mOffset, offset);
+        mOffsetAnimator.addUpdateListener(mOffsetUpdateListener);
+        mOffsetAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mOffsetAnimator = null;
+            }
+        });
+        mOffsetAnimator.setInterpolator(interpolator);
+        mOffsetAnimator.setStartDelay(startDelay);
+        mOffsetAnimator.setDuration(duration);
+        mOffsetAnimator.start();
+    }
+
+    private void updateLayout() {
+        updateCircleRect();
+        updateLogo();
+        invalidateOutline();
+        invalidate();
+        updateClipping();
+    }
+
+    private void updateClipping() {
+        boolean clip = mCircleSize < mCircleMinSize;
+        if (clip != mClipToOutline) {
+            setClipToOutline(clip);
+            mClipToOutline = clip;
+        }
+    }
+
+    private void updateLogo() {
+        float translationX = (mCircleRect.left + mCircleRect.right) / 2.0f - mLogo.getWidth() / 2.0f;
+        float translationY = (mCircleRect.top + mCircleRect.bottom) / 2.0f
+                - mLogo.getHeight() / 2.0f - mCircleMinSize / 7f;
+        float t = (mStaticOffset - mOffset) / (float) mStaticOffset;
+        translationY += t * mStaticOffset * 0.1f;
+        float alpha = 1.0f-t;
+        alpha = Math.max((alpha - 0.5f) * 2.0f, 0);
+        mLogo.setImageAlpha((int) (alpha * 255));
+        mLogo.setTranslationX(translationX);
+        mLogo.setTranslationY(translationY);
+    }
+
+    private void updateCircleRect() {
+        updateCircleRect(mCircleRect, mOffset, false);
+    }
+
+    private void updateCircleRect(Rect rect, float offset, boolean useStaticSize) {
+        int left, top;
+        float circleSize = useStaticSize ? mCircleMinSize : mCircleSize;
+        left = (int) (getWidth() - circleSize) / 2;
+        top = (int) (getHeight() - circleSize / 2 - mBaseMargin - offset);
+        rect.set(left, top, (int) (left + circleSize), (int) (top + circleSize));
+    }
+
+    public void startExitAnimation(long delay) {
+        animateCircleSize(0, 200, delay, mDisappearInterpolator);
+        animateOffset(0, 200, delay, mDisappearInterpolator);
+    }
+
+    public void startEnterAnimation() {
+        applyCircleSize(0);
+        post(new Runnable() {
+            @Override
+            public void run() {
+                animateCircleSize(mCircleMinSize, 300, 0 /* delay */, mOvershootInterpolator);
+                animateOffset(mStaticOffset, 400, 0 /* delay */, mAppearInterpolator);
+            }
+        });
+    }
+
+    public void reset() {
+        mClipToOutline = false;
+        mBackgroundPaint.setAlpha(255);
+        mOutlineAlpha = 1.0f;
+    }
+
+    @Override
+    public boolean hasOverlappingRendering() {
+        // not really true but it's ok during an animation, as it's never permanent
+        return false;
+    }
+}