• Android底层摸索改BUG（一）：Android系统状态栏显示不下Wifi图标

    这是我入职的第一个BUG，头疼，隔壁一周解决了，我多花了几天

    其中最大的原因就是我思考复杂了，在公司系统上，此BUG标题为：

    请确认Wifi优先级，状态栏Wifi被忽略

    BUG意思就是：当前安卓系统状态栏图标有显示尺寸的测量，如果比如需要显示8个图标，已经在状态栏绘制不下，则显示一个点表示省略，而不希望wifi被省略

    我思考了一下一直以为就是优先级问题，是不是Android底层状态栏有各个图标优先级，图标过多的时候优先级高的就不会被隐藏，而其实最后参考了公司以前相关BUG的修改，其实只是状态栏的图标大小修改即可，将图标改小，状态栏就可以多一个显示图标，Wifi就不会被隐藏。（点向后一个图标挪了一位）

    在尺寸文件中进行修改：对这两个尺寸进行改小（可以调一下刷机看一下）

    1.  <dimen name="status_bar_icon_size">14dip</dimen>
    2.  <dimen name="status_bar_system_icon_size">11.5dp</dimen>

    值得一提的是上面的逻辑：超出的图标隐藏、绘制、测量相关的Java类是：StatusIconContainer.Java（虽然和BUG不在这改，记录一下）

    1. /**
    2.  * StatusIconContainer 是 StatusBarMobileView 内部的一个自定义视图容器，用于管理状态图标的显示。
    3.  * 它负责在 StatusBarMobileView 中管理状态图标的布局和可见性。
    4.  */
    5. public class StatusIconContainer extends AlphaOptimizedLinearLayout {
    6.     //TAG    
    7.     private static final String TAG = "StatusIconContainer";
    8.     //是否打开DEBUG模式，会Log相关信息
    9.     private static final boolean DEBUG = false;
    10.     //是否打开DEBUG_OVERFLOW，会在状态栏绘制边框用来显示区域什么的
    11.     private static final boolean DEBUG_OVERFLOW = false;
    12.     // 最多可以显示 8 个状态图标，包括电池图标
    13.     private static final int MAX_ICONS = 7;
    14.     //    private static final int MAX_ICONS = 8;
    15.     //点的个数        
    16.     private static final int MAX_DOTS = 1;
    17.     //Dot  点  Icon图标 相关属性
    18.     private int mDotPadding;
    19.     private int mIconSpacing;
    20.     private int mStaticDotDiameter;
    21.     private int mUnderflowWidth;
    22.     private int mUnderflowStart = 0;
    23.     // 是否可以在溢出空间中绘制
    24.     private boolean mNeedsUnderflow;
    25.     // 单个 StatusBarIconView 的点图标在此宽度内居中显示
    26.     private int mIconDotFrameWidth;
    27.     private boolean mShouldRestrictIcons = true;
    28.     // 用于计算哪些状态要在布局期间可见
    29.     private ArrayList mLayoutStates = new ArrayList<>();
    30.     // 为了正确计数和测量
    31.     private ArrayList mMeasureViews = new ArrayList<>();
    32.     // 任何被忽略的图标将不会被添加为子视图
    33.     private ArrayList mIgnoredSlots = new ArrayList<>();
    34.  
    35.     /**
    36.      * 创建 StatusIconContainer 的构造函数。
    37.      *
    38.      * @param context Android 上下文对象
    39.      */
    40.     public StatusIconContainer(Context context) {
    41.         this(context, null);
    42.     }
    43.  
    44.     /**
    45.      * 创建 StatusIconContainer 的构造函数。
    46.      *
    47.      * @param context Android 上下文对象
    48.      * @param attrs   属性集
    49.      */
    50.     public StatusIconContainer(Context context, AttributeSet attrs) {
    51.         super(context, attrs);
    52.         initDimens();
    53.         setWillNotDraw(!DEBUG_OVERFLOW);
    54.     }
    55.  
    56.     @Override
    57.     protected void onFinishInflate() {
    58.         super.onFinishInflate();
    59.     }
    60.  
    61.     /**
    62.      * 设置是否限制状态图标的显示。
    63.      *
    64.      * @param should 是否应该限制状态图标的显示
    65.      */
    66.     public void setShouldRestrictIcons(boolean should) {
    67.         mShouldRestrictIcons = should;
    68.     }
    69.  
    70.     /**
    71.      * 检查是否正在限制状态图标的显示。
    72.      *
    73.      * @return 如果正在限制状态图标的显示，则返回 true；否则返回 false。
    74.      */
    75.     public boolean isRestrictingIcons() {
    76.         return mShouldRestrictIcons;
    77.     }
    78.  
    79.     /**
    80.      * 初始化尺寸参数。
    81.      */
    82.     private void initDimens() {
    83.         // 这是与 StatusBarIconView 使用相同的值
    84.         mIconDotFrameWidth = getResources().getDimensionPixelSize(
    85.                 com.android.internal.R.dimen.status_bar_icon_size);
    86.         mDotPadding = getResources().getDimensionPixelSize(R.dimen.overflow_icon_dot_padding);
    87.         mIconSpacing = getResources().getDimensionPixelSize(R.dimen.status_bar_system_icon_spacing);
    88.         // 点图标
    89.         int radius = getResources().getDimensionPixelSize(R.dimen.overflow_dot_radius);
    90.         // 计算点的直径 R.dimen.overflow_dot_radius 2dp
    91.         mStaticDotDiameter = 2 * radius;
    92.         // 不能超过宽度 mIconDotFrameWidth 图标宽度 最大图标个数-1（可能还有个点，所以-1） 每个宽高
    93.         mUnderflowWidth = mIconDotFrameWidth + (MAX_DOTS - 1) * (mStaticDotDiameter + mDotPadding);
    94.         android.util.Log.d(TAG, "initDimens: " + mUnderflowStart);
    95.     }
    96.  
    97.     @Override
    98.     protected void onLayout(boolean changed, int l, int t, int r, int b) {
    99.         float midY = getHeight() / 2.0f;
    100.  
    101.         // 首先对所有子视图进行布局，以便稍后移动它们
    102.         for (int i = 0; i < getChildCount(); i++) {
    103.             View child = getChildAt(i);
    104.             int width = child.getMeasuredWidth();
    105.             int height = child.getMeasuredHeight();
    106.             int top = (int) (midY - height / 2.0f);
    107.             child.layout(0, top, width, top + height);
    108.         }
    109.  
    110.         resetViewStates();
    111.         calculateIconTranslations();
    112.         applyIconStates();
    113.     }
    114. //绘制
    115.     @Override
    116.     protected void onDraw(Canvas canvas) {
    117.         super.onDraw(canvas);
    118.         if (DEBUG_OVERFLOW) {
    119.             //如果开启了DEBUG_OVERFLOW模式画框框
    120.             Paint paint = new Paint();
    121.             paint.setStyle(Style.STROKE);
    122.             paint.setColor(Color.RED);
    123.  
    124.             // 显示边界框
    125.             canvas.drawRect(getPaddingStart(), 0, getWidth() - getPaddingEnd(), getHeight(), paint);
    126.  
    127.             // 显示溢出框
    128.             paint.setColor(Color.GREEN);
    129.             canvas.drawRect(
    130.                     mUnderflowStart, 0, mUnderflowStart + mUnderflowWidth, getHeight(), paint);
    131.         }
    132.     }
    133.     //测量
    134.     @Override
    135.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    136.         mMeasureViews.clear();
    137.         int mode = MeasureSpec.getMode(widthMeasureSpec);
    138.         final int width = MeasureSpec.getSize(widthMeasureSpec);
    139.         final int count = getChildCount();
    140.         // 收集所有希望进行布局的视图
    141.         for (int i = 0; i < count; i++) {
    142.             // 获取子视图
    143.             StatusIconDisplayable icon = (StatusIconDisplayable) getChildAt(i);
    144.             // 如果视图可见且没有被阻止，则加入可见视图列表
    145.             if (icon.isIconVisible() && !icon.isIconBlocked()
    146.                     && !mIgnoredSlots.contains(icon.getSlot())) {
    147.                 mMeasureViews.add((View) icon);
    148.             }
    149.         }
    150.  
    151.         // 可见视图数量
    152.         int visibleCount = mMeasureViews.size();
    153.         int maxVisible = visibleCount <= MAX_ICONS ? MAX_ICONS : MAX_ICONS - 1;
    154.         int totalWidth = mPaddingLeft + mPaddingRight;
    155.         boolean trackWidth = true;
    156.  
    157.         // 测量所有子视图，以便它们报告正确的宽度
    158.         int childWidthSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.UNSPECIFIED);
    159.         mNeedsUnderflow = mShouldRestrictIcons && visibleCount > MAX_ICONS;
    160.         for (int i = 0; i < visibleCount; i++) {
    161.             View child = mMeasureViews.get(i);
    162.             measureChild(child, childWidthSpec, heightMeasureSpec);
    163.             int spacing = i == visibleCount - 1 ? 0 : mIconSpacing;
    164.             if (mShouldRestrictIcons) {
    165.                 if (i < maxVisible && trackWidth) {
    166.                     totalWidth += getViewTotalMeasuredWidth(child) + spacing;
    167.                 } else if (trackWidth) {
    168.                     // 达到图标限制；为点图标添加空间
    169.                     totalWidth += mUnderflowWidth;
    170.                     trackWidth = false;
    171.                 }
    172.             } else {
    173.                 totalWidth += getViewTotalMeasuredWidth(child) + spacing;
    174.             }
    175.         }
    176.  
    177.         if (mode == MeasureSpec.EXACTLY) {
    178.             if (!mNeedsUnderflow && totalWidth > width) {
    179.                 mNeedsUnderflow = true;
    180.             }
    181.             setMeasuredDimension(width, MeasureSpec.getSize(heightMeasureSpec));
    182.         } else {
    183.             if (mode == MeasureSpec.AT_MOST && totalWidth > width) {
    184.                 mNeedsUnderflow = true;
    185.                 totalWidth = width;
    186.             }
    187.             setMeasuredDimension(totalWidth, MeasureSpec.getSize(heightMeasureSpec));
    188.         }
    189.     }
    190.  
    191.     @Override
    192.     public void onViewAdded(View child) {
    193.         super.onViewAdded(child);
    194.         StatusIconState vs = new StatusIconState();
    195.         vs.justAdded = true;
    196.         child.setTag(R.id.status_bar_view_state_tag, vs);
    197.     }
    198.  
    199.     @Override
    200.     public void onViewRemoved(View child) {
    201.         super.onViewRemoved(child);
    202.         child.setTag(R.id.status_bar_view_state_tag, null);
    203.     }
    204.  
    205.     /**
    206.      * 添加要忽略的图标槽的名称。它将不会显示在布局中也不会被测量。
    207.      *
    208.      * @param slotName 图标的名称，就像在 frameworks/base/core/res/res/values/config.xml 中定义的那样
    209.      */
    210.     public void addIgnoredSlot(String slotName) {
    211.         android.util.Log.d(TAG, "addIgnoredSlot: " + slotName);
    212.         boolean added = addIgnoredSlotInternal(slotName);
    213.         if (added) {
    214.             requestLayout();
    215.         }
    216.     }
    217.  
    218.     /**
    219.      * 添加要忽略的图标槽的名称的列表。
    220.      *
    221.      * @param slots 要忽略的图标的名称列表
    222.      */
    223.     public void addIgnoredSlots(List slots) {
    224.         for (String slot : slots) {
    225.             android.util.Log.d(TAG, "addIgnoredSlots: " + slot);
    226.         }
    227.  
    228.         boolean willAddAny = false;
    229.         for (String slot : slots) {
    230.             willAddAny |= addIgnoredSlotInternal(slot);
    231.         }
    232.  
    233.         if (willAddAny) {
    234.             requestLayout();
    235.         }
    236.     }
    237.  
    238.     /**
    239.      * 内部添加要忽略的图标槽名称。
    240.      *
    241.      * @param slotName 图标的名称，就像在 frameworks/base/core/res/res/values/config.xml 中定义的那样
    242.      * @return 如果成功添加，则返回 true，否则返回 false
    243.      */
    244.     private boolean addIgnoredSlotInternal(String slotName) {
    245.         android.util.Log.d(TAG, "addIgnoredSlotInternal: " + slotName);
    246.         if (mIgnoredSlots.contains(slotName)) {
    247.             return false;
    248.         }
    249.         mIgnoredSlots.add(slotName);
    250.         return true;
    251.     }
    252.  
    253.     /**
    254.      * 从忽略的图标槽中移除一个名称。
    255.      *
    256.      * @param slotName 要移除的图标槽的名称
    257.      */
    258.     public void removeIgnoredSlot(String slotName) {
    259.         android.util.Log.d(TAG, "removeIgnoredSlot: " + slotName);
    260.         boolean removed = mIgnoredSlots.remove(slotName);
    261.         if (removed) {
    262.             requestLayout();
    263.         }
    264.     }
    265.  
    266.     /**
    267.      * 从忽略的图标槽中移除名称的列表。
    268.      *
    269.      * @param slots 要移除的图标槽的名称列表
    270.      */
    271.     public void removeIgnoredSlots(List slots) {
    272.         for (String slot: slots) {
    273.             android.util.Log.d(TAG, "removeIgnoredSlot: " + slot);
    274.         }
    275.         boolean removedAny = false;
    276.         for (String slot : slots) {
    277.             removedAny |= mIgnoredSlots.remove(slot);
    278.         }
    279.  
    280.         if (removedAny) {
    281.             requestLayout();
    282.         }
    283.     }
    284.  
    285.     /**
    286.      * 设置要忽略的图标槽的列表，清除当前的列表。
    287.      *
    288.      * @param slots 要忽略的图标槽的名称列表
    289.      */
    290.     public void setIgnoredSlots(List slots) {
    291.         mIgnoredSlots.clear();
    292.         addIgnoredSlots(slots);
    293.     }
    294.  
    295.     /**
    296.      * 返回与特定槽名称相对应的视图。
    297.      * 仅用于操作它如何呈现。
    298.      *
    299.      * @param slot 槽名称，与 com.android.internal.R.config_statusBarIcons 中定义的名称相对应
    300.      * @return 如果此容器拥有相应的视图，则返回该视图，否则返回 null
    301.      */
    302.     public View getViewForSlot(String slot) {
    303.         for (int i = 0; i < getChildCount(); i++) {
    304.             View child = getChildAt(i);
    305.             if (child instanceof StatusIconDisplayable
    306.                     && ((StatusIconDisplayable) child).getSlot().equals(slot)) {
    307.                 return child;
    308.             }
    309.         }
    310.         return null;
    311.     }
    312.  
    313.     /**
    314.      * 布局从右到左发生。
    315.      */
    316.     private void calculateIconTranslations() {
    317.         mLayoutStates.clear();
    318.         float width = getWidth();
    319.         float translationX = width - getPaddingEnd();
    320.         float contentStart = getPaddingStart();
    321.         int childCount = getChildCount();
    322.         // Underflow === 不显示内容直到此索引
    323.         if (DEBUG) Log.d(TAG, "calculateIconTranslations: start=" + translationX
    324.                 + " width=" + width + " underflow=" + mNeedsUnderflow);
    325.  
    326.         // 收集所有希望可见的状态
    327.         for (int i = childCount - 1; i >= 0; i--) {
    328.             View child = getChildAt(i);
    329.             StatusIconDisplayable iconView = (StatusIconDisplayable) child;
    330.             StatusIconState childState = getViewStateFromChild(child);
    331.  
    332.             if (!iconView.isIconVisible() || iconView.isIconBlocked()
    333.                     || mIgnoredSlots.contains(iconView.getSlot())) {
    334.                 childState.visibleState = STATE_HIDDEN;
    335.                 if (DEBUG) Log.d(TAG, "skipping child (" + iconView.getSlot() + ") not visible");
    336.                 continue;
    337.             }
    338.  
    339.             // 移动 translationX 到布局的位置，以添加视图而不截断子视图
    340.             translationX -= getViewTotalWidth(child);
    341.             childState.visibleState = STATE_ICON;
    342.             childState.xTranslation = translationX;
    343.             mLayoutStates.add(0, childState);
    344.  
    345.             // 为下一个视图移动 translationX 以腾出间隔
    346.             translationX -= mIconSpacing;
    347.         }
    348.  
    349.         // 显示 1 至 MAX_ICONS 个图标，或 (MAX_ICONS - 1) 个图标 + 溢出
    350.         int totalVisible = mLayoutStates.size();
    351.         int maxVisible = totalVisible <= MAX_ICONS ? MAX_ICONS : MAX_ICONS - 1;
    352.  
    353.         mUnderflowStart = 0;
    354.         int visible = 0;
    355.         int firstUnderflowIndex = -1;
    356.         for (int i = totalVisible - 1; i >= 0; i--) {
    357.             StatusIconState state = mLayoutStates.get(i);
    358.             // 如果在测量时发现需要溢出，则允许在此之前腾出空间
    359.             if (mNeedsUnderflow && (state.xTranslation < (contentStart + mUnderflowWidth)) ||
    360.                     (mShouldRestrictIcons && visible >= maxVisible)) {
    361.                 firstUnderflowIndex = i;
    362.                 break;
    363.             }
    364.             mUnderflowStart = (int) Math.max(
    365.                     contentStart, state.xTranslation - mUnderflowWidth - mIconSpacing);
    366.             visible++;
    367.         }
    368.         //开始判断是否超出  超出则画点
    369.         if (firstUnderflowIndex != -1) {
    370.             int totalDots = 0;
    371.             int dotWidth = mStaticDotDiameter + mDotPadding;
    372.             int dotOffset = mUnderflowStart + mUnderflowWidth - mIconDotFrameWidth;
    373.             for (int i = firstUnderflowIndex; i >= 0; i--) {
    374.                 StatusIconState state = mLayoutStates.get(i);
    375.                 if (totalDots < MAX_DOTS) {
    376.                     state.xTranslation = dotOffset;
    377.                     state.visibleState = STATE_DOT;
    378.                     dotOffset -= dotWidth;
    379.                     totalDots++;
    380.                 } else {
    381.                     state.visibleState = STATE_HIDDEN;
    382.                 }
    383.             }
    384.         }
    385.  
    386.         // 从 NotificationIconContainer 中拿来的，不是最优解，但保持布局逻辑简洁
    387.         if (isLayoutRtl()) {
    388.             for (int i = 0; i < childCount; i++) {
    389.                 View child = getChildAt(i);
    390.                 StatusIconState state = getViewStateFromChild(child);
    391.                 state.xTranslation = width - state.xTranslation - child.getWidth();
    392.             }
    393.         }
    394.     }
    395.  
    396.     private void applyIconStates() {
    397.         for (int i = 0; i < getChildCount(); i++) {
    398.             View child = getChildAt(i);
    399.             StatusIconState vs = getViewStateFromChild(child);
    400.             if (vs != null) {
    401.                 vs.applyToView(child);
    402.             }
    403.         }
    404.     }
    405.  
    406.     private void resetViewStates() {
    407.         for (int i = 0; i < getChildCount(); i++) {
    408.             View child = getChildAt(i);
    409.             StatusIconState vs = getViewStateFromChild(child);
    410.             if (vs == null) {
    411.                 continue;
    412.             }
    413.  
    414.             vs.initFrom(child);
    415.             vs.alpha = 1.0f;
    416.             vs.hidden = false;
    417.         }
    418.     }
    419.  
    420.     private static @Nullable StatusIconState getViewStateFromChild(View child) {
    421.         return (StatusIconState) child.getTag(R.id.status_bar_view_state_tag);
    422.     }
    423.  
    424.     private static int getViewTotalMeasuredWidth(View child) {
    425.         return child.getMeasuredWidth() + child.getPaddingStart() + child.getPaddingEnd();
    426.     }
    427.  
    428.     private static int getViewTotalWidth(View child) {
    429.         return child.getWidth() + child.getPaddingStart() + child.getPaddingEnd();
    430.     }
    431.  
    432.     public static class StatusIconState extends ViewState {
    433.         /// StatusBarIconView.STATE_*
    434.         public int visibleState = STATE_ICON;
    435.         public boolean justAdded = true;
    436.  
    437.         // 从视图末尾的距离是最相关的，用于动画
    438.         float distanceToViewEnd = -1;
    439.  
    440.         @Override
    441.         public void applyToView(View view) {
    442.             float parentWidth = 0;
    443.             if (view.getParent() instanceof View) {
    444.                 parentWidth = ((View) view.getParent()).getWidth();
    445.             }
    446.  
    447.             float currentDistanceToEnd = parentWidth - xTranslation;
    448.  
    449.             if (!(view instanceof StatusIconDisplayable)) {
    450.                 return;
    451.             }
    452.             StatusIconDisplayable icon = (StatusIconDisplayable) view;
    453.             AnimationProperties animationProperties = null;
    454.             boolean animateVisibility = true;
    455.  
    456.             // 用于计算哪些状态在布局过程中是可见的，找出哪些属性的状态转换(如果有的话)我们需要动画
    457.             // 确定要动画的状态转换的属性（如果有）
    458.             if (justAdded
    459.                     || icon.getVisibleState() == STATE_HIDDEN && visibleState == STATE_ICON) {
    460.                 // 图标正在出现，通过将其放在它将出现的位置并动画 alpha 来淡入它
    461.                 super.applyToView(view);
    462.                 view.setAlpha(0.f);
    463.                 icon.setVisibleState(STATE_HIDDEN);
    464.                 animationProperties = ADD_ICON_PROPERTIES;
    465.             } else if (icon.getVisibleState() != visibleState) {
    466.                 if (icon.getVisibleState() == STATE_ICON && visibleState == STATE_HIDDEN) {
    467.                     // 消失，不要执行任何复杂的操作
    468.                     animateVisibility = false;
    469.                 } else {
    470.                     // 所有其他转换（到/从点等）
    471.                     animationProperties = ANIMATE_ALL_PROPERTIES;
    472.                 }
    473.             } else if (visibleState != STATE_HIDDEN && distanceToViewEnd != currentDistanceToEnd) {
    474.                 // 可见性不在发生变化，只需动画位置
    475.                 animationProperties = X_ANIMATION_PROPERTIES;
    476.             }
    477.  
    478.             icon.setVisibleState(visibleState, animateVisibility);
    479.             if (animationProperties != null) {
    480.                 view.animate().cancel();
    481.                 icon.addTransformationToViewGroup(view, animationProperties, null);
    482.             }
    483.             icon.applyInShelfTransformation(view, this, animationProperties, animationProperties);
    484.         }
    485.     }
    486. }

  • 相关阅读:
    网安之python基础作业(2-3)
    linux中好玩的数据流定向和管道命令一
    Android 性能优化如何深入学习：启动、内存、崩溃优化一个都不能少
    Allegro差分自动添加回流地孔操作指导
    k8s 存储卷详解与动静部署详解
    微信小程序：全新独家云开发微群人脉
    Elasticsearch各个版本重要特性
    Android(Linux)常用的Shell指令
    SpringCloud-Sleuth服务追踪
    设计模式学习（三）：工厂模式
  • 原文地址：https://blog.csdn.net/m0_59558544/article/details/134038994