a53b3983bf
PiperOrigin-RevId: 210155157 Change-Id: I707512aab6ac57aaebb93275669ae16b92b0e66d
425 lines
15 KiB
Java
425 lines
15 KiB
Java
/*
|
|
* 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.setupwizardlib;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.annotation.TargetApi;
|
|
import android.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Shader.TileMode;
|
|
import android.graphics.drawable.BitmapDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.LayerDrawable;
|
|
import android.os.Build.VERSION;
|
|
import android.os.Build.VERSION_CODES;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.TypedValue;
|
|
import android.view.Gravity;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.ScrollView;
|
|
import android.widget.TextView;
|
|
import com.android.setupwizardlib.template.HeaderMixin;
|
|
import com.android.setupwizardlib.template.NavigationBarMixin;
|
|
import com.android.setupwizardlib.template.ProgressBarMixin;
|
|
import com.android.setupwizardlib.template.RequireScrollMixin;
|
|
import com.android.setupwizardlib.template.ScrollViewScrollHandlingDelegate;
|
|
import com.android.setupwizardlib.view.Illustration;
|
|
import com.android.setupwizardlib.view.NavigationBar;
|
|
|
|
public class SetupWizardLayout extends TemplateLayout {
|
|
|
|
private static final String TAG = "SetupWizardLayout";
|
|
|
|
public SetupWizardLayout(Context context) {
|
|
super(context, 0, 0);
|
|
init(null, R.attr.suwLayoutTheme);
|
|
}
|
|
|
|
public SetupWizardLayout(Context context, int template) {
|
|
this(context, template, 0);
|
|
}
|
|
|
|
public SetupWizardLayout(Context context, int template, int containerId) {
|
|
super(context, template, containerId);
|
|
init(null, R.attr.suwLayoutTheme);
|
|
}
|
|
|
|
public SetupWizardLayout(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
init(attrs, R.attr.suwLayoutTheme);
|
|
}
|
|
|
|
@TargetApi(VERSION_CODES.HONEYCOMB)
|
|
public SetupWizardLayout(Context context, AttributeSet attrs, int defStyleAttr) {
|
|
super(context, attrs, defStyleAttr);
|
|
init(attrs, defStyleAttr);
|
|
}
|
|
|
|
// All the constructors delegate to this init method. The 3-argument constructor is not
|
|
// available in LinearLayout before v11, so call super with the exact same arguments.
|
|
private void init(AttributeSet attrs, int defStyleAttr) {
|
|
registerMixin(HeaderMixin.class, new HeaderMixin(this, attrs, defStyleAttr));
|
|
registerMixin(ProgressBarMixin.class, new ProgressBarMixin(this));
|
|
registerMixin(NavigationBarMixin.class, new NavigationBarMixin(this));
|
|
final RequireScrollMixin requireScrollMixin = new RequireScrollMixin(this);
|
|
registerMixin(RequireScrollMixin.class, requireScrollMixin);
|
|
|
|
final ScrollView scrollView = getScrollView();
|
|
if (scrollView != null) {
|
|
requireScrollMixin.setScrollHandlingDelegate(
|
|
new ScrollViewScrollHandlingDelegate(requireScrollMixin, scrollView));
|
|
}
|
|
|
|
final TypedArray a =
|
|
getContext()
|
|
.obtainStyledAttributes(attrs, R.styleable.SuwSetupWizardLayout, defStyleAttr, 0);
|
|
|
|
// Set the background from XML, either directly or built from a bitmap tile
|
|
final Drawable background = a.getDrawable(R.styleable.SuwSetupWizardLayout_suwBackground);
|
|
if (background != null) {
|
|
setLayoutBackground(background);
|
|
} else {
|
|
final Drawable backgroundTile =
|
|
a.getDrawable(R.styleable.SuwSetupWizardLayout_suwBackgroundTile);
|
|
if (backgroundTile != null) {
|
|
setBackgroundTile(backgroundTile);
|
|
}
|
|
}
|
|
|
|
// Set the illustration from XML, either directly or built from image + horizontal tile
|
|
final Drawable illustration = a.getDrawable(R.styleable.SuwSetupWizardLayout_suwIllustration);
|
|
if (illustration != null) {
|
|
setIllustration(illustration);
|
|
} else {
|
|
final Drawable illustrationImage =
|
|
a.getDrawable(R.styleable.SuwSetupWizardLayout_suwIllustrationImage);
|
|
final Drawable horizontalTile =
|
|
a.getDrawable(R.styleable.SuwSetupWizardLayout_suwIllustrationHorizontalTile);
|
|
if (illustrationImage != null && horizontalTile != null) {
|
|
setIllustration(illustrationImage, horizontalTile);
|
|
}
|
|
}
|
|
|
|
// Set the top padding of the illustration
|
|
int decorPaddingTop =
|
|
a.getDimensionPixelSize(R.styleable.SuwSetupWizardLayout_suwDecorPaddingTop, -1);
|
|
if (decorPaddingTop == -1) {
|
|
decorPaddingTop = getResources().getDimensionPixelSize(R.dimen.suw_decor_padding_top);
|
|
}
|
|
setDecorPaddingTop(decorPaddingTop);
|
|
|
|
// Set the illustration aspect ratio. See Illustration.setAspectRatio(float). This will
|
|
// override suwDecorPaddingTop if its value is not 0.
|
|
float illustrationAspectRatio =
|
|
a.getFloat(R.styleable.SuwSetupWizardLayout_suwIllustrationAspectRatio, -1f);
|
|
if (illustrationAspectRatio == -1f) {
|
|
final TypedValue out = new TypedValue();
|
|
getResources().getValue(R.dimen.suw_illustration_aspect_ratio, out, true);
|
|
illustrationAspectRatio = out.getFloat();
|
|
}
|
|
setIllustrationAspectRatio(illustrationAspectRatio);
|
|
|
|
a.recycle();
|
|
}
|
|
|
|
@Override
|
|
protected Parcelable onSaveInstanceState() {
|
|
final Parcelable parcelable = super.onSaveInstanceState();
|
|
final SavedState ss = new SavedState(parcelable);
|
|
ss.isProgressBarShown = isProgressBarShown();
|
|
return ss;
|
|
}
|
|
|
|
@Override
|
|
protected void onRestoreInstanceState(Parcelable state) {
|
|
if (!(state instanceof SavedState)) {
|
|
Log.w(TAG, "Ignoring restore instance state " + state);
|
|
super.onRestoreInstanceState(state);
|
|
return;
|
|
}
|
|
|
|
final SavedState ss = (SavedState) state;
|
|
super.onRestoreInstanceState(ss.getSuperState());
|
|
final boolean isProgressBarShown = ss.isProgressBarShown;
|
|
setProgressBarShown(isProgressBarShown);
|
|
}
|
|
|
|
@Override
|
|
protected View onInflateTemplate(LayoutInflater inflater, int template) {
|
|
if (template == 0) {
|
|
template = R.layout.suw_template;
|
|
}
|
|
return inflateTemplate(inflater, R.style.SuwThemeMaterial_Light, template);
|
|
}
|
|
|
|
@Override
|
|
protected ViewGroup findContainer(int containerId) {
|
|
if (containerId == 0) {
|
|
containerId = R.id.suw_layout_content;
|
|
}
|
|
return super.findContainer(containerId);
|
|
}
|
|
|
|
public NavigationBar getNavigationBar() {
|
|
return getMixin(NavigationBarMixin.class).getNavigationBar();
|
|
}
|
|
|
|
public ScrollView getScrollView() {
|
|
final View view = findManagedViewById(R.id.suw_bottom_scroll_view);
|
|
return view instanceof ScrollView ? (ScrollView) view : null;
|
|
}
|
|
|
|
public void requireScrollToBottom() {
|
|
final RequireScrollMixin requireScrollMixin = getMixin(RequireScrollMixin.class);
|
|
final NavigationBar navigationBar = getNavigationBar();
|
|
if (navigationBar != null) {
|
|
requireScrollMixin.requireScrollWithNavigationBar(navigationBar);
|
|
} else {
|
|
Log.e(TAG, "Cannot require scroll. Navigation bar is null.");
|
|
}
|
|
}
|
|
|
|
public void setHeaderText(int title) {
|
|
getMixin(HeaderMixin.class).setText(title);
|
|
}
|
|
|
|
public void setHeaderText(CharSequence title) {
|
|
getMixin(HeaderMixin.class).setText(title);
|
|
}
|
|
|
|
public CharSequence getHeaderText() {
|
|
return getMixin(HeaderMixin.class).getText();
|
|
}
|
|
|
|
public TextView getHeaderTextView() {
|
|
return getMixin(HeaderMixin.class).getTextView();
|
|
}
|
|
|
|
/**
|
|
* Set the illustration of the layout. The drawable will be applied as is, and the bounds will be
|
|
* set as implemented in {@link com.android.setupwizardlib.view.Illustration}. To create a
|
|
* suitable drawable from an asset and a horizontal repeating tile, use {@link
|
|
* #setIllustration(int, int)} instead.
|
|
*
|
|
* @param drawable The drawable specifying the illustration.
|
|
*/
|
|
public void setIllustration(Drawable drawable) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view instanceof Illustration) {
|
|
final Illustration illustration = (Illustration) view;
|
|
illustration.setIllustration(drawable);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the illustration of the layout, which will be created asset and the horizontal tile as
|
|
* suitable. On phone layouts (not sw600dp), the asset will be scaled, maintaining aspect ratio.
|
|
* On tablets (sw600dp), the assets will always have 256dp height and the rest of the illustration
|
|
* area that the asset doesn't fill will be covered by the horizontalTile.
|
|
*
|
|
* @param asset Resource ID of the illustration asset.
|
|
* @param horizontalTile Resource ID of the horizontally repeating tile for tablet layout.
|
|
*/
|
|
public void setIllustration(int asset, int horizontalTile) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view instanceof Illustration) {
|
|
final Illustration illustration = (Illustration) view;
|
|
final Drawable illustrationDrawable = getIllustration(asset, horizontalTile);
|
|
illustration.setIllustration(illustrationDrawable);
|
|
}
|
|
}
|
|
|
|
private void setIllustration(Drawable asset, Drawable horizontalTile) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view instanceof Illustration) {
|
|
final Illustration illustration = (Illustration) view;
|
|
final Drawable illustrationDrawable = getIllustration(asset, horizontalTile);
|
|
illustration.setIllustration(illustrationDrawable);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the aspect ratio of the illustration. This will be the space (padding top) reserved above
|
|
* the header text. This will override the padding top of the illustration.
|
|
*
|
|
* @param aspectRatio The aspect ratio
|
|
* @see com.android.setupwizardlib.view.Illustration#setAspectRatio(float)
|
|
*/
|
|
public void setIllustrationAspectRatio(float aspectRatio) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view instanceof Illustration) {
|
|
final Illustration illustration = (Illustration) view;
|
|
illustration.setAspectRatio(aspectRatio);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the top padding of the decor view. If the decor is an Illustration and the aspect ratio is
|
|
* set, this value will be overridden.
|
|
*
|
|
* <p>Note: Currently the default top padding for tablet landscape is 128dp, which is the offset
|
|
* of the card from the top. This is likely to change in future versions so this value aligns with
|
|
* the height of the illustration instead.
|
|
*
|
|
* @param paddingTop The top padding in pixels.
|
|
*/
|
|
public void setDecorPaddingTop(int paddingTop) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view != null) {
|
|
view.setPadding(
|
|
view.getPaddingLeft(), paddingTop, view.getPaddingRight(), view.getPaddingBottom());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the background of the layout, which is expected to be able to extend infinitely. If it is a
|
|
* bitmap tile and you want it to repeat, use {@link #setBackgroundTile(int)} instead.
|
|
*/
|
|
public void setLayoutBackground(Drawable background) {
|
|
final View view = findManagedViewById(R.id.suw_layout_decor);
|
|
if (view != null) {
|
|
//noinspection deprecation
|
|
view.setBackgroundDrawable(background);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the background of the layout to a repeating bitmap tile. To use a different kind of
|
|
* drawable, use {@link #setLayoutBackground(android.graphics.drawable.Drawable)} instead.
|
|
*/
|
|
public void setBackgroundTile(int backgroundTile) {
|
|
final Drawable backgroundTileDrawable = getContext().getResources().getDrawable(backgroundTile);
|
|
setBackgroundTile(backgroundTileDrawable);
|
|
}
|
|
|
|
private void setBackgroundTile(Drawable backgroundTile) {
|
|
if (backgroundTile instanceof BitmapDrawable) {
|
|
((BitmapDrawable) backgroundTile).setTileModeXY(TileMode.REPEAT, TileMode.REPEAT);
|
|
}
|
|
setLayoutBackground(backgroundTile);
|
|
}
|
|
|
|
private Drawable getIllustration(int asset, int horizontalTile) {
|
|
final Context context = getContext();
|
|
final Drawable assetDrawable = context.getResources().getDrawable(asset);
|
|
final Drawable tile = context.getResources().getDrawable(horizontalTile);
|
|
return getIllustration(assetDrawable, tile);
|
|
}
|
|
|
|
@SuppressLint("RtlHardcoded")
|
|
private Drawable getIllustration(Drawable asset, Drawable horizontalTile) {
|
|
final Context context = getContext();
|
|
if (context.getResources().getBoolean(R.bool.suwUseTabletLayout)) {
|
|
// If it is a "tablet" (sw600dp), create a LayerDrawable with the horizontal tile.
|
|
if (horizontalTile instanceof BitmapDrawable) {
|
|
((BitmapDrawable) horizontalTile).setTileModeX(TileMode.REPEAT);
|
|
((BitmapDrawable) horizontalTile).setGravity(Gravity.TOP);
|
|
}
|
|
if (asset instanceof BitmapDrawable) {
|
|
// Always specify TOP | LEFT, Illustration will flip the entire LayerDrawable.
|
|
((BitmapDrawable) asset).setGravity(Gravity.TOP | Gravity.LEFT);
|
|
}
|
|
final LayerDrawable layers = new LayerDrawable(new Drawable[] {horizontalTile, asset});
|
|
if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) {
|
|
layers.setAutoMirrored(true);
|
|
}
|
|
return layers;
|
|
} else {
|
|
// If it is a "phone" (not sw600dp), simply return the illustration
|
|
if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) {
|
|
asset.setAutoMirrored(true);
|
|
}
|
|
return asset;
|
|
}
|
|
}
|
|
|
|
public boolean isProgressBarShown() {
|
|
return getMixin(ProgressBarMixin.class).isShown();
|
|
}
|
|
|
|
/**
|
|
* Sets whether the progress bar below the header text is shown or not. The progress bar is a
|
|
* lazily inflated ViewStub, which means the progress bar will not actually be part of the view
|
|
* hierarchy until the first time this is set to {@code true}.
|
|
*/
|
|
public void setProgressBarShown(boolean shown) {
|
|
getMixin(ProgressBarMixin.class).setShown(shown);
|
|
}
|
|
|
|
/** @deprecated Use {@link #setProgressBarShown(boolean)} */
|
|
@Deprecated
|
|
public void showProgressBar() {
|
|
setProgressBarShown(true);
|
|
}
|
|
|
|
/** @deprecated Use {@link #setProgressBarShown(boolean)} */
|
|
@Deprecated
|
|
public void hideProgressBar() {
|
|
setProgressBarShown(false);
|
|
}
|
|
|
|
public void setProgressBarColor(ColorStateList color) {
|
|
getMixin(ProgressBarMixin.class).setColor(color);
|
|
}
|
|
|
|
public ColorStateList getProgressBarColor() {
|
|
return getMixin(ProgressBarMixin.class).getColor();
|
|
}
|
|
|
|
/* Misc */
|
|
|
|
protected static class SavedState extends BaseSavedState {
|
|
|
|
boolean isProgressBarShown = false;
|
|
|
|
public SavedState(Parcelable parcelable) {
|
|
super(parcelable);
|
|
}
|
|
|
|
public SavedState(Parcel source) {
|
|
super(source);
|
|
isProgressBarShown = source.readInt() != 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(Parcel dest, int flags) {
|
|
super.writeToParcel(dest, flags);
|
|
dest.writeInt(isProgressBarShown ? 1 : 0);
|
|
}
|
|
|
|
public static final Parcelable.Creator<SavedState> CREATOR =
|
|
new Parcelable.Creator<SavedState>() {
|
|
|
|
@Override
|
|
public SavedState createFromParcel(Parcel parcel) {
|
|
return new SavedState(parcel);
|
|
}
|
|
|
|
@Override
|
|
public SavedState[] newArray(int size) {
|
|
return new SavedState[size];
|
|
}
|
|
};
|
|
}
|
|
}
|