android-10.0.0_r2/s

/*
 * 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.google.android.setupdesign;

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.google.android.setupcompat.internal.TemplateLayout;
import com.google.android.setupcompat.template.SystemNavBarMixin;
import com.google.android.setupdesign.template.HeaderMixin;
import com.google.android.setupdesign.template.NavigationBarMixin;
import com.google.android.setupdesign.template.ProgressBarMixin;
import com.google.android.setupdesign.template.RequireScrollMixin;
import com.google.android.setupdesign.template.ScrollViewScrollHandlingDelegate;
import com.google.android.setupdesign.view.Illustration;
import com.google.android.setupdesign.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.sudLayoutTheme);
  }

  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.sudLayoutTheme);
  }

  public SetupWizardLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(attrs, R.attr.sudLayoutTheme);
  }

  @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(SystemNavBarMixin.class, new SystemNavBarMixin(this, /* window= */ null));
    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.SudSetupWizardLayout, defStyleAttr, 0);

    // Set the background from XML, either directly or built from a bitmap tile
    final Drawable background = a.getDrawable(R.styleable.SudSetupWizardLayout_sudBackground);
    if (background != null) {
      setLayoutBackground(background);
    } else {
      final Drawable backgroundTile =
          a.getDrawable(R.styleable.SudSetupWizardLayout_sudBackgroundTile);
      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.SudSetupWizardLayout_sudIllustration);
    if (illustration != null) {
      setIllustration(illustration);
    } else {
      final Drawable illustrationImage =
          a.getDrawable(R.styleable.SudSetupWizardLayout_sudIllustrationImage);
      final Drawable horizontalTile =
          a.getDrawable(R.styleable.SudSetupWizardLayout_sudIllustrationHorizontalTile);
      if (illustrationImage != null && horizontalTile != null) {
        setIllustration(illustrationImage, horizontalTile);
      }
    }

    // Set the top padding of the illustration
    int decorPaddingTop =
        a.getDimensionPixelSize(R.styleable.SudSetupWizardLayout_sudDecorPaddingTop, -1);
    if (decorPaddingTop == -1) {
      decorPaddingTop = getResources().getDimensionPixelSize(R.dimen.sud_decor_padding_top);
    }
    setDecorPaddingTop(decorPaddingTop);

    // Set the illustration aspect ratio. See Illustration.setAspectRatio(float). This will
    // override sudDecorPaddingTop if its value is not 0.
    float illustrationAspectRatio =
        a.getFloat(R.styleable.SudSetupWizardLayout_sudIllustrationAspectRatio, -1f);
    if (illustrationAspectRatio == -1f) {
      final TypedValue out = new TypedValue();
      getResources().getValue(R.dimen.sud_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.sud_template;
    }
    return inflateTemplate(inflater, R.style.SudThemeMaterial_Light, template);
  }

  @Override
  protected ViewGroup findContainer(int containerId) {
    if (containerId == 0) {
      containerId = R.id.sud_layout_content;
    }
    return super.findContainer(containerId);
  }

  public NavigationBar getNavigationBar() {
    return getMixin(NavigationBarMixin.class).getNavigationBar();
  }

  public ScrollView getScrollView() {
    final View view = findManagedViewById(R.id.sud_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.google.android.setupdesign.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.sud_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.sud_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.sud_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.google.android.setupdesign.view.Illustration#setAspectRatio(float)
   */
  public void setIllustrationAspectRatio(float aspectRatio) {
    final View view = findManagedViewById(R.id.sud_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.sud_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.sud_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.sudUseTabletLayout)) {
      // 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];
          }
        };
  }
}