blob: 231392c445aae68e70a8cf743ba1dd74b4ed7626 [file] [log] [blame]
/*
* Copyright (C) 2018 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.wallpaper.widget;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.Point;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.view.animation.Interpolator;
import android.widget.LinearLayout;
import android.widget.Scroller;
import androidx.annotation.Nullable;
import androidx.core.text.TextUtilsCompat;
import androidx.core.view.ViewCompat;
import androidx.interpolator.view.animation.LinearOutSlowInInterpolator;
import androidx.viewpager.widget.PagerAdapter;
import androidx.viewpager.widget.ViewPager;
import androidx.viewpager.widget.ViewPager.OnPageChangeListener;
import com.android.wallpaper.R;
import com.android.wallpaper.util.ScreenSizeCalculator;
import java.lang.reflect.Field;
import java.util.Locale;
/**
* A Widget consisting of a ViewPager linked to a PageIndicator and previous/next arrows that can be
* used to page over that ViewPager.
* To use it, set a {@link PagerAdapter} using {@link #setAdapter(PagerAdapter)}, and optionally use
* a {@link #setOnPageChangeListener(OnPageChangeListener)} to listen for page changes.
*/
public class PreviewPager extends LinearLayout {
private static final String TAG = "PreviewPager";
private static final int STYLE_PEEKING = 0;
private static final int STYLE_ASPECT_RATIO = 1;
private final ViewPager mViewPager;
private final PageIndicator mPageIndicator;
private final View mPreviousArrow;
private final View mNextArrow;
private final ViewPager.OnPageChangeListener mPageListener;
private int mPageStyle;
private PagerAdapter mAdapter;
private ViewPager.OnPageChangeListener mExternalPageListener;
private float mScreenAspectRatio;
public PreviewPager(Context context) {
this(context, null);
}
public PreviewPager(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public PreviewPager(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
LayoutInflater.from(context).inflate(R.layout.preview_pager, this);
Resources res = context.getResources();
TypedArray a = context.obtainStyledAttributes(attrs,
R.styleable.PreviewPager, defStyleAttr, 0);
mPageStyle = a.getInteger(R.styleable.PreviewPager_card_style, STYLE_PEEKING);
a.recycle();
mViewPager = findViewById(R.id.preview_viewpager);
mViewPager.setPageTransformer(false, (view, position) -> {
int origin = mViewPager.getPaddingStart();
int leftBoundary = -view.getWidth();
int rightBoundary = mViewPager.getWidth();
int pageWidth = view.getWidth();
int offset = (int) (pageWidth * position);
// left origin right
// boundary boundary
// ---------------|----------|----------|----------
// Cover alpha: 1.0 0 1.0
float alpha;
if (offset <= leftBoundary || offset >= rightBoundary) {
alpha = 1.0f;
} else if (offset <= origin) {
// offset in (leftBoundary, origin]
alpha = (float) Math.abs(offset - origin) / Math.abs(leftBoundary - origin);
} else {
// offset in (origin, rightBoundary)
alpha = (float) Math.abs(offset - origin) / Math.abs(rightBoundary - origin);
}
}, LAYER_TYPE_NONE);
mViewPager.setPageMargin(res.getDimensionPixelOffset(R.dimen.preview_page_gap));
mViewPager.setClipToPadding(false);
if (mPageStyle == STYLE_PEEKING) {
int screenWidth = mViewPager.getResources().getDisplayMetrics().widthPixels;
int hMargin = res.getDimensionPixelOffset(R.dimen.preview_page_horizontal_margin);
hMargin = Math.max(hMargin, screenWidth/8);
mViewPager.setPadding(
hMargin,
res.getDimensionPixelOffset(R.dimen.preview_page_top_margin),
hMargin,
res.getDimensionPixelOffset(R.dimen.preview_page_bottom_margin));
} else if (mPageStyle == STYLE_ASPECT_RATIO) {
WindowManager windowManager = context.getSystemService(WindowManager.class);
Point screenSize = ScreenSizeCalculator.getInstance()
.getScreenSize(windowManager.getDefaultDisplay());
mScreenAspectRatio = (float) screenSize.y / screenSize.x;
mViewPager.setPadding(
0,
res.getDimensionPixelOffset(R.dimen.preview_page_top_margin),
0,
res.getDimensionPixelOffset(R.dimen.preview_page_bottom_margin));
// Set the default margin to make sure not peeking the second page before calculating
// the real margin.
mViewPager.setPageMargin(screenSize.x / 2);
mViewPager.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View view, int left, int top, int right, int bottom,
int oldLeft, int oldTop, int oldRight, int oldBottom) {
// Set the minimum margin which can't peek the second page.
mViewPager.setPageMargin(view.getPaddingEnd());
mViewPager.removeOnLayoutChangeListener(this);
}
});
}
setupPagerScroller(context);
mPageIndicator = findViewById(R.id.page_indicator);
mPreviousArrow = findViewById(R.id.arrow_previous);
mPreviousArrow.setOnClickListener(v -> {
final int previousPos = mViewPager.getCurrentItem() - 1;
mViewPager.setCurrentItem(previousPos, true);
});
mNextArrow = findViewById(R.id.arrow_next);
mNextArrow.setOnClickListener(v -> {
final int NextPos = mViewPager.getCurrentItem() + 1;
mViewPager.setCurrentItem(NextPos, true);
});
mPageListener = createPageListener();
mViewPager.addOnPageChangeListener(mPageListener);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
if (mPageStyle == STYLE_ASPECT_RATIO) {
int availableWidth = MeasureSpec.getSize(widthMeasureSpec);
int availableHeight = MeasureSpec.getSize(heightMeasureSpec);
int indicatorHeight = ((View) mPageIndicator.getParent()).getLayoutParams().height;
int pagerHeight = availableHeight - indicatorHeight;
if (availableWidth > 0) {
int absoluteCardWidth = (int) ((pagerHeight - mViewPager.getPaddingBottom()
- mViewPager.getPaddingTop())/ mScreenAspectRatio);
int hPadding = (availableWidth / 2) - (absoluteCardWidth / 2);
mViewPager.setPaddingRelative(
hPadding,
mViewPager.getPaddingTop(),
hPadding,
mViewPager.getPaddingBottom());
}
}
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
public void forceCardWidth(int widthPixels) {
mViewPager.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View v, int left, int top, int right, int bottom,
int oldLeft, int oldTop, int oldRight, int oldBottom) {
int hPadding = (mViewPager.getWidth() - widthPixels) / 2;
mViewPager.setPadding(hPadding, mViewPager.getPaddingTop(),
hPadding, mViewPager.getPaddingBottom());
mViewPager.removeOnLayoutChangeListener(this);
}
});
mViewPager.invalidate();
}
/**
* Call this method to set the {@link PagerAdapter} backing the {@link ViewPager} in this
* widget.
*/
public void setAdapter(@Nullable PagerAdapter adapter) {
if (adapter == null) {
mAdapter = null;
mViewPager.setAdapter(null);
return;
}
int initialPage = 0;
if (mViewPager.getAdapter() != null) {
initialPage = isRtl() ? mAdapter.getCount() - 1 - mViewPager.getCurrentItem()
: mViewPager.getCurrentItem();
}
mAdapter = adapter;
mViewPager.setAdapter(adapter);
mViewPager.setCurrentItem(isRtl() ? mAdapter.getCount() - 1 - initialPage : initialPage);
mAdapter.registerDataSetObserver(new DataSetObserver() {
@Override
public void onChanged() {
initIndicator();
}
});
initIndicator();
updateIndicator(mViewPager.getCurrentItem());
}
/**
* Checks if it is in RTL mode.
*
* @return {@code true} if it's in RTL mode; {@code false} otherwise.
*/
public boolean isRtl() {
if (ViewCompat.isLayoutDirectionResolved(mViewPager)) {
return ViewCompat.getLayoutDirection(mViewPager) == ViewCompat.LAYOUT_DIRECTION_RTL;
}
return TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault())
== ViewCompat.LAYOUT_DIRECTION_RTL;
}
/**
* Set a {@link OnPageChangeListener} to be notified when the ViewPager's page state changes
*/
public void setOnPageChangeListener(@Nullable ViewPager.OnPageChangeListener listener) {
mExternalPageListener = listener;
}
/**
* Switches to the specific preview page.
*
* @param index preview page index to select
*/
public void switchPreviewPage(int index) {
mViewPager.setCurrentItem(index);
}
private void initIndicator() {
mPageIndicator.setNumPages(mAdapter.getCount());
mPageIndicator.setLocation(mViewPager.getCurrentItem());
}
private void setupPagerScroller(Context context) {
try {
// TODO(b/159082165): Revisit if we can refactor it better.
Field scroller = ViewPager.class.getDeclaredField("mScroller");
scroller.setAccessible(true);
PreviewPagerScroller previewPagerScroller =
new PreviewPagerScroller(context, new LinearOutSlowInInterpolator());
scroller.set(mViewPager, previewPagerScroller);
} catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
Log.e(TAG, "Failed to setup pager scroller.", e);
}
}
private ViewPager.OnPageChangeListener createPageListener() {
return new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(
int position, float positionOffset, int positionOffsetPixels) {
// For certain sizes, positionOffset never makes it to 1, so round it as we don't
// need that much precision
float location = (float) Math.round((position + positionOffset) * 100) / 100;
mPageIndicator.setLocation(location);
if (mExternalPageListener != null) {
mExternalPageListener.onPageScrolled(position, positionOffset,
positionOffsetPixels);
}
}
@Override
public void onPageSelected(int position) {
int adapterCount = mAdapter.getCount();
if (position < 0 || position >= adapterCount) {
return;
}
updateIndicator(position);
if (mExternalPageListener != null) {
mExternalPageListener.onPageSelected(position);
}
}
@Override
public void onPageScrollStateChanged(int state) {
if (mExternalPageListener != null) {
mExternalPageListener.onPageScrollStateChanged(state);
}
}
};
}
private void updateIndicator(int position) {
int adapterCount = mAdapter.getCount();
if (adapterCount > 1) {
mPreviousArrow.setVisibility(position != 0 ? View.VISIBLE : View.GONE);
mNextArrow.setVisibility(position != (adapterCount - 1) ? View.VISIBLE : View.GONE);
} else {
mPageIndicator.setVisibility(View.GONE);
mPreviousArrow.setVisibility(View.GONE);
mNextArrow.setVisibility(View.GONE);
}
}
private static class PreviewPagerScroller extends Scroller {
private static final int DURATION_MS = 500;
PreviewPagerScroller(Context context, Interpolator interpolator) {
super(context, interpolator);
}
@Override
public void startScroll(int startX, int startY, int dx, int dy, int duration) {
super.startScroll(startX, startY, dx, dy, DURATION_MS);
}
}
}