1 files changed, 531 insertions, 0 deletions
diff --git a/common/src/com/android/tv/common/ui/setup/leanback/OnboardingFragment.java b/common/src/com/android/tv/common/ui/setup/leanback/OnboardingFragment.java
new file mode 100644
index 00000000..adbd98c2
--- /dev/null
+++ b/common/src/com/android/tv/common/ui/setup/leanback/OnboardingFragment.java
@@ -0,0 +1,531 @@
+/*
+ * 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.tv.common.ui.setup.leanback;
+
+import android.animation.Animator;
+import android.animation.AnimatorInflater;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.app.Fragment;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnKeyListener;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver.OnPreDrawListener;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.android.tv.common.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * An OnboardingFragment provides a common and simple way to build onboarding screen for
+ * applications.
+ * <p>
+ * <h3>Building the screen</h3>
+ * The view structure of onboarding screen is composed of the common parts and custom parts. The
+ * common parts are composed of title, description and page navigator and the custom parts are
+ * composed of background, contents and foreground.
+ * <p>
+ * To build the screen views, the inherited class should override:
+ * <ul>
+ * <li>{@link #onCreateBackgroundView} to provide the background view. Background view has the same
+ * size as the screen and the lowest z-order.</li>
+ * <li>{@link #onCreateContentView} to provide the contents view. The content view is located in
+ * the content area at the center of the screen.</li>
+ * <li>{@link #onCreateForegroundView} to provide the foreground view. Foreground view has the same
+ * size as the screen and the highest z-order</li>
+ * </ul>
+ * <p>
+ * Each of these methods can return {@code null} if the application doesn't want to provide it.
+ * <p>
+ * <h3>Page information</h3>
+ * The onboarding screen may have several pages which explain the functionality of the application.
+ * The inherited class should provide the page information by overriding the methods:
+ * <p>
+ * <ul>
+ * <li>{@link #getPageCount} to provide the number of pages.</li>
+ * <li>{@link #getPageTitle} to provide the title of the page.</li>
+ * <li>{@link #getPageDescription} to provide the description of the page.</li>
+ * </ul>
+ * <p>
+ * <h3><a name="logoAnimation">Logo Splash Animation</a></h3>
+ * When onboarding screen appears, the logo splash animation is played by default. The animation
+ * fades in the logo image, pauses in a few seconds and fades it out. To support this animation with
+ * its own logo image, the inherited class should override the following method.
+ * <p>
+ * <ul>
+ * <li>{@link #getLogoResourceId()}</li>
+ * </ul>
+ * <p>
+ * <h3>Animation</h3>
+ * This page has three kinds of animations:
+ * <p>
+ * <ul>
+ * <li><b>Logo splash animation</b> which starts as soon as onboarding screen is shown as described
+ * in <a href="#logoAnimation">Logo Splash Animation</a>.</li>
+ * <li><b>Page enter animation</b> which runs just after the logo animation finishes. The
+ * application can run the animations of their custom views by overriding
+ * {@link #onStartEnterAnimation}.</li>
+ * <li><b>Page change animation</b> which runs when the page changes. The pages can move backward or
+ * forward direction and the application can start the page change animations by overriding
+ * {@link #onStartPageChangeAnimation}.</li>
+ * </ul>
+ * <p>
+ * <h3>Finishing the screen</h3>
+ * <p>
+ * If the user finishes the onboarding screen after navigating all the pages,
+ * {@link #onFinishFragment} is called. The inherited class can override this method to show another
+ * fragment or activity, or just remove this fragment.
+ *
+ * @hide
+ */
+abstract public class OnboardingFragment extends Fragment {
+    private static final long LOGO_SPLASH_PAUSE_DURATION_MS = 1333;
+    private static final long START_DELAY_TITLE_MS = 33;
+    private static final long START_DELAY_DESCRIPTION_MS = 33;
+
+    private static final long HEADER_ANIMATION_DURATION_MS = 417;
+    private static final long DESCRIPTION_START_DELAY_MS = 33;
+    private static final long HEADER_APPEAR_DELAY_MS = 500;
+    private static final int SLIDE_DISTANCE = 60;
+
+    private static int sSlideDistance;
+
+    private static final TimeInterpolator HEADER_APPEAR_INTERPOLATOR = new DecelerateInterpolator();
+    private static final TimeInterpolator HEADER_DISAPPEAR_INTERPOLATOR
+            = new AccelerateInterpolator();
+
+    private PagingIndicator mPageIndicator;
+    private View mStartButton;
+    private ImageView mLogoView;
+    private TextView mTitleView;
+    private TextView mDescriptionView;
+
+    private boolean mEnterTransitionFinished;
+    private int mCurrentPageIndex;
+
+    private AnimatorSet mAnimator;
+
+    /**
+     * Called to have the inherited class create its own start animation. The start animation runs
+     * after logo splash animation ends.
+     */
+    abstract protected void onStartEnterAnimation();
+
+    private final OnClickListener mOnClickListener = new OnClickListener() {
+        @Override
+        public void onClick(View view) {
+            if (!mEnterTransitionFinished) {
+                // Do not change page until the enter transition finishes.
+                return;
+            }
+            if (mCurrentPageIndex == getPageCount() - 1) {
+                onFinishFragment();
+            } else {
+                ++mCurrentPageIndex;
+                onPageChanged(mCurrentPageIndex - 1);
+            }
+        }
+    };
+
+    private final OnKeyListener mOnKeyListener = new OnKeyListener() {
+        @Override
+        public boolean onKey(View v, int keyCode, KeyEvent event) {
+            if (!mEnterTransitionFinished) {
+                // Ignore key event until the enter transition finishes.
+                return keyCode != KeyEvent.KEYCODE_BACK;
+            }
+            if (event.getAction() == KeyEvent.ACTION_DOWN) {
+                return false;
+            }
+            switch (keyCode) {
+                case KeyEvent.KEYCODE_BACK:
+                    if (mCurrentPageIndex == 0) {
+                        return false;
+                    }
+                    // pass through
+                case KeyEvent.KEYCODE_DPAD_LEFT:
+                    if (mCurrentPageIndex > 0) {
+                        --mCurrentPageIndex;
+                        onPageChanged(mCurrentPageIndex + 1);
+                    }
+                    return true;
+                case KeyEvent.KEYCODE_DPAD_RIGHT:
+                    if (mCurrentPageIndex < getPageCount() - 1) {
+                        ++mCurrentPageIndex;
+                        onPageChanged(mCurrentPageIndex - 1);
+                    }
+                    return true;
+            }
+            return false;
+        }
+    };
+
+    @Nullable
+    @Override
+    public View onCreateView(LayoutInflater inflater, final ViewGroup container,
+            Bundle savedInstanceState) {
+        ViewGroup view = (ViewGroup) inflater.inflate(R.layout.lb_onboarding_fragment, container,
+                false);
+        mPageIndicator = (PagingIndicator) view.findViewById(R.id.page_indicator);
+        mPageIndicator.setPageCount(getPageCount());
+        mPageIndicator.setOnClickListener(mOnClickListener);
+        mPageIndicator.setOnKeyListener(mOnKeyListener);
+        mStartButton = view.findViewById(R.id.button_start);
+        mStartButton.setOnClickListener(mOnClickListener);
+        mStartButton.setOnKeyListener(mOnKeyListener);
+        mLogoView = (ImageView) view.findViewById(R.id.logo);
+        mLogoView.setImageResource(getLogoResourceId());
+        mTitleView = (TextView) view.findViewById(R.id.title);
+        mTitleView.setText(getPageTitle(0));
+        mDescriptionView = (TextView) view.findViewById(R.id.description);
+        mDescriptionView.setText(getPageDescription(0));
+        if (sSlideDistance == 0) {
+            sSlideDistance = (int) (SLIDE_DISTANCE * getActivity().getResources()
+                    .getDisplayMetrics().scaledDensity);
+        }
+        mCurrentPageIndex = 0;
+        mPageIndicator.onPageSelected(0, false);
+        view.requestFocus();
+        if (getLogoResourceId() != 0) {
+            container.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListener() {
+                @Override
+                public boolean onPreDraw() {
+                    container.getViewTreeObserver().removeOnPreDrawListener(this);
+                    startLogoAnimation();
+                    return true;
+                }
+            });
+        } else {
+            onLogoAnimationFinished();
+        }
+        return view;
+    }
+
+    private void startLogoAnimation() {
+        mLogoView.setVisibility(View.VISIBLE);
+        Animator inAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                R.animator.lb_onboarding_logo_enter);
+        Animator outAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                R.animator.lb_onboarding_logo_exit);
+        outAnimator.setStartDelay(LOGO_SPLASH_PAUSE_DURATION_MS);
+        AnimatorSet animator = new AnimatorSet();
+        animator.playSequentially(inAnimator, outAnimator);
+        animator.setTarget(mLogoView);
+        animator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mEnterTransitionFinished = true;
+                if (getActivity() != null) {
+                    onLogoAnimationFinished();
+                    onStartEnterAnimation();
+                }
+            }
+        });
+        animator.start();
+    }
+
+    private void onLogoAnimationFinished() {
+        mLogoView.setVisibility(View.GONE);
+        // Create custom views.
+        LayoutInflater inflater = LayoutInflater.from(getActivity());
+        ViewGroup backgroundContainer = (ViewGroup) getView().findViewById(
+                R.id.background_container);
+        View background = onCreateBackgroundView(inflater, backgroundContainer);
+        if (background != null) {
+            backgroundContainer.setVisibility(View.VISIBLE);
+            backgroundContainer.addView(background);
+        }
+        ViewGroup contentContainer = (ViewGroup) getView().findViewById(R.id.content_container);
+        View content = onCreateContentView(inflater, contentContainer);
+        if (content != null) {
+            contentContainer.setVisibility(View.VISIBLE);
+            contentContainer.addView(content);
+        }
+        ViewGroup foregroundContainer = (ViewGroup) getView().findViewById(
+                R.id.foreground_container);
+        View foreground = onCreateForegroundView(inflater, foregroundContainer);
+        if (foreground != null) {
+            foregroundContainer.setVisibility(View.VISIBLE);
+            foregroundContainer.addView(foreground);
+        }
+        // Make views visible which were invisible while logo animation is running.
+        getView().findViewById(R.id.page_container).setVisibility(View.VISIBLE);
+        getView().findViewById(R.id.content_container).setVisibility(View.VISIBLE);
+
+        List<Animator> animators = new ArrayList<>();
+        Animator animator = AnimatorInflater.loadAnimator(getActivity(),
+                R.animator.lb_onboarding_page_indicator_enter);
+        if (getPageCount() <= 1) {
+            // Start button
+            mStartButton.setVisibility(View.VISIBLE);
+            animator.setTarget(mStartButton);
+        } else {
+            // Page indicator
+            mPageIndicator.setVisibility(View.VISIBLE);
+            animator.setTarget(mPageIndicator);
+        }
+        animators.add(animator);
+        // Header title
+        View view = getActivity().findViewById(R.id.title);
+        view.setAlpha(0);
+        animator = AnimatorInflater.loadAnimator(getActivity(),
+                R.animator.lb_onboarding_title_enter);
+        animator.setStartDelay(START_DELAY_TITLE_MS);
+        animator.setTarget(view);
+        animators.add(animator);
+        // Header description
+        view = getActivity().findViewById(R.id.description);
+        view.setAlpha(0);
+        animator = AnimatorInflater.loadAnimator(getActivity(),
+                R.animator.lb_onboarding_description_enter);
+        animator.setStartDelay(START_DELAY_DESCRIPTION_MS);
+        animator.setTarget(view);
+        animators.add(animator);
+        mAnimator = new AnimatorSet();
+        mAnimator.playTogether(animators);
+        mAnimator.start();
+        onStartEnterAnimation();
+        // Search focus and give the focus to the appropriate child which has become visible.
+        getView().requestFocus();
+    }
+
+    /**
+     * Returns the page count.
+     *
+     * @return The page count.
+     */
+    abstract protected int getPageCount();
+
+    /**
+     * Returns the title of the given page.
+     *
+     * @param pageIndex The page index.
+     *
+     * @return The title of the page.
+     */
+    abstract protected String getPageTitle(int pageIndex);
+
+    /**
+     * Returns the description of the given page.
+     *
+     * @param pageIndex The page index.
+     *
+     * @return The description of the page.
+     */
+    abstract protected String getPageDescription(int pageIndex);
+
+    /**
+     * Returns the index of the current page.
+     *
+     * @return The index of the current page.
+     */
+    protected final int getCurrentPageIndex() {
+        return mCurrentPageIndex;
+    }
+
+    /**
+     * Returns the resource ID of the splash logo image.
+     *
+     * @return The resource ID of the splash logo image.
+     */
+    abstract protected int getLogoResourceId();
+
+    /**
+     * Called to have the inherited class create background view. This is optional and the fragment
+     * which doesn't have the background view can return {@code null}. This is called inside
+     * {@link #onCreateView}.
+     *
+     * @param inflater The LayoutInflater object that can be used to inflate the views,
+     * @param container The parent view that the additional views are attached to.The fragment
+     *        should not add the view by itself.
+     *
+     * @return The background view for the onboarding screen, or {@code null}.
+     */
+    @Nullable
+    abstract protected View onCreateBackgroundView(LayoutInflater inflater, ViewGroup container);
+
+    /**
+     * Called to have the inherited class create content view. This is optional and the fragment
+     * which doesn't have the content view can return {@code null}. This is called inside
+     * {@link #onCreateView}.
+     *
+     * <p>The content view would be located at the center of the screen.
+     *
+     * @param inflater The LayoutInflater object that can be used to inflate the views,
+     * @param container The parent view that the additional views are attached to.The fragment
+     *        should not add the view by itself.
+     *
+     * @return The content view for the onboarding screen, or {@code null}.
+     */
+    @Nullable
+    abstract protected View onCreateContentView(LayoutInflater inflater, ViewGroup container);
+
+    /**
+     * Called to have the inherited class create foreground view. This is optional and the fragment
+     * which doesn't need the foreground view can return {@code null}. This is called inside
+     * {@link #onCreateView}.
+     *
+     * <p>This foreground view would have the highest z-order.
+     *
+     * @param inflater The LayoutInflater object that can be used to inflate the views,
+     * @param container The parent view that the additional views are attached to.The fragment
+     *        should not add the view by itself.
+     *
+     * @return The foreground view for the onboarding screen, or {@code null}.
+     */
+    @Nullable
+    abstract protected View onCreateForegroundView(LayoutInflater inflater, ViewGroup container);
+
+    /**
+     * Called when the onboarding flow finishes.
+     */
+    protected void onFinishFragment() { }
+
+    /**
+     * Called when the page changes.
+     */
+    private void onPageChanged(int previousPage) {
+        if (mAnimator != null) {
+            mAnimator.end();
+        }
+        mPageIndicator.onPageSelected(mCurrentPageIndex, true);
+
+        List<Animator> animators = new ArrayList<>();
+        // Header animation
+        Animator fadeAnimator = null;
+        if (previousPage < getCurrentPageIndex()) {
+            // sliding to left
+            animators.add(createAnimator(mTitleView, false, Gravity.START, 0));
+            animators.add(fadeAnimator = createAnimator(mDescriptionView, false, Gravity.START,
+                    DESCRIPTION_START_DELAY_MS));
+            animators.add(createAnimator(mTitleView, true, Gravity.END,
+                    HEADER_APPEAR_DELAY_MS));
+            animators.add(createAnimator(mDescriptionView, true, Gravity.END,
+                    HEADER_APPEAR_DELAY_MS + DESCRIPTION_START_DELAY_MS));
+        } else {
+            // sliding to right
+            animators.add(createAnimator(mTitleView, false, Gravity.END, 0));
+            animators.add(fadeAnimator = createAnimator(mDescriptionView, false, Gravity.END,
+                    DESCRIPTION_START_DELAY_MS));
+            animators.add(createAnimator(mTitleView, true, Gravity.START,
+                    HEADER_APPEAR_DELAY_MS));
+            animators.add(createAnimator(mDescriptionView, true, Gravity.START,
+                    HEADER_APPEAR_DELAY_MS + DESCRIPTION_START_DELAY_MS));
+        }
+        final int currentPageIndex = getCurrentPageIndex();
+        fadeAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mTitleView.setText(getPageTitle(currentPageIndex));
+                mDescriptionView.setText(getPageDescription(currentPageIndex));
+            }
+        });
+
+        // Animator for switching between page indicator and button.
+        if (getCurrentPageIndex() == getPageCount() - 1) {
+            mStartButton.setVisibility(View.VISIBLE);
+            Animator navigatorFadeOutAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                    R.animator.lb_onboarding_page_indicator_fade_out);
+            navigatorFadeOutAnimator.setTarget(mPageIndicator);
+            Animator buttonFadeInAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                    R.animator.lb_onboarding_start_button_fade_in);
+            buttonFadeInAnimator.setTarget(mStartButton);
+            animators.add(navigatorFadeOutAnimator);
+            navigatorFadeOutAnimator.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mPageIndicator.setVisibility(View.GONE);
+                }
+            });
+            animators.add(buttonFadeInAnimator);
+        } else if (previousPage == getPageCount() - 1) {
+            mPageIndicator.setVisibility(View.VISIBLE);
+            Animator navigatorFadeInAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                    R.animator.lb_onboarding_page_indicator_fade_in);
+            navigatorFadeInAnimator.setTarget(mPageIndicator);
+            Animator buttonFadeOutAnimator = AnimatorInflater.loadAnimator(getActivity(),
+                    R.animator.lb_onboarding_start_button_fade_out);
+            buttonFadeOutAnimator.setTarget(mStartButton);
+            buttonFadeOutAnimator.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mStartButton.setVisibility(View.GONE);
+                }
+            });
+            mAnimator = new AnimatorSet();
+            mAnimator.playTogether(navigatorFadeInAnimator, buttonFadeOutAnimator);
+            mAnimator.start();
+        }
+        mAnimator = new AnimatorSet();
+        mAnimator.playTogether(animators);
+        mAnimator.start();
+        onStartPageChangeAnimation(previousPage);
+    }
+
+    private Animator createAnimator(View view, boolean fadeIn, int slideDirection,
+            long startDelay) {
+        boolean isLtr = getView().getLayoutDirection() == View.LAYOUT_DIRECTION_LTR;
+        boolean slideRight = (isLtr && slideDirection == Gravity.END)
+                || (!isLtr && slideDirection == Gravity.START)
+                || slideDirection == Gravity.RIGHT;
+        Animator fadeAnimator;
+        Animator slideAnimator;
+        if (fadeIn) {
+            fadeAnimator = ObjectAnimator.ofFloat(view, View.ALPHA, 0.0f, 1.0f);
+            slideAnimator = ObjectAnimator.ofFloat(view, View.TRANSLATION_X,
+                    slideRight ? sSlideDistance : -sSlideDistance, 0);
+            fadeAnimator.setInterpolator(HEADER_APPEAR_INTERPOLATOR);
+            slideAnimator.setInterpolator(HEADER_APPEAR_INTERPOLATOR);
+        } else {
+            fadeAnimator = ObjectAnimator.ofFloat(view, View.ALPHA, 1.0f, 0.0f);
+            slideAnimator = ObjectAnimator.ofFloat(view, View.TRANSLATION_X, 0,
+                    slideRight ? sSlideDistance : -sSlideDistance);
+            fadeAnimator.setInterpolator(HEADER_DISAPPEAR_INTERPOLATOR);
+            slideAnimator.setInterpolator(HEADER_DISAPPEAR_INTERPOLATOR);
+        }
+        fadeAnimator.setDuration(HEADER_ANIMATION_DURATION_MS);
+        fadeAnimator.setTarget(view);
+        slideAnimator.setDuration(HEADER_ANIMATION_DURATION_MS);
+        slideAnimator.setTarget(view);
+        AnimatorSet animator = new AnimatorSet();
+        animator.playTogether(fadeAnimator, slideAnimator);
+        if (startDelay > 0) {
+            animator.setStartDelay(startDelay);
+        }
+        return animator;
+    }
+
+    /**
+     * Called to have the inherited class run its own page change animation
+     *
+     * @param previousPage The previous page.
+     */
+    abstract protected void onStartPageChangeAnimation(int previousPage);
+}