ADD week 5

2025-03-31 16:33:42 +02:00
parent 86f265f22d
commit bf645048e6
4927 changed files with 544053 additions and 0 deletions
--- a/02-Easy5/E5/sources/androidx/appcompat/widget/LinearLayoutCompat.java
+++ b/02-Easy5/E5/sources/androidx/appcompat/widget/LinearLayoutCompat.java
@@ -0,0 +1,670 @@
+package androidx.appcompat.widget;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.widget.LinearLayout;
+import androidx.appcompat.R;
+import androidx.constraintlayout.core.widgets.analyzer.BasicMeasure;
+import androidx.core.view.GravityCompat;
+import androidx.core.view.ViewCompat;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public class LinearLayoutCompat extends ViewGroup {
+    private static final String ACCESSIBILITY_CLASS_NAME = "androidx.appcompat.widget.LinearLayoutCompat";
+    public static final int HORIZONTAL = 0;
+    private static final int INDEX_BOTTOM = 2;
+    private static final int INDEX_CENTER_VERTICAL = 0;
+    private static final int INDEX_FILL = 3;
+    private static final int INDEX_TOP = 1;
+    public static final int SHOW_DIVIDER_BEGINNING = 1;
+    public static final int SHOW_DIVIDER_END = 4;
+    public static final int SHOW_DIVIDER_MIDDLE = 2;
+    public static final int SHOW_DIVIDER_NONE = 0;
+    public static final int VERTICAL = 1;
+    private static final int VERTICAL_GRAVITY_COUNT = 4;
+    private boolean mBaselineAligned;
+    private int mBaselineAlignedChildIndex;
+    private int mBaselineChildTop;
+    private Drawable mDivider;
+    private int mDividerHeight;
+    private int mDividerPadding;
+    private int mDividerWidth;
+    private int mGravity;
+    private int[] mMaxAscent;
+    private int[] mMaxDescent;
+    private int mOrientation;
+    private int mShowDividers;
+    private int mTotalLength;
+    private boolean mUseLargestChild;
+    private float mWeightSum;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface DividerMode {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface OrientationMode {
+    }
+
+    public int getBaselineAlignedChildIndex() {
+        return this.mBaselineAlignedChildIndex;
+    }
+
+    int getChildrenSkipCount(View view, int i) {
+        return 0;
+    }
+
+    public Drawable getDividerDrawable() {
+        return this.mDivider;
+    }
+
+    public int getDividerPadding() {
+        return this.mDividerPadding;
+    }
+
+    public int getDividerWidth() {
+        return this.mDividerWidth;
+    }
+
+    public int getGravity() {
+        return this.mGravity;
+    }
+
+    int getLocationOffset(View view) {
+        return 0;
+    }
+
+    int getNextLocationOffset(View view) {
+        return 0;
+    }
+
+    public int getOrientation() {
+        return this.mOrientation;
+    }
+
+    public int getShowDividers() {
+        return this.mShowDividers;
+    }
+
+    public float getWeightSum() {
+        return this.mWeightSum;
+    }
+
+    public boolean isBaselineAligned() {
+        return this.mBaselineAligned;
+    }
+
+    public boolean isMeasureWithLargestChildEnabled() {
+        return this.mUseLargestChild;
+    }
+
+    int measureNullChild(int i) {
+        return 0;
+    }
+
+    public void setBaselineAligned(boolean z) {
+        this.mBaselineAligned = z;
+    }
+
+    public void setDividerPadding(int i) {
+        this.mDividerPadding = i;
+    }
+
+    public void setMeasureWithLargestChildEnabled(boolean z) {
+        this.mUseLargestChild = z;
+    }
+
+    @Override // android.view.ViewGroup
+    public boolean shouldDelayChildPressedState() {
+        return false;
+    }
+
+    public LinearLayoutCompat(Context context) {
+        this(context, null);
+    }
+
+    public LinearLayoutCompat(Context context, AttributeSet attributeSet) {
+        this(context, attributeSet, 0);
+    }
+
+    public LinearLayoutCompat(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i);
+        this.mBaselineAligned = true;
+        this.mBaselineAlignedChildIndex = -1;
+        this.mBaselineChildTop = 0;
+        this.mGravity = 8388659;
+        TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(context, attributeSet, R.styleable.LinearLayoutCompat, i, 0);
+        ViewCompat.saveAttributeDataForStyleable(this, context, R.styleable.LinearLayoutCompat, attributeSet, obtainStyledAttributes.getWrappedTypeArray(), i, 0);
+        int i2 = obtainStyledAttributes.getInt(R.styleable.LinearLayoutCompat_android_orientation, -1);
+        if (i2 >= 0) {
+            setOrientation(i2);
+        }
+        int i3 = obtainStyledAttributes.getInt(R.styleable.LinearLayoutCompat_android_gravity, -1);
+        if (i3 >= 0) {
+            setGravity(i3);
+        }
+        boolean z = obtainStyledAttributes.getBoolean(R.styleable.LinearLayoutCompat_android_baselineAligned, true);
+        if (!z) {
+            setBaselineAligned(z);
+        }
+        this.mWeightSum = obtainStyledAttributes.getFloat(R.styleable.LinearLayoutCompat_android_weightSum, -1.0f);
+        this.mBaselineAlignedChildIndex = obtainStyledAttributes.getInt(R.styleable.LinearLayoutCompat_android_baselineAlignedChildIndex, -1);
+        this.mUseLargestChild = obtainStyledAttributes.getBoolean(R.styleable.LinearLayoutCompat_measureWithLargestChild, false);
+        setDividerDrawable(obtainStyledAttributes.getDrawable(R.styleable.LinearLayoutCompat_divider));
+        this.mShowDividers = obtainStyledAttributes.getInt(R.styleable.LinearLayoutCompat_showDividers, 0);
+        this.mDividerPadding = obtainStyledAttributes.getDimensionPixelSize(R.styleable.LinearLayoutCompat_dividerPadding, 0);
+        obtainStyledAttributes.recycle();
+    }
+
+    public void setShowDividers(int i) {
+        if (i != this.mShowDividers) {
+            requestLayout();
+        }
+        this.mShowDividers = i;
+    }
+
+    public void setDividerDrawable(Drawable drawable) {
+        if (drawable == this.mDivider) {
+            return;
+        }
+        this.mDivider = drawable;
+        if (drawable != null) {
+            this.mDividerWidth = drawable.getIntrinsicWidth();
+            this.mDividerHeight = drawable.getIntrinsicHeight();
+        } else {
+            this.mDividerWidth = 0;
+            this.mDividerHeight = 0;
+        }
+        setWillNotDraw(drawable == null);
+        requestLayout();
+    }
+
+    @Override // android.view.View
+    protected void onDraw(Canvas canvas) {
+        if (this.mDivider == null) {
+            return;
+        }
+        if (this.mOrientation == 1) {
+            drawDividersVertical(canvas);
+        } else {
+            drawDividersHorizontal(canvas);
+        }
+    }
+
+    void drawDividersVertical(Canvas canvas) {
+        int bottom;
+        int virtualChildCount = getVirtualChildCount();
+        for (int i = 0; i < virtualChildCount; i++) {
+            View virtualChildAt = getVirtualChildAt(i);
+            if (virtualChildAt != null && virtualChildAt.getVisibility() != 8 && hasDividerBeforeChildAt(i)) {
+                drawHorizontalDivider(canvas, (virtualChildAt.getTop() - ((LayoutParams) virtualChildAt.getLayoutParams()).topMargin) - this.mDividerHeight);
+            }
+        }
+        if (hasDividerBeforeChildAt(virtualChildCount)) {
+            View virtualChildAt2 = getVirtualChildAt(virtualChildCount - 1);
+            if (virtualChildAt2 == null) {
+                bottom = (getHeight() - getPaddingBottom()) - this.mDividerHeight;
+            } else {
+                bottom = virtualChildAt2.getBottom() + ((LayoutParams) virtualChildAt2.getLayoutParams()).bottomMargin;
+            }
+            drawHorizontalDivider(canvas, bottom);
+        }
+    }
+
+    void drawDividersHorizontal(Canvas canvas) {
+        int right;
+        int left;
+        int i;
+        int left2;
+        int virtualChildCount = getVirtualChildCount();
+        boolean isLayoutRtl = ViewUtils.isLayoutRtl(this);
+        for (int i2 = 0; i2 < virtualChildCount; i2++) {
+            View virtualChildAt = getVirtualChildAt(i2);
+            if (virtualChildAt != null && virtualChildAt.getVisibility() != 8 && hasDividerBeforeChildAt(i2)) {
+                LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
+                if (isLayoutRtl) {
+                    left2 = virtualChildAt.getRight() + layoutParams.rightMargin;
+                } else {
+                    left2 = (virtualChildAt.getLeft() - layoutParams.leftMargin) - this.mDividerWidth;
+                }
+                drawVerticalDivider(canvas, left2);
+            }
+        }
+        if (hasDividerBeforeChildAt(virtualChildCount)) {
+            View virtualChildAt2 = getVirtualChildAt(virtualChildCount - 1);
+            if (virtualChildAt2 != null) {
+                LayoutParams layoutParams2 = (LayoutParams) virtualChildAt2.getLayoutParams();
+                if (isLayoutRtl) {
+                    left = virtualChildAt2.getLeft() - layoutParams2.leftMargin;
+                    i = this.mDividerWidth;
+                    right = left - i;
+                } else {
+                    right = virtualChildAt2.getRight() + layoutParams2.rightMargin;
+                }
+            } else if (isLayoutRtl) {
+                right = getPaddingLeft();
+            } else {
+                left = getWidth() - getPaddingRight();
+                i = this.mDividerWidth;
+                right = left - i;
+            }
+            drawVerticalDivider(canvas, right);
+        }
+    }
+
+    void drawHorizontalDivider(Canvas canvas, int i) {
+        this.mDivider.setBounds(getPaddingLeft() + this.mDividerPadding, i, (getWidth() - getPaddingRight()) - this.mDividerPadding, this.mDividerHeight + i);
+        this.mDivider.draw(canvas);
+    }
+
+    void drawVerticalDivider(Canvas canvas, int i) {
+        this.mDivider.setBounds(i, getPaddingTop() + this.mDividerPadding, this.mDividerWidth + i, (getHeight() - getPaddingBottom()) - this.mDividerPadding);
+        this.mDivider.draw(canvas);
+    }
+
+    @Override // android.view.View
+    public int getBaseline() {
+        int i;
+        if (this.mBaselineAlignedChildIndex < 0) {
+            return super.getBaseline();
+        }
+        int childCount = getChildCount();
+        int i2 = this.mBaselineAlignedChildIndex;
+        if (childCount <= i2) {
+            throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout set to an index that is out of bounds.");
+        }
+        View childAt = getChildAt(i2);
+        int baseline = childAt.getBaseline();
+        if (baseline == -1) {
+            if (this.mBaselineAlignedChildIndex == 0) {
+                return -1;
+            }
+            throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout points to a View that doesn't know how to get its baseline.");
+        }
+        int i3 = this.mBaselineChildTop;
+        if (this.mOrientation == 1 && (i = this.mGravity & 112) != 48) {
+            if (i == 16) {
+                i3 += ((((getBottom() - getTop()) - getPaddingTop()) - getPaddingBottom()) - this.mTotalLength) / 2;
+            } else if (i == 80) {
+                i3 = ((getBottom() - getTop()) - getPaddingBottom()) - this.mTotalLength;
+            }
+        }
+        return i3 + ((LayoutParams) childAt.getLayoutParams()).topMargin + baseline;
+    }
+
+    public void setBaselineAlignedChildIndex(int i) {
+        if (i >= 0 && i < getChildCount()) {
+            this.mBaselineAlignedChildIndex = i;
+            return;
+        }
+        throw new IllegalArgumentException("base aligned child index out of range (0, " + getChildCount() + ")");
+    }
+
+    View getVirtualChildAt(int i) {
+        return getChildAt(i);
+    }
+
+    int getVirtualChildCount() {
+        return getChildCount();
+    }
+
+    public void setWeightSum(float f) {
+        this.mWeightSum = Math.max(0.0f, f);
+    }
+
+    @Override // android.view.View
+    protected void onMeasure(int i, int i2) {
+        if (this.mOrientation == 1) {
+            measureVertical(i, i2);
+        } else {
+            measureHorizontal(i, i2);
+        }
+    }
+
+    protected boolean hasDividerBeforeChildAt(int i) {
+        if (i == 0) {
+            return (this.mShowDividers & 1) != 0;
+        }
+        if (i == getChildCount()) {
+            return (this.mShowDividers & 4) != 0;
+        }
+        if ((this.mShowDividers & 2) == 0) {
+            return false;
+        }
+        for (int i2 = i - 1; i2 >= 0; i2--) {
+            if (getChildAt(i2).getVisibility() != 8) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:155:0x031c, code lost:
+    
+        if (r14.width == (-1)) goto L148;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    void measureVertical(int r34, int r35) {
+        /*
+            Method dump skipped, instructions count: 910
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureVertical(int, int):void");
+    }
+
+    private void forceUniformWidth(int i, int i2) {
+        int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredWidth(), BasicMeasure.EXACTLY);
+        for (int i3 = 0; i3 < i; i3++) {
+            View virtualChildAt = getVirtualChildAt(i3);
+            if (virtualChildAt.getVisibility() != 8) {
+                LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
+                if (layoutParams.width == -1) {
+                    int i4 = layoutParams.height;
+                    layoutParams.height = virtualChildAt.getMeasuredHeight();
+                    measureChildWithMargins(virtualChildAt, makeMeasureSpec, 0, i2, 0);
+                    layoutParams.height = i4;
+                }
+            }
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:196:0x0453  */
+    /* JADX WARN: Removed duplicated region for block: B:198:0x0456  */
+    /* JADX WARN: Removed duplicated region for block: B:44:0x0199  */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x019c  */
+    /* JADX WARN: Removed duplicated region for block: B:54:0x01d0  */
+    /* JADX WARN: Removed duplicated region for block: B:59:0x01db  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    void measureHorizontal(int r38, int r39) {
+        /*
+            Method dump skipped, instructions count: 1295
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureHorizontal(int, int):void");
+    }
+
+    private void forceUniformHeight(int i, int i2) {
+        int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredHeight(), BasicMeasure.EXACTLY);
+        for (int i3 = 0; i3 < i; i3++) {
+            View virtualChildAt = getVirtualChildAt(i3);
+            if (virtualChildAt.getVisibility() != 8) {
+                LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
+                if (layoutParams.height == -1) {
+                    int i4 = layoutParams.width;
+                    layoutParams.width = virtualChildAt.getMeasuredWidth();
+                    measureChildWithMargins(virtualChildAt, i2, 0, makeMeasureSpec, 0);
+                    layoutParams.width = i4;
+                }
+            }
+        }
+    }
+
+    void measureChildBeforeLayout(View view, int i, int i2, int i3, int i4, int i5) {
+        measureChildWithMargins(view, i2, i3, i4, i5);
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    protected void onLayout(boolean z, int i, int i2, int i3, int i4) {
+        if (this.mOrientation == 1) {
+            layoutVertical(i, i2, i3, i4);
+        } else {
+            layoutHorizontal(i, i2, i3, i4);
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:25:0x009f  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    void layoutVertical(int r18, int r19, int r20, int r21) {
+        /*
+            r17 = this;
+            r6 = r17
+            int r7 = r17.getPaddingLeft()
+            int r0 = r20 - r18
+            int r1 = r17.getPaddingRight()
+            int r8 = r0 - r1
+            int r0 = r0 - r7
+            int r1 = r17.getPaddingRight()
+            int r9 = r0 - r1
+            int r10 = r17.getVirtualChildCount()
+            int r0 = r6.mGravity
+            r1 = r0 & 112(0x70, float:1.57E-43)
+            r2 = 8388615(0x800007, float:1.1754953E-38)
+            r11 = r0 & r2
+            r0 = 16
+            if (r1 == r0) goto L3b
+            r0 = 80
+            if (r1 == r0) goto L2f
+            int r0 = r17.getPaddingTop()
+            goto L47
+        L2f:
+            int r0 = r17.getPaddingTop()
+            int r0 = r0 + r21
+            int r0 = r0 - r19
+            int r1 = r6.mTotalLength
+            int r0 = r0 - r1
+            goto L47
+        L3b:
+            int r0 = r17.getPaddingTop()
+            int r1 = r21 - r19
+            int r2 = r6.mTotalLength
+            int r1 = r1 - r2
+            int r1 = r1 / 2
+            int r0 = r0 + r1
+        L47:
+            r1 = 0
+            r12 = 0
+        L49:
+            if (r12 >= r10) goto Lc8
+            android.view.View r13 = r6.getVirtualChildAt(r12)
+            r14 = 1
+            if (r13 != 0) goto L59
+            int r1 = r6.measureNullChild(r12)
+            int r0 = r0 + r1
+            goto Lc5
+        L59:
+            int r1 = r13.getVisibility()
+            r2 = 8
+            if (r1 == r2) goto Lc5
+            int r4 = r13.getMeasuredWidth()
+            int r15 = r13.getMeasuredHeight()
+            android.view.ViewGroup$LayoutParams r1 = r13.getLayoutParams()
+            r5 = r1
+            androidx.appcompat.widget.LinearLayoutCompat$LayoutParams r5 = (androidx.appcompat.widget.LinearLayoutCompat.LayoutParams) r5
+            int r1 = r5.gravity
+            if (r1 >= 0) goto L75
+            r1 = r11
+        L75:
+            int r2 = androidx.core.view.ViewCompat.getLayoutDirection(r17)
+            int r1 = androidx.core.view.GravityCompat.getAbsoluteGravity(r1, r2)
+            r1 = r1 & 7
+            if (r1 == r14) goto L8d
+            r2 = 5
+            if (r1 == r2) goto L88
+            int r1 = r5.leftMargin
+            int r1 = r1 + r7
+            goto L98
+        L88:
+            int r1 = r8 - r4
+            int r2 = r5.rightMargin
+            goto L97
+        L8d:
+            int r1 = r9 - r4
+            int r1 = r1 / 2
+            int r1 = r1 + r7
+            int r2 = r5.leftMargin
+            int r1 = r1 + r2
+            int r2 = r5.rightMargin
+        L97:
+            int r1 = r1 - r2
+        L98:
+            r2 = r1
+            boolean r1 = r6.hasDividerBeforeChildAt(r12)
+            if (r1 == 0) goto La2
+            int r1 = r6.mDividerHeight
+            int r0 = r0 + r1
+        La2:
+            int r1 = r5.topMargin
+            int r16 = r0 + r1
+            int r0 = r6.getLocationOffset(r13)
+            int r3 = r16 + r0
+            r0 = r17
+            r1 = r13
+            r14 = r5
+            r5 = r15
+            r0.setChildFrame(r1, r2, r3, r4, r5)
+            int r0 = r14.bottomMargin
+            int r15 = r15 + r0
+            int r0 = r6.getNextLocationOffset(r13)
+            int r15 = r15 + r0
+            int r16 = r16 + r15
+            int r0 = r6.getChildrenSkipCount(r13, r12)
+            int r12 = r12 + r0
+            r0 = r16
+        Lc5:
+            r1 = 1
+            int r12 = r12 + r1
+            goto L49
+        Lc8:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.layoutVertical(int, int, int, int):void");
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:26:0x00a7  */
+    /* JADX WARN: Removed duplicated region for block: B:29:0x00b0  */
+    /* JADX WARN: Removed duplicated region for block: B:37:0x00f7  */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x00e3  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    void layoutHorizontal(int r25, int r26, int r27, int r28) {
+        /*
+            Method dump skipped, instructions count: 321
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.layoutHorizontal(int, int, int, int):void");
+    }
+
+    private void setChildFrame(View view, int i, int i2, int i3, int i4) {
+        view.layout(i, i2, i3 + i, i4 + i2);
+    }
+
+    public void setOrientation(int i) {
+        if (this.mOrientation != i) {
+            this.mOrientation = i;
+            requestLayout();
+        }
+    }
+
+    public void setGravity(int i) {
+        if (this.mGravity != i) {
+            if ((8388615 & i) == 0) {
+                i |= GravityCompat.START;
+            }
+            if ((i & 112) == 0) {
+                i |= 48;
+            }
+            this.mGravity = i;
+            requestLayout();
+        }
+    }
+
+    public void setHorizontalGravity(int i) {
+        int i2 = i & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK;
+        int i3 = this.mGravity;
+        if ((8388615 & i3) != i2) {
+            this.mGravity = i2 | ((-8388616) & i3);
+            requestLayout();
+        }
+    }
+
+    public void setVerticalGravity(int i) {
+        int i2 = i & 112;
+        int i3 = this.mGravity;
+        if ((i3 & 112) != i2) {
+            this.mGravity = i2 | (i3 & (-113));
+            requestLayout();
+        }
+    }
+
+    @Override // android.view.ViewGroup
+    public LayoutParams generateLayoutParams(AttributeSet attributeSet) {
+        return new LayoutParams(getContext(), attributeSet);
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // android.view.ViewGroup
+    public LayoutParams generateDefaultLayoutParams() {
+        int i = this.mOrientation;
+        if (i == 0) {
+            return new LayoutParams(-2, -2);
+        }
+        if (i == 1) {
+            return new LayoutParams(-1, -2);
+        }
+        return null;
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    @Override // android.view.ViewGroup
+    public LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
+        return new LayoutParams(layoutParams);
+    }
+
+    @Override // android.view.ViewGroup
+    protected boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
+        return layoutParams instanceof LayoutParams;
+    }
+
+    @Override // android.view.View
+    public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
+        super.onInitializeAccessibilityEvent(accessibilityEvent);
+        accessibilityEvent.setClassName(ACCESSIBILITY_CLASS_NAME);
+    }
+
+    @Override // android.view.View
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo accessibilityNodeInfo) {
+        super.onInitializeAccessibilityNodeInfo(accessibilityNodeInfo);
+        accessibilityNodeInfo.setClassName(ACCESSIBILITY_CLASS_NAME);
+    }
+
+    public static class LayoutParams extends LinearLayout.LayoutParams {
+        public LayoutParams(Context context, AttributeSet attributeSet) {
+            super(context, attributeSet);
+        }
+
+        public LayoutParams(int i, int i2) {
+            super(i, i2);
+        }
+
+        public LayoutParams(int i, int i2, float f) {
+            super(i, i2, f);
+        }
+
+        public LayoutParams(ViewGroup.LayoutParams layoutParams) {
+            super(layoutParams);
+        }
+
+        public LayoutParams(ViewGroup.MarginLayoutParams marginLayoutParams) {
+            super(marginLayoutParams);
+        }
+    }
+}