4860e4ee48
Test: make setup-wizard-lib Bug: 76692459 Change-Id: I40171e973d442b1a1815e9e7d7c2cc984cb38bac
276 lines
11 KiB
Java
276 lines
11 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.TargetApi;
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.os.Build.VERSION_CODES;
|
|
import android.util.AttributeSet;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.ViewTreeObserver;
|
|
import android.widget.FrameLayout;
|
|
|
|
import androidx.annotation.Keep;
|
|
import androidx.annotation.LayoutRes;
|
|
import androidx.annotation.StyleRes;
|
|
|
|
import com.android.setupwizardlib.template.Mixin;
|
|
import com.android.setupwizardlib.util.FallbackThemeWrapper;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* A generic template class that inflates a template, provided in the constructor or in
|
|
* {@code android:layout} through XML, and adds its children to a "container" in the template. When
|
|
* inflating this layout from XML, the {@code android:layout} and {@code suwContainer} attributes
|
|
* are required.
|
|
*/
|
|
public class TemplateLayout extends FrameLayout {
|
|
|
|
/**
|
|
* The container of the actual content. This will be a view in the template, which child views
|
|
* will be added to when {@link #addView(View)} is called.
|
|
*/
|
|
private ViewGroup mContainer;
|
|
|
|
private Map<Class<? extends Mixin>, Mixin> mMixins = new HashMap<>();
|
|
|
|
public TemplateLayout(Context context, int template, int containerId) {
|
|
super(context);
|
|
init(template, containerId, null, R.attr.suwLayoutTheme);
|
|
}
|
|
|
|
public TemplateLayout(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
init(0, 0, attrs, R.attr.suwLayoutTheme);
|
|
}
|
|
|
|
@TargetApi(VERSION_CODES.HONEYCOMB)
|
|
public TemplateLayout(Context context, AttributeSet attrs, int defStyleAttr) {
|
|
super(context, attrs, defStyleAttr);
|
|
init(0, 0, 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(int template, int containerId, AttributeSet attrs, int defStyleAttr) {
|
|
final TypedArray a = getContext().obtainStyledAttributes(attrs,
|
|
R.styleable.SuwTemplateLayout, defStyleAttr, 0);
|
|
if (template == 0) {
|
|
template = a.getResourceId(R.styleable.SuwTemplateLayout_android_layout, 0);
|
|
}
|
|
if (containerId == 0) {
|
|
containerId = a.getResourceId(R.styleable.SuwTemplateLayout_suwContainer, 0);
|
|
}
|
|
inflateTemplate(template, containerId);
|
|
|
|
a.recycle();
|
|
}
|
|
|
|
/**
|
|
* Registers a mixin with a given class. This method should be called in the constructor.
|
|
*
|
|
* @param cls The class to register the mixin. In most cases, {@code cls} is the same as
|
|
* {@code mixin.getClass()}, but {@code cls} can also be a super class of that. In
|
|
* the latter case the the mixin must be retrieved using {@code cls} in
|
|
* {@link #getMixin(Class)}, not the subclass.
|
|
* @param mixin The mixin to be registered.
|
|
* @param <M> The class of the mixin to register. This is the same as {@code cls}
|
|
*/
|
|
protected <M extends Mixin> void registerMixin(Class<M> cls, M mixin) {
|
|
mMixins.put(cls, mixin);
|
|
}
|
|
|
|
/**
|
|
* Same as {@link android.view.View#findViewById(int)}, but may include views that are managed
|
|
* by this view but not currently added to the view hierarchy. e.g. recycler view or list view
|
|
* headers that are not currently shown.
|
|
*/
|
|
// Returning generic type is the common pattern used for findViewBy* methods
|
|
@SuppressWarnings("TypeParameterUnusedInFormals")
|
|
public <T extends View> T findManagedViewById(int id) {
|
|
return findViewById(id);
|
|
}
|
|
|
|
/**
|
|
* Get a {@link Mixin} from this template registered earlier in
|
|
* {@link #registerMixin(Class, Mixin)}.
|
|
*
|
|
* @param cls The class marker of Mixin being requested. The actual Mixin returned may be a
|
|
* subclass of this marker. Note that this must be the same class as registered in
|
|
* {@link #registerMixin(Class, Mixin)}, which is not necessarily the
|
|
* same as the concrete class of the instance returned by this method.
|
|
* @param <M> The type of the class marker.
|
|
* @return The mixin marked by {@code cls}, or null if the template does not have a matching
|
|
* mixin.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public <M extends Mixin> M getMixin(Class<M> cls) {
|
|
return (M) mMixins.get(cls);
|
|
}
|
|
|
|
@Override
|
|
public void addView(View child, int index, ViewGroup.LayoutParams params) {
|
|
mContainer.addView(child, index, params);
|
|
}
|
|
|
|
private void addViewInternal(View child) {
|
|
super.addView(child, -1, generateDefaultLayoutParams());
|
|
}
|
|
|
|
private void inflateTemplate(int templateResource, int containerId) {
|
|
final LayoutInflater inflater = LayoutInflater.from(getContext());
|
|
final View templateRoot = onInflateTemplate(inflater, templateResource);
|
|
addViewInternal(templateRoot);
|
|
|
|
mContainer = findContainer(containerId);
|
|
if (mContainer == null) {
|
|
throw new IllegalArgumentException("Container cannot be null in TemplateLayout");
|
|
}
|
|
onTemplateInflated();
|
|
}
|
|
|
|
/**
|
|
* This method inflates the template. Subclasses can override this method to customize the
|
|
* template inflation, or change to a different default template. The root of the inflated
|
|
* layout should be returned, and not added to the view hierarchy.
|
|
*
|
|
* @param inflater A LayoutInflater to inflate the template.
|
|
* @param template The resource ID of the template to be inflated, or 0 if no template is
|
|
* specified.
|
|
* @return Root of the inflated layout.
|
|
*/
|
|
protected View onInflateTemplate(LayoutInflater inflater, @LayoutRes int template) {
|
|
return inflateTemplate(inflater, 0, template);
|
|
}
|
|
|
|
/**
|
|
* Inflate the template using the given inflater and theme. The fallback theme will be applied
|
|
* to the theme without overriding the values already defined in the theme, but simply providing
|
|
* default values for values which have not been defined. This allows templates to add
|
|
* additional required theme attributes without breaking existing clients.
|
|
*
|
|
* <p>In general, clients should still set the activity theme to the corresponding theme in
|
|
* setup wizard lib, so that the content area gets the correct styles as well.
|
|
*
|
|
* @param inflater A LayoutInflater to inflate the template.
|
|
* @param fallbackTheme A fallback theme to apply to the template. If the values defined in the
|
|
* fallback theme is already defined in the original theme, the value in
|
|
* the original theme takes precedence.
|
|
* @param template The layout template to be inflated.
|
|
* @return Root of the inflated layout.
|
|
*
|
|
* @see FallbackThemeWrapper
|
|
*/
|
|
protected final View inflateTemplate(LayoutInflater inflater, @StyleRes int fallbackTheme,
|
|
@LayoutRes int template) {
|
|
if (template == 0) {
|
|
throw new IllegalArgumentException("android:layout not specified for TemplateLayout");
|
|
}
|
|
if (fallbackTheme != 0) {
|
|
inflater = LayoutInflater.from(
|
|
new FallbackThemeWrapper(inflater.getContext(), fallbackTheme));
|
|
}
|
|
return inflater.inflate(template, this, false);
|
|
}
|
|
|
|
protected ViewGroup findContainer(int containerId) {
|
|
if (containerId == 0) {
|
|
// Maintain compatibility with the deprecated way of specifying container ID.
|
|
containerId = getContainerId();
|
|
}
|
|
return (ViewGroup) findViewById(containerId);
|
|
}
|
|
|
|
/**
|
|
* This is called after the template has been inflated and added to the view hierarchy.
|
|
* Subclasses can implement this method to modify the template as necessary, such as caching
|
|
* views retrieved from findViewById, or other view operations that need to be done in code.
|
|
* You can think of this as {@link View#onFinishInflate()} but for inflation of the
|
|
* template instead of for child views.
|
|
*/
|
|
protected void onTemplateInflated() {
|
|
}
|
|
|
|
/**
|
|
* @return ID of the default container for this layout. This will be used to find the container
|
|
* ViewGroup, which all children views of this layout will be placed in.
|
|
* @deprecated Override {@link #findContainer(int)} instead.
|
|
*/
|
|
@Deprecated
|
|
protected int getContainerId() {
|
|
return 0;
|
|
}
|
|
|
|
/* Animator support */
|
|
|
|
private float mXFraction;
|
|
private ViewTreeObserver.OnPreDrawListener mPreDrawListener;
|
|
|
|
/**
|
|
* Set the X translation as a fraction of the width of this view. Make sure this method is not
|
|
* stripped out by proguard when using this with {@link android.animation.ObjectAnimator}. You
|
|
* may need to add
|
|
* <code>
|
|
* -keep @androidx.annotation.Keep class *
|
|
* </code>
|
|
* to your proguard configuration if you are seeing mysterious {@link NoSuchMethodError} at
|
|
* runtime.
|
|
*/
|
|
@Keep
|
|
@TargetApi(VERSION_CODES.HONEYCOMB)
|
|
public void setXFraction(float fraction) {
|
|
mXFraction = fraction;
|
|
final int width = getWidth();
|
|
if (width != 0) {
|
|
setTranslationX(width * fraction);
|
|
} else {
|
|
// If we haven't done a layout pass yet, wait for one and then set the fraction before
|
|
// the draw occurs using an OnPreDrawListener. Don't call translationX until we know
|
|
// getWidth() has a reliable, non-zero value or else we will see the fragment flicker on
|
|
// screen.
|
|
if (mPreDrawListener == null) {
|
|
mPreDrawListener = new ViewTreeObserver.OnPreDrawListener() {
|
|
@Override
|
|
public boolean onPreDraw() {
|
|
getViewTreeObserver().removeOnPreDrawListener(mPreDrawListener);
|
|
setXFraction(mXFraction);
|
|
return true;
|
|
}
|
|
};
|
|
getViewTreeObserver().addOnPreDrawListener(mPreDrawListener);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the X translation as a fraction of the width, as previously set in
|
|
* {@link #setXFraction(float)}.
|
|
*
|
|
* @see #setXFraction(float)
|
|
*/
|
|
@Keep
|
|
@TargetApi(VERSION_CODES.HONEYCOMB)
|
|
public float getXFraction() {
|
|
return mXFraction;
|
|
}
|
|
}
|