Update version to 2.7

.github/ISSUE_TEMPLATE/----------.md

@@ -1,7 +1,7 @@
 ---
-name: 通知优化图标适配反馈
+name: 通知图标优化适配反馈
 about: 提交通知图标优化适配必须使用此模板提交
-title: "[通知优化图标适配反馈]"
+title: "[通知图标优化适配反馈]"
 labels: To be adapted
 assignees: ''
 

.idea/misc.xml

@@ -7,9 +7,15 @@
         <entry key="app/src/main/res/drawable-night/permotion_round.xml" value="0.256" />
         <entry key="app/src/main/res/drawable-v24/ic_launcher_foreground.xml" value="0.44871794871794873" />
         <entry key="app/src/main/res/drawable/bg_dark_round.xml" value="0.2325" />
+        <entry key="app/src/main/res/drawable/bg_dialog_background.xml" value="0.2325" />
         <entry key="app/src/main/res/drawable/bg_green_round.xml" value="0.255" />
+        <entry key="app/src/main/res/drawable/bg_orange_round.xml" value="0.2325" />
         <entry key="app/src/main/res/drawable/bg_warn_round.xml" value="0.2325" />
         <entry key="app/src/main/res/drawable/bg_yellow_round.xml" value="0.255" />
+        <entry key="app/src/main/res/drawable/ic_nf_icon_refresh.xml" value="0.2325" />
+        <entry key="app/src/main/res/drawable/ic_nf_icon_update.xml" value="0.2325" />
+        <entry key="app/src/main/res/drawable/ic_notify_icon.xml" value="0.2325" />
+        <entry key="app/src/main/res/drawable/ic_system_clock.xml" value="0.2325" />
         <entry key="app/src/main/res/drawable/permotion_round.xml" value="0.256" />
         <entry key="app/src/main/res/drawable/white_round.xml" value="0.256" />
         <entry key="app/src/main/res/layout-w1240dp/dia_source_from.xml" value="0.36484375" />
@@ -17,7 +23,7 @@
         <entry key="app/src/main/res/layout-w936dp/dia_status_icon_cout.xml" value="0.935546875" />
         <entry key="app/src/main/res/layout/activity_config.xml" value="0.42168674698795183" />
         <entry key="app/src/main/res/layout/activity_login.xml" value="0.4375" />
-        <entry key="app/src/main/res/layout/activity_main.xml" value="0.3448275862068966" />
+        <entry key="app/src/main/res/layout/activity_main.xml" value="0.30387540746106484" />
         <entry key="app/src/main/res/layout/adapter_config.xml" value="0.375" />
         <entry key="app/src/main/res/layout/dia_icon_filter.xml" value="0.4307692307692308" />
         <entry key="app/src/main/res/layout/dia_icon_search.xml" value="0.4307692307692308" />

PRIVACY.md

@@ -0,0 +1,359 @@
+### MIUI 原生通知图标 隐私政策
+
+> 简体中文
+
+版本：1.0
+
+修订与生效日期：2022年4月25日
+
+#### 前言
+
+为帮助您使用 MIUI 原生通知图标产品(以下简称“本产品”)或服务，我们可能收集与提供服务相关的设备信息或申请设备权限，您有权拒绝或撤回授权；
+
+我们采取了互联网业内标准的技术措施和数据安全措施来保护您的设备信息安全；
+
+除非再次征得您的同意，我们不会将您的设备信息用于本政策未载明的其他目的；
+
+在阅读本协议前，请确认您已年满 18 岁，否则请在父母的陪同下阅读本协议。
+
+#### 目录
+
+```
+1.  引言
+2. 本产品处理设备信息的法律依据
+3. 我们如何收集和使用您的设备信息
+3.1 向您提供本产品和/或服务的核心业务功能
+3.2 征得授权同意的例外
+4. 我们如何转让、公开披露您的设备信息
+4.1 转让您的设备信息
+4.2 公开披露
+4.3 共享、转让、公开披露设备信息授权同意的例外
+5. 您管理设备信息的权利
+5.1 设备权限调用
+6. 如何更新与修改本政策
+7. 争议解决
+8. 名词解释
+```
+
+1. 引言
+
+【特别提示】
+
+请您在使用我们的各项产品和/或服务前，仔细阅读并充分理解本政策。一旦您使用或继续使用本产品/服务，即表示您同意我们按照本政策处理您的相关信息。
+
+2. 本产品处理设备信息的法律依据
+
+如果您是中华人民共和国大陆地区的用户，我们将依据《中华人民共和国网络安全法》、《信息安全技术 个人信息安全规范》（GB/T 35273-2017）以及其他相关法律法规收集和使用您的设备信息或申请设备权限，为您提供本产品或服务。 我们通常只会在征得您同意的情况下收集您的设备信息。
+
+3. 我们如何收集和使用您的设备信息
+
+我们会遵循正当、合法、必要的原则，出于本政策所述的以下目的，收集和使用您在使用服务过程中主动提供或因使用本产品和/或服务而产生的设备信息。如果我们要将您的设备信息用于本政策未载明的其它用途，或基于特定目的将收集而来的信息用于其他目的，我们将以合理的方式向您告知，并在使用前再次征得您的同意。
+
+3.1 向您提供本产品和/或服务的核心业务功能
+
+为实现 本产品的核心业务功能，我们可能需要向您收集设备信息。以下将详细列出 本产品的核心业务功能及为实现该功能所需收集的设备信息，若您拒绝收集，则无法使用该服务。
+
+查看设备中的所有应用信息。 本产品会读取您的设备应用列表；
+
+搜索功能。 当您使用 本产品提供的搜索功能时，我们可能会使用应用数据缓存，收集您设备上的信息并进行本地存储。 该信息通常无法单独识别您的个人身份。
+
+3.2 征得授权同意的例外
+
+根据相关法律法规的规定，在以下情形中，我们可以在不征得您的授权同意的情况下收集、使用一些必要的设备信息：
+
+```
+a. 与国家安全、国防安全直接相关的；
+b. 与公共安全、公共卫生、重大公共利益直接相关的；
+c. 与犯罪侦查、起诉、审判和判决执行等直接相关的；
+d. 出于维护您或其他个人的生命、财产等重大合法权益但又很难得到本人同意的；
+e. 所收集的设备信息是您自行向社会公众公开的；
+f. 从合法公开披露的信息中收集到您的设备信息，如从合法的新闻报道、政府信息公开等渠道；
+g. 根据您的要求签订和履行合同所必需的；
+h. 用于维护 本产品的产品和/或服务的安全稳定运行所必需的，例如发现、处置产品或服务的故障；
+i. 法律法规规定的其他情形。
+```
+
+4. 我们如何共享、转让、公开披露您的设备信息
+
+4.1 转让您的设备信息
+
+除非获取您的明确同意，我们不会将您的设备信息转让给任何公司、组织或个人。
+
+4.2 公开披露
+
+除非获取您的明确同意，我们不会公开披露您的设备信息。
+
+4.3 共享、转让、公开披露设备信息授权同意的例外
+
+根据相关法律法规的规定，在以下情形中，我们可以在不征得您的授权同意的情况下共享、转让、公开披露您的设备信息：
+
+```
+A. 与国家安全、国防安全有关的；
+B. 与公共安全、公共卫生、重大公共利益有关的；
+C. 与犯罪侦查、起诉、审判和判决执行等有关的；
+D. 出于维护您或其他个人的生命、财产等重大合法权益但又很难得到本人同意的；
+E. 您自行向社会公众公开的设备信息；
+F. 从合法公开披露的信息中收集到的设备信息的，如合法的新闻报道、政府信息公开等渠道。
+G. 法律法规规定的其他情形。
+```
+
+根据法律规定，共享、转让经去标识化处理的设备信息，且确保数据接收方无法复原并重新识别设备信息主体的，不属于设备信息的对外共享、转让及公开披露行为，对此类数据的保存及处理将无需另行向您通知并征得您的同意。
+
+5. 您管理设备信息的权利
+
+5.1 设备权限调用
+
+我们在提供服务的过程中，可能需要您开通一些设备权限，例如网络连接、查看设备应用列表等访问权限。 您也可以在设备的【设置】功能中随时选择关闭部分或者全部权限，从而拒绝我们收集您相应的设备信息。在不同设备中，权限显示方式及关闭方式可能有所不同，具体请参考设备及系统开发方说明或指引。
+
+6. 如何更新与修改本政策
+
+6.1 本政策为本产品的重要组成部分。 本产品保留不时更新或修改本政策的权利。
+
+6.2 未经您明确同意，我们不会削减您按照本政策所应享有的权利。我们会通过 App 客户端推送通知、弹窗形式等合理方式通知您，以便您能及时了解本政策所做的任何变更。
+
+6.3 对于重大变更，视具体情况我们 可能还会提供更为显著的通知 说明本政策的具体变更内容。 重大变更包括但不限于：
+
+```
+A. 我们的服务模式发生重大变化。如处理设备信息的目的、处理的设备信息类型、设备信息的使用方式等；
+B. 我们在所有权结构、组织架构等方面发生重大变化。如业务调整、破产并购等引起的所有者变更等；
+C. 设备信息共享、转让或公开披露的主要对象发生变化；
+D. 您参与设备信息处理方面的权利及其行使方式发生重大变化；
+E. 我们负责处理设备信息安全的责任部门、联络方式及投诉渠道发生变化；
+F. 设备信息安全影响评估报告表明存在高风险时。
+```
+
+6.4 若您不同意修改后的隐私政策，您有权并应立即停止使用 本产品的服务。如果您继续使用 本产品的服务，则视为您接受 本产品对本政策相关条款所做的修改。
+
+7. 争议解决
+
+7.1 如果您认为我们的设备信息处理行为损害了您的合法权益，您也可向有关政府部门进行反映。
+
+8. 名词解释
+
+本隐私政策中使用到的名词，在通常意义中有如下定义：
+
+设备信息： 设备信息是指以电子或者其他方式记录的能够单独或者与其他信息结合识别设备身份的各种信息，包括但不限于设备的品牌、型号、系统版本、 唯一设备标识符、 网络 IP 地址、Cookie等；
+
+设备： 设备是指可用于访问本产品和/或服务的装置，例如台式计算机、笔记本电脑、平板电脑或智能手机。 唯一设备标识符： 唯一设备标识符（专属 ID 或 UUID）是指由设备制造商编入到设备中的一串字符，可用于以独有方式标识相应设备（例如手机的 IMEI
+号）。唯一设备标识符有多种用途，其中可在不能使用 Cookie（例如在移动应用程序中）时用以提供广告。
+
+IP 地址： 每台上网的设备都会指定一个编号，称为互联网协议 ( IP ) 地址。这些编号通常都是根据地理区域指定的。IP 地址通常可用于识别设备连接至互联网时所在的位置。
+
+信息收集技术： 我们在《MIUI 原生通知图标 隐私政策》中所述的“自动收集”包括以下方式： A. Cookie（曲奇档案） Cookie 是您浏览网页时，网站服务器放在客户端（您的计算机、移动电话或其他智能终端内）里面的一个小小的文本文件，当您再次访问相应网站时，网站就可通过
+Cookie 识别您的浏览器。Cookie 可能会存储用户偏好及其他信息。您可以将浏览器配置为拒绝所有 Cookie 或在网站发送 Cookie 时显示提示。不过，如果没有 Cookie，某些网站功能或服务可能无法正常工作。 B. Web beacon（网络信标） Web beacon
+是装嵌在网站或电邮内的电子图像文件案或其他技术，可用于计算访客数目、记录您是否及何时阅览电邮或网站，或用以使用某些 Cookie。 C. Log files（日志文件） Log files 储存自动收集的若干数据。该等数据包括互联网协议（ IP ）地址、浏览器类型、互联网服务提供商（
+ISP ）、引用/退出页面、操作系统、日期/时间戳和点击流数据等。 D. ET Tag（实体标签） ET Tag 是在互联网浏览器与互联网服务器之间背后传送的 HTTP 协议标头，可代替 Cookie，用以追踪个别使用者，使我们可更深入地了解和改善我们的服务。 E. JavaScript
+JavaScript 是一种编程语言，用于制作更具互动性和动态的网页。JavaScript 可以设定 Cookie、阅读 Cookie 及删除 Cookie。
+
+算法： 计算机在执行解题运算时遵循的流程或一系列规则。
+
+应用数据缓存： 应用数据缓存是指设备上的一种数据存储机制。使用它有很多好处，例如，可让网络应用在未连接互联网的情况下运行，以及可通过提高内容加载速度来改善相关应用的性能。
+
+非个人身份信息： 记录的与用户相关的信息，但实际上不可直接或间接识别您身份的信息，包括经过去标识化、匿名化处理或化名方式提供的设备信息。
+
+去标识化： 指通过对设备信息的技术处理，使其在不借助额外信息的情况下，无法识别设备信息主体的过程。
+
+匿名化： 指通过对设备信息的技术处理，使得设备信息主体无法被识别，且处理后的信息不能被复原的过程。
+
+服务器日志： 与大多数网站一样，我们的服务器会自动记录您在访问网站时所发出的网页请求。这些“服务器日志”通常包括您的网络请求、互联网协议地址、浏览器类型、浏览器语言、请求的日期和时间及可以唯一识别您的浏览器的一个或多个 Cookie。
+
+### MIUINativeNotifyIcon Privacy Policy
+
+> English
+
+Version: 1.0
+
+Amendment and effective date: April 25, 2022
+
+#### Preface
+
+In order to help you use MIUINativeNotifyIcon products (hereinafter referred to as "this product") or services, we may collect device information
+related to the provision of services or apply for device permissions, and you have the right to refuse or withdraw authorization;
+
+We have adopted technical measures and data security measures that are standard in the Internet industry to protect the security of your device
+information;
+
+Unless we obtain your consent again, we will not use your device information for other purposes not specified in this policy;
+
+Before reading this agreement, please confirm that you are at least 18 years old, otherwise please read this agreement with your parents.
+
+#### content
+
+````
+1 Introduction
+2. Legal basis for this product to process device information
+3. How we collect and use your device information
+3.1 Provide you with the core business functions of this product and/or service
+3.2 Exceptions to Authorized Consent
+4. How we transfer and publicly disclose your device information
+4.1 Transfer your device information
+4.2 Public disclosure
+4.3 Exceptions to Authorization and Consent for Sharing, Transfer, and Public Disclosure of Device Information
+5. Your Right to Manage Device Information
+5.1 Device permission call
+6. How to update and modify this policy
+7. Dispute Resolution
+8. Glossary
+````
+
+1 Introduction
+
+【Special Note】
+
+Please read and fully understand this policy before using our products and/or services. Once you use or continue to use this product/service, you
+agree that we will process your relevant information in accordance with this policy.
+
+2. Legal basis for this product to process device information
+
+If you are a user in the mainland of the People's Republic of China, we will collect and use your Device information or apply for device
+permissions to provide you with this product or service. We generally only collect your device information with your consent.
+
+3. How we collect and use your device information
+
+We will follow the principles of legitimacy, lawfulness, and necessity, and for the following purposes described in this policy, to collect and
+use the device information that you actively provide during the use of the service or that arises from the use of this product and/or service. If
+we want to use your device information for other purposes not specified in this policy, or use the collected information for other purposes based
+on a specific purpose, we will inform you in a reasonable manner and ask again before use with your consent.
+
+3.1 Provide you with the core business functions of this product and/or service
+
+In order to implement the core business functions of this product, we may need to collect device information from you. The following will list in
+detail the core business functions of this product and the device information that needs to be collected to achieve this function. If you refuse
+to collect, you cannot use the service.
+
+View all app information on the device. This product will read your device application list;
+
+searching feature. When you use the search function provided by this product, we may use application data cache, collect information on your
+device and store it locally. This information generally does not individually identify you as an individual.
+
+3.2 Exceptions to Authorized Consent
+
+According to relevant laws and regulations, we may collect and use some necessary device information without your authorization and consent under
+the following circumstances:
+
+````
+a. Directly related to national security and national defense security;
+b. Directly related to public safety, public health, and major public interests;
+c. Directly related to criminal investigation, prosecution, trial and execution of judgments;
+d. In order to protect your or other personal life, property and other major legitimate rights and interests, but it is difficult to obtain my consent;
+e. The collected device information is disclosed to the public by you;
+f. Your device information is collected from legally publicly disclosed information, such as legal news reports, government information disclosure and other channels;
+g. Necessary to enter into and perform a contract at your request;
+h. Necessary to maintain the safe and stable operation of the products and/or services of this product, such as finding and disposing of faults in the products or services;
+i. Other situations stipulated by laws and regulations.
+````
+
+4. How we share, transfer, and publicly disclose your device information
+
+4.1 Transfer your device information
+
+We will not transfer your device information to any company, organization or individual without your express consent.
+
+4.2 Public disclosure
+
+We will not publicly disclose your device information without your express consent.
+
+4.3 Exceptions to Authorization and Consent for Sharing, Transfer, and Public Disclosure of Device Information
+
+According to relevant laws and regulations, we may share, transfer and publicly disclose your device information without your authorization and
+consent in the following circumstances:
+
+````
+A. Related to national security and national defense security;
+B. Related to public safety, public health, and major public interests;
+C. Related to criminal investigation, prosecution, trial and execution of judgments;
+D. In order to protect your or other personal life, property and other major legitimate rights and interests, but it is difficult to obtain my consent;
+E. The device information that you disclose to the public by yourself;
+F. Device information collected from legally publicly disclosed information, such as legal news reports, government information disclosure and other channels.
+G. Other situations stipulated by laws and regulations.
+````
+
+According to the law, sharing and transferring de-identified device information and ensuring that the data recipient cannot restore and
+re-identify the subject of the device information is not an act of external sharing, transfer and public disclosure of device information.
+Storage and processing will not be required to notify you and obtain your consent.
+
+5. Your Right to Manage Device Information
+
+5.1 Device permission call
+
+In the process of providing services, we may require you to activate some device permissions, such as network connection, viewing device
+application list and other access permissions. You can also choose to turn off some or all permissions at any time in the [Settings] function of
+the device, thereby refusing us to collect your corresponding device information. In different devices, the display method and closing method of
+permissions may be different. For details, please refer to the instructions or guidelines of the device and system developers.
+
+6. How to update and modify this policy
+
+6.1 This policy is an important part of this product. This product reserves the right to update or modify this policy from time to time.
+
+6.2 We will not reduce your rights under this Policy without your express consent. We will notify you through reasonable means such as app client
+push notifications and pop-up windows, so that you can keep abreast of any changes to this policy.
+
+6.3 For major changes, we may also provide a more prominent notice to explain the specific changes to this policy as the case may be. Significant
+changes include, but are not limited to:
+
+````
+A. Significant changes to our service model. Such as the purpose of processing device information, the type of device information processed, the way of using device information, etc.;
+B. We have made significant changes in our ownership structure, organizational structure, etc. Such as changes in owners caused by business adjustments, bankruptcy mergers and acquisitions, etc.;
+C. The main object of equipment information sharing, transfer or public disclosure has changed;
+D. Significant changes in your rights to participate in the processing of device information and the way you exercise it;
+E. The responsible department, contact information and complaint channel that we are responsible for handling equipment information security have changed;
+F. When the equipment information security impact assessment report indicates that there is a high risk.
+````
+
+6.4 If you do not agree with the revised Privacy Policy, you have the right and should immediately stop using the services of this product. If
+you continue to use the services of this product, it is deemed that you accept the modifications made by this product to the relevant terms of
+this policy.
+
+7. Dispute Resolution
+
+7.1 If you believe that our device information processing has damaged your legitimate rights and interests, you can also report to the relevant
+government departments.
+
+8. Glossary
+
+Terms used in this Privacy Policy have the following definitions in their usual meanings:
+
+Device information: Device information refers to various information recorded electronically or in other ways that can identify the identity of
+the device alone or in combination with other information, including but not limited to the brand, model, system version, unique device
+identifier, network IP address of the device , Cookies, etc.;
+
+Device: A device is a device that can be used to access the Product and/or Service, such as a desktop computer, laptop, tablet or smartphone.
+Unique Device Identifier: A Unique Device Identifier (Unique ID or UUID) is a string of characters programmed into a device by the device
+manufacturer that can be used to uniquely identify the device (such as the IMEI of a mobile phone)
+No). Unique device identifiers are used for a variety of purposes, including serving advertisements when cookies cannot be used, such as in
+mobile applications.
+
+IP Address: Every device that goes online is assigned a number called an Internet Protocol (IP) address. These numbers are usually assigned by
+geographic area. An IP address can often be used to identify where a device is connected to the Internet.
+
+Information collection technology: The "automatic collection" described in the "MIUINativeNotifyIcon Privacy Policy" includes the following
+methods: A. Cookie (cookie file) Cookie is when you browse the web, the website server places it on the client (your A small text file in a
+computer, mobile phone or other intelligent terminal), when you visit the corresponding website again, the website can pass Cookies identify your
+browser. Cookies may store user preferences and other information. You can configure your browser to refuse all cookies or to display a prompt
+when a website sends a cookie. However, some website features or services may not function properly without cookies. B. Web beacon (web beacon)
+Web beacon An electronic image file or other technology embedded in a website or email that can be used to count visitors, record whether and
+when you view an email or website, or to use certain cookies. C. Log files Log files store certain data collected automatically. This data
+includes Internet Protocol (IP) address, browser type, Internet Service Provider (
+ISP), referring/exit pages, operating system, date/time stamp and clickstream data, etc. D. ET Tag (Entity Tag) ET Tag is an HTTP protocol header
+transmitted behind the Internet browser and Internet server, which can replace cookies to track individual users, so that we can better
+understand and improve our Serve. E. JavaScript JavaScript is a programming language used to make more interactive and dynamic web pages.
+JavaScript can set cookies, read cookies and delete cookies.
+
+Algorithm: A process or set of rules that a computer follows when performing a problem-solving operation.
+
+App data cache: App data cache refers to a data storage mechanism on the device. There are many benefits to using it, such as allowing web
+applications to run without an internet connection, and improving the performance of related applications by increasing the speed of content
+loading.
+
+Non-Personally Identifiable Information: Information that is recorded about a user but does not actually identify you directly or indirectly,
+including device information that has been de-identified, anonymized, or provided under a pseudonym.
+
+De-identification: refers to the process of technical processing of device information to make it impossible to identify the subject of device
+information without the aid of additional information.
+
+Anonymization: refers to the process in which the subject of the device information cannot be identified and the processed information cannot be
+recovered through the technical processing of the device information.
+
+Server Logs: Like most websites, our servers automatically log the web page requests you make while visiting the website. These "server logs"
+typically include your web request, internet protocol address, browser type, browser language, date and time of the request, and one or more
+cookies that uniquely identify your browser.

README.md

@@ -1,52 +1,62 @@
 # MIUI 原生通知图标
 
-![Eclipse Marketplace](https://img.shields.io/badge/build-passing-brightgreen)
-![Eclipse Marketplace](https://img.shields.io/badge/license-AGPL3.0-blue)
-![Eclipse Marketplace](https://img.shields.io/badge/version-v2.16-green)
-[![Telegram](https://img.shields.io/static/v1?label=Telegram&message=交流讨论&color=0088cc)](https://t.me/XiaofangInternet)
+[![Blank](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/fankes/MIUINativeNotifyIcon)
+[![Blank](https://img.shields.io/badge/license-AGPL3.0-blue)](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/LICENSE)
+[![Blank](https://img.shields.io/badge/version-v2.7-green)](https://github.com/fankes/MIUINativeNotifyIcon/releases)
+[![Blank](https://img.shields.io/github/downloads/fankes/MIUINativeNotifyIcon/total?label=Release)](https://github.com/fankes/MIUINativeNotifyIcon/releases)
+[![Blank](https://img.shields.io/github/downloads/Xposed-Modules-Repo/com.fankes.miui.notify/total?label=LSPosed%20Repo&logo=Android&style=flat&labelColor=F48FB1&logoColor=ffffff)](https://github.com/Xposed-Modules-Repo/com.fankes.miui.notify/releases)
+[![Telegram](https://img.shields.io/badge/Follow-Telegram-blue.svg?logo=telegram)](https://t.me/XiaofangInternet)
 <br/><br/>
 <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/app/src/main/ic_launcher-playstore.png" width = "100" height = "100"/>
 <br/>
 Fix the native notification bar icon function abandoned by the MIUI development team.<br/>
 修复被 MIUI 开发组丢弃的原生通知图标，支持 MIUI 12、12.5、13 以及最新版本。
 
-# 开始使用
+## Developer
 
-点击下载最新版本
-<a href='https://github.com/fankes/MIUINativeNotifyIcon/releases'>![Eclipse Marketplace](https://img.shields.io/badge/download-v2.16-green)</a>
-<br/><br/>
-⚠️ 适配说明<br/>
+[酷安 @星夜不荟](http://www.coolapk.com/u/876977)
+
+## 适配说明
+
+- 此模块仅支持 <b>LSPosed</b>(作用域“系统界面”)、<b>~~EdXposed(随时停止支持)~~</b>、不支持<b>太极、无极</b>
 
-- 此模块仅支持 LSPosed(作用域“系统界面”)、~~EdXposed(随时停止支持)~~、不支持太极无极
 - 请确保你使用的是 MIUI 官方版本，任何第三方官改包发生的问题，开发者没有义务去解决和修复，请自求多福
+
 - 目前最低支持基于 Android 9 版本的 MIUI 12 或 MIUI 12.5(最低建议)
+
 - 建议最低从 MIUI 12.5 `2021-5-18` 开发版以后开始使用模块，之前的版本可能或多或少存在 MIUI 自身 BUG 不生效、黑白块的问题
+
 - 请始终保持最新版本的 LSPosed，旧版本可能会出现 Hook 不生效的问题，若最新版本依然不生效请在作用域中长按“系统界面”(“系统 UI”)选择重新优化
 
-# 请勿用于非法用途
+## 请勿用于非法用途
 
 - 本模块完全开源免费，如果好用你可以打赏支持开发，但是请不要用于非法用途。
+
 - 本模块发布地址仅有 [Xposed-Modules-Repo](https://github.com/Xposed-Modules-Repo/com.fankes.miui.notify/releases)、
-  [Release](https://github.com/fankes/MIUINativeNotifyIcon/releases)
-  及[蓝奏云](https://fankes.lanzouy.com/b030o2e8h)，从其他非正规渠道下载到的版本或对您造成任何影响均与我们无关。
+  [Release](https://github.com/fankes/MIUINativeNotifyIcon/releases)、[蓝奏云](https://fankes.lanzouy.com/b030o2e8h) 及**酷安应用市场**
+  ，从其他非正规渠道下载到的版本或对您造成任何影响均与我们无关。
 
-# 贡献通知图标优化名单
+## 贡献通知图标优化名单
 
-此项目是 `AndroidNotifyIconAdapt` 项目的一部分，详情请参考下方。<br/>
+此项目是 `AndroidNotifyIconAdapt` 项目的一部分，详情请参考下方。
 
 - [Android 通知图标规范适配计划](https://github.com/fankes/AndroidNotifyIconAdapt)
 
-# 历史背景
+## 历史背景
+
+这个模块诞生来源于 MIUI 的乱改和不规范，本来 MIUI 9 之后，官方给出了原生通知图标样式，后面由于用户反应通知栏经常出现黑白块。
+
+这当然不是系统的错，而是国内 APP 和 `MIPUSH` 的通知极其不规范的通知图标设计。
+
+但是呢，接到反馈后 MIUI 开发组选择直接忽略这个问题，在 `2021-5-18` 的开发版开始，把全部通知图标都改成了 APP 的彩色图标，使得之前拥有自有样式的原生图标也被破坏。
+
+对于 Android 开发者来说，官方文档中的 `setSmallIcon` 不再适用于魔改后的 MIUI，这将会严重破坏非常多的状态图标。
+
+当然，国内的手机生态除了 `MIPUSH` 的营销通知就是社交软件的通知，可能大部分人都不会在意这件事情。
 
-这个模块诞生来源于 MIUI 的乱改和不规范，本来 MIUI 9 之后，官方给出了原生通知图标样式，后面由于用户反应通知栏经常出现黑白块。<br/><br/>
-这当然不是系统的错，而是国内 APP 和 `MIPUSH` 的通知极其不规范的通知图标设计。<br/><br/>
-但是呢，接到反馈后 MIUI 开发组选择直接忽略这个问题，在 `2021-5-18` 的开发版开始，把全部通知图标都改成了 APP 的彩色图标，使得之前拥有自有样式的原生图标也被破坏。<br/><br/>
-对于 Android 开发者来说，官方文档中的 `setSmallIcon` 不再适用于魔改后的 MIUI，这将会严重破坏非常多的状态图标。<br/><br/>
-当然，国内的手机生态除了 `MIPUSH` 的营销通知就是社交软件的通知，可能大部分人都不会在意这件事情。<br/><br/>
 但是，这个模块就是为了修复被 MIUI 开发组忽略的图标问题才诞生的，并完美地给 MIUI 修复了黑白块图标的问题。
-<br/>
 
-# 探索历程
+## 探索历程
 
 原生 Android 的小图标和通知图标具有状态性。<br/><br/>
 <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/native.jpg" height = "35"/><br/><br/>
@@ -58,33 +68,49 @@ Fix the native notification bar icon function abandoned by the MIUI development
 而 MIUI 做了什么呢？<br/><br/>
 <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/miui_n_1.jpg" height = "100"/><br/>
 <img src="https://github.com/fankes/MIUINativeNotifyIcon/blob/master/images/miui_n_2.jpg" height = "100"/><br/><br/>
-不曾记得是什么版本开始，MIUI 把通知图标改成了这个鬼样子，寻找开发组提案也是无人问津，最后转念一想，自己干吧。<br/><br/>
+不曾记得是什么版本开始，MIUI 把通知图标改成了这个鬼样子，寻找开发组提案也是无人问津，最后转念一想，自己干吧。
+
 由于目前大量通知图标都来自 `MIPUSH` 发出的营销通知，而 `MIPUSH` 的图标都是统一的彩色应用图标，很多应用也没有适配这一特性， 在通知栏广告满天飞的情况下，MIUI
-选择放弃原生通知功能，而做出这种违反原生通知规则的做法，而这些彩色图标被设置为单色调图标，也确实会发生黑白块的问题，但是同时又会破坏遵守规范的图标。<br/><br/>
+选择放弃原生通知功能，而做出这种违反原生通知规则的做法，而这些彩色图标被设置为单色调图标，也确实会发生黑白块的问题，但是同时又会破坏遵守规范的图标。
+
 真的没有办法了吗？在不断探索下，我找到了原生支持色彩判断的类。
 
-```
+```kotlin
 com.android.internal.util.ContrastColorUtil
 ```
 
 这个类中有一个方法可以拿出来判断图标的灰度效果。
 
-```
+```kotlin
 ContrastColorUtil.getInstance().isGrayscaleIcon(drawable)
 ```
 
-问题就被解决了，顺便修了一下被 MIUI 破坏的通知图标以及优化了一下应用本身方块图标的圆角......<br/><br/>
-最后，我想大声问一句 MIUI 开发组：“就这？” 就这么简单的问题为什么拖了这么长时间也没有结论，还要交给用户去修复，这真的是一种负责任的表现吗？<br/><br/>
-后来一想，也是啊，被国内生态毒害的用户，怎么可能会去想到这些问题呢，最后只能是我自作多情，还对 MIUI 留有一点情怀吧。<br/><br/>
+问题就被解决了，顺便修了一下被 MIUI 破坏的通知图标以及优化了一下应用本身方块图标的圆角......
+
+最后，我想大声问一句 MIUI 开发组：“就这？” 就这么简单的问题为什么拖了这么长时间也没有结论，还要交给用户去修复，这真的是一种负责任的表现吗？
+
+后来一想，也是啊，被国内生态毒害的用户，怎么可能会去想到这些问题呢，最后只能是我自作多情，还对 MIUI 留有一点情怀吧。
+
 ——来自一个无可奈何的 MIUI 老用户
 
-# 后记
+## 后记
+
+近期重新适配了 MIUI 12、12.5、13 版本，每个版本的图标设置方法都不一样，而且改的乱七八糟的，我都要无语了，只能用了很多折中方案，毕竟我也没有那么大精力每个版本去修复，实在是累了。
+
+特地的把自己能有的小米手机刷成各种 MIUI 版本去为酷友做专项适配，我也是很累了，也希望你们能够多多支持，也能让 MIUI 做得更好。
 
-近期重新适配了 MIUI 12、12.5、13 版本，每个版本的图标设置方法都不一样，而且改的乱七八糟的，我都要无语了，只能用了很多折中方案，毕竟我也没有那么大精力每个版本去修复，实在是累了。<br/><br/>
-特地的把自己能有的小米手机刷成各种 MIUI 版本去为酷友做专项适配，我也是很累了，也希望你们能够多多支持，也能让 MIUI 做得更好。<br/><br/>
 MIUI 再不重写，怕是永远会变成安卓之光。雷军，金凡！！
 
-# 许可证
+## 捐赠支持
+
+- 工作不易，无意外情况此项目将继续维护下去，提供更多可能，欢迎打赏。<br/><br/>
+  <img src="https://github.com/fankes/YuKiHookAPI/blob/master/img-src/wechat_code.jpg" width = "200" height = "200"/>
+
+## 隐私政策
+
+- [PRIVACY](https://github.com/fankes/MIUINativeNotifyIcon/blob/master/PRIVACY.md)
+
+## 许可证
 
 - [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.html)
 
@@ -105,5 +131,6 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ```
 
-Powered by [YukiHookAPI](https://github.com/fankes/YukiHookAPI)<br/><br/>
-版权所有 © 2019-2022 Fankes Studio(qzmmcn@163.com)
+Powered by [YukiHookAPI](https://github.com/fankes/YukiHookAPI)
+
+版权所有 © 2019-2022 Fankes Studio(qzmmcn@163.com)

app/build.gradle

@@ -1,7 +1,7 @@
 plugins {
     id 'com.android.application'
     id 'kotlin-android'
-    id 'com.google.devtools.ksp' version '1.6.10-1.0.2'
+    id 'com.google.devtools.ksp' version '1.6.21-1.0.5'
 }
 
 android {
@@ -30,51 +30,44 @@ android {
 
     buildTypes {
         release {
-            minifyEnabled true
+            minifyEnabled rootProject.ext.enableR8
+            shrinkResources rootProject.ext.enableR8
+            zipAlignEnabled rootProject.ext.enableR8
             signingConfig signingConfigs.debug
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
     }
     kotlinOptions {
-        jvmTarget = '1.8'
+        jvmTarget = '11'
+        freeCompilerArgs = [
+                '-Xno-param-assertions',
+                '-Xno-call-assertions',
+                '-Xno-receiver-assertions'
+        ]
     }
     buildFeatures {
         viewBinding true
     }
-}
-
-/** 移除无效耗时 lint Task */
-tasks.whenTaskAdded {
-    task -> if (task.name == "lintVitalRelease") task.enabled = false
-}
-
-/** 移除无效耗时 lint Task */
-tasks.whenTaskAdded {
-    task -> if (task.name == "lintVitalAnalyzeRelease") task.enabled = false
-}
-
-/** 移除无效耗时 lint Task */
-tasks.whenTaskAdded {
-    task -> if (task.name == "lintVitalReportRelease") task.enabled = false
+    lintOptions {
+        checkReleaseBuilds false
+    }
 }
 
 dependencies {
     compileOnly 'de.robv.android.xposed:api:82'
-    implementation 'com.highcapable.yukihookapi:api:1.0.5-fix'
-    ksp 'com.highcapable.yukihookapi:ksp-xposed:1.0.5-fix'
+    implementation 'com.highcapable.yukihookapi:api:1.0.92'
+    ksp 'com.highcapable.yukihookapi:ksp-xposed:1.0.92'
     implementation "com.github.topjohnwu.libsu:core:3.1.2"
     implementation 'androidx.annotation:annotation:1.3.0'
-    implementation 'com.geyifeng.immersionbar:immersionbar:3.2.0'
-    implementation 'com.geyifeng.immersionbar:immersionbar-ktx:3.2.0'
     implementation 'com.squareup.okhttp3:okhttp:4.9.3'
     implementation 'androidx.core:core-ktx:1.7.0'
     implementation 'androidx.appcompat:appcompat:1.4.1'
-    implementation 'com.google.android.material:material:1.5.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
+    implementation 'com.google.android.material:material:1.6.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'

app/proguard-rules.pro

@@ -20,29 +20,25 @@
 # hide the original source file name.
 #-renamesourcefileattribute SourceFile
 
--dontwarn
 -ignorewarnings
 -optimizationpasses 10
 -dontusemixedcaseclassnames
 -dontoptimize
 -verbose
 -overloadaggressively
--repackageclasses o
 -allowaccessmodification
 -adaptclassstrings
 -adaptresourcefilenames
 -adaptresourcefilecontents
 
-#-optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/*
--renamesourcefileattribute H
+-renamesourcefileattribute P
 -keepattributes SourceFile,LineNumberTable
 
--keep class android.support**
--keep class androidx**
+-assumenosideeffects class kotlin.jvm.internal.Intrinsics {
+    public static *** throwUninitializedProperty(...);
+    public static *** throwUninitializedPropertyAccessException(...);
+}
 
--keep public class * extends android.app.Activity
--keep public class * extends android.app.Application
--keep public class * extends android.app.Service
--keep public class * extends android.content.ContentProvider
--keep public class * extends android.app.backup.BackupAgentHelper
--keep public class * extends android.preference.Preference
+-keepclassmembers class * implements androidx.viewbinding.ViewBinding {
+    *** inflate(android.view.LayoutInflater);
+}

app/src/main/AndroidManifest.xml

@@ -4,6 +4,7 @@
     package="com.fankes.miui.notify">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 
     <application
         android:name=".application.MNNApplication"
@@ -13,7 +14,8 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.MIUINativeNotifyIcon"
-        tools:ignore="AllowBackup">
+        android:usesCleartextTraffic="true"
+        tools:ignore="AllowBackup,ExportedService">
 
         <meta-data
             android:name="xposedmodule"
@@ -24,11 +26,15 @@
         <meta-data
             android:name="xposedminversion"
             android:value="93" />
+        <meta-data
+            android:name="xposedscope"
+            android:resource="@array/module_scope" />
 
         <activity
-            android:name=".ui.MainActivity"
+            android:name=".ui.activity.MainActivity"
             android:exported="true"
             android:screenOrientation="behind">
+
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
@@ -42,7 +48,8 @@
             android:exported="true"
             android:label="@string/app_name"
             android:screenOrientation="behind"
-            android:targetActivity=".ui.MainActivity">
+            android:targetActivity=".ui.activity.MainActivity">
+
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
@@ -51,8 +58,26 @@
         </activity-alias>
 
         <activity
-            android:name=".ui.ConfigureActivity"
-            android:exported="false"
+            android:name=".ui.activity.ConfigureActivity"
+            android:exported="true"
             android:screenOrientation="behind" />
+
+        <activity
+            android:name=".ui.activity.auto.NotifyIconRuleUpdateActivity"
+            android:excludeFromRecents="true"
+            android:exported="true"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+
+        <service
+            android:name=".service.QuickStartTileService"
+            android:exported="true"
+            android:icon="@drawable/ic_notify_icon"
+            android:label="@string/tile_name"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
     </application>
 </manifest>

app/src/main/java/com/fankes/miui/notify/application/MNNApplication.kt

@@ -24,24 +24,13 @@
 
 package com.fankes.miui.notify.application
 
-import android.app.Application
 import androidx.appcompat.app.AppCompatDelegate
+import com.highcapable.yukihookapi.hook.xposed.application.ModuleApplication
 
-class MNNApplication : Application() {
-
-    companion object {
-
-        /** 全局静态实例 */
-        private var context: MNNApplication? = null
-
-        /** 调用全局静态实例 */
-        val appContext get() = context ?: error("App is death")
-    }
+class MNNApplication : ModuleApplication() {
 
     override fun onCreate() {
         super.onCreate()
-        /** 设置静态实例 */
-        context = this
         /** 跟随系统夜间模式 */
         AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
     }

app/src/main/java/com/fankes/miui/notify/data/DataConst.kt

@@ -0,0 +1,48 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/3/26.
+ */
+package com.fankes.miui.notify.data
+
+import com.fankes.miui.notify.hook.HookConst
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+
+object DataConst {
+
+    val ENABLE_MODULE = PrefsData("_enable_module", true)
+    val ENABLE_MODULE_LOG = PrefsData("_enable_module_log", false)
+    val ENABLE_HIDE_ICON = PrefsData("_hide_icon", false)
+    val ENABLE_COLOR_ICON_COMPAT = PrefsData("_color_icon_compat", false)
+    val ENABLE_NOTIFY_ICON_FIX = PrefsData("_notify_icon_fix", true)
+    val ENABLE_NOTIFY_ICON_FORCE_APP_ICON = PrefsData("_notify_icon_force_app_icon", false)
+    val ENABLE_NOTIFY_ICON_FIX_NOTIFY = PrefsData("_notify_icon_fix_notify", true)
+    val ENABLE_HOOK_STATUS_ICON_COUNT = PrefsData("_enable_hook_status_icon_count", true)
+    val ENABLE_NOTIFY_ICON_FIX_AUTO = PrefsData("_enable_notify_icon_fix_auto", true)
+    val NOTIFY_ICON_CORNER = PrefsData("_notify_icon_corner", 15)
+    val NOTIFY_ICON_DATAS = PrefsData("_notify_icon_datas", "")
+    val NOTIFY_ICON_FIX_AUTO_TIME = PrefsData("_notify_icon_fix_auto_time", "07:00")
+    val HOOK_STATUS_ICON_COUNT = PrefsData("_hook_status_icon_count", 5)
+
+    val IGNORED_ANDROID_VERSION_TO_LOW = PrefsData("_ignored_android_version_to_low", false)
+
+    val SOURCE_SYNC_WAY = PrefsData("_rule_source_sync_way", HookConst.TYPE_SOURCE_SYNC_WAY_1)
+    val SOURCE_SYNC_WAY_CUSTOM_URL = PrefsData("_rule_source_sync_way_custom_url", "")
+}

app/src/main/java/com/fankes/miui/notify/hook/HookConst.kt

@@ -20,25 +20,12 @@
  *
  * This file is Created by fankes on 2022/1/24.
  */
-@file:Suppress("DEPRECATION", "SetWorldReadable")
+@file:Suppress("SetWorldReadable")
 
 package com.fankes.miui.notify.hook
 
 object HookConst {
 
-    const val ENABLE_MODULE = "_enable_module"
-    const val ENABLE_MODULE_LOG = "_enable_module_log"
-    const val ENABLE_HIDE_ICON = "_hide_icon"
-    const val ENABLE_COLOR_ICON_HOOK = "_color_icon_hook"
-    const val ENABLE_COLOR_ICON_COMPAT = "_color_icon_compat"
-    const val ENABLE_NOTIFY_ICON_FIX = "_notify_icon_fix"
-    const val ENABLE_HOOK_STATUS_ICON_COUNT = "_enable_hook_status_icon_count"
-    const val NOTIFY_ICON_DATAS = "_notify_icon_datas"
-    const val HOOK_STATUS_ICON_COUNT = "_hook_status_icon_count"
-
-    const val SOURCE_SYNC_WAY = "_source_sync_way"
-    const val SOURCE_SYNC_WAY_CUSTOM_URL = "_source_sync_way_custom_url"
-
     const val TYPE_SOURCE_SYNC_WAY_1 = 1000
     const val TYPE_SOURCE_SYNC_WAY_2 = 2000
     const val TYPE_SOURCE_SYNC_WAY_3 = 3000

app/src/main/java/com/fankes/miui/notify/hook/HookEntry.kt

@@ -22,448 +22,21 @@
  */
 package com.fankes.miui.notify.hook
 
-import android.app.NotificationManager
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Color
-import android.graphics.Outline
-import android.graphics.drawable.Drawable
-import android.graphics.drawable.Icon
-import android.os.Build
-import android.service.notification.StatusBarNotification
-import android.view.View
-import android.view.ViewGroup
-import android.view.ViewOutlineProvider
-import android.widget.ImageView
-import androidx.core.graphics.drawable.toBitmap
-import com.fankes.miui.notify.bean.IconDataBean
-import com.fankes.miui.notify.hook.HookConst.ENABLE_COLOR_ICON_COMPAT
-import com.fankes.miui.notify.hook.HookConst.ENABLE_COLOR_ICON_HOOK
-import com.fankes.miui.notify.hook.HookConst.ENABLE_HOOK_STATUS_ICON_COUNT
-import com.fankes.miui.notify.hook.HookConst.ENABLE_MODULE
-import com.fankes.miui.notify.hook.HookConst.ENABLE_MODULE_LOG
-import com.fankes.miui.notify.hook.HookConst.ENABLE_NOTIFY_ICON_FIX
-import com.fankes.miui.notify.hook.HookConst.HOOK_STATUS_ICON_COUNT
+import com.fankes.miui.notify.data.DataConst
 import com.fankes.miui.notify.hook.HookConst.SYSTEMUI_PACKAGE_NAME
-import com.fankes.miui.notify.hook.factory.isAppNotifyHookAllOf
-import com.fankes.miui.notify.hook.factory.isAppNotifyHookOf
-import com.fankes.miui.notify.params.IconPackParams
-import com.fankes.miui.notify.utils.drawable.drawabletoolbox.DrawableBuilder
-import com.fankes.miui.notify.utils.factory.*
-import com.fankes.miui.notify.utils.tool.BitmapCompatTool
+import com.fankes.miui.notify.hook.entity.SystemUIHooker
+import com.fankes.miui.notify.utils.factory.isLowerAndroidP
+import com.fankes.miui.notify.utils.factory.isNotMIUI
+import com.fankes.miui.notify.utils.factory.isNotSupportMiuiVersion
+import com.fankes.miui.notify.utils.factory.miuiVersion
 import com.highcapable.yukihookapi.annotation.xposed.InjectYukiHookWithXposed
-import com.highcapable.yukihookapi.hook.bean.VariousClass
-import com.highcapable.yukihookapi.hook.factory.*
-import com.highcapable.yukihookapi.hook.log.loggerD
+import com.highcapable.yukihookapi.hook.factory.configs
+import com.highcapable.yukihookapi.hook.factory.encase
 import com.highcapable.yukihookapi.hook.log.loggerW
-import com.highcapable.yukihookapi.hook.param.PackageParam
-import com.highcapable.yukihookapi.hook.type.android.ContextClass
-import com.highcapable.yukihookapi.hook.type.android.DrawableClass
-import com.highcapable.yukihookapi.hook.type.android.ImageViewClass
-import com.highcapable.yukihookapi.hook.type.java.BooleanType
-import com.highcapable.yukihookapi.hook.type.java.IntType
-import com.highcapable.yukihookapi.hook.xposed.proxy.YukiHookXposedInitProxy
+import com.highcapable.yukihookapi.hook.xposed.proxy.IYukiHookXposedInit
 
-@InjectYukiHookWithXposed
-class HookEntry : YukiHookXposedInitProxy {
-
-    companion object {
-
-        /** MIUI 新版本存在的类 */
-        private const val SystemUIApplicationClass = "$SYSTEMUI_PACKAGE_NAME.SystemUIApplication"
-
-        /** MIUI 新版本存在的类 */
-        private const val NotificationHeaderViewWrapperInjectorClass =
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationHeaderViewWrapperInjector"
-
-        /** 原生存在的类 */
-        private const val ContrastColorUtilClass = "com.android.internal.util.ContrastColorUtil"
-
-        /** 原生存在的类 */
-        private const val StatusBarIconViewClass = "$SYSTEMUI_PACKAGE_NAME.statusbar.StatusBarIconView"
-
-        /** 原生存在的类 */
-        private const val NotificationIconContainerClass = "$SYSTEMUI_PACKAGE_NAME.statusbar.phone.NotificationIconContainer"
-
-        /** 根据多个版本存在不同的包名相同的类 */
-        private val ExpandableNotificationRowClass = VariousClass(
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.ExpandableNotificationRow",
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.ExpandableNotificationRow"
-        )
-
-        /** 根据多个版本存在不同的包名相同的类 */
-        private val NotificationViewWrapperClass = VariousClass(
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationViewWrapper",
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationViewWrapper"
-        )
-
-        /** 根据多个版本存在不同的包名相同的类 */
-        private val NotificationHeaderViewWrapperClass = VariousClass(
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationHeaderViewWrapper",
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationHeaderViewWrapper"
-        )
-
-        /** 根据多个版本存在不同的包名相同的类 */
-        private val NotificationUtilClass = VariousClass(
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationUtil",
-            "$SYSTEMUI_PACKAGE_NAME.miui.statusbar.notification.NotificationUtil"
-        )
-
-        /** 根据多个版本存在不同的包名相同的类 */
-        private val ExpandedNotificationClass = VariousClass(
-            "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.ExpandedNotification",
-            "$SYSTEMUI_PACKAGE_NAME.miui.statusbar.ExpandedNotification"
-        )
-    }
-
-    /** 缓存的通知优化图标数组 */
-    private var iconDatas = ArrayList<IconDataBean>()
-
-    /** 是否显示通知图标 - 跟随 Hook 保存 */
-    private var isShowNotificationIcons = true
-
-    /**
-     * - 这个是修复彩色图标的关键核心代码判断
-     *
-     * 判断是否为灰度图标 - 反射执行系统方法
-     * @param context 实例
-     * @param drawable 要判断的图标
-     * @return [Boolean]
-     */
-    private fun PackageParam.isGrayscaleIcon(context: Context, drawable: Drawable) =
-        if (!prefs.getBoolean(ENABLE_COLOR_ICON_COMPAT)) safeOfFalse {
-            ContrastColorUtilClass.clazz.let {
-                it.method {
-                    name = "isGrayscaleIcon"
-                    param(DrawableClass)
-                }.get(it.method {
-                    name = "getInstance"
-                    param(ContextClass)
-                }.get().invoke(context)).invoke<Boolean>(drawable) ?: false
-            }
-        } else BitmapCompatTool.isGrayscaleDrawable(drawable)
-
-    /**
-     * 是否为旧版本 MIUI 方案
-     *
-     * 拥有 “handleHeaderViews” 方法
-     * @return [Boolean]
-     */
-    private val PackageParam.hasHandleHeaderViews
-        get() = safeOfFalse {
-            NotificationHeaderViewWrapperClass.clazz.hasMethod(name = "handleHeaderViews")
-        }
-
-    /**
-     * 获取当前通知栏的样式
-     *
-     *  - ❗新版本可能不存在这个方法
-     * @return [Boolean]
-     */
-    private val PackageParam.isShowMiuiStyle
-        get() = safeOfFalse {
-            NotificationUtilClass.clazz.method { name = "showMiuiStyle" }.get().invoke() ?: false
-        }
-
-    /**
-     * 适配通知栏、状态栏图标
-     *
-     * 适配第三方图标包对系统包管理器更换图标后的彩色图标
-     *
-     * 自动识别 MIPUSH 图标
-     * @param context 实例
-     * @param iconDrawable 原始图标
-     * @return [Drawable] 适配的图标
-     */
-    private fun StatusBarNotification.compatNotifyIcon(context: Context, iconDrawable: Drawable) = safeOf(iconDrawable) {
-        /** 给 MIPUSH 设置 APP 自己的图标 */
-        if (isXmsf && opPkgName.isNotBlank())
-            findAppIcon(context)
-        else iconDrawable
-    }
-
-    /**
-     * 获取推送通知的应用名称
-     * @param context 实例
-     * @return [String]
-     */
-    private fun StatusBarNotification.findAppName(context: Context) = safeOf(default = "<unknown>") {
-        context.packageManager.getPackageInfo(opPkgName, 0).applicationInfo.loadLabel(context.packageManager)
-    }
-
-    /**
-     * 获取通知栏、状态栏 APP 图标
-     * @param context 实例
-     * @return [Drawable] 适配的图标
-     */
-    private fun StatusBarNotification.findAppIcon(context: Context) = safeOf(notification.smallIcon.loadDrawable(context)) {
-        context.packageManager.getPackageInfo(opPkgName, 0).applicationInfo.loadIcon(context.packageManager)
-    }
-
-    /**
-     * 打印日志
-     * @param tag 标识
-     * @param context 实例
-     * @param expandedNf 通知实例
-     * @param isCustom 是否为通知优化生效图标
-     * @param isGrayscale 是否为灰度图标
-     */
-    private fun PackageParam.printLogcat(
-        tag: String,
-        context: Context,
-        expandedNf: StatusBarNotification?,
-        isCustom: Boolean,
-        isGrayscale: Boolean
-    ) {
-        if (prefs.getBoolean(ENABLE_MODULE_LOG)) loggerD(
-            msg = "$tag --> [${expandedNf?.findAppName(context)}][${expandedNf?.opPkgName}] " +
-                    "custom [$isCustom] " +
-                    "grayscale [$isGrayscale] " +
-                    "xmsf [${expandedNf?.isXmsf}]"
-        )
-    }
-
-    /**
-     * 获取推送通知的包名
-     *
-     * 自动兼容旧版本系统
-     * @return [String]
-     */
-    private val StatusBarNotification.compatOpPkgName
-        get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) opPkg else packageName ?: ""
-
-    /**
-     * 判断通知是否来自 MIPUSH
-     * @return [Boolean]
-     */
-    private val StatusBarNotification.isXmsf get() = compatOpPkgName == "com.xiaomi.xmsf"
-
-    /**
-     * 获取推送通知的包名
-     *
-     * 自动判断 MIPUSH
-     * @return [String]
-     */
-    private val StatusBarNotification.opPkgName get() = if (isXmsf) xmsfPkgName else compatOpPkgName
-
-    /**
-     * 获取 MIPUSH 通知真实包名
-     * @return [String]
-     */
-    private val StatusBarNotification.xmsfPkgName: String
-        get() {
-            val xmsfPkg = notification.extras.getString("xmsf_target_package") ?: ""
-            val targetPkg = notification.extras.getString("target_package") ?: ""
-            return xmsfPkg.ifBlank { targetPkg.ifBlank { compatOpPkgName } }
-        }
-
-    /**
-     * 获取全局上下文
-     * @return [Context] or null
-     */
-    private val PackageParam.globalContext
-        get() = safeOfNull {
-            SystemUIApplicationClass.clazz.method { name = "getContext" }.ignoredError().get().invoke<Context>()
-        }
-
-    /**
-     * 自动适配状态栏、通知栏自定义小图标
-     * @param isGrayscaleIcon 是否为灰度图标
-     * @param packageName APP 包名
-     * @return [Pair] - ([Bitmap] 位图,[Int] 颜色)
-     */
-    private fun PackageParam.compatCustomIcon(isGrayscaleIcon: Boolean, packageName: String): Pair<Bitmap?, Int> {
-        var customPair: Pair<Bitmap?, Int>? = null
-        if (prefs.getBoolean(ENABLE_NOTIFY_ICON_FIX, default = true))
-            run {
-                if (iconDatas.isNotEmpty())
-                    iconDatas.forEach {
-                        if (packageName == it.packageName && isAppNotifyHookOf(it)) {
-                            if (!isGrayscaleIcon || isAppNotifyHookAllOf(it))
-                                customPair = Pair(it.iconBitmap, it.iconColor)
-                            return@run
-                        }
-                    }
-            }
-        return customPair ?: Pair(null, 0)
-    }
-
-    /**
-     * Hook 状态栏小图标
-     *
-     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
-     * @param context 实例
-     * @param expandedNf 通知实例
-     * @param iconDrawable 小图标 [Drawable]
-     * @param it 回调小图标 - ([Bitmap] 小图标)
-     */
-    private fun PackageParam.hookSmallIconOnSet(
-        context: Context,
-        expandedNf: StatusBarNotification?,
-        iconDrawable: Drawable?,
-        it: (Bitmap) -> Unit
-    ) = runSafe(msg = "GetSmallIconOnSet") {
-        if (iconDrawable == null) return@runSafe
-        /** 如果没开启修复 APP 的彩色图标 */
-        if (!prefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)) return@runSafe
-        /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-        expandedNf?.also { notifyInstance ->
-            /** 判断是 MIUI 样式就停止 Hook */
-            if (context.isMiuiNotifyStyle) {
-                it(notifyInstance.findAppIcon(context).toBitmap())
-                return@runSafe
-            }
-            /** 判断是否不是灰度图标 */
-            val isNotGrayscaleIcon = notifyInstance.isXmsf || !isGrayscaleIcon(context, iconDrawable)
-
-            /** 目标彩色通知 APP 图标 */
-            val customIcon = compatCustomIcon(!isNotGrayscaleIcon, notifyInstance.opPkgName).first
-            /** 打印日志 */
-            printLogcat(tag = "StatusIcon", context, notifyInstance, isCustom = customIcon != null, !isNotGrayscaleIcon)
-            when {
-                /** 处理自定义通知图标优化 */
-                customIcon != null -> it(customIcon)
-                /** 若不是灰度图标自动处理为圆角 */
-                isNotGrayscaleIcon -> it(notifyInstance.compatNotifyIcon(context, iconDrawable).toBitmap())
-            }
-        }
-    }
-
-    /**
-     * Hook 通知栏小图标
-     *
-     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
-     * @param context 实例
-     * @param expandedNf 通知实例
-     * @param iconImageView 通知图标实例
-     * @param isExpanded 通知是否展开 - 可做最小化通知处理
-     */
-    private fun PackageParam.hookNotifyIconOnSet(
-        context: Context,
-        expandedNf: StatusBarNotification?,
-        iconImageView: ImageView,
-        isExpanded: Boolean
-    ) = runSafe(msg = "AutoSetAppIconOnSet") {
-        /** 判断是 MIUI 样式就停止 Hook */
-        if (context.isMiuiNotifyStyle) return@runSafe
-        /** 如果没开启修复 APP 的彩色图标 */
-        if (!prefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)) return@runSafe
-        /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-        expandedNf?.let { notifyInstance ->
-
-            /** 新版风格反色 */
-            val newStyle = if (context.isSystemInDarkMode) 0xFF2D2D2D.toInt() else Color.WHITE
-
-            /** 旧版风格反色 */
-            val oldStyle = if (context.isNotSystemInDarkMode) 0xFF707070.toInt() else Color.WHITE
-
-            /** 通知图标原始颜色 */
-            val iconColor = notifyInstance.notification.color
-
-            /** 是否有通知栏图标颜色 */
-            val hasIconColor = iconColor != 0
-
-            /** 通知图标适配颜色 */
-            val supportColor = iconColor.let {
-                when {
-                    isUpperOfAndroidS -> newStyle
-                    it == 0 || !isExpanded -> oldStyle
-                    else -> it
-                }
-            }
-
-            /** 获取通知小图标 */
-            val iconDrawable = notifyInstance.notification.smallIcon.loadDrawable(context)
-
-            /** 判断图标风格 */
-            val isGrayscaleIcon = !notifyInstance.isXmsf && isGrayscaleIcon(context, iconDrawable)
-
-            /** 自定义默认小图标 */
-            var customIcon: Bitmap?
-
-            /** 自定义默认小图标颜色 */
-            var customIconColor: Int
-            compatCustomIcon(isGrayscaleIcon, notifyInstance.opPkgName).also {
-                customIcon = it.first
-                customIconColor = if (isUpperOfAndroidS || isExpanded) it.second else 0
-            }
-            /** 打印日志 */
-            printLogcat(tag = "NotifyIcon", context, notifyInstance, isCustom = customIcon != null, isGrayscaleIcon)
-            /** 处理自定义通知图标优化 */
-            if (customIcon != null)
-                iconImageView.apply {
-                    /** 设置自定义小图标 */
-                    setImageBitmap(customIcon)
-                    /** 上色 */
-                    setColorFilter(if (isUpperOfAndroidS || customIconColor == 0) supportColor else customIconColor)
-                    /** Android 12 设置图标外圈颜色 */
-                    if (isUpperOfAndroidS && customIconColor != 0)
-                        background = DrawableBuilder().rounded().solidColor(customIconColor).build()
-                }
-            else {
-                /** 重新设置图标 - 防止系统更改它 */
-                iconImageView.setImageDrawable(iconDrawable)
-                /** 判断如果是灰度图标就给他设置一个白色颜色遮罩 */
-                if (isGrayscaleIcon) iconImageView.apply {
-                    /** 设置图标着色 */
-                    setColorFilter(supportColor)
-                    /** Android 12 设置图标外圈颜色 */
-                    if (isUpperOfAndroidS && hasIconColor)
-                        background = DrawableBuilder().rounded().solidColor(iconColor).build()
-                } else iconImageView.apply {
-                    /** 重新设置图标 */
-                    setImageDrawable(notifyInstance.compatNotifyIcon(context, iconDrawable))
-                    /** 设置裁切到边界 */
-                    clipToOutline = true
-                    /** 设置一个圆角轮廓裁切 */
-                    outlineProvider = object : ViewOutlineProvider() {
-                        override fun getOutline(view: View, out: Outline) {
-                            out.setRoundRect(
-                                0, 0,
-                                view.width, view.height, 5.dp(context)
-                            )
-                        }
-                    }
-                    /** 清除原生的背景边距设置 */
-                    if (isUpperOfAndroidS) setPadding(0, 0, 0, 0)
-                    /** 清除原生的主题色背景圆圈颜色 */
-                    if (isUpperOfAndroidS) background = null
-                }
-            }
-        }
-    }
-
-    /**
-     * 判断状态栏小图标颜色以及反射的核心方法
-     *
-     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
-     * @param context 实例
-     * @param expandedNf 状态栏实例
-     * @return [Boolean] 是否忽略通知图标颜色
-     */
-    private fun PackageParam.hasIgnoreStatusBarIconColor(context: Context, expandedNf: StatusBarNotification?) =
-        if (!context.isMiuiNotifyStyle)
-            if (prefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)) safeOfFalse {
-                /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
-                expandedNf?.let { notifyInstance ->
-                    /** 获取通知小图标 */
-                    val iconDrawable = notifyInstance.notification.smallIcon.loadDrawable(context)
-
-                    /** 判断是否不是灰度图标 */
-                    val isNotGrayscaleIcon = notifyInstance.isXmsf || !isGrayscaleIcon(context, iconDrawable)
-
-                    /** 获取目标修复彩色图标的 APP */
-                    val isTargetFixApp = compatCustomIcon(!isNotGrayscaleIcon, notifyInstance.opPkgName).first != null
-                    /**
-                     * 只要不是灰度就返回彩色图标
-                     * 否则不对颜色进行反色处理防止一些系统图标出现异常
-                     */
-                    (if (isTargetFixApp) false else isNotGrayscaleIcon).also {
-                        printLogcat(tag = "IconColor", context, expandedNf, isTargetFixApp, !isNotGrayscaleIcon)
-                    }
-                } ?: true.also { printLogcat(tag = "IconColor", context, expandedNf = null, isCustom = false, isGrayscale = false) }
-            } else false.also { printLogcat(tag = "IconColor", context, expandedNf, isCustom = false, isGrayscale = true) }
-        else true.also { printLogcat(tag = "IconColor", context, expandedNf, isCustom = false, isGrayscale = false) }
+@InjectYukiHookWithXposed(isUsingResourcesHook = false)
+class HookEntry : IYukiHookXposedInit {
 
     override fun onInit() = configs {
         debugTag = "MIUINativeNotifyIcon"
@@ -480,183 +53,9 @@ class HookEntry : YukiHookXposedInitProxy {
                 /** 不是支持的 MIUI 系统停止 Hook */
                 isNotSupportMiuiVersion -> loggerW(msg = "Aborted Hook -> This MIUI Version $miuiVersion not supported")
                 /** Hook 被手动关闭停止 Hook */
-                !prefs.getBoolean(ENABLE_MODULE, default = true) -> loggerW(msg = "Aborted Hook -> Hook Closed")
+                prefs.get(DataConst.ENABLE_MODULE).not() -> loggerW(msg = "Aborted Hook -> Hook Closed")
                 /** 开始 Hook */
-                else -> {
-                    /** 缓存图标数据 */
-                    iconDatas = IconPackParams(param = this).iconDatas
-                    /** 执行 Hook */
-                    NotificationUtilClass.hook {
-                        /** 强制回写系统的状态栏图标样式为原生 */
-                        injectMember {
-                            method {
-                                name = "shouldSubstituteSmallIcon"
-                                param(ExpandedNotificationClass.clazz)
-                            }
-                            /**
-                             * 为了防止 MIUI 自身的版本不同造成的各种 BUG
-                             * 判断是 MIUI 样式就停止 Hook
-                             */
-                            replaceAny { globalContext?.isMiuiNotifyStyle ?: isShowMiuiStyle }
-                        }
-                        /** 强制回写系统的状态栏图标样式为原生 */
-                        injectMember {
-                            var isUseLegacy = false
-                            method {
-                                name = "getSmallIcon"
-                                param(ExpandedNotificationClass.clazz, IntType)
-                            }.remedys {
-                                method {
-                                    name = "getSmallIcon"
-                                    param(ExpandedNotificationClass.clazz)
-                                }
-                                method {
-                                    name = "getSmallIcon"
-                                    param(ContextClass, ExpandedNotificationClass.clazz)
-                                }.onFind { isUseLegacy = true }
-                            }
-                            afterHook {
-                                (globalContext ?: firstArgs as Context).also { context ->
-                                    hookSmallIconOnSet(
-                                        context = context,
-                                        args[if (isUseLegacy) 1 else 0] as? StatusBarNotification?,
-                                        (result as Icon).loadDrawable(context)
-                                    ) { icon -> result = Icon.createWithBitmap(icon) }
-                                }
-                            }
-                        }
-                    }
-                    StatusBarIconViewClass.hook {
-                        /** Hook 状态栏图标的颜色 */
-                        injectMember {
-                            method { name = "updateIconColor" }
-                            afterHook {
-                                instance<ImageView>().also {
-                                    if (hasIgnoreStatusBarIconColor(it.context, field { name = "mNotification" }
-                                            .of<StatusBarNotification>(instance))) it.apply {
-                                        alpha = 1f
-                                        colorFilter = null
-                                    }
-                                    /**
-                                     * 防止图标不是纯黑的问题
-                                     * 图标在任何场景下跟随状态栏其它图标保持半透明
-                                     */
-                                    else it.apply {
-                                        field { name = "mCurrentSetColor" }.of<Int>(instance)?.also { color ->
-                                            alpha = if (color.isWhite) 0.95f else 0.8f
-                                            setColorFilter(if (color.isWhite) color else Color.BLACK)
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    NotificationIconContainerClass.hook {
-                        injectMember {
-                            method { name = "calculateIconTranslations" }
-                            afterHook {
-                                /** 修复最新开发版状态栏图标只能显示一个的问题 */
-                                instance<ViewGroup>().layoutParams.width = 9999
-                            }
-                        }
-                        injectMember {
-                            method { name = "updateState" }
-                            beforeHook {
-                                /** 解除状态栏通知图标个数限制 */
-                                if (isShowNotificationIcons && prefs.getBoolean(ENABLE_HOOK_STATUS_ICON_COUNT, default = true))
-                                    field { name = "MAX_STATIC_ICONS" }
-                                        .get(instance).set(prefs.getInt(HOOK_STATUS_ICON_COUNT, default = 5)
-                                            .let { if (it in 0..100) it else 5 })
-                            }
-                        }
-                        /** 旧版方法 - 新版不存在 */
-                        injectMember {
-                            method {
-                                name = "setMaxStaticIcons"
-                                param(IntType)
-                                beforeHook { isShowNotificationIcons = firstArgs as Int > 0 }
-                            }
-                        }.ignoredNoSuchMemberFailure()
-                        /** 新版方法 - 旧版不存在 */
-                        injectMember {
-                            method {
-                                name = "miuiShowNotificationIcons"
-                                param(BooleanType)
-                            }
-                            beforeHook { isShowNotificationIcons = firstArgs as Boolean }
-                        }.ignoredNoSuchMemberFailure()
-                    }.by { safeOfFalse { NotificationIconContainerClass.clazz.hasField(name = "MAX_STATIC_ICONS") } }
-                    NotificationHeaderViewWrapperClass.hook {
-                        /** 修复下拉通知图标自动设置回 APP 图标的方法 */
-                        injectMember {
-                            if (hasHandleHeaderViews)
-                                method { name = "handleHeaderViews" }
-                            else method { name = "resolveHeaderViews" }
-                            afterHook {
-                                /** 获取小图标 */
-                                val iconImageView =
-                                    NotificationHeaderViewWrapperClass.clazz
-                                        .field { name = "mIcon" }.of<ImageView>(instance) ?: return@afterHook
-
-                                /** 通知是否展开 */
-                                var isExpanded = false
-
-                                /**
-                                 * 从父类中得到 mRow 变量 - [ExpandableNotificationRowClass]
-                                 * 获取其中的得到通知方法
-                                 */
-                                val expandedNf = ExpandableNotificationRowClass.clazz
-                                    .method { name = "getEntry" }
-                                    .get(NotificationViewWrapperClass.clazz.field {
-                                        name = "mRow"
-                                    }.get(instance).self?.also {
-                                        isExpanded = ExpandableNotificationRowClass.clazz.method {
-                                            name = "isExpanded"
-                                            returnType = BooleanType
-                                        }.get(it).invoke<Boolean>() == true
-                                    }).call()?.let {
-                                        it.javaClass.method {
-                                            name = "getSbn"
-                                        }.get(it).invoke<StatusBarNotification>()
-                                    } ?: ExpandableNotificationRowClass.clazz
-                                    .method { name = "getStatusBarNotification" }
-                                    .get(NotificationViewWrapperClass.clazz.field { name = "mRow" }.get(instance).self)
-                                    .invoke<StatusBarNotification>()
-
-                                /** 获取优先级 */
-                                val importance =
-                                    (iconImageView.context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager?)
-                                        ?.getNotificationChannel(expandedNf?.notification?.channelId)?.importance ?: 0
-                                /** 非最小化优先级的通知全部设置为展开状态 */
-                                if (importance != 1) isExpanded = true
-                                /** 执行 Hook */
-                                hookNotifyIconOnSet(iconImageView.context, expandedNf, iconImageView, isExpanded)
-                            }
-                        }
-                    }
-                    /** 干掉下拉通知图标自动设置回 APP 图标的方法 */
-                    NotificationHeaderViewWrapperInjectorClass.hook {
-                        injectMember {
-                            method {
-                                name = "setAppIcon"
-                                param(ContextClass, ImageViewClass, ExpandedNotificationClass.clazz)
-                            }.remedys {
-                                method {
-                                    name = "setAppIcon"
-                                    param(ImageViewClass, ExpandedNotificationClass.clazz)
-                                }
-                            }
-                            intercept()
-                        }.ignoredNoSuchMemberFailure()
-                        injectMember {
-                            method {
-                                name = "resetIconBgAndPaddings"
-                                param(ImageViewClass, ExpandedNotificationClass.clazz)
-                            }
-                            intercept()
-                        }.ignoredNoSuchMemberFailure()
-                    }.ignoredHookClassNotFoundFailure()
-                }
+                else -> loadHooker(SystemUIHooker)
             }
         }
     }

app/src/main/java/com/fankes/miui/notify/hook/entity/SystemUIHooker.kt

@@ -0,0 +1,903 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/3/25.
+ */
+@file:Suppress("StaticFieldLeak")
+
+package com.fankes.miui.notify.hook.entity
+
+import android.app.NotificationManager
+import android.app.WallpaperManager
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.Outline
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.Icon
+import android.os.Build
+import android.os.SystemClock
+import android.service.notification.StatusBarNotification
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewOutlineProvider
+import android.widget.ImageView
+import androidx.core.graphics.drawable.toBitmap
+import androidx.core.view.children
+import com.fankes.miui.notify.bean.IconDataBean
+import com.fankes.miui.notify.data.DataConst
+import com.fankes.miui.notify.hook.HookConst.SYSTEMUI_PACKAGE_NAME
+import com.fankes.miui.notify.hook.factory.isAppNotifyHookAllOf
+import com.fankes.miui.notify.hook.factory.isAppNotifyHookOf
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.utils.drawable.drawabletoolbox.DrawableBuilder
+import com.fankes.miui.notify.utils.factory.*
+import com.fankes.miui.notify.utils.tool.BitmapCompatTool
+import com.fankes.miui.notify.utils.tool.IconAdaptationTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.highcapable.yukihookapi.hook.bean.VariousClass
+import com.highcapable.yukihookapi.hook.entity.YukiBaseHooker
+import com.highcapable.yukihookapi.hook.factory.*
+import com.highcapable.yukihookapi.hook.log.loggerD
+import com.highcapable.yukihookapi.hook.log.loggerW
+import com.highcapable.yukihookapi.hook.type.android.*
+import com.highcapable.yukihookapi.hook.type.java.BooleanType
+import com.highcapable.yukihookapi.hook.type.java.IntType
+
+/**
+ * 系统界面核心 Hook 类
+ */
+object SystemUIHooker : YukiBaseHooker() {
+
+    /** MIUI 新版本存在的类 */
+    private const val SystemUIApplicationClass = "$SYSTEMUI_PACKAGE_NAME.SystemUIApplication"
+
+    /** MIUI 新版本存在的类 */
+    private const val NotificationHeaderViewWrapperInjectorClass =
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationHeaderViewWrapperInjector"
+
+    /** MIUI 新版本存在的类 */
+    private const val MiuiNotificationViewWrapperClass =
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.MiuiNotificationViewWrapper"
+
+    /** MIUI 新版本存在的类 */
+    private const val MiuiNotificationChildrenContainerClass =
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.stack.MiuiNotificationChildrenContainer"
+
+    /** 原生存在的类 */
+    private const val NotificationChildrenContainerClass =
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.stack.NotificationChildrenContainer"
+
+    /** 原生存在的类 */
+    private const val ContrastColorUtilClass = "com.android.internal.util.ContrastColorUtil"
+
+    /** 原生存在的类 */
+    private const val StatusBarIconViewClass = "$SYSTEMUI_PACKAGE_NAME.statusbar.StatusBarIconView"
+
+    /** 原生存在的类 */
+    private const val NotificationIconContainerClass = "$SYSTEMUI_PACKAGE_NAME.statusbar.phone.NotificationIconContainer"
+
+    /** 原生存在的类 */
+    private const val PluginManagerImplClass = "$SYSTEMUI_PACKAGE_NAME.shared.plugins.PluginManagerImpl"
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val MiuiClockClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.views.MiuiClock",
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.policy.MiuiClock"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val StatusBarNotificationPresenterClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.phone.StatusBarNotificationPresenter",
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.phone.StatusBar"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val ExpandableNotificationRowClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.ExpandableNotificationRow",
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.ExpandableNotificationRow"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val NotificationViewWrapperClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationViewWrapper",
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationViewWrapper"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val NotificationHeaderViewWrapperClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.row.wrapper.NotificationHeaderViewWrapper",
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationHeaderViewWrapper"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val NotificationUtilClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.NotificationUtil",
+        "$SYSTEMUI_PACKAGE_NAME.miui.statusbar.notification.NotificationUtil"
+    )
+
+    /** 根据多个版本存在不同的包名相同的类 */
+    private val ExpandedNotificationClass = VariousClass(
+        "$SYSTEMUI_PACKAGE_NAME.statusbar.notification.ExpandedNotification",
+        "$SYSTEMUI_PACKAGE_NAME.miui.statusbar.ExpandedNotification"
+    )
+
+    /** 缓存的通知图标优化数组 */
+    private var iconDatas = ArrayList<IconDataBean>()
+
+    /** 是否显示通知图标 - 跟随 Hook 保存 */
+    private var isShowNotificationIcons = true
+
+    /** 是否已经使用过缓存刷新功能 */
+    private var isUsingCachingMethod = false
+
+    /** 状态栏通知图标容器 */
+    private var notificationIconContainer: ViewGroup? = null
+
+    /** 通知栏通知控制器 */
+    private var notificationPresenter: Any? = null
+
+    /** 仅监听一次主题壁纸颜色变化 */
+    private var isWallpaperColorListenerSetUp = false
+
+    /**
+     * 是否启用通知图标优化功能
+     * @param isHooking 是否判断启用通知功能 - 默认：是
+     * @return [Boolean]
+     */
+    private fun isEnableHookColorNotifyIcon(isHooking: Boolean = true) =
+        prefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX) && (if (isHooking) prefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX_NOTIFY) else true)
+
+    /**
+     * - 这个是修复彩色图标的关键核心代码判断
+     *
+     * 判断是否为灰度图标 - 反射执行系统方法
+     * @param context 实例
+     * @param drawable 要判断的图标
+     * @return [Boolean]
+     */
+    private fun isGrayscaleIcon(context: Context, drawable: Drawable) =
+        if (prefs.get(DataConst.ENABLE_COLOR_ICON_COMPAT).not()) safeOfFalse {
+            ContrastColorUtilClass.clazz.let {
+                it.method {
+                    name = "isGrayscaleIcon"
+                    param(DrawableClass)
+                }.get(it.method {
+                    name = "getInstance"
+                    param(ContextClass)
+                }.get().invoke(context)).boolean(drawable)
+            }
+        } else BitmapCompatTool.isGrayscaleDrawable(drawable)
+
+    /**
+     * 是否为旧版本 MIUI 方案
+     *
+     * 拥有 “handleHeaderViews” 方法
+     * @return [Boolean]
+     */
+    private val hasHandleHeaderViews
+        get() = safeOfFalse { NotificationHeaderViewWrapperClass.clazz.hasMethod { name = "handleHeaderViews" } }
+
+    /**
+     * 获取是否存在忽略图标色彩处理的方法
+     * @return [Boolean]
+     */
+    private val hasIgnoreStatusBarIconColor
+        get() = safeOfFalse {
+            NotificationUtilClass.clazz.hasMethod {
+                name = "ignoreStatusBarIconColor"
+                param(ExpandedNotificationClass)
+            }
+        }
+
+    /**
+     * 处理为圆角图标
+     * @return [Drawable]
+     */
+    private fun Drawable.rounded(context: Context) =
+        safeOf(default = this) { BitmapDrawable(context.resources, toBitmap().round(10.dpFloat(context))) }
+
+    /**
+     * 适配通知栏、状态栏来自系统推送的彩色 APP 图标
+     *
+     * 适配第三方图标包对系统包管理器更换图标后的彩色图标
+     * @param context 实例
+     * @param iconDrawable 原始图标
+     * @return [Drawable] 适配的图标
+     */
+    private fun StatusBarNotification.compatPushingIcon(context: Context, iconDrawable: Drawable) = safeOf(iconDrawable) {
+        /** 给 MIPUSH 设置 APP 自己的图标 */
+        if (isXmsf && nfPkgName.isNotBlank())
+            context.findAppIcon(xmsfPkgName) ?: iconDrawable
+        else iconDrawable
+    }
+
+    /**
+     * 打印日志
+     * @param tag 标识
+     * @param context 实例
+     * @param expandedNf 通知实例
+     * @param isCustom 是否为通知优化生效图标
+     * @param isGrayscale 是否为灰度图标
+     */
+    private fun printLogcat(
+        tag: String,
+        context: Context,
+        expandedNf: StatusBarNotification?,
+        isCustom: Boolean,
+        isGrayscale: Boolean
+    ) {
+        if (prefs.get(DataConst.ENABLE_MODULE_LOG)) loggerD(
+            msg = "$tag --> [${context.findAppName(name = expandedNf?.nfPkgName ?: "")}][${expandedNf?.nfPkgName}] " +
+                    "custom [$isCustom] " +
+                    "grayscale [$isGrayscale] " +
+                    "xmsf [${expandedNf?.isXmsf}]"
+        )
+    }
+
+    /**
+     * 获取推送通知的包名
+     *
+     * 自动兼容旧版本系统
+     * @return [String]
+     */
+    private val StatusBarNotification.compatOpPkgName
+        get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) opPkg else packageName ?: ""
+
+    /**
+     * 判断通知是否来自 MIPUSH
+     * @return [Boolean]
+     */
+    private val StatusBarNotification.isXmsf get() = compatOpPkgName == "com.xiaomi.xmsf"
+
+    /**
+     * 获取推送通知的包名
+     *
+     * 自动判断 MIPUSH
+     * @return [String]
+     */
+    private val StatusBarNotification.nfPkgName get() = if (isXmsf) xmsfPkgName else packageName
+
+    /**
+     * 获取 MIPUSH 通知真实包名
+     * @return [String]
+     */
+    private val StatusBarNotification.xmsfPkgName: String
+        get() {
+            val xmsfPkg = notification.extras.getString("xmsf_target_package") ?: ""
+            val targetPkg = notification.extras.getString("target_package") ?: ""
+            return xmsfPkg.ifBlank { targetPkg.ifBlank { packageName } }
+        }
+
+    /**
+     * 获取全局上下文
+     * @return [Context] or null
+     */
+    private val globalContext
+        get() = safeOfNull {
+            SystemUIApplicationClass.clazz.method { name = "getContext" }.ignoredError().get().invoke<Context?>() ?: appContext
+        }
+
+    /**
+     * 注册主题壁纸改变颜色监听
+     *
+     *  - 仅限在 Android 12 以下注册
+     * @param view 实例
+     */
+    private fun registerWallpaperColorChanged(view: View) = runInSafe {
+        if (isWallpaperColorListenerSetUp.not() && isUpperOfAndroidS.not()) view.apply {
+            WallpaperManager.getInstance(context).addOnColorsChangedListener({ _, _ -> refreshNotificationIcons() }, handler)
+        }
+        isWallpaperColorListenerSetUp = true
+    }
+
+    /** 刷新状态栏小图标 */
+    private fun refreshStatusBarIcons() = runInSafe {
+        StatusBarIconViewClass.clazz.field { name = "mNotification" }.also { result ->
+            notificationIconContainer?.children?.forEach {
+                /** 得到通知实例 */
+                val nf = result.get(it).cast<StatusBarNotification>() ?: return
+                /** 刷新状态栏图标 */
+                compatStatusIcon(it.context, nf, nf.notification.smallIcon.loadDrawable(it.context)).also { pair ->
+                    pair.first.let { e -> (it as? ImageView?)?.setImageDrawable(e) }
+                }
+            }
+        }
+    }
+
+    /** 刷新通知小图标 */
+    private fun refreshNotificationIcons() = runInSafe {
+        notificationPresenter?.current {
+            method {
+                name = "updateNotificationsOnDensityOrFontScaleChanged"
+                emptyParam()
+            }.call()
+        }
+    }
+
+    /**
+     * 自动适配状态栏、通知栏自定义小图标
+     * @param isGrayscaleIcon 是否为灰度图标
+     * @param packageName APP 包名
+     * @return [Pair] - ([Bitmap] 位图,[Int] 颜色)
+     */
+    private fun compatCustomIcon(isGrayscaleIcon: Boolean, packageName: String): Pair<Bitmap?, Int> {
+        var customPair: Pair<Bitmap?, Int>? = null
+        if (prefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)) run {
+            iconDatas.takeIf { it.isNotEmpty() }?.forEach {
+                if (packageName == it.packageName && isAppNotifyHookOf(it)) {
+                    if (isGrayscaleIcon.not() || isAppNotifyHookAllOf(it))
+                        customPair = Pair(it.iconBitmap, it.iconColor)
+                    return@run
+                }
+            }
+        }
+        return customPair ?: Pair(null, 0)
+    }
+
+    /**
+     * Hook 状态栏小图标
+     *
+     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
+     * @param context 实例
+     * @param expandedNf 通知实例
+     * @param iconDrawable 小图标 [Drawable]
+     * @return [Pair] 回调小图标 - ([Drawable] 小图标,[Boolean] 是否替换)
+     */
+    private fun compatStatusIcon(context: Context, expandedNf: StatusBarNotification?, iconDrawable: Drawable?) =
+        expandedNf?.let { notifyInstance ->
+            if (iconDrawable == null) return@let Pair(null, false)
+            /** 判断是否不是灰度图标 */
+            val isNotGrayscaleIcon = notifyInstance.isXmsf || isGrayscaleIcon(context, iconDrawable).not()
+
+            /** 目标彩色通知 APP 图标 */
+            val customIcon = compatCustomIcon(isNotGrayscaleIcon.not(), notifyInstance.nfPkgName).first
+            /** 打印日志 */
+            printLogcat(tag = "StatusIcon", context, notifyInstance, isCustom = customIcon != null, isNotGrayscaleIcon.not())
+            when {
+                /** 处理自定义通知图标优化 */
+                customIcon != null -> Pair(BitmapDrawable(context.resources, customIcon), true)
+                /** 若不是灰度图标自动处理为圆角 */
+                isNotGrayscaleIcon -> Pair(notifyInstance.compatPushingIcon(context, iconDrawable).rounded(context), true)
+                /** 否则返回原始小图标 */
+                else -> Pair(notifyInstance.notification.smallIcon.loadDrawable(context), false)
+            }
+        } ?: Pair(null, false)
+
+    /**
+     * Hook 通知栏小图标
+     *
+     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
+     * @param context 实例
+     * @param expandedNf 通知实例
+     * @param iconImageView 通知图标实例
+     * @param isExpanded 通知是否展开 - 可做最小化通知处理 - 默认：是
+     * @param isUseAndroid12Style 是否使用 Android 12 通知图标风格 - 默认跟随系统版本决定
+     */
+    private fun compatNotifyIcon(
+        context: Context,
+        expandedNf: StatusBarNotification?,
+        iconImageView: ImageView,
+        isExpanded: Boolean = true,
+        isUseAndroid12Style: Boolean = isUpperOfAndroidS,
+    ) = runInSafe(msg = "compatNotifyIcon") {
+        /**
+         * 设置默认通知图标
+         * @param drawable 通知图标
+         */
+        fun setDefaultNotifyIcon(drawable: Drawable?) {
+            iconImageView.apply {
+                /** 重新设置图标 */
+                setImageDrawable(drawable)
+                /** 设置裁切到边界 */
+                clipToOutline = true
+                /** 设置一个圆角轮廓裁切 */
+                outlineProvider = object : ViewOutlineProvider() {
+                    override fun getOutline(view: View, out: Outline) {
+                        out.setRoundRect(
+                            0, 0,
+                            view.width, view.height, 5.dpFloat(context)
+                        )
+                    }
+                }
+                if (isUseAndroid12Style) {
+                    /** 清除原生的背景边距 */
+                    setPadding(0, 0, 0, 0)
+                    /** 清除原生的主题色背景圆圈颜色 */
+                    background = null
+                }
+                /** 清除遮罩颜色 */
+                colorFilter = null
+            }
+        }
+        /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
+        expandedNf?.let { notifyInstance ->
+
+            /** 新版风格反色 */
+            val newStyle = if (context.isSystemInDarkMode) 0xFF2D2D2D.toInt() else Color.WHITE
+
+            /** 旧版风格反色 */
+            val oldStyle = if (context.isNotSystemInDarkMode) 0xFF707070.toInt() else Color.WHITE
+
+            /** 通知图标边框圆角大小 */
+            val iconCorner = prefs.get(DataConst.NOTIFY_ICON_CORNER)
+
+            /** 通知图标原始颜色 */
+            val iconColor = notifyInstance.notification.color
+
+            /** 是否有通知栏图标颜色 */
+            val hasIconColor = iconColor != 0
+
+            /** 通知图标适配颜色 */
+            val supportColor = iconColor.let {
+                when {
+                    isUseAndroid12Style -> newStyle
+                    it == 0 || isExpanded.not() -> oldStyle
+                    else -> it
+                }
+            }
+
+            /** 获取通知小图标 */
+            val iconDrawable = notifyInstance.notification.smallIcon.loadDrawable(context)
+
+            /** 判断图标风格 */
+            val isGrayscaleIcon = notifyInstance.isXmsf.not() && isGrayscaleIcon(context, iconDrawable)
+
+            /** 自定义默认小图标 */
+            var customIcon: Bitmap?
+
+            /** 自定义默认小图标颜色 */
+            var customIconColor: Int
+            compatCustomIcon(isGrayscaleIcon, notifyInstance.nfPkgName).also {
+                customIcon = it.first
+                customIconColor = if (isUseAndroid12Style || isExpanded)
+                    (it.second.takeIf { e -> e != 0 } ?: (if (isUseAndroid12Style) context.systemAccentColor else 0)) else 0
+            }
+            /** 打印日志 */
+            printLogcat(tag = "NotifyIcon", context, notifyInstance, isCustom = customIcon != null, isGrayscaleIcon)
+            /** 处理自定义通知图标优化 */
+            when {
+                prefs.get(DataConst.ENABLE_NOTIFY_ICON_FORCE_APP_ICON) && isEnableHookColorNotifyIcon(isHooking = false) ->
+                    setDefaultNotifyIcon(context.findAppIcon(notifyInstance.nfPkgName))
+                customIcon != null -> iconImageView.apply {
+                    /** 设置不要裁切到边界 */
+                    clipToOutline = false
+                    /** 设置自定义小图标 */
+                    setImageBitmap(customIcon)
+                    /** 上色 */
+                    setColorFilter(if (isUseAndroid12Style || customIconColor == 0) supportColor else customIconColor)
+                    /** Android 12 设置图标外圈颜色 */
+                    if (isUseAndroid12Style && customIconColor != 0)
+                        background = DrawableBuilder()
+                            .rectangle()
+                            .cornerRadius(iconCorner.dp(context))
+                            .solidColor(if (context.isSystemInDarkMode) customIconColor.brighter else customIconColor)
+                            .build()
+                    /** 设置原生的背景边距 */
+                    if (isUseAndroid12Style) setPadding(4.dp(context), 4.dp(context), 4.dp(context), 4.dp(context))
+                }
+                else -> {
+                    /** 重新设置图标 - 防止系统更改它 */
+                    iconImageView.setImageDrawable(iconDrawable)
+                    /** 判断如果是灰度图标就给他设置一个白色颜色遮罩 */
+                    if (isGrayscaleIcon) iconImageView.apply {
+                        /** 设置不要裁切到边界 */
+                        clipToOutline = false
+                        /** 设置图标着色 */
+                        setColorFilter(supportColor)
+                        /** Android 12 设置图标外圈颜色 */
+                        (if (hasIconColor) iconColor else context.systemAccentColor).also {
+                            if (isUseAndroid12Style)
+                                background = DrawableBuilder()
+                                    .rectangle()
+                                    .cornerRadius(iconCorner.dp(context))
+                                    .solidColor(if (context.isSystemInDarkMode) it.brighter else it)
+                                    .build()
+                        }
+                        /** 设置原生的背景边距 */
+                        if (isUseAndroid12Style) setPadding(4.dp(context), 4.dp(context), 4.dp(context), 4.dp(context))
+                    } else setDefaultNotifyIcon(notifyInstance.compatPushingIcon(context, iconDrawable))
+                }
+            }
+        }
+    }
+
+    /**
+     * 判断状态栏小图标颜色以及反射的核心方法
+     *
+     * 区分系统版本 - 由于每个系统版本的方法不一样这里单独拿出来进行 Hook
+     * @param context 实例
+     * @param expandedNf 状态栏实例
+     * @return [Boolean] 是否忽略通知图标颜色
+     */
+    private fun hasIgnoreStatusBarIconColor(context: Context, expandedNf: StatusBarNotification?) = safeOfFalse {
+        /** 获取通知对象 - 由于 MIUI 的版本迭代不规范性可能是空的 */
+        expandedNf?.let { notifyInstance ->
+            /** 获取通知小图标 */
+            val iconDrawable = notifyInstance.notification.smallIcon.loadDrawable(context)
+
+            /** 判断是否不是灰度图标 */
+            val isNotGrayscaleIcon = notifyInstance.isXmsf || isGrayscaleIcon(context, iconDrawable).not()
+
+            /** 获取目标修复彩色图标的 APP */
+            val isTargetFixApp = compatCustomIcon(isNotGrayscaleIcon.not(), notifyInstance.nfPkgName).first != null
+            /**
+             * 只要不是灰度就返回彩色图标
+             * 否则不对颜色进行反色处理防止一些系统图标出现异常
+             */
+            (if (isTargetFixApp) false else isNotGrayscaleIcon).also {
+                printLogcat(tag = "IconColor", context, expandedNf, isTargetFixApp, isNotGrayscaleIcon.not())
+            }
+        } ?: true.also { printLogcat(tag = "IconColor", context, expandedNf = null, isCustom = false, isGrayscale = false) }
+    }
+
+    /**
+     * 从 [NotificationViewWrapperClass] 中获取 [ExpandableNotificationRowClass]
+     * @return [Pair] - ([Boolean] 通知是否展开,[Any] 通知 Row 实例)
+     */
+    private fun Any.getRowPair(): Pair<Boolean, Any?> {
+        /** 通知是否展开 */
+        var isExpanded = false
+
+        /**
+         * 从父类中得到 mRow 变量 - [ExpandableNotificationRowClass]
+         * 获取其中的得到通知方法
+         */
+        val row = NotificationViewWrapperClass.clazz.field {
+            name = "mRow"
+        }.get(this).self?.also {
+            isExpanded = ExpandableNotificationRowClass.clazz.method {
+                name = "isExpanded"
+                returnType = BooleanType
+            }.get(it).boolean()
+        }
+        return Pair(isExpanded, row)
+    }
+
+    /**
+     * 从 [ExpandableNotificationRowClass] 中获取 [StatusBarNotification]
+     * @return [StatusBarNotification] or null
+     */
+    private fun Any?.getSbn() =
+        ExpandableNotificationRowClass.clazz
+            .method { name = "getEntry" }
+            .get(this).call()?.let {
+                it.javaClass.method {
+                    name = "getSbn"
+                }.get(it).invoke<StatusBarNotification>()
+            } ?: ExpandableNotificationRowClass.clazz
+            .method { name = "getStatusBarNotification" }
+            .get(NotificationViewWrapperClass.clazz.field { name = "mRow" }.get(this).self)
+            .invoke<StatusBarNotification>()
+
+    /** 注册 */
+    private fun register() {
+        /** 解锁后重新刷新状态栏图标防止系统重新设置它 */
+        onAppLifecycle { registerReceiver(Intent.ACTION_USER_PRESENT) { _, _ -> if (isUsingCachingMethod) refreshStatusBarIcons() } }
+        /** 刷新图标缓存 */
+        SystemUITool.Host.onRefreshSystemUI(param = this) { recachingPrefs(it) }
+    }
+
+    /** 缓存图标数据 */
+    private fun cachingIconDatas() {
+        iconDatas.clear()
+        IconPackParams(param = this).iconDatas.apply {
+            when {
+                isNotEmpty() -> forEach { iconDatas.add(it) }
+                isEmpty() && isEnableHookColorNotifyIcon(isHooking = false) -> loggerW(msg = "NotifyIconSupportData is empty!")
+            }
+        }
+    }
+
+    /**
+     * 刷新缓存数据
+     * @param isRefreshCacheOnly 仅刷新缓存不刷新图标和通知改变 - 默认：否
+     * @return [Boolean] 是否成功
+     */
+    private fun recachingPrefs(isRefreshCacheOnly: Boolean = false): Boolean {
+        /** 必要的延迟防止 Sp 存储不刷新 */
+        SystemClock.sleep(100)
+        /** 获取可读写状态 */
+        return prefs.isXSharePrefsReadable.also {
+            isUsingCachingMethod = true
+            prefs.clearCache()
+            cachingIconDatas()
+            if (isRefreshCacheOnly) return@also
+            refreshStatusBarIcons()
+            refreshNotificationIcons()
+        }
+    }
+
+    override fun onHook() {
+        /** 注册 */
+        register()
+        /** 缓存图标数据 */
+        cachingIconDatas()
+        /** 注入 MIUI 自己增加的一个工具类 */
+        NotificationUtilClass.hook {
+            /** 强制回写系统的状态栏图标样式为原生 */
+            injectMember {
+                method {
+                    name = "shouldSubstituteSmallIcon"
+                    param(ExpandedNotificationClass)
+                }
+                replaceToFalse()
+            }
+            /** 强制回写系统的状态栏图标样式为原生 */
+            injectMember {
+                var isUseLegacy = false
+                method {
+                    name = "getSmallIcon"
+                    param(ExpandedNotificationClass, IntType)
+                }.remedys {
+                    method {
+                        name = "getSmallIcon"
+                        param(ExpandedNotificationClass)
+                    }
+                    method {
+                        name = "getSmallIcon"
+                        param(ContextClass, ExpandedNotificationClass)
+                    }.onFind { isUseLegacy = true }
+                }
+                afterHook {
+                    (globalContext ?: args().first().cast())?.also { context ->
+                        val expandedNf = args(if (isUseLegacy) 1 else 0).cast<StatusBarNotification?>()
+                        /** Hook 状态栏小图标 */
+                        compatStatusIcon(
+                            context = context,
+                            expandedNf,
+                            result<Icon>()?.loadDrawable(context)
+                        ).also { pair -> if (pair.second) result = Icon.createWithBitmap(pair.first?.toBitmap()) }
+                    }
+                }
+            }
+        }
+        /** 注入状态栏通知图标实例 */
+        StatusBarIconViewClass.hook {
+            /** Hook 状态栏通知图标的颜色 */
+            injectMember {
+                method { name = "updateIconColor" }
+                afterHook {
+                    instance<ImageView>().also {
+                        if (hasIgnoreStatusBarIconColor(it.context, field { name = "mNotification" }
+                                .get(instance).cast<StatusBarNotification>())) it.apply {
+                            alpha = 1f
+                            colorFilter = null
+                        } else it.apply {
+                            /**
+                             * 防止图标不是纯黑的问题
+                             * 图标在任何场景下跟随状态栏其它图标保持半透明
+                             * MIUI 12 进行单独判断
+                             */
+                            field { name = "mCurrentSetColor" }.get(instance).int().also { color ->
+                                if (hasIgnoreStatusBarIconColor) {
+                                    alpha = if (color.isWhite) 0.95f else 0.8f
+                                    setColorFilter(if (color.isWhite) color else Color.BLACK)
+                                } else setColorFilter(color)
+                            }
+                        }
+                    }
+                }
+            }
+            /** 注册广播 */
+            injectMember {
+                method {
+                    name = "setNotification"
+                    param(StatusBarNotificationClass)
+                }.remedys {
+                    method {
+                        name = "setNotification"
+                        param(ExpandedNotificationClass)
+                    }
+                }
+                afterHook {
+                    /** 注册壁纸颜色监听 */
+                    if (args().first().any() != null) instance<ImageView>().also { registerWallpaperColorChanged(it) }
+                }
+            }
+        }
+        /** 注入通知控制器实例 */
+        StatusBarNotificationPresenterClass.hook {
+            injectMember {
+                allConstructors()
+                afterHook { notificationPresenter = instance }
+            }
+        }
+        /** 注入状态栏通知图标容器实例 */
+        NotificationIconContainerClass.hook {
+            injectMember {
+                method { name = "calculateIconTranslations" }
+                afterHook {
+                    /** 缓存实例 */
+                    notificationIconContainer = instance<ViewGroup>()
+                    /** 修复部分开发版状态栏图标只能显示一个的问题 */
+                    when (miuiIncrementalVersion.lowercase()) {
+                        "22.3.14", "22.3.15", "22.3.16", "v13.0.1.1.16.dev", "22.3.18" ->
+                            instance<ViewGroup>().layoutParams.width = 9999
+                    }
+                }
+            }
+            injectMember {
+                method { name = "updateState" }
+                beforeHook {
+                    /** 解除状态栏通知图标个数限制 */
+                    if (isShowNotificationIcons && prefs.get(DataConst.ENABLE_HOOK_STATUS_ICON_COUNT))
+                        field { name = "MAX_STATIC_ICONS" }
+                            .get(instance).set(prefs.get(DataConst.HOOK_STATUS_ICON_COUNT)
+                                .let { if (it in 0..100) it else 5 })
+                }
+            }.by { NotificationIconContainerClass.clazz.hasField { name = "MAX_STATIC_ICONS" } }
+            /** 旧版方法 - 新版不存在 */
+            injectMember {
+                method {
+                    name = "setMaxStaticIcons"
+                    param(IntType)
+                }
+                beforeHook { isShowNotificationIcons = args().first().int() > 0 }
+            }.ignoredNoSuchMemberFailure()
+            /** 新版方法 - 旧版不存在 */
+            injectMember {
+                method {
+                    name = "miuiShowNotificationIcons"
+                    param(BooleanType)
+                }
+                beforeHook { isShowNotificationIcons = args().first().boolean() }
+            }.ignoredNoSuchMemberFailure()
+        }
+        /** 注入原生通知包装纸实例 */
+        NotificationHeaderViewWrapperClass.hook {
+            /** 修复下拉通知图标自动设置回 APP 图标的方法 */
+            injectMember {
+                if (hasHandleHeaderViews)
+                    method { name = "handleHeaderViews" }
+                else method { name = "resolveHeaderViews" }
+                afterHook {
+                    /** 获取小图标 */
+                    val iconImageView =
+                        NotificationHeaderViewWrapperClass.clazz
+                            .field { name = "mIcon" }.get(instance).cast<ImageView>() ?: return@afterHook
+
+                    /** 获取 [ExpandableNotificationRowClass] */
+                    val rowPair = instance.getRowPair()
+
+                    /** 获取 [StatusBarNotification] */
+                    val expandedNf = rowPair.second.getSbn()
+
+                    /** 通知是否展开 */
+                    var isExpanded = rowPair.first
+
+                    /** 获取优先级 */
+                    val importance =
+                        (iconImageView.context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager?)
+                            ?.getNotificationChannel(expandedNf?.notification?.channelId)?.importance ?: 0
+                    /** 非最小化优先级的通知全部设置为展开状态 */
+                    if (importance != 1) isExpanded = true
+                    /** 执行 Hook */
+                    compatNotifyIcon(iconImageView.context, expandedNf, iconImageView, isExpanded)
+                }
+            }
+        }
+        /** 修改 MIUI 风格通知栏的通知图标 */
+        MiuiNotificationViewWrapperClass.hook {
+            /** 替换通知小图标 */
+            injectMember {
+                method { name = "handleAppIcon" }
+                replaceUnit {
+                    field { name = "mAppIcon" }.get(instance).cast<ImageView>()?.apply {
+                        compatNotifyIcon(
+                            context = context,
+                            expandedNf = instance.getRowPair().second.getSbn(),
+                            iconImageView = this,
+                            isUseAndroid12Style = true
+                        )
+                    }
+                }
+            }
+        }.ignoredHookClassNotFoundFailure()
+        /** 修改 MIUI 风格通知栏的通知图标 - 折叠通知 */
+        MiuiNotificationChildrenContainerClass.hook {
+            /** 替换通知小图标 */
+            injectMember {
+                method {
+                    name = "updateAppIcon"
+                    param(BooleanType)
+                }
+                afterHook {
+                    val expandedNf = NotificationChildrenContainerClass.clazz.field {
+                        name = "mContainingNotification"
+                    }.get(instance).self.getSbn()
+                    field { name = "mAppIcon" }.get(instance).cast<ImageView>()?.apply {
+                        compatNotifyIcon(context, expandedNf, iconImageView = this, isUseAndroid12Style = true)
+                    }
+                }
+            }
+        }.ignoredHookClassNotFoundFailure()
+        /** 干掉下拉通知图标自动设置回 APP 图标的方法 */
+        NotificationHeaderViewWrapperInjectorClass.hook {
+            injectMember {
+                method {
+                    name = "setAppIcon"
+                    param(ContextClass, ImageViewClass, ExpandedNotificationClass)
+                }.remedys {
+                    method {
+                        name = "setAppIcon"
+                        param(ImageViewClass, ExpandedNotificationClass)
+                    }
+                }
+                intercept()
+            }.ignoredNoSuchMemberFailure()
+            injectMember {
+                method {
+                    name = "resetIconBgAndPaddings"
+                    param(ImageViewClass, ExpandedNotificationClass)
+                }
+                intercept()
+            }.ignoredNoSuchMemberFailure()
+        }.ignoredHookClassNotFoundFailure()
+        /** 发送适配新的 APP 图标通知 */
+        PluginManagerImplClass.hook {
+            injectMember {
+                method {
+                    name = "onReceive"
+                    param(ContextClass, IntentClass)
+                }
+                afterHook {
+                    if (isEnableHookColorNotifyIcon()) args().last().cast<Intent>()?.also {
+                        if (it.action.equals(Intent.ACTION_PACKAGE_REPLACED).not() &&
+                            it.getBooleanExtra(Intent.EXTRA_REPLACING, false)
+                        ) return@also
+                        when (it.action) {
+                            Intent.ACTION_PACKAGE_ADDED ->
+                                it.data?.schemeSpecificPart?.also { newPkgName ->
+                                    if (iconDatas.takeIf { e -> e.isNotEmpty() }
+                                            ?.filter { e -> e.packageName == newPkgName }
+                                            .isNullOrEmpty()
+                                    ) IconAdaptationTool.pushNewAppSupportNotify(args().first().cast()!!, newPkgName)
+                                }
+                            Intent.ACTION_PACKAGE_REMOVED ->
+                                IconAdaptationTool.removeNewAppSupportNotify(
+                                    context = args().first().cast()!!,
+                                    packageName = it.data?.schemeSpecificPart ?: ""
+                                )
+                        }
+                    }
+                }
+            }
+        }
+        /** 自动检查通知图标优化更新的注入监听 */
+        MiuiClockClass.hook {
+            injectMember {
+                method { name = "updateTime" }
+                afterHook {
+                    instance<View>().context.also {
+                        /** 注册定时监听 */
+                        if (isEnableHookColorNotifyIcon() && prefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX_AUTO))
+                            IconAdaptationTool.prepareAutoUpdateIconRule(
+                                context = it,
+                                timeSet = prefs.get(DataConst.NOTIFY_ICON_FIX_AUTO_TIME)
+                            )
+                    }
+                }
+            }
+        }.ignoredHookClassNotFoundFailure()
+    }
+}

app/src/main/java/com/fankes/miui/notify/hook/factory/DataFactory.kt

@@ -31,40 +31,36 @@ import com.highcapable.yukihookapi.hook.param.PackageParam
  * 获取此 APP 的通知图标是否被 Hook
  * @param bean 图标 bean
  */
-fun PackageParam.isAppNotifyHookOf(bean: IconDataBean) = prefs.getBoolean(key = bean.toEnabledName(), default = bean.isEnabled)
+fun PackageParam.isAppNotifyHookOf(bean: IconDataBean) = prefs.getBoolean(bean.toEnabledName(), bean.isEnabled)
 
 /**
  * 获取此 APP 的通知图标是否被 Hook
  * @param bean 图标 bean
  */
-fun Context.isAppNotifyHookOf(bean: IconDataBean) = modulePrefs.getBoolean(key = bean.toEnabledName(), default = bean.isEnabled)
+fun Context.isAppNotifyHookOf(bean: IconDataBean) = modulePrefs.getBoolean(bean.toEnabledName(), bean.isEnabled)
 
 /**
  * 设置 Hook 此 APP 的通知图标
  * @param bean 图标 bean
  * @param isHook 是否 Hook
  */
-fun Context.putAppNotifyHookOf(bean: IconDataBean, isHook: Boolean) =
-    modulePrefs.putBoolean(key = bean.toEnabledName(), value = isHook)
+fun Context.putAppNotifyHookOf(bean: IconDataBean, isHook: Boolean) = modulePrefs.putBoolean(bean.toEnabledName(), isHook)
 
 /**
  * 获取此 APP 的通知图标是否被全部 Hook
  * @param bean 图标 bean
  */
-fun PackageParam.isAppNotifyHookAllOf(bean: IconDataBean) =
-    prefs.getBoolean(key = bean.toEnabledAllName(), default = bean.isEnabledAll)
+fun PackageParam.isAppNotifyHookAllOf(bean: IconDataBean) = prefs.getBoolean(bean.toEnabledAllName(), bean.isEnabledAll)
 
 /**
  * 获取此 APP 的通知图标是否被全部 Hook
  * @param bean 图标 bean
  */
-fun Context.isAppNotifyHookAllOf(bean: IconDataBean) =
-    modulePrefs.getBoolean(key = bean.toEnabledAllName(), default = bean.isEnabledAll)
+fun Context.isAppNotifyHookAllOf(bean: IconDataBean) = modulePrefs.getBoolean(bean.toEnabledAllName(), bean.isEnabledAll)
 
 /**
  * 设置全部 Hook 此 APP 的通知图标
  * @param bean 图标 bean
  * @param isHook 是否 Hook
  */
-fun Context.putAppNotifyHookAllOf(bean: IconDataBean, isHook: Boolean) =
-    modulePrefs.putBoolean(key = bean.toEnabledAllName(), value = isHook)
+fun Context.putAppNotifyHookAllOf(bean: IconDataBean, isHook: Boolean) = modulePrefs.putBoolean(bean.toEnabledAllName(), isHook)

app/src/main/java/com/fankes/miui/notify/params/IconPackParams.kt

@@ -27,7 +27,7 @@ package com.fankes.miui.notify.params
 import android.content.Context
 import android.graphics.Color
 import com.fankes.miui.notify.bean.IconDataBean
-import com.fankes.miui.notify.hook.HookConst.NOTIFY_ICON_DATAS
+import com.fankes.miui.notify.data.DataConst
 import com.fankes.miui.notify.utils.factory.*
 import com.highcapable.yukihookapi.hook.factory.modulePrefs
 import com.highcapable.yukihookapi.hook.param.PackageParam
@@ -47,7 +47,7 @@ class IconPackParams(private val context: Context? = null, private val param: Pa
      * 已存储的 JSON 数据
      * @return [String]
      */
-    internal val storageDataJson get() = (context?.modulePrefs ?: param?.prefs)?.getString(NOTIFY_ICON_DATAS)
+    internal val storageDataJson get() = (context?.modulePrefs ?: param?.prefs)?.direct()?.get(DataConst.NOTIFY_ICON_DATAS)
 
     /**
      * 获取图标数据
@@ -134,5 +134,5 @@ class IconPackParams(private val context: Context? = null, private val param: Pa
      * 保存图标数据
      * @param dataJson 图标数据 JSON
      */
-    fun save(dataJson: String) = context?.modulePrefs?.putString(NOTIFY_ICON_DATAS, dataJson)
+    fun save(dataJson: String) = context?.modulePrefs?.put(DataConst.NOTIFY_ICON_DATAS, dataJson)
 }

app/src/main/java/com/fankes/miui/notify/service/QuickStartTileService.kt

@@ -18,30 +18,19 @@
  * and eula along with this software.  If not, see
  * <https://www.gnu.org/licenses/>
  *
- * This file is Created by fankes on 2022/1/30.
+ * This file is Created by fankes on 2022/3/26.
  */
-package com.fankes.miui.notify.ui.base
+package com.fankes.miui.notify.service
 
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.utils.factory.isNotSystemInDarkMode
-import com.gyf.immersionbar.ktx.immersionBar
+import android.service.quicksettings.TileService
+import com.fankes.miui.notify.ui.activity.ConfigureActivity
+import com.fankes.miui.notify.utils.factory.navigate
 
-abstract class BaseActivity : AppCompatActivity() {
+class QuickStartTileService : TileService() {
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        /** 隐藏系统的标题栏 */
-        supportActionBar?.hide()
-        /** 初始化沉浸状态栏 */
-        immersionBar {
-            statusBarColor(R.color.colorThemeBackground)
-            autoDarkModeEnable(true)
-            statusBarDarkFont(isNotSystemInDarkMode)
-            navigationBarColor(R.color.colorThemeBackground)
-            navigationBarDarkIcon(isNotSystemInDarkMode)
-            fitsSystemWindows(true)
-        }
+    override fun onClick() {
+        super.onClick()
+        /** 启动通知图标优化列表窗口 */
+        navigate<ConfigureActivity>()
     }
 }

app/src/main/java/com/fankes/miui/notify/ui/ConfigureActivity.kt

@@ -1,449 +0,0 @@
-/*
- * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
- * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
- * https://github.com/fankes/MIUINativeNotifyIcon
- *
- * This software is non-free but opensource software: you can redistribute it
- * and/or modify it under the terms of the GNU Affero General Public License
- * as published by the Free Software Foundation; either
- * version 3 of the License, or any later version.
- * <p>
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * and eula along with this software.  If not, see
- * <https://www.gnu.org/licenses/>
- *
- * This file is Created by fankes on 2022/1/30.
- */
-@file:Suppress("SetTextI18n", "InflateParams", "DEPRECATION")
-
-package com.fankes.miui.notify.ui
-
-import android.app.ProgressDialog
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.BaseAdapter
-import android.widget.ListView
-import android.widget.TextView
-import androidx.constraintlayout.utils.widget.ImageFilterView
-import androidx.core.view.isVisible
-import androidx.core.widget.doOnTextChanged
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.bean.IconDataBean
-import com.fankes.miui.notify.hook.HookConst.SOURCE_SYNC_WAY
-import com.fankes.miui.notify.hook.HookConst.SOURCE_SYNC_WAY_CUSTOM_URL
-import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_1
-import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_2
-import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_3
-import com.fankes.miui.notify.hook.factory.isAppNotifyHookAllOf
-import com.fankes.miui.notify.hook.factory.isAppNotifyHookOf
-import com.fankes.miui.notify.hook.factory.putAppNotifyHookAllOf
-import com.fankes.miui.notify.hook.factory.putAppNotifyHookOf
-import com.fankes.miui.notify.params.IconPackParams
-import com.fankes.miui.notify.ui.base.BaseActivity
-import com.fankes.miui.notify.utils.factory.*
-import com.fankes.miui.notify.utils.tool.ClientRequestTool
-import com.fankes.miui.notify.utils.tool.SystemUITool
-import com.fankes.miui.notify.view.MaterialSwitch
-import com.google.android.material.radiobutton.MaterialRadioButton
-import com.google.android.material.textfield.TextInputEditText
-import com.highcapable.yukihookapi.hook.factory.modulePrefs
-import com.highcapable.yukihookapi.hook.xposed.YukiHookModuleStatus
-
-class ConfigureActivity : BaseActivity() {
-
-    /** 当前筛选条件 */
-    private var filterText = ""
-
-    /** 回调适配器改变 */
-    private var onChanged: (() -> Unit)? = null
-
-    /** 回调滚动事件改变 */
-    private var onScrollEvent: ((Boolean) -> Unit)? = null
-
-    /** 全部的通知优化图标数据 */
-    private var iconAllDatas = ArrayList<IconDataBean>()
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_config)
-        /** 检查激活状态 */
-        if (!YukiHookModuleStatus.isActive()) {
-            showDialog {
-                title = "模块没有激活"
-                msg = "模块没有激活，你无法使用这里的功能，请先激活模块。"
-                confirmButton(text = "我知道了") { finish() }
-                noCancelable()
-            }
-            return
-        }
-        /** 返回按钮点击事件 */
-        findViewById<View>(R.id.title_back_icon).setOnClickListener { onBackPressed() }
-        /** 刷新适配器结果相关 */
-        refreshAdapterResult()
-        /** 设置上下按钮点击事件 */
-        findViewById<View>(R.id.config_title_up).setOnClickListener {
-            snake(msg = "滚动到顶部")
-            onScrollEvent?.invoke(false)
-        }
-        findViewById<View>(R.id.config_title_down).setOnClickListener {
-            snake(msg = "滚动到底部")
-            onScrollEvent?.invoke(true)
-        }
-        /** 设置过滤按钮点击事件 */
-        findViewById<View>(R.id.config_title_filter).setOnClickListener {
-            showDialog {
-                title = "按条件过滤"
-                var editText: TextInputEditText
-                addView(R.layout.dia_icon_filter).apply {
-                    editText = findViewById<TextInputEditText>(R.id.dia_icon_filter_input_edit).apply {
-                        requestFocus()
-                        invalidate()
-                        if (filterText.isNotBlank()) {
-                            setText(filterText)
-                            setSelection(filterText.length)
-                        }
-                    }
-                }
-                confirmButton {
-                    if (editText.text.toString().isNotBlank()) {
-                        filterText = editText.text.toString().trim()
-                        refreshAdapterResult()
-                    } else {
-                        toast(msg = "条件不能为空")
-                        it.performClick()
-                    }
-                }
-                cancelButton()
-                if (filterText.isNotBlank())
-                    neutralButton(text = "清除条件") {
-                        filterText = ""
-                        refreshAdapterResult()
-                    }
-            }
-        }
-        /** 设置同步列表按钮点击事件 */
-        findViewById<View>(R.id.config_title_sync).setOnClickListener { onStartRefresh() }
-        /** 设置列表元素和 Adapter */
-        findViewById<ListView>(R.id.config_list_view).apply {
-            adapter = object : BaseAdapter() {
-
-                private val inflater = LayoutInflater.from(context)
-
-                override fun getCount() = iconDatas.size
-
-                override fun getItem(position: Int) = iconDatas[position]
-
-                override fun getItemId(position: Int) = position.toLong()
-
-                override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
-                    var cView = convertView
-                    val holder: ViewHolder
-                    if (convertView == null) {
-                        holder = ViewHolder()
-                        cView = inflater.inflate(R.layout.adapter_config, null).also {
-                            holder.appIcon = it.findViewById(R.id.adp_app_icon)
-                            holder.appName = it.findViewById(R.id.adp_app_name)
-                            holder.pkgName = it.findViewById(R.id.adp_app_pkg_name)
-                            holder.cbrName = it.findViewById(R.id.adp_cbr_name)
-                            holder.switchOpen = it.findViewById(R.id.adp_app_open_switch)
-                            holder.switchAll = it.findViewById(R.id.adp_app_all_switch)
-                        }
-                        cView.tag = holder
-                    } else holder = convertView.tag as ViewHolder
-                    getItem(position).also {
-                        holder.appIcon.setImageBitmap(it.iconBitmap)
-                        (if (it.iconColor != 0) it.iconColor else resources.getColor(R.color.colorTextGray)).also { color ->
-                            holder.appIcon.setColorFilter(color)
-                            holder.appName.setTextColor(color)
-                        }
-                        holder.appName.text = it.appName
-                        holder.pkgName.text = it.packageName
-                        holder.cbrName.text = "贡献者：" + it.contributorName
-                        isAppNotifyHookOf(it).also { e ->
-                            holder.switchOpen.isChecked = e
-                            holder.switchAll.isEnabled = e
-                        }
-                        holder.switchOpen.setOnCheckedChangeListener { btn, b ->
-                            if (!btn.isPressed) return@setOnCheckedChangeListener
-                            putAppNotifyHookOf(it, b)
-                            holder.switchAll.isEnabled = b
-                            SystemUITool.showNeedRestartSnake(context = this@ConfigureActivity)
-                        }
-                        holder.switchAll.isChecked = isAppNotifyHookAllOf(it)
-                        holder.switchAll.setOnCheckedChangeListener { btn, b ->
-                            if (!btn.isPressed) return@setOnCheckedChangeListener
-                            putAppNotifyHookAllOf(it, b)
-                            SystemUITool.showNeedRestartSnake(context = this@ConfigureActivity)
-                        }
-                    }
-                    return cView!!
-                }
-
-                inner class ViewHolder {
-                    lateinit var appIcon: ImageFilterView
-                    lateinit var appName: TextView
-                    lateinit var pkgName: TextView
-                    lateinit var cbrName: TextView
-                    lateinit var switchOpen: MaterialSwitch
-                    lateinit var switchAll: MaterialSwitch
-                }
-            }.apply {
-                setOnItemLongClickListener { _, _, p, _ ->
-                    showDialog {
-                        title = "复制“${iconDatas[p].appName}”的规则"
-                        msg = "是否复制单条规则到剪贴板？"
-                        confirmButton { copyToClipboard(iconDatas[p].toString()) }
-                        cancelButton()
-                    }
-                    true
-                }
-                onChanged = { notifyDataSetChanged() }
-            }
-            onScrollEvent = { post { setSelection(if (it) iconDatas.lastIndex else 0) } }
-        }
-        /** 设置点击事件 */
-        findViewById<View>(R.id.config_cbr_button).setOnClickListener {
-            openBrowser(url = "https://github.com/fankes/AndroidNotifyIconAdapt/blob/main/CONTRIBUTING.md")
-        }
-        /** 装载数据 */
-        mockLocalData()
-        /** 更新数据 */
-        onStartRefresh()
-    }
-
-    /** 装载或刷新本地数据 */
-    private fun mockLocalData() {
-        iconAllDatas = IconPackParams(context = this).iconDatas
-        refreshAdapterResult()
-    }
-
-    /** 首次进入或更新数据 */
-    private fun onStartRefresh() =
-        showDialog {
-            title = "同步列表"
-            var sourceType = modulePrefs.getInt(SOURCE_SYNC_WAY, TYPE_SOURCE_SYNC_WAY_1)
-            var customUrl = modulePrefs.getString(SOURCE_SYNC_WAY_CUSTOM_URL)
-            addView(R.layout.dia_source_from).apply {
-                val radio1 = findViewById<MaterialRadioButton>(R.id.dia_sf_rd1)
-                val radio2 = findViewById<MaterialRadioButton>(R.id.dia_sf_rd2)
-                val radio3 = findViewById<MaterialRadioButton>(R.id.dia_sf_rd3)
-                val edLin = findViewById<View>(R.id.dia_sf_text_lin)
-                findViewById<TextInputEditText>(R.id.dia_sf_text).apply {
-                    if (customUrl.isNotBlank()) {
-                        setText(customUrl)
-                        setSelection(customUrl.length)
-                    }
-                    doOnTextChanged { text, _, _, _ ->
-                        customUrl = text.toString()
-                        modulePrefs.putString(SOURCE_SYNC_WAY_CUSTOM_URL, text.toString())
-                    }
-                }
-                edLin.isVisible = sourceType == TYPE_SOURCE_SYNC_WAY_3
-                radio1.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_1
-                radio2.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_2
-                radio3.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_3
-                radio1.setOnClickListener {
-                    radio2.isChecked = false
-                    radio3.isChecked = false
-                    edLin.isVisible = false
-                    sourceType = TYPE_SOURCE_SYNC_WAY_1
-                    modulePrefs.putInt(SOURCE_SYNC_WAY, TYPE_SOURCE_SYNC_WAY_1)
-                }
-                radio2.setOnClickListener {
-                    radio1.isChecked = false
-                    radio3.isChecked = false
-                    edLin.isVisible = false
-                    sourceType = TYPE_SOURCE_SYNC_WAY_2
-                    modulePrefs.putInt(SOURCE_SYNC_WAY, TYPE_SOURCE_SYNC_WAY_2)
-                }
-                radio3.setOnClickListener {
-                    radio1.isChecked = false
-                    radio2.isChecked = false
-                    edLin.isVisible = true
-                    sourceType = TYPE_SOURCE_SYNC_WAY_3
-                    modulePrefs.putInt(SOURCE_SYNC_WAY, TYPE_SOURCE_SYNC_WAY_3)
-                }
-            }
-            confirmButton {
-                when (sourceType) {
-                    TYPE_SOURCE_SYNC_WAY_1 -> onRefreshing(url = "https://raw.fastgit.org/fankes/AndroidNotifyIconAdapt/main")
-                    TYPE_SOURCE_SYNC_WAY_2 -> onRefreshing(url = "https://raw.githubusercontent.com/fankes/AndroidNotifyIconAdapt/main")
-                    TYPE_SOURCE_SYNC_WAY_3 ->
-                        if (customUrl.isNotBlank())
-                            if (customUrl.startsWith("http://") || customUrl.startsWith("https://"))
-                                onRefreshingCustom(customUrl)
-                            else snake(msg = "同步地址不是一个合法的 URL")
-                        else snake(msg = "同步地址不能为空")
-                    else -> snake(msg = "同步类型错误")
-                }
-            }
-            cancelButton()
-            neutralButton(text = "自定义规则") {
-                showDialog {
-                    title = "自定义规则"
-                    var editText: TextInputEditText
-                    addView(R.layout.dia_source_from_string).apply {
-                        editText = findViewById<TextInputEditText>(R.id.dia_sfs_input_edit).apply {
-                            requestFocus()
-                            invalidate()
-                        }
-                    }
-                    IconPackParams(context = this@ConfigureActivity).also { params ->
-                        confirmButton(text = "合并") {
-                            editText.text.toString().also { jsonString ->
-                                when {
-                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> snake(msg = "不是有效的 JSON 数据")
-                                    jsonString.isNotBlank() -> {
-                                        params.save(
-                                            params.splicingJsonArray(
-                                                dataJson1 = params.storageDataJson ?: "[]",
-                                                dataJson2 = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]"
-                                            )
-                                        )
-                                        filterText = ""
-                                        mockLocalData()
-                                        SystemUITool.showNeedUpdateApplySnake(context = this@ConfigureActivity)
-                                    }
-                                    else -> snake(msg = "请输入有效内容")
-                                }
-                            }
-                        }
-                        cancelButton(text = "覆盖") {
-                            editText.text.toString().also { jsonString ->
-                                when {
-                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> snake(msg = "不是有效的 JSON 数据")
-                                    jsonString.isNotBlank() -> {
-                                        params.save(dataJson = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]")
-                                        filterText = ""
-                                        mockLocalData()
-                                        SystemUITool.showNeedUpdateApplySnake(context = this@ConfigureActivity)
-                                    }
-                                    else -> snake(msg = "请输入有效内容")
-                                }
-                            }
-                        }
-                    }
-                    neutralButton(text = "取消")
-                }
-            }
-        }
-
-    /**
-     * 开始更新数据
-     * @param url
-     */
-    private fun onRefreshing(url: String) = ClientRequestTool.checkingInternetConnect(context = this) {
-        ProgressDialog(this).apply {
-            setDefaultStyle(context = this@ConfigureActivity)
-            setCancelable(false)
-            setTitle("同步中")
-            setMessage("正在同步 OS 数据")
-            show()
-        }.also {
-            ClientRequestTool.wait(
-                context = this,
-                url = "$url/OS/MIUI/NotifyIconsSupportConfig.json"
-            ) { isDone1, ctOS ->
-                it.setMessage("正在同步 APP 数据")
-                ClientRequestTool.wait(
-                    context = this,
-                    url = "$url/APP/NotifyIconsSupportConfig.json"
-                ) { isDone2, ctAPP ->
-                    it.cancel()
-                    IconPackParams(context = this).also { params ->
-                        if (isDone1 && isDone2) params.splicingJsonArray(ctOS, ctAPP).also {
-                            when {
-                                params.isHackString(it) -> snake(msg = "请求需要验证，请尝试魔法上网或关闭魔法")
-                                params.isNotVaildJson(it) -> snake(msg = "在线规则发生问题，请稍后重试")
-                                params.isCompareDifferent(it) -> {
-                                    params.save(it)
-                                    filterText = ""
-                                    mockLocalData()
-                                    SystemUITool.showNeedUpdateApplySnake(context = this)
-                                }
-                                else -> snake(msg = "列表数据已是最新")
-                            }
-                        } else showDialog {
-                            title = "连接失败"
-                            msg = "连接失败，错误如下：\n${if (!isDone1) ctOS else ctAPP}"
-                            confirmButton(text = "解决方案") {
-                                openBrowser(url = "https://www.baidu.com/s?wd=github%2Braw%2B%E6%97%A0%E6%B3%95%E8%AE%BF%E9%97%AE")
-                            }
-                            cancelButton()
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 开始更新数据
-     * @param url
-     */
-    private fun onRefreshingCustom(url: String) = ClientRequestTool.checkingInternetConnect(context = this) {
-        ProgressDialog(this).apply {
-            setDefaultStyle(context = this@ConfigureActivity)
-            setCancelable(false)
-            setTitle("同步中")
-            setMessage("正在通过自定义地址同步数据")
-            show()
-        }.also {
-            ClientRequestTool.wait(
-                context = this,
-                url = url
-            ) { isDone, content ->
-                it.cancel()
-                IconPackParams(context = this).also { params ->
-                    if (isDone)
-                        when {
-                            params.isHackString(content) -> snake(msg = "请求需要验证，请尝试魔法上网或关闭魔法")
-                            params.isNotVaildJson(content) -> snake(msg = "目标地址不是有效的 JSON 数据")
-                            params.isCompareDifferent(content) -> {
-                                params.save(content)
-                                filterText = ""
-                                mockLocalData()
-                                SystemUITool.showNeedUpdateApplySnake(context = this)
-                            }
-                            else -> snake(msg = "列表数据已是最新")
-                        }
-                    else showDialog {
-                        title = "连接失败"
-                        msg = "连接失败，错误如下：\n$content"
-                        confirmButton(text = "我知道了")
-                    }
-                }
-            }
-        }
-    }
-
-    /** 刷新适配器结果相关 */
-    private fun refreshAdapterResult() {
-        onChanged?.invoke()
-        findViewById<TextView>(R.id.config_title_count_text).text =
-            if (filterText.isBlank()) "已适配 ${iconDatas.size} 个 APP 的通知图标"
-            else "“${filterText}” 匹配到 ${iconDatas.size} 个结果"
-        findViewById<TextView>(R.id.config_list_no_data_view).apply {
-            text = if (iconAllDatas.isEmpty()) "噫，竟然什么都没有~\n请点击右上角同步按钮获取云端数据" else "噫，竟然什么都没找到~"
-            isVisible = iconDatas.isEmpty()
-        }
-    }
-
-    /**
-     * 当前结果下的图标数组
-     * @return [Array]
-     */
-    private val iconDatas
-        get() = if (filterText.isBlank()) iconAllDatas
-        else iconAllDatas.filter {
-            it.appName.lowercase().contains(filterText.lowercase()) || it.packageName.lowercase().contains(filterText.lowercase())
-        }
-}

app/src/main/java/com/fankes/miui/notify/ui/MainActivity.kt

@@ -1,304 +0,0 @@
-/*
- * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
- * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
- * https://github.com/fankes/MIUINativeNotifyIcon
- *
- * This software is non-free but opensource software: you can redistribute it
- * and/or modify it under the terms of the GNU Affero General Public License
- * as published by the Free Software Foundation; either
- * version 3 of the License, or any later version.
- * <p>
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * and eula along with this software.  If not, see
- * <https://www.gnu.org/licenses/>
- *
- * This file is Created by fankes on 2022/1/24.
- */
-@file:Suppress("SetTextI18n")
-
-package com.fankes.miui.notify.ui
-
-import android.content.ComponentName
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Bundle
-import android.view.View
-import android.widget.LinearLayout
-import android.widget.TextView
-import androidx.appcompat.widget.SwitchCompat
-import androidx.constraintlayout.utils.widget.ImageFilterView
-import androidx.core.view.isGone
-import androidx.core.view.isVisible
-import com.fankes.miui.notify.BuildConfig
-import com.fankes.miui.notify.R
-import com.fankes.miui.notify.hook.HookConst.ENABLE_COLOR_ICON_COMPAT
-import com.fankes.miui.notify.hook.HookConst.ENABLE_COLOR_ICON_HOOK
-import com.fankes.miui.notify.hook.HookConst.ENABLE_HIDE_ICON
-import com.fankes.miui.notify.hook.HookConst.ENABLE_HOOK_STATUS_ICON_COUNT
-import com.fankes.miui.notify.hook.HookConst.ENABLE_MODULE
-import com.fankes.miui.notify.hook.HookConst.ENABLE_MODULE_LOG
-import com.fankes.miui.notify.hook.HookConst.ENABLE_NOTIFY_ICON_FIX
-import com.fankes.miui.notify.hook.HookConst.HOOK_STATUS_ICON_COUNT
-import com.fankes.miui.notify.params.IconPackParams
-import com.fankes.miui.notify.ui.base.BaseActivity
-import com.fankes.miui.notify.utils.factory.*
-import com.fankes.miui.notify.utils.tool.SystemUITool
-import com.google.android.material.textfield.TextInputEditText
-import com.highcapable.yukihookapi.hook.factory.modulePrefs
-import com.highcapable.yukihookapi.hook.xposed.YukiHookModuleStatus
-
-class MainActivity : BaseActivity() {
-
-    companion object {
-
-        /** 模块版本 */
-        private const val moduleVersion = BuildConfig.VERSION_NAME
-    }
-
-    private var isWarnDialogShowing = false // 警告对话框是否显示
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-        /** 设置文本 */
-        findViewById<TextView>(R.id.main_text_version).text = "模块版本：$moduleVersion"
-        findViewById<TextView>(R.id.main_text_miui_version).text = "系统版本：$miuiFullVersion"
-        when {
-            /** 判断是否为 MIUI 系统 */
-            isNotMIUI ->
-                showDialog {
-                    title = "不是 MIUI 系统"
-                    msg = "此模块专为 MIUI 系统打造，当前无法识别你的系统为 MIUI，所以模块无法工作。\n" +
-                            "如有问题请联系 酷安 @星夜不荟"
-                    confirmButton(text = "退出") { finish() }
-                    noCancelable()
-                }
-            /** 判断最低 Android 系统版本 */
-            isLowerAndroidP ->
-                showDialog {
-                    title = "Android 系统版本过低"
-                    msg = "此模块最低支持基于 Android 9 的 MIUI 系统，你的系统版本过低不再进行适配。\n" +
-                            "如有问题请联系 酷安 @星夜不荟"
-                    confirmButton(text = "退出") { finish() }
-                    noCancelable()
-                }
-            /** 判断最低 MIUI 版本 */
-            isNotSupportMiuiVersion ->
-                showDialog {
-                    title = "MIUI 版本过低"
-                    msg = "此模块最低支持 MIUI 12 系统，你的 MIUI 版本为 ${miuiVersion}，不再进行适配。\n" +
-                            "如有问题请联系 酷安 @星夜不荟"
-                    confirmButton(text = "退出") { finish() }
-                    noCancelable()
-                }
-            /** 判断是否 Hook */
-            YukiHookModuleStatus.isActive() -> {
-                if (IconPackParams(context = this).iconDatas.isEmpty()
-                    && modulePrefs.getBoolean(ENABLE_NOTIFY_ICON_FIX, default = true)
-                ) showDialog {
-                    title = "配置通知图标优化名单"
-                    msg = "模块需要获取在线规则以更新“通知图标优化名单”，它现在是空的，这看起来是你第一次使用模块，请首先进行配置才可以使用相关功能。\n" +
-                            "你可以随时在本页面下方找到“配置通知图标优化名单”手动前往。"
-                    confirmButton(text = "前往") { startActivity(Intent(this@MainActivity, ConfigureActivity::class.java)) }
-                    cancelButton()
-                    noCancelable()
-                }
-            }
-            else ->
-                showDialog {
-                    title = "模块没有激活"
-                    msg = "检测到模块没有激活，模块需要 Xposed 环境依赖，" +
-                            "同时需要系统拥有 Root 权限，" +
-                            "请自行查看本页面使用帮助与说明第二条。\n" +
-                            "由于需要修改系统应用达到效果，模块不支持太极阴、应用转生。"
-                    confirmButton(text = "我知道了")
-                    noCancelable()
-                }
-        }
-        /** 初始化 View */
-        val moduleEnableSwitch = findViewById<SwitchCompat>(R.id.module_enable_switch)
-        val moduleEnableLogSwitch = findViewById<SwitchCompat>(R.id.module_enable_log_switch)
-        val statusIconCountItem = findViewById<View>(R.id.config_item_s_count_hook)
-        val statusIconCountChildItem = findViewById<View>(R.id.config_item_s_count_child_hook)
-        val statusIconCountSwitch = findViewById<SwitchCompat>(R.id.config_status_icon_count_switch)
-        val statusIconCountText = findViewById<TextView>(R.id.config_status_icon_count_text)
-        val colorIconHookItem = findViewById<View>(R.id.config_item_color_hook)
-        val notifyIconConfigItem = findViewById<View>(R.id.config_item_notify)
-        val hideIconInLauncherSwitch = findViewById<SwitchCompat>(R.id.hide_icon_in_launcher_switch)
-        val colorIconHookSwitch = findViewById<SwitchCompat>(R.id.color_icon_fix_switch)
-        val colorIconCompatSwitch = findViewById<SwitchCompat>(R.id.color_icon_compat_switch)
-        val colorIconCompatText = findViewById<View>(R.id.color_icon_compat_text)
-        val notifyIconFixSwitch = findViewById<SwitchCompat>(R.id.notify_icon_fix_switch)
-        val notifyIconFixButton = findViewById<View>(R.id.config_notify_app_button)
-
-        /** 获取 Sp 存储的信息 */
-        var statusBarIconCount = modulePrefs.getInt(HOOK_STATUS_ICON_COUNT, default = 5)
-        colorIconHookItem.isVisible = modulePrefs.getBoolean(ENABLE_MODULE, default = true)
-        statusIconCountItem.isVisible = modulePrefs.getBoolean(ENABLE_MODULE, default = true)
-        colorIconCompatSwitch.isVisible = modulePrefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)
-        colorIconCompatText.isVisible = modulePrefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)
-        notifyIconConfigItem.isVisible = modulePrefs.getBoolean(ENABLE_MODULE, default = true) &&
-                modulePrefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)
-        notifyIconFixButton.isVisible = modulePrefs.getBoolean(ENABLE_NOTIFY_ICON_FIX, default = true)
-        statusIconCountSwitch.isChecked = modulePrefs.getBoolean(ENABLE_HOOK_STATUS_ICON_COUNT, default = true)
-        statusIconCountChildItem.isVisible = modulePrefs.getBoolean(ENABLE_HOOK_STATUS_ICON_COUNT, default = true)
-        moduleEnableSwitch.isChecked = modulePrefs.getBoolean(ENABLE_MODULE, default = true)
-        moduleEnableLogSwitch.isChecked = modulePrefs.getBoolean(ENABLE_MODULE_LOG, default = false)
-        hideIconInLauncherSwitch.isChecked = modulePrefs.getBoolean(ENABLE_HIDE_ICON)
-        colorIconHookSwitch.isChecked = modulePrefs.getBoolean(ENABLE_COLOR_ICON_HOOK, default = true)
-        colorIconCompatSwitch.isChecked = modulePrefs.getBoolean(ENABLE_COLOR_ICON_COMPAT)
-        notifyIconFixSwitch.isChecked = modulePrefs.getBoolean(ENABLE_NOTIFY_ICON_FIX, default = true)
-        statusIconCountText.text = statusBarIconCount.toString()
-        moduleEnableSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_MODULE, b)
-            moduleEnableLogSwitch.isVisible = b
-            colorIconHookItem.isVisible = b
-            statusIconCountItem.isVisible = b
-            notifyIconConfigItem.isVisible = b && colorIconHookSwitch.isChecked
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        moduleEnableLogSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_MODULE_LOG, b)
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        hideIconInLauncherSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_HIDE_ICON, b)
-            packageManager.setComponentEnabledSetting(
-                ComponentName(this@MainActivity, "com.fankes.miui.notify.Home"),
-                if (b) PackageManager.COMPONENT_ENABLED_STATE_DISABLED else PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
-                PackageManager.DONT_KILL_APP
-            )
-        }
-        statusIconCountSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_HOOK_STATUS_ICON_COUNT, b)
-            statusIconCountChildItem.isVisible = b
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        colorIconHookSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_COLOR_ICON_HOOK, b)
-            notifyIconConfigItem.isVisible = b
-            colorIconCompatSwitch.isVisible = b
-            colorIconCompatText.isVisible = b
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        colorIconCompatSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_COLOR_ICON_COMPAT, b)
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        notifyIconFixSwitch.setOnCheckedChangeListener { btn, b ->
-            if (!btn.isPressed) return@setOnCheckedChangeListener
-            modulePrefs.putBoolean(ENABLE_NOTIFY_ICON_FIX, b)
-            notifyIconFixButton.isVisible = b
-            SystemUITool.showNeedRestartSnake(context = this)
-        }
-        /** 通知图标优化名单按钮点击事件 */
-        notifyIconFixButton.setOnClickListener { startActivity(Intent(this, ConfigureActivity::class.java)) }
-        /** 设置警告 */
-        findViewById<View>(R.id.config_warn_s_count_dis_tip).isGone = miuiVersionCode > 12.5
-        /** 修改状态栏通知图标个数按钮点击事件 */
-        findViewById<View>(R.id.config_status_icon_count_button).setOnClickListener {
-            showDialog {
-                title = "设置最多显示的图标个数"
-                var editText: TextInputEditText
-                addView(R.layout.dia_status_icon_count).apply {
-                    editText = findViewById<TextInputEditText>(R.id.dia_status_icon_count_input_edit).apply {
-                        requestFocus()
-                        invalidate()
-                        setText(statusBarIconCount.toString())
-                        setSelection(statusBarIconCount.toString().length)
-                    }
-                }
-                confirmButton {
-                    when {
-                        (runCatching { editText.text.toString().toInt() }.getOrNull() ?: -1)
-                                !in 0..100 -> snake(msg = "请输入有效数值")
-                        editText.text.toString().isNotBlank() -> runCatching {
-                            statusBarIconCount = editText.text.toString().trim().toInt()
-                            modulePrefs.putInt(HOOK_STATUS_ICON_COUNT, statusBarIconCount)
-                            statusIconCountText.text = statusBarIconCount.toString()
-                            SystemUITool.showNeedRestartSnake(context = this@MainActivity)
-                        }.onFailure { snake(msg = "数值格式无效") }
-                        else -> snake(msg = "请输入有效数值")
-                    }
-                }
-                cancelButton()
-            }
-        }
-        /** 重启按钮点击事件 */
-        findViewById<View>(R.id.title_restart_icon).setOnClickListener { SystemUITool.restartSystemUI(context = this) }
-        /** 项目地址按钮点击事件 */
-        findViewById<View>(R.id.title_github_icon).setOnClickListener {
-            openBrowser(url = "https://github.com/fankes/MIUINativeNotifyIcon")
-        }
-        /** 恰饭！ */
-        findViewById<View>(R.id.link_with_follow_me).setOnClickListener {
-            openBrowser(url = "https://www.coolapk.com/u/876977", packageName = "com.coolapk.market")
-        }
-    }
-
-    /** 刷新模块状态 */
-    private fun refreshModuleStatus() {
-        findViewById<LinearLayout>(R.id.main_lin_status).setBackgroundResource(
-            when {
-                YukiHookModuleStatus.isActive() && isMiuiNotifyStyle -> R.drawable.bg_yellow_round
-                YukiHookModuleStatus.isActive() -> R.drawable.bg_green_round
-                else -> R.drawable.bg_dark_round
-            }
-        )
-        findViewById<ImageFilterView>(R.id.main_img_status).setImageResource(
-            when {
-                YukiHookModuleStatus.isActive() && !isMiuiNotifyStyle -> R.mipmap.ic_success
-                else -> R.mipmap.ic_warn
-            }
-        )
-        findViewById<TextView>(R.id.main_text_status).text =
-            when {
-                YukiHookModuleStatus.isActive() && isMiuiNotifyStyle -> "模块已激活，但未在工作"
-                YukiHookModuleStatus.isActive() -> "模块已激活"
-                else -> "模块未激活"
-            }
-    }
-
-    override fun onResume() {
-        super.onResume()
-        /** 刷新模块状态 */
-        refreshModuleStatus()
-        /** 经典样式启用后给出警告 */
-        if (!isWarnDialogShowing && YukiHookModuleStatus.isActive() && isMiuiNotifyStyle)
-            showDialog {
-                isWarnDialogShowing = true
-                title = "经典通知栏样式已启用"
-                msg = "当你启用了经典通知栏样式后，为防止 MIUI 自身不规范 APP 图标被破坏，状态栏图标将不再做原生处理。\n\n" +
-                        "若要使用原生样式，请前往 设置>通知管理>通知显示设置 中将样式设置为“原生样式”，新版本为 设置>通知与控制中心>通知显示设置。"
-                confirmButton(text = "去设置") {
-                    runCatching {
-                        startActivity(Intent().apply {
-                            component = ComponentName(
-                                "com.miui.notification",
-                                "miui.notification.management.activity.NotificationDisplaySettingsActivity"
-                            )
-                            /** 防止顶栈一样重叠在自己的 APP 中 */
-                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                        })
-                    }.onFailure {
-                        toast(msg = "启动失败，请手动调整设置")
-                    }
-                    isWarnDialogShowing = false
-                }
-                cancelButton { isWarnDialogShowing = false }
-                noCancelable()
-            }
-    }
-}

app/src/main/java/com/fankes/miui/notify/ui/activity/ConfigureActivity.kt

@@ -0,0 +1,274 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/1/30.
+ */
+@file:Suppress("SetTextI18n", "InflateParams", "DEPRECATION")
+
+package com.fankes.miui.notify.ui.activity
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.BaseAdapter
+import androidx.core.view.isVisible
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.bean.IconDataBean
+import com.fankes.miui.notify.databinding.ActivityConfigBinding
+import com.fankes.miui.notify.databinding.AdapterConfigBinding
+import com.fankes.miui.notify.databinding.DiaIconFilterBinding
+import com.fankes.miui.notify.hook.factory.isAppNotifyHookAllOf
+import com.fankes.miui.notify.hook.factory.isAppNotifyHookOf
+import com.fankes.miui.notify.hook.factory.putAppNotifyHookAllOf
+import com.fankes.miui.notify.hook.factory.putAppNotifyHookOf
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.*
+import com.fankes.miui.notify.utils.tool.IconRuleManagerTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.highcapable.yukihookapi.YukiHookAPI
+
+class ConfigureActivity : BaseActivity<ActivityConfigBinding>() {
+
+    /** 当前筛选条件 */
+    private var filterText = ""
+
+    /** 回调适配器改变 */
+    private var onChanged: (() -> Unit)? = null
+
+    /** 回调滚动事件改变 */
+    private var onScrollEvent: ((Boolean) -> Unit)? = null
+
+    /** 全部的通知图标优化数据 */
+    private var iconAllDatas = ArrayList<IconDataBean>()
+
+    override fun onCreate() {
+        /** 检查激活状态 */
+        if (YukiHookAPI.Status.isXposedModuleActive.not()) {
+            showDialog {
+                title = "模块没有激活"
+                msg = "模块没有激活，你无法使用这里的功能，请先激活模块。"
+                confirmButton(text = "我知道了") { finish() }
+                noCancelable()
+            }
+            return
+        }
+        /** 返回按钮点击事件 */
+        binding.titleBackIcon.setOnClickListener { onBackPressed() }
+        /** 刷新适配器结果相关 */
+        refreshAdapterResult()
+        /** 设置上下按钮点击事件 */
+        binding.configTitleUp.setOnClickListener {
+            snake(msg = "滚动到顶部")
+            onScrollEvent?.invoke(false)
+        }
+        binding.configTitleDown.setOnClickListener {
+            snake(msg = "滚动到底部")
+            onScrollEvent?.invoke(true)
+        }
+        /** 设置过滤按钮点击事件 */
+        binding.configTitleFilter.setOnClickListener {
+            showDialog {
+                title = "按条件过滤"
+                val editText = bind<DiaIconFilterBinding>().diaIconFilterInputEdit.apply {
+                    requestFocus()
+                    invalidate()
+                    if (filterText.isNotBlank()) {
+                        setText(filterText)
+                        setSelection(filterText.length)
+                    }
+                }
+                confirmButton {
+                    if (editText.text.toString().isNotBlank()) {
+                        filterText = editText.text.toString().trim()
+                        refreshAdapterResult()
+                    } else {
+                        toast(msg = "条件不能为空")
+                        it.performClick()
+                    }
+                }
+                cancelButton()
+                if (filterText.isNotBlank())
+                    neutralButton(text = "清除条件") {
+                        filterText = ""
+                        refreshAdapterResult()
+                    }
+            }
+        }
+        /** 设置同步列表按钮点击事件 */
+        binding.configTitleSync.setOnClickListener { onStartRefresh() }
+        /** 设置列表元素和 Adapter */
+        binding.configListView.apply {
+            adapter = object : BaseAdapter() {
+
+                override fun getCount() = iconDatas.size
+
+                override fun getItem(position: Int) = iconDatas[position]
+
+                override fun getItemId(position: Int) = position.toLong()
+
+                override fun getView(position: Int, convertView: View?, parent: ViewGroup?): View {
+                    var cView = convertView
+                    val holder: AdapterConfigBinding
+                    if (convertView == null) {
+                        holder = AdapterConfigBinding.inflate(LayoutInflater.from(context))
+                        cView = holder.root
+                        cView.tag = holder
+                    } else holder = convertView.tag as AdapterConfigBinding
+                    getItem(position).also {
+                        holder.adpAppIcon.setImageBitmap(it.iconBitmap)
+                        (if (it.iconColor != 0) it.iconColor else resources.getColor(R.color.colorTextGray)).also { color ->
+                            holder.adpAppIcon.setColorFilter(color)
+                            holder.adpAppName.setTextColor(color)
+                        }
+                        holder.adpAppName.text = it.appName
+                        holder.adpAppPkgName.text = it.packageName
+                        holder.adpCbrName.text = "贡献者：" + it.contributorName
+                        isAppNotifyHookOf(it).also { e ->
+                            holder.adpAppOpenSwitch.isChecked = e
+                            holder.adpAppAllSwitch.isEnabled = e
+                        }
+                        holder.adpAppOpenSwitch.setOnCheckedChangeListener { btn, b ->
+                            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+                            putAppNotifyHookOf(it, b)
+                            holder.adpAppAllSwitch.isEnabled = b
+                            SystemUITool.refreshSystemUI(context = this@ConfigureActivity)
+                        }
+                        holder.adpAppAllSwitch.isChecked = isAppNotifyHookAllOf(it)
+                        holder.adpAppAllSwitch.setOnCheckedChangeListener { btn, b ->
+                            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+                            fun saveState() {
+                                putAppNotifyHookAllOf(it, b)
+                                SystemUITool.refreshSystemUI(context = this@ConfigureActivity)
+                            }
+                            if (b) showDialog {
+                                title = "全部替换"
+                                msg = "此功能仅针对严重不遵守规范的 APP 通知图标才需要开启，例如：APP 推送通知后无法识别出现的黑白块图标。\n\n" +
+                                        "此功能在一般情况下请保持关闭并跟随在线规则的配置，并不要随意改变此配置，" +
+                                        "开启后 APP 的通知图标可能会被规则破坏，你确定还要开启吗？"
+                                confirmButton { saveState() }
+                                cancelButton { btn.isChecked = btn.isChecked.not() }
+                                noCancelable()
+                            } else saveState()
+                        }
+                    }
+                    return cView!!
+                }
+            }.apply {
+                setOnItemLongClickListener { _, _, p, _ ->
+                    showDialog {
+                        title = "复制“${iconDatas[p].appName}”的规则"
+                        msg = "是否复制单条规则到剪贴板？"
+                        confirmButton { copyToClipboard(iconDatas[p].toString()) }
+                        cancelButton()
+                    }
+                    true
+                }
+                onChanged = { notifyDataSetChanged() }
+            }
+            onScrollEvent = { post { setSelection(if (it) iconDatas.lastIndex else 0) } }
+        }
+        /** 设置点击事件 */
+        binding.configCbrButton.setOnClickListener {
+            showDialog {
+                title = "感谢你的贡献"
+                msg = "通知图标优化名单需要大家的共同维护才能得以完善，请选择你的贡献方式。"
+                confirmButton(text = "贡献规则") { openBrowser(url = "https://github.com/fankes/AndroidNotifyIconAdapt/blob/main/CONTRIBUTING.md") }
+                cancelButton(text = "请求适配") { openBrowser(url = "https://github.com/fankes/MIUINativeNotifyIcon/issues/new/choose") }
+                neutralButton(text = "暂时不用")
+            }
+        }
+        /** 装载数据 */
+        mockLocalData()
+        /** 更新数据 */
+        when {
+            intent?.getBooleanExtra("isNewAppSupport", false) == true ->
+                showDialog {
+                    val appName = intent?.getStringExtra("appName") ?: ""
+                    val pkgName = intent?.getStringExtra("pkgName") ?: ""
+                    title = "新安装应用通知图标适配"
+                    msg = "你已安装 $appName($pkgName)\n\n" +
+                            "此应用未在通知优化名单中发现适配数据，若此应用发送的通知为彩色图标，" +
+                            "可随时点击本页面下方的“贡献通知图标优化名单”按钮提交贡献或请求适配。\n\n" +
+                            "若你已知晓此应用会遵守原生通知图标规范，可忽略此提示。\n\n" +
+                            "你可以现在立即同步适配列表，以获取最新的适配数据。"
+                    confirmButton(text = "同步列表") { onStartRefresh() }
+                    cancelButton(text = "复制名称+包名") { copyToClipboard(content = "$appName($pkgName)") }
+                    neutralButton(text = "取消")
+                    noCancelable()
+                }
+            intent?.getBooleanExtra("isShowUpdDialog", true) == true -> onStartRefresh()
+        }
+        /** 清除数据 */
+        intent?.apply {
+            removeExtra("isNewAppSupport")
+            removeExtra("isShowUpdDialog")
+        }
+    }
+
+    /** 开始手动同步 */
+    private fun onStartRefresh() =
+        IconRuleManagerTool.syncByHand(context = this) {
+            filterText = ""
+            mockLocalData()
+        }
+
+    /** 装载或刷新本地数据 */
+    private fun mockLocalData() {
+        iconAllDatas = IconPackParams(context = this).iconDatas
+        refreshAdapterResult()
+    }
+
+    /** 刷新适配器结果相关 */
+    private fun refreshAdapterResult() {
+        onChanged?.invoke()
+        binding.configTitleCountText.text =
+            if (filterText.isBlank()) "已适配 ${iconDatas.size} 个 APP 的通知图标"
+            else "“${filterText}” 匹配到 ${iconDatas.size} 个结果"
+        binding.configListNoDataView.apply {
+            text = if (iconAllDatas.isEmpty()) "噫，竟然什么都没有~\n请点击右上角同步按钮获取云端数据" else "噫，竟然什么都没找到~"
+            isVisible = iconDatas.isEmpty()
+        }
+    }
+
+    /**
+     * 当前结果下的图标数组
+     * @return [Array]
+     */
+    private val iconDatas
+        get() = if (filterText.isBlank()) iconAllDatas
+        else iconAllDatas.filter {
+            it.appName.lowercase().contains(filterText.lowercase()) || it.packageName.lowercase().contains(filterText.lowercase())
+        }
+
+    override fun onBackPressed() {
+        if (MainActivity.isActivityLive.not())
+            showDialog {
+                title = "提示"
+                msg = "要返回模块主页吗？"
+                confirmButton {
+                    super.onBackPressed()
+                    navigate<MainActivity>()
+                }
+                cancelButton { super.onBackPressed() }
+            }
+        else super.onBackPressed()
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/MainActivity.kt

@@ -0,0 +1,359 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/1/24.
+ */
+@file:Suppress("SetTextI18n")
+
+package com.fankes.miui.notify.ui.activity
+
+import android.content.ComponentName
+import android.content.pm.PackageManager
+import android.widget.SeekBar
+import androidx.core.view.isGone
+import androidx.core.view.isVisible
+import com.fankes.miui.notify.BuildConfig
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.data.DataConst
+import com.fankes.miui.notify.databinding.ActivityMainBinding
+import com.fankes.miui.notify.databinding.DiaStatusIconCountBinding
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.*
+import com.fankes.miui.notify.utils.tool.GithubReleaseTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.fankes.miui.notify.utils.tool.YukiPromoteTool
+import com.highcapable.yukihookapi.YukiHookAPI
+import com.highcapable.yukihookapi.hook.factory.modulePrefs
+
+class MainActivity : BaseActivity<ActivityMainBinding>() {
+
+    companion object {
+
+        /** 窗口是否启动 */
+        internal var isActivityLive = false
+
+        /** 模块版本 */
+        private const val moduleVersion = BuildConfig.VERSION_NAME
+
+        /** 预发布的版本标识 */
+        private const val pendingFlag = ""
+    }
+
+    /** 模块是否可用 */
+    private var isModuleRegular = false
+
+    /** 模块是否有效 */
+    private var isModuleValied = false
+
+    override fun onCreate() {
+        /** 设置可用性 */
+        isActivityLive = true
+        /** 设置文本 */
+        binding.mainTextVersion.text = "模块版本：$moduleVersion $pendingFlag"
+        binding.mainTextMiuiVersion.text = "系统版本：$miuiFullVersion"
+        /** 检查更新 */
+        GithubReleaseTool.checkingForUpdate(context = this, moduleVersion) { version, function ->
+            binding.mainTextReleaseVersion.apply {
+                text = "点击更新 $version"
+                isVisible = true
+                setOnClickListener { function() }
+            }
+        }
+        when {
+            /** 判断是否为 MIUI 系统 */
+            isNotMIUI ->
+                showDialog {
+                    title = "不是 MIUI 系统"
+                    msg = "此模块专为 MIUI 系统打造，当前无法识别你的系统为 MIUI，所以模块无法工作。\n" +
+                            "如有问题请联系 酷安 @星夜不荟"
+                    confirmButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断最低 Android 系统版本 */
+            isLowerAndroidP ->
+                showDialog {
+                    title = "Android 系统版本过低"
+                    msg = "此模块最低支持基于 Android 9 的 MIUI 系统，你的系统版本过低不再进行适配。\n" +
+                            "如有问题请联系 酷安 @星夜不荟"
+                    confirmButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断最低 MIUI 版本 */
+            isNotSupportMiuiVersion ->
+                showDialog {
+                    title = "MIUI 版本过低"
+                    msg = "此模块最低支持 MIUI 12 系统，你的 MIUI 版本为 ${miuiVersion}，不再进行适配。\n" +
+                            "如有问题请联系 酷安 @星夜不荟"
+                    confirmButton(text = "退出") { finish() }
+                    noCancelable()
+                }
+            /** 判断是否 Hook */
+            YukiHookAPI.Status.isXposedModuleActive -> {
+                if (IconPackParams(context = this).iconDatas.isEmpty() && modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX))
+                    showDialog {
+                        title = "配置通知图标优化名单"
+                        msg = "模块需要获取在线规则以更新“通知图标优化名单”，它现在是空的，这看起来是你第一次使用模块，请首先进行配置才可以使用相关功能。\n" +
+                                "你可以随时在本页面下方找到“配置通知图标优化名单”手动前往。"
+                        confirmButton(text = "前往") { navigate<ConfigureActivity>() }
+                        cancelButton()
+                        noCancelable()
+                    }
+                if (isNotNoificationEnabled && modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX))
+                    showDialog {
+                        title = "模块的通知权限已关闭"
+                        msg = "请开启通知权限，以确保你能收到通知图标优化在线规则的更新。"
+                        confirmButton { openNotifySetting() }
+                        cancelButton()
+                        noCancelable()
+                    }
+                if (isLowerAndroidR && modulePrefs.get(DataConst.IGNORED_ANDROID_VERSION_TO_LOW).not())
+                    showDialog {
+                        title = "Android 版本过低"
+                        msg = "你当前使用的 Android 版本过低，模块的部分功能可能会发生问题，" +
+                                "由于设备有限，无法逐一调试，若有好的建议可向我们贡献代码提交适配请求，建议在 Android 11 及以上版本中使用效果最佳。"
+                        confirmButton(text = "我知道了") { modulePrefs.put(DataConst.IGNORED_ANDROID_VERSION_TO_LOW, value = true) }
+                        noCancelable()
+                    }
+                /** 推广、恰饭 */
+                YukiPromoteTool.promote(context = this)
+            }
+            else ->
+                showDialog {
+                    title = "模块没有激活"
+                    msg = "检测到模块没有激活，模块需要 Xposed 环境依赖，" +
+                            "同时需要系统拥有 Root 权限，" +
+                            "请自行查看本页面使用帮助与说明第二条。\n" +
+                            "由于需要修改系统应用达到效果，模块不支持太极阴、应用转生。"
+                    confirmButton(text = "我知道了")
+                    noCancelable()
+                }
+        }
+        var statusBarIconCount = modulePrefs.get(DataConst.HOOK_STATUS_ICON_COUNT)
+        var notifyIconAutoSyncTime = modulePrefs.get(DataConst.NOTIFY_ICON_FIX_AUTO_TIME)
+        binding.colorIconHookItem.isVisible = modulePrefs.get(DataConst.ENABLE_MODULE)
+        binding.statusIconCountItem.isVisible = modulePrefs.get(DataConst.ENABLE_MODULE)
+        binding.notifyIconConfigItem.isVisible = modulePrefs.get(DataConst.ENABLE_MODULE)
+        binding.notifyIconFixButton.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)
+        binding.notifyIconCustomCornerItem.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX) &&
+                modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FORCE_APP_ICON).not()
+        binding.notifyIconForceAppIconItem.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)
+        binding.notifyIconFixNotifyItem.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)
+        binding.notifyIconAutoSyncItem.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)
+        binding.statusIconCountSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_HOOK_STATUS_ICON_COUNT)
+        binding.statusIconCountChildItem.isVisible = modulePrefs.get(DataConst.ENABLE_HOOK_STATUS_ICON_COUNT)
+        binding.notifyIconAutoSyncChildItem.isVisible = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX_AUTO)
+        binding.moduleEnableSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_MODULE)
+        binding.moduleEnableLogSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_MODULE_LOG)
+        binding.hideIconInLauncherSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_HIDE_ICON)
+        binding.colorIconCompatSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_COLOR_ICON_COMPAT)
+        binding.notifyIconFixSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX)
+        binding.notifyIconForceAppIconSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FORCE_APP_ICON)
+        binding.notifyIconFixNotifySwitch.isChecked = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX_NOTIFY)
+        binding.notifyIconAutoSyncSwitch.isChecked = modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FIX_AUTO)
+        binding.notifyIconCustomCornerSeekbar.progress = modulePrefs.get(DataConst.NOTIFY_ICON_CORNER)
+        binding.notifyIconCustomCornerText.text = "${modulePrefs.get(DataConst.NOTIFY_ICON_CORNER)} dp"
+        binding.statusIconCountText.text = statusBarIconCount.toString()
+        binding.notifyIconAutoSyncText.text = notifyIconAutoSyncTime
+        binding.moduleEnableSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_MODULE, b)
+            binding.moduleEnableLogSwitch.isVisible = b
+            binding.colorIconHookItem.isVisible = b
+            binding.statusIconCountItem.isVisible = b
+            binding.notifyIconConfigItem.isVisible = b
+            SystemUITool.showNeedRestartSnake(context = this)
+        }
+        binding.moduleEnableLogSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_MODULE_LOG, b)
+            SystemUITool.showNeedRestartSnake(context = this)
+        }
+        binding.hideIconInLauncherSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_HIDE_ICON, b)
+            packageManager.setComponentEnabledSetting(
+                ComponentName(this@MainActivity, "com.fankes.miui.notify.Home"),
+                if (b) PackageManager.COMPONENT_ENABLED_STATE_DISABLED else PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+                PackageManager.DONT_KILL_APP
+            )
+        }
+        binding.statusIconCountSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_HOOK_STATUS_ICON_COUNT, b)
+            binding.statusIconCountChildItem.isVisible = b
+            SystemUITool.showNeedRestartSnake(context = this)
+        }
+        binding.colorIconCompatSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_COLOR_ICON_COMPAT, b)
+            SystemUITool.refreshSystemUI(context = this)
+        }
+        binding.notifyIconFixSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_NOTIFY_ICON_FIX, b)
+            binding.notifyIconFixButton.isVisible = b
+            binding.notifyIconCustomCornerItem.isVisible = b && modulePrefs.get(DataConst.ENABLE_NOTIFY_ICON_FORCE_APP_ICON).not()
+            binding.notifyIconForceAppIconItem.isVisible = b
+            binding.notifyIconFixNotifyItem.isVisible = b
+            binding.notifyIconAutoSyncItem.isVisible = b
+            SystemUITool.refreshSystemUI(context = this)
+        }
+        binding.notifyIconForceAppIconSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            fun saveState() {
+                binding.notifyIconCustomCornerItem.isVisible = b.not()
+                modulePrefs.put(DataConst.ENABLE_NOTIFY_ICON_FORCE_APP_ICON, b)
+                SystemUITool.refreshSystemUI(context = this)
+            }
+            if (b) showDialog {
+                title = "破坏性功能警告"
+                msg = "开启这个功能后，任何通知栏中的通知图标都会被强制替换为当前推送通知的 APP 的图标，" +
+                        "某些系统级别的 APP 通知图标可能会显示异常或发生图标丢失。\n\n" +
+                        "此功能仅面向一些追求图标美观度的用户，我们不推荐开启这个功能，且发生任何 BUG 都不会去修复，仍然继续开启吗？"
+                confirmButton { saveState() }
+                cancelButton { btn.isChecked = btn.isChecked.not() }
+                noCancelable()
+            } else saveState()
+        }
+        binding.notifyIconFixNotifySwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_NOTIFY_ICON_FIX_NOTIFY, b)
+            SystemUITool.refreshSystemUI(context = this, isRefreshCacheOnly = true)
+        }
+        binding.notifyIconAutoSyncSwitch.setOnCheckedChangeListener { btn, b ->
+            if (btn.isPressed.not()) return@setOnCheckedChangeListener
+            modulePrefs.put(DataConst.ENABLE_NOTIFY_ICON_FIX_AUTO, b)
+            binding.notifyIconAutoSyncChildItem.isVisible = b
+            SystemUITool.refreshSystemUI(context = this, isRefreshCacheOnly = true)
+        }
+        binding.notifyIconCustomCornerSeekbar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+            override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) {
+                binding.notifyIconCustomCornerText.text = "$progress dp"
+            }
+
+            override fun onStopTrackingTouch(seekBar: SeekBar) {
+                modulePrefs.put(DataConst.NOTIFY_ICON_CORNER, seekBar.progress)
+                SystemUITool.refreshSystemUI(context = this@MainActivity)
+            }
+
+            override fun onStartTrackingTouch(seekBar: SeekBar?) {}
+        })
+        /** 通知图标优化名单按钮点击事件 */
+        binding.notifyIconFixButton.setOnClickListener { navigate<ConfigureActivity>() }
+        /** 设置警告 */
+        binding.warnSCountDisTip.isGone = miuiVersionCode > 12.5
+        /** 修改状态栏通知图标个数按钮点击事件 */
+        binding.statusIconCountButton.setOnClickListener {
+            showDialog {
+                title = "设置最多显示的图标个数"
+                val editText = bind<DiaStatusIconCountBinding>().diaStatusIconCountInputEdit.apply {
+                    requestFocus()
+                    invalidate()
+                    setText(statusBarIconCount.toString())
+                    setSelection(statusBarIconCount.toString().length)
+                }
+                confirmButton {
+                    when {
+                        (runCatching { editText.text.toString().toInt() }.getOrNull() ?: -1)
+                                !in 0..100 -> snake(msg = "请输入有效数值")
+                        editText.text.toString().isNotBlank() -> runCatching {
+                            statusBarIconCount = editText.text.toString().trim().toInt()
+                            modulePrefs.put(DataConst.HOOK_STATUS_ICON_COUNT, statusBarIconCount)
+                            binding.statusIconCountText.text = statusBarIconCount.toString()
+                            SystemUITool.showNeedRestartSnake(context)
+                        }.onFailure { snake(msg = "数值格式无效") }
+                        else -> snake(msg = "请输入有效数值")
+                    }
+                }
+                cancelButton()
+            }
+        }
+        /** 自动更新在线规则修改时间按钮点击事件 */
+        binding.notifyIconAutoSyncButton.setOnClickListener {
+            showTimePicker(notifyIconAutoSyncTime) {
+                showDialog {
+                    title = "每天 $it 自动更新"
+                    msg = "设置保存后将在每天 $it 自动同步名单到最新云端数据，若数据已是最新则不会显示任何提示，否则会发送一条通知。\n\n" +
+                            "请确保：\n\n" +
+                            "1.模块没有被禁止前台以及后台联网权限\n" +
+                            "2.模块没有被禁止被其它 APP 关联唤醒\n" +
+                            "3.模块的系统通知权限已开启\n\n" +
+                            "模块无需保持在后台运行，到达同步时间后会自动启动，如果到达时间后模块正在运行则会自动取消本次计划任务。"
+                    confirmButton(text = "保存设置") {
+                        notifyIconAutoSyncTime = it
+                        binding.notifyIconAutoSyncText.text = it
+                        modulePrefs.put(DataConst.NOTIFY_ICON_FIX_AUTO_TIME, it)
+                        SystemUITool.refreshSystemUI(context, isRefreshCacheOnly = true)
+                    }
+                    cancelButton()
+                    noCancelable()
+                }
+            }
+        }
+        /** 重启按钮点击事件 */
+        binding.titleRestartIcon.setOnClickListener { SystemUITool.restartSystemUI(context = this) }
+        /** 项目地址按钮点击事件 */
+        binding.titleGithubIcon.setOnClickListener { openBrowser(url = "https://github.com/fankes/MIUINativeNotifyIcon") }
+        /** 恰饭！ */
+        binding.linkWithFollowMe.setOnClickListener {
+            openBrowser(url = "https://www.coolapk.com/u/876977", packageName = "com.coolapk.market")
+        }
+    }
+
+    /** 刷新模块状态 */
+    private fun refreshModuleStatus() {
+        binding.mainLinStatus.setBackgroundResource(
+            when {
+                YukiHookAPI.Status.isXposedModuleActive && (isModuleRegular.not() || isModuleValied.not()) -> R.drawable.bg_yellow_round
+                YukiHookAPI.Status.isXposedModuleActive -> R.drawable.bg_green_round
+                else -> R.drawable.bg_dark_round
+            }
+        )
+        binding.mainImgStatus.setImageResource(
+            when {
+                YukiHookAPI.Status.isXposedModuleActive -> R.mipmap.ic_success
+                else -> R.mipmap.ic_warn
+            }
+        )
+        binding.mainTextStatus.text =
+            when {
+                YukiHookAPI.Status.isXposedModuleActive && isModuleRegular.not() && modulePrefs.get(DataConst.ENABLE_MODULE).not() -> "模块已停用"
+                YukiHookAPI.Status.isXposedModuleActive && isModuleRegular.not() -> "模块已激活，请重启系统界面"
+                YukiHookAPI.Status.isXposedModuleActive && isModuleValied.not() -> "模块已更新，请重启系统界面"
+                YukiHookAPI.Status.isXposedModuleActive -> "模块已激活"
+                else -> "模块未激活"
+            }
+        binding.mainTextApiWay.isVisible = YukiHookAPI.Status.isXposedModuleActive
+        binding.mainTextApiWay.text = "Activated by ${YukiHookAPI.Status.executorName} API ${YukiHookAPI.Status.executorVersion}"
+    }
+
+    override fun onResume() {
+        super.onResume()
+        /** 刷新模块状态 */
+        refreshModuleStatus()
+        /** 检查模块激活状态 */
+        SystemUITool.checkingActivated(context = this) { isValied ->
+            isModuleRegular = true
+            isModuleValied = isValied
+            refreshModuleStatus()
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/auto/NotifyIconRuleUpdateActivity.kt

@@ -0,0 +1,61 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/3/26.
+ */
+@file:Suppress("DEPRECATION")
+
+package com.fankes.miui.notify.ui.activity.auto
+
+import android.app.Activity
+import android.os.Bundle
+import android.view.View
+import android.view.WindowManager
+import com.fankes.miui.notify.ui.activity.base.BaseActivity
+import com.fankes.miui.notify.utils.factory.delayedRun
+import com.fankes.miui.notify.utils.tool.IconRuleManagerTool
+import com.fankes.miui.notify.utils.tool.SystemUITool
+import com.highcapable.yukihookapi.hook.xposed.application.ModuleApplication.Companion.appContext
+
+class NotifyIconRuleUpdateActivity : Activity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        /** 设置透明窗口 */
+        window?.decorView?.systemUiVisibility =
+            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+        window?.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS)
+        window?.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION)
+        /** 检测运行状态 */
+        if (BaseActivity.isMainThreadRunning) {
+            finish()
+            return
+        }
+        /** 拉取云端数据 */
+        IconRuleManagerTool.sync(appContext) {
+            /** 刷新系统界面 */
+            SystemUITool.refreshSystemUI()
+            /** 结束当前窗口 */
+            runOnUiThread { delayedRun(ms = 1000) { finish() } }
+        }
+        /** 切换到后台 */
+        moveTaskToBack(true)
+    }
+}

app/src/main/java/com/fankes/miui/notify/ui/activity/base/BaseActivity.kt

@@ -0,0 +1,79 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/1/30.
+ */
+@file:Suppress("UNCHECKED_CAST")
+
+package com.fankes.miui.notify.ui.activity.base
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.content.res.ResourcesCompat
+import androidx.core.view.ViewCompat
+import androidx.viewbinding.ViewBinding
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.utils.factory.isNotSystemInDarkMode
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.type.android.LayoutInflaterClass
+import java.lang.reflect.ParameterizedType
+
+abstract class BaseActivity<VB : ViewBinding> : AppCompatActivity() {
+
+    companion object {
+
+        /** 应用是否正在运行 */
+        var isMainThreadRunning = false
+    }
+
+    /** 获取绑定布局对象 */
+    lateinit var binding: VB
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        isMainThreadRunning = true
+        javaClass.genericSuperclass.also { type ->
+            if (type is ParameterizedType) {
+                binding = (type.actualTypeArguments[0] as Class<VB>).method {
+                    name = "inflate"
+                    param(LayoutInflaterClass)
+                }.get().invoke<VB>(layoutInflater) ?: error("binding failed")
+                setContentView(binding.root)
+            } else error("binding but got wrong type")
+        }
+        /** 隐藏系统的标题栏 */
+        supportActionBar?.hide()
+        /** 初始化沉浸状态栏 */
+        ViewCompat.getWindowInsetsController(window.decorView)?.apply {
+            isAppearanceLightStatusBars = isNotSystemInDarkMode
+            isAppearanceLightNavigationBars = isNotSystemInDarkMode
+        }
+        ResourcesCompat.getColor(resources, R.color.colorThemeBackground, null).also {
+            window?.statusBarColor = it
+            window?.navigationBarColor = it
+            window?.navigationBarDividerColor = it
+        }
+        /** 装载子类 */
+        onCreate()
+    }
+
+    /** 回调 [onCreate] 方法 */
+    abstract fun onCreate()
+}

app/src/main/java/com/fankes/miui/notify/ui/view/MaterialSwitch.kt

@@ -22,15 +22,17 @@
  */
 @file:Suppress("SameParameterValue")
 
-package com.fankes.miui.notify.view
+package com.fankes.miui.notify.ui.view
 
 import android.content.Context
 import android.content.res.ColorStateList
 import android.graphics.Color
+import android.text.TextUtils
 import android.util.AttributeSet
 import androidx.appcompat.widget.SwitchCompat
 import com.fankes.miui.notify.utils.drawable.drawabletoolbox.DrawableBuilder
 import com.fankes.miui.notify.utils.factory.dp
+import com.fankes.miui.notify.utils.factory.isSystemInDarkMode
 
 class MaterialSwitch(context: Context, attrs: AttributeSet?) : SwitchCompat(context, attrs) {
 
@@ -43,27 +45,31 @@ class MaterialSwitch(context: Context, attrs: AttributeSet?) : SwitchCompat(cont
         return ColorStateList(states, colors)
     }
 
+    private val thumbColor get() = if (context.isSystemInDarkMode) 0xFF7C7C7C else 0xFFCCCCCC
+
     init {
         trackDrawable = DrawableBuilder()
             .rectangle()
             .rounded()
             .solidColor(0xFF656565.toInt())
-            .height(20.dp(context).toInt())
-            .cornerRadius(15.dp(context).toInt())
+            .height(20.dp(context))
+            .cornerRadius(15.dp(context))
             .build()
         thumbDrawable = DrawableBuilder()
             .rectangle()
             .rounded()
             .solidColor(Color.WHITE)
-            .size(20.dp(context).toInt(), 20.dp(context).toInt())
-            .cornerRadius(20.dp(context).toInt())
-            .strokeWidth(8.dp(context).toInt())
+            .size(20.dp(context), 20.dp(context))
+            .cornerRadius(20.dp(context))
+            .strokeWidth(8.dp(context))
             .strokeColor(Color.TRANSPARENT)
             .build()
         trackTintList = toColors(
             0xFF656565.toInt(),
-            0xFFCCCCCC.toInt(),
-            0xFFCCCCCC.toInt()
+            thumbColor.toInt(),
+            thumbColor.toInt()
         )
+        isSingleLine = true
+        ellipsize = TextUtils.TruncateAt.END
     }
 }

app/src/main/java/com/fankes/miui/notify/utils/factory/DialogBuilderFactory.kt

@@ -20,94 +20,190 @@
  *
  * This file is Created by fankes on 2022/1/7.
  */
-@file:Suppress("unused", "DEPRECATION")
+@file:Suppress("unused", "OPT_IN_USAGE", "EXPERIMENTAL_API_USAGE")
 
 package com.fankes.miui.notify.utils.factory
 
-import android.app.AlertDialog
+import android.app.Dialog
+import android.app.TimePickerDialog
 import android.content.Context
-import android.util.DisplayMetrics
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
 import android.view.LayoutInflater
 import android.view.View
-import android.view.WindowManager
-import kotlin.math.round
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import android.widget.ProgressBar
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.viewbinding.ViewBinding
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.highcapable.yukihookapi.annotation.CauseProblemsApi
+import com.highcapable.yukihookapi.hook.factory.method
+import com.highcapable.yukihookapi.hook.type.android.LayoutInflaterClass
 
 /**
  * 构造对话框
- * @param it 对话框方法体
+ * @param isUseBlackTheme 是否使用深色主题
+ * @param initiate 对话框方法体
  */
-fun Context.showDialog(it: DialogBuilder.() -> Unit) = DialogBuilder(this).apply(it).show()
+fun Context.showDialog(isUseBlackTheme: Boolean = false, initiate: DialogBuilder.() -> Unit) =
+    DialogBuilder(context = this, isUseBlackTheme).apply(initiate).show()
+
+/**
+ * 显示时间选择对话框
+ * @param timeSet 当前时间 - 不写将使用当前时间格式：HH:mm
+ * @param result 回调 - 小时与分钟 HH:mm
+ */
+fun Context.showTimePicker(timeSet: String = "", result: (String) -> Unit) =
+    TimePickerDialog(this, { _, h, m -> result("${h.autoZero}:${m.autoZero}") }, timeSet.hour, timeSet.minute, true).show()
 
 /**
  * 对话框构造器
  * @param context 实例
+ * @param isUseBlackTheme 是否使用深色主题 - 对 AndroidX 风格无效
  */
-class DialogBuilder(private val context: Context) {
+class DialogBuilder(val context: Context, private val isUseBlackTheme: Boolean) {
 
-    private var instance: AlertDialog.Builder? = null // 实例对象
+    private var instanceAndroidX: androidx.appcompat.app.AlertDialog.Builder? = null // 实例对象
+    private var instanceAndroid: android.app.AlertDialog.Builder? = null // 实例对象
 
-    private var customLayoutView: View? = null // 自定义布局
+    private var dialogInstance: Dialog? = null // 对话框实例
+
+    @CauseProblemsApi
+    var customLayoutView: View? = null // 自定义布局
+
+    /**
+     * 是否需要使用 AndroidX 风格对话框
+     * @return [Boolean]
+     */
+    private val isUsingAndroidX get() = runCatching { context is AppCompatActivity }.getOrNull() ?: false
 
     init {
-        instance = AlertDialog.Builder(context, android.R.style.Theme_Material_Light_Dialog)
+        if (isUsingAndroidX)
+            runInSafe { instanceAndroidX = MaterialAlertDialogBuilder(context) }
+        else runInSafe {
+            instanceAndroid = android.app.AlertDialog.Builder(
+                context,
+                if (isUseBlackTheme) android.R.style.Theme_Material_Dialog else android.R.style.Theme_Material_Light_Dialog
+            )
+        }
     }
 
     /** 设置对话框不可关闭 */
-    fun noCancelable() = instance?.setCancelable(false)
+    fun noCancelable() {
+        if (isUsingAndroidX)
+            runInSafe { instanceAndroidX?.setCancelable(false) }
+        else runInSafe { instanceAndroid?.setCancelable(false) }
+    }
 
     /** 设置对话框标题 */
     var title
         get() = ""
         set(value) {
-            instance?.setTitle(value)
+            if (isUsingAndroidX)
+                runInSafe { instanceAndroidX?.setTitle(value) }
+            else runInSafe { instanceAndroid?.setTitle(value) }
         }
 
     /** 设置对话框消息内容 */
     var msg
         get() = ""
         set(value) {
-            instance?.setMessage(value)
+            if (isUsingAndroidX)
+                runInSafe { instanceAndroidX?.setMessage(value) }
+            else runInSafe { instanceAndroid?.setMessage(value) }
+        }
+
+    /** 设置进度条对话框消息内容 */
+    var progressContent
+        get() = ""
+        set(value) {
+            if (customLayoutView == null)
+                customLayoutView = LinearLayout(context).apply {
+                    orientation = LinearLayout.HORIZONTAL
+                    gravity = Gravity.CENTER or Gravity.START
+                    addView(ProgressBar(context))
+                    addView(View(context).apply { layoutParams = ViewGroup.LayoutParams(20.dp(context), 5) })
+                    addView(TextView(context).apply {
+                        tag = "progressContent"
+                        text = value
+                    })
+                    setPadding(20.dp(context), 20.dp(context), 20.dp(context), 20.dp(context))
+                }
+            else customLayoutView?.findViewWithTag<TextView>("progressContent")?.text = value
         }
 
     /**
      * 设置对话框自定义布局
-     * @param resId 属性资源 Id
-     * @return [View]
+     * @return [ViewBinding]
      */
-    fun addView(resId: Int): View {
-        customLayoutView = LayoutInflater.from(context).inflate(resId, null)
-        return customLayoutView ?: error("Inflate $resId failed")
-    }
+    inline fun <reified T : ViewBinding> bind() =
+        T::class.java.method {
+            name = "inflate"
+            param(LayoutInflaterClass)
+        }.get().invoke<T>(LayoutInflater.from(context))?.apply {
+            customLayoutView = root
+        } ?: error("binding failed")
 
     /**
      * 设置对话框确定按钮
      * @param text 按钮文本内容
-     * @param it 点击事件
+     * @param callback 点击事件
      */
-    fun confirmButton(text: String = "确定", it: () -> Unit = {}) =
-        instance?.setPositiveButton(text) { _, _ -> it() }
+    fun confirmButton(text: String = "确定", callback: () -> Unit = {}) {
+        if (isUsingAndroidX)
+            runInSafe { instanceAndroidX?.setPositiveButton(text) { _, _ -> callback() } }
+        else runInSafe { instanceAndroid?.setPositiveButton(text) { _, _ -> callback() } }
+    }
 
     /**
      * 设置对话框取消按钮
      * @param text 按钮文本内容
-     * @param it 点击事件
+     * @param callback 点击事件
      */
-    fun cancelButton(text: String = "取消", it: () -> Unit = {}) =
-        instance?.setNegativeButton(text) { _, _ -> it() }
+    fun cancelButton(text: String = "取消", callback: () -> Unit = {}) {
+        if (isUsingAndroidX)
+            runInSafe { instanceAndroidX?.setNegativeButton(text) { _, _ -> callback() } }
+        else runInSafe { instanceAndroid?.setNegativeButton(text) { _, _ -> callback() } }
+    }
 
     /**
      * 设置对话框第三个按钮
      * @param text 按钮文本内容
-     * @param it 点击事件
+     * @param callback 点击事件
      */
-    fun neutralButton(text: String = "更多", it: () -> Unit = {}) =
-        instance?.setNeutralButton(text) { _, _ -> it() }
+    fun neutralButton(text: String = "更多", callback: () -> Unit = {}) {
+        if (isUsingAndroidX)
+            runInSafe { instanceAndroidX?.setNeutralButton(text) { _, _ -> callback() } }
+        else runInSafe { instanceAndroid?.setNeutralButton(text) { _, _ -> callback() } }
+    }
+
+    /** 取消对话框 */
+    fun cancel() = dialogInstance?.cancel()
 
     /** 显示对话框 */
-    internal fun show() = instance?.create()?.apply {
-        val dm = DisplayMetrics()
-        (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay.getMetrics(dm)
-        customLayoutView?.let { setView(it.apply { minimumWidth = round(x = dm.widthPixels / 1.3).toInt() }) }
-        setDefaultStyle(context = this@DialogBuilder.context)
-    }?.show()
+    internal fun show() =
+        if (isUsingAndroidX) runInSafe {
+            instanceAndroidX?.create()?.apply {
+                customLayoutView?.let { setView(it) }
+                dialogInstance = this
+            }?.show()
+        } else runInSafe {
+            instanceAndroid?.create()?.apply {
+                customLayoutView?.let { setView(it) }
+                window?.setBackgroundDrawable(
+                    GradientDrawable(
+                        GradientDrawable.Orientation.TOP_BOTTOM,
+                        if (isUseBlackTheme) intArrayOf(0xFF2D2D2D.toInt(), 0xFF2D2D2D.toInt())
+                        else intArrayOf(Color.WHITE, Color.WHITE)
+                    ).apply {
+                        shape = GradientDrawable.RECTANGLE
+                        gradientType = GradientDrawable.LINEAR_GRADIENT
+                        cornerRadius = 15.dpFloat(this@DialogBuilder.context)
+                    })
+                dialogInstance = this
+            }?.show()
+        }
 }

app/src/main/java/com/fankes/miui/notify/utils/factory/ExceptionFactory.kt

@@ -78,6 +78,6 @@ inline fun <T> safeOf(default: T, result: () -> T) = try {
  * @param msg 出错输出的消息 - 默认为空
  * @param block 正常回调
  */
-inline fun <T> T.runSafe(msg: String = "", block: () -> Unit) {
+inline fun <T> T.runInSafe(msg: String = "", block: () -> Unit) {
     runCatching(block).onFailure { if (msg.isNotBlank()) loggerE(msg = msg, e = it) }
 }

app/src/main/java/com/fankes/miui/notify/utils/factory/FunctionFactory.kt

@@ -25,39 +25,45 @@
 package com.fankes.miui.notify.utils.factory
 
 import android.app.Activity
-import android.app.AlertDialog
+import android.app.Notification
+import android.app.Service
+import android.app.WallpaperManager
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
 import android.content.Intent
+import android.content.pm.ApplicationInfo
 import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.content.res.Configuration
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.graphics.Color
-import android.graphics.drawable.GradientDrawable
+import android.graphics.*
+import android.graphics.drawable.Drawable
+import android.net.ConnectivityManager
 import android.net.Uri
 import android.os.Build
+import android.os.Handler
 import android.provider.Settings
 import android.util.Base64
 import android.widget.Toast
-import com.fankes.miui.notify.application.MNNApplication.Companion.appContext
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.getSystemService
 import com.google.android.material.snackbar.Snackbar
 import com.highcapable.yukihookapi.hook.factory.classOf
 import com.highcapable.yukihookapi.hook.factory.hasClass
 import com.highcapable.yukihookapi.hook.factory.method
 import com.highcapable.yukihookapi.hook.type.java.StringType
+import com.highcapable.yukihookapi.hook.xposed.application.ModuleApplication.Companion.appContext
 import com.topjohnwu.superuser.Shell
 import java.io.ByteArrayOutputStream
+import java.text.SimpleDateFormat
+import java.util.*
 
 
 /**
  * 系统深色模式是否开启
  * @return [Boolean] 是否开启
  */
-val isSystemInDarkMode
-    get() = (appContext.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+val isSystemInDarkMode get() = appContext.isSystemInDarkMode
 
 /**
  * 系统深色模式是否没开启
@@ -71,12 +77,6 @@ inline val isNotSystemInDarkMode get() = !isSystemInDarkMode
  */
 val Context.isSystemInDarkMode get() = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
 
-/**
- * 通知栏是否为 MIUI 样式
- * @return [Boolean] 是否符合条件
- */
-val Context.isMiuiNotifyStyle get() = safeOfFalse { Settings.System.getInt(contentResolver, "status_bar_notification_style") == 0 }
-
 /**
  * 系统深色模式是否没开启
  * @return [Boolean] 是否开启
@@ -95,6 +95,12 @@ inline val isUpperOfAndroidS get() = Build.VERSION.SDK_INT > Build.VERSION_CODES
  */
 inline val isLowerAndroidP get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.P
 
+/**
+ * 系统版本是否低于 Android 11
+ * @return [Boolean] 是否符合条件
+ */
+inline val isLowerAndroidR get() = Build.VERSION.SDK_INT < Build.VERSION_CODES.R
+
 /**
  * 当前设备是否是 MIUI 定制 Android 系统
  * @return [Boolean] 是否符合条件
@@ -151,12 +157,18 @@ val miuiVersion
  */
 val miuiVersionCode get() = safeOf(default = 0f) { miuiVersion.toFloat() }
 
+/**
+ * 获取 MIUI 次版本号
+ * @return [String]
+ */
+val miuiIncrementalVersion get() = findPropString(key = "ro.system.build.version.incremental").trim()
+
 /**
  * 获取 MIUI 完全版本
  * @return [String]
  */
 val miuiFullVersion
-    get() = if (isMIUI) findPropString(key = "ro.system.build.version.incremental").let {
+    get() = if (isMIUI) miuiIncrementalVersion.let {
         if (it.lowercase().contains("a") ||
             it.lowercase().contains("b") ||
             it.lowercase().contains("c") ||
@@ -218,11 +230,112 @@ val Context.versionName get() = packageInfo.versionName ?: ""
 val Context.versionCode get() = packageInfo.versionCode
 
 /**
- * dp 转换为 px
+ * 得到 APP 名称
+ * @param name APP 包名
+ * @return [String]
+ */
+fun Context.findAppName(name: String) =
+    safeOfNothing { packageManager?.getPackageInfo(name, 0)?.applicationInfo?.loadLabel(packageManager).toString() }
+
+/**
+ * 得到 APP 图标
+ * @param name APP 包名
+ * @return [Drawable] or null
+ */
+fun Context.findAppIcon(name: String) =
+    safeOfNull { packageManager?.getPackageInfo(name, 0)?.applicationInfo?.loadIcon(packageManager) }
+
+/**
+ * 获取 APP 是否为 DEBUG 版本
+ * @param name APP 包名
+ * @return [Boolean]
+ */
+fun Context.isAppDebuggable(name: String) =
+    safeOfFalse { (packageManager?.getPackageInfo(name, 0)?.applicationInfo?.flags?.and(ApplicationInfo.FLAG_DEBUGGABLE) ?: 0) != 0 }
+
+/**
+ * 对数值自动补零
+ * @return [String]
+ */
+val Int.autoZero: String get() = if (this < 10) "0$this" else toString()
+
+/**
+ * 从字符串获取小时
+ * @return [Int]
+ */
+val String.hour
+    get() = safeOfNan {
+        Calendar.getInstance().also {
+            it.time = SimpleDateFormat("HH:mm", Locale.CHINA).parse(this) as Date
+        }.get(Calendar.HOUR_OF_DAY)
+    }
+
+/**
+ * 从字符串获取分钟
+ * @return [Int]
+ */
+val String.minute
+    get() = safeOfNan {
+        Calendar.getInstance().also {
+            it.time = SimpleDateFormat("HH:mm", Locale.CHINA).parse(this) as Date
+        }.get(Calendar.MINUTE)
+    }
+
+/**
+ * 是否关闭了通知权限
+ * @return [Boolean]
+ */
+val isNotNoificationEnabled get() = !NotificationManagerCompat.from(appContext).areNotificationsEnabled()
+
+/**
+ * 网络连接是否正常
+ * @return [Boolean] 网络是否连接
+ */
+val isNetWorkSuccess
+    get() = safeOfFalse { appContext.getSystemService<ConnectivityManager>()?.activeNetworkInfo != null }
+
+/**
+ * dp 转换为 pxInt
+ * @param context 使用的实例
+ * @return [Int]
+ */
+fun Number.dp(context: Context) = dpFloat(context).toInt()
+
+/**
+ * dp 转换为 pxFloat
  * @param context 使用的实例
  * @return [Float]
  */
-fun Number.dp(context: Context) = (toFloat() * context.resources.displayMetrics.density)
+fun Number.dpFloat(context: Context) = toFloat() * context.resources.displayMetrics.density
+
+/**
+ * 获取系统主题色
+ * @return [Int] Android < 12 返回 [wallpaperColor]
+ */
+val Context.systemAccentColor
+    get() = safeOf(wallpaperColor) { if (isUpperOfAndroidS) resources.getColor(android.R.color.system_accent1_600) else wallpaperColor }
+
+/**
+ * 获取系统壁纸颜色
+ * @return [Int] 无法获取时返回透明色
+ */
+val Context.wallpaperColor
+    get() = safeOfNan {
+        WallpaperManager.getInstance(this).getWallpaperColors(WallpaperManager.FLAG_SYSTEM)?.primaryColor?.toArgb() ?: 0
+    }
+
+/**
+ * 获取较浅的颜色
+ * @return [Int]
+ */
+val Int.brighter: Int
+    get() {
+        val hsv = FloatArray(3)
+        Color.colorToHSV(this, hsv)
+        hsv[1] = hsv[1] - 0.3f
+        hsv[2] = hsv[2] + 0.3f
+        return Color.HSVToColor(hsv)
+    }
 
 /**
  * 是否为白色
@@ -272,19 +385,24 @@ val ByteArray.bitmap: Bitmap get() = BitmapFactory.decodeByteArray(this, 0, size
 val String.bitmap: Bitmap get() = unbase64.bitmap
 
 /**
- * 设置对话框默认风格
- * @param context 使用的实例
+ * 圆角图片
+ * @param radius 圆角度
+ * @return [Bitmap] 圆角后的位图 - 失败会返回处理之前的位图
  */
-fun AlertDialog.setDefaultStyle(context: Context) =
-    window?.setBackgroundDrawable(
-        GradientDrawable(
-            GradientDrawable.Orientation.TOP_BOTTOM,
-            intArrayOf(Color.WHITE, Color.WHITE)
-        ).apply {
-            shape = GradientDrawable.RECTANGLE
-            gradientType = GradientDrawable.LINEAR_GRADIENT
-            cornerRadius = 15.dp(context)
-        })
+fun Bitmap.round(radius: Float): Bitmap = safeOf(default = this) {
+    Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).also { out ->
+        Canvas(out).also { canvas ->
+            Paint().also { paint ->
+                paint.isAntiAlias = true
+                canvas.drawARGB(0, 0, 0, 0)
+                paint.color = Color.WHITE
+                canvas.drawRoundRect(RectF(Rect(0, 0, width, height)), radius, radius, paint)
+                paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN)
+                canvas.drawBitmap(this, Rect(0, 0, width, height), Rect(0, 0, width, height), paint)
+            }
+        }
+    }
+}
 
 /**
  * 获取系统 Prop 值
@@ -300,12 +418,19 @@ fun findPropString(key: String, default: String = "") = safeOf(default) {
 }
 
 /**
- * 执行命令 - su
+ * 是否有 Root 权限
+ * @return [Boolean]
+ */
+val isRootAccess get() = safeOfFalse { Shell.rootAccess() }
+
+/**
+ * 执行命令
  * @param cmd 命令
+ * @param isSu 是否使用 Root 权限执行 - 默认：是
  * @return [String] 执行结果
  */
-fun execShellSu(cmd: String) = safeOfNothing {
-    Shell.su(cmd).exec().out.let {
+fun execShell(cmd: String, isSu: Boolean = true) = safeOfNothing {
+    (if (isSu) Shell.su(cmd) else Shell.sh(cmd)).exec().out.let {
         if (it.isNotEmpty()) it[0].trim() else ""
     }
 }
@@ -316,18 +441,29 @@ fun execShellSu(cmd: String) = safeOfNothing {
  */
 fun toast(msg: String) = Toast.makeText(appContext, msg, Toast.LENGTH_SHORT).show()
 
+/**
+ * 跳转到指定页面
+ *
+ * [T] 为指定的 [Activity]
+ */
+inline fun <reified T : Activity> Context.navigate() = runInSafe {
+    startActivity(Intent(if (this is Service) applicationContext else this, T::class.java).apply {
+        if (this@navigate !is Activity) flags = Intent.FLAG_ACTIVITY_NEW_TASK
+    })
+}
+
 /**
  * 弹出 [Snackbar]
  * @param msg 提示内容
  * @param actionText 按钮文本 - 不写默认取消按钮
- * @param it 按钮事件回调
+ * @param callback 按钮事件回调
  */
-fun Context.snake(msg: String, actionText: String = "", it: () -> Unit = {}) =
+fun Context.snake(msg: String, actionText: String = "", callback: () -> Unit = {}) =
     Snackbar.make((this as Activity).findViewById(android.R.id.content), msg, Snackbar.LENGTH_LONG)
         .apply {
             if (actionText.isBlank()) return@apply
-            setActionTextColor(Color.WHITE)
-            setAction(actionText) { it() }
+            setActionTextColor(if (isSystemInDarkMode) Color.BLACK else Color.WHITE)
+            setAction(actionText) { callback() }
         }.show()
 
 /**
@@ -349,15 +485,54 @@ fun Context.openBrowser(url: String, packageName: String = "") = runCatching {
     else snake(msg = "启动系统浏览器失败")
 }
 
+/**
+ * 跳转 APP 自身设置界面
+ * @param packageName 包名
+ */
+fun Context.openSelfSetting(packageName: String = appContext.packageName) = runCatching {
+    if (packageName.isInstall)
+        startActivity(Intent().apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+            data = Uri.fromParts("package", packageName, null)
+        })
+    else toast(msg = "你没有安装此应用")
+}.onFailure { toast(msg = "启动 $packageName 应用信息失败") }
+
+/** 跳转通知设置界面 */
+fun Context.openNotifySetting() = runCatching {
+    Intent().also { intent ->
+        intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
+        intent.putExtra(Notification.EXTRA_CHANNEL_ID, applicationInfo.uid)
+        startActivity(intent)
+    }
+}.onFailure { snake(msg = "跳转通知设置失败") }
+
 /**
  * 复制到剪贴板
  * @param content 要复制的文本
  */
-fun Context.copyToClipboard(content: String) = runSafe {
+fun Context.copyToClipboard(content: String) = runInSafe {
     (getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager).apply {
         setPrimaryClip(ClipData.newPlainText(null, content))
         (primaryClip?.getItemAt(0)?.text ?: "").also {
             if (it != content) snake(msg = "复制失败") else snake(msg = "已复制")
         }
     }
-}
+}
+
+/**
+ * 时间戳 -> 时间
+ * @param format 格式化方法 - 默认：yyyy-MM-dd HH:mm:ss
+ * @return [String] 目标字符串时间
+ */
+fun Long.stampToDate(format: String = "yyyy-MM-dd HH:mm:ss") =
+    safeOfNothing { SimpleDateFormat(format, Locale.CHINA).format(Date(this)) ?: "" }
+
+/**
+ * 延迟执行
+ * @param ms 毫秒 - 默认：150
+ * @param it 方法体
+ */
+fun Any?.delayedRun(ms: Long = 150, it: () -> Unit) = runInSafe { Handler().postDelayed({ it() }, ms) }

app/src/main/java/com/fankes/miui/notify/utils/tool/BitmapCompatTool.kt

@@ -88,7 +88,7 @@ object BitmapCompatTool {
             ensureBufferSize(size)
             tempCompactBitmap?.getPixels(tempBuffer, 0, width, 0, 0, width, height)
             for (i in 0 until size)
-                if (!isGrayscaleColor(tempBuffer[i])) {
+                if (isGrayscaleColor(tempBuffer[i]).not()) {
                     cachedBitmapGrayscales[bitmap.generationId] = false
                     return@let false
                 }

app/src/main/java/com/fankes/miui/notify/utils/tool/ClientRequestTool.kt

@@ -1,150 +0,0 @@
-/*
- * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
- * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
- * https://github.com/fankes/MIUINativeNotifyIcon
- *
- * This software is non-free but opensource software: you can redistribute it
- * and/or modify it under the terms of the GNU Affero General Public License
- * as published by the Free Software Foundation; either
- * version 3 of the License, or any later version.
- * <p>
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * and eula along with this software.  If not, see
- * <https://www.gnu.org/licenses/>
- *
- * This file is Created by fankes on 2022/2/25.
- */
-@file:Suppress("TrustAllX509TrustManager", "CustomX509TrustManager", "DEPRECATION")
-
-package com.fankes.miui.notify.utils.tool
-
-import android.app.Activity
-import android.app.ProgressDialog
-import android.content.Intent
-import android.net.Uri
-import android.provider.Settings
-import com.fankes.miui.notify.utils.factory.safeOfNull
-import com.fankes.miui.notify.utils.factory.setDefaultStyle
-import com.fankes.miui.notify.utils.factory.showDialog
-import com.fankes.miui.notify.utils.factory.snake
-import com.highcapable.yukihookapi.hook.log.loggerD
-import okhttp3.*
-import java.io.IOException
-import java.security.SecureRandom
-import java.security.cert.X509Certificate
-import javax.net.ssl.*
-
-/**
- * 网络请求管理类
- */
-object ClientRequestTool {
-
-    /**
-     * 检查网络连接情况
-     * @param context 实例
-     * @param it 已连接回调
-     */
-    fun checkingInternetConnect(context: Activity, it: () -> Unit) =
-        ProgressDialog(context).apply {
-            setDefaultStyle(context)
-            setCancelable(false)
-            setTitle("准备中")
-            setMessage("正在检查网络连接情况")
-        }.apply {
-            wait(context, url = "https://www.baidu.com") { isDone, _ ->
-                cancel()
-                if (isDone) it() else
-                    context.showDialog {
-                        title = "网络不可用"
-                        msg = "无法连接到互联网，请检查你当前的设备是否可以上网，且没有在手机管家中禁用本模块的联网权限。"
-                        confirmButton(text = "检查设置") {
-                            runCatching {
-                                context.startActivity(Intent().apply {
-                                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                                    action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
-                                    data = Uri.fromParts("package", context.packageName, null)
-                                })
-                            }.onFailure { context.snake(msg = "启动应用信息页面失败") }
-                        }
-                        cancelButton()
-                    }
-            }
-        }.show()
-
-    /**
-     * 发送 GET 请求内容并等待
-     * @param context 实例
-     * @param url 请求地址
-     * @param it 回调 - ([Boolean] 是否成功,[String] 成功的内容或失败消息)
-     */
-    fun wait(context: Activity, url: String, it: (Boolean, String) -> Unit) = runCatching {
-        OkHttpClient().newBuilder().apply {
-            SSLSocketClient.sSLSocketFactory?.let { sslSocketFactory(it, SSLSocketClient.trustManager) }
-            hostnameVerifier(SSLSocketClient.hostnameVerifier)
-        }.build().newCall(
-            Request.Builder()
-                .url(url)
-                .get()
-                .build()
-        ).enqueue(object : Callback {
-            override fun onFailure(call: Call, e: IOException) {
-                context.runOnUiThread { it(false, e.toString()) }
-            }
-
-            override fun onResponse(call: Call, response: Response) {
-                val bodyString = response.body?.string() ?: ""
-                context.runOnUiThread { it(true, bodyString) }
-            }
-        })
-    }.onFailure { it(false, "URL 无效") }
-
-    /**
-     * 自动信任 SSL 证书
-     *
-     * 放行全部加密 SSL 请求
-     */
-    object SSLSocketClient {
-
-        /**
-         * 格式化实例
-         * @return [SSLSocketFactory] or null
-         */
-        val sSLSocketFactory
-            get() = safeOfNull {
-                SSLContext.getInstance("TLS").let {
-                    it.init(null, arrayOf<TrustManager>(trustManager), SecureRandom())
-                    it.socketFactory
-                }
-            }
-
-        /**
-         * 使用的实例
-         * @return [HostnameVerifier]
-         */
-        val hostnameVerifier get() = HostnameVerifier { _, _ -> true }
-
-        /**
-         * 信任管理者
-         * @return [X509TrustManager]
-         */
-        val trustManager
-            get() = object : X509TrustManager {
-
-                override fun checkClientTrusted(chain: Array<X509Certificate?>?, authType: String?) {
-                    loggerD(msg = "TrustX509 --> $authType")
-                }
-
-                override fun checkServerTrusted(chain: Array<X509Certificate?>?, authType: String?) {
-                    loggerD(msg = "TrustX509 --> $authType")
-                }
-
-                override fun getAcceptedIssuers() = arrayOf<X509Certificate>()
-            }
-    }
-}

app/src/main/java/com/fankes/miui/notify/utils/tool/GithubReleaseTool.kt

@@ -0,0 +1,128 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/3/20.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Activity
+import android.content.Context
+import com.fankes.miui.notify.utils.factory.*
+import okhttp3.*
+import org.json.JSONObject
+import java.io.IOException
+import java.io.Serializable
+
+/**
+ * 获取 Github Release 最新版本工具类
+ */
+object GithubReleaseTool {
+
+    /** 仓库作者 */
+    private const val REPO_AUTHOR = "fankes"
+
+    /** 仓库名称 */
+    private const val REPO_NAME = "MIUINativeNotifyIcon"
+
+    /**
+     * 获取最新版本信息
+     * @param context 实例
+     * @param version 当前版本
+     * @param result 成功后回调 - ([String] 最新版本,[Function] 更新对话框方法体)
+     */
+    fun checkingForUpdate(context: Context, version: String, result: (String, () -> Unit) -> Unit) = checkingInternetConnect(context) {
+        OkHttpClient().newBuilder().build().newCall(
+            Request.Builder()
+                .url("https://api.github.com/repos/$REPO_AUTHOR/$REPO_NAME/releases/latest")
+                .get()
+                .build()
+        ).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {}
+
+            override fun onResponse(call: Call, response: Response) = runInSafe {
+                JSONObject(response.body?.string() ?: "").apply {
+                    GithubReleaseBean(
+                        name = getString("name"),
+                        htmlUrl = getString("html_url"),
+                        content = getString("body"),
+                        date = getString("published_at").replace(oldValue = "T", newValue = " ").replace(oldValue = "Z", newValue = "")
+                    ).apply {
+                        fun showUpdate() = context.showDialog {
+                            title = "最新版本 $name"
+                            msg = "发布于 $date\n\n" +
+                                    "更新日志\n\n" + content
+                            confirmButton(text = "更新") { context.openBrowser(htmlUrl) }
+                            cancelButton()
+                        }
+                        if (name != version) (context as? Activity?)?.runOnUiThread {
+                            showUpdate()
+                            result(name) { showUpdate() }
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param callback 已连接回调
+     */
+    private fun checkingInternetConnect(context: Context, callback: () -> Unit) = runInSafe {
+        if (isNetWorkSuccess)
+            OkHttpClient().newBuilder().build().newCall(
+                Request.Builder()
+                    .url("https://www.baidu.com")
+                    .get()
+                    .build()
+            ).enqueue(object : Callback {
+                override fun onFailure(call: Call, e: IOException) {
+                    (context as? Activity?)?.runOnUiThread {
+                        context.showDialog {
+                            title = "网络不可用"
+                            msg = "模块的联网权限可能已被禁用，请开启联网权限以定期检查更新。"
+                            confirmButton(text = "去开启") { context.openSelfSetting() }
+                            cancelButton()
+                            noCancelable()
+                        }
+                    }
+                }
+
+                override fun onResponse(call: Call, response: Response) = runInSafe {
+                    (context as? Activity?)?.runOnUiThread { runInSafe { callback() } }
+                }
+            })
+    }
+
+    /**
+     * Github Release bean
+     * @param name 版本名称
+     * @param htmlUrl 网页地址
+     * @param content 更新日志
+     * @param date 发布时间
+     */
+    private data class GithubReleaseBean(
+        var name: String,
+        var htmlUrl: String,
+        var content: String,
+        var date: String
+    ) : Serializable
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/IconAdaptationTool.kt

@@ -0,0 +1,192 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/3/21.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.drawable.Icon
+import android.os.Build
+import androidx.core.graphics.drawable.toBitmap
+import com.fankes.miui.notify.BuildConfig
+import com.fankes.miui.notify.hook.HookEntry
+import com.fankes.miui.notify.utils.factory.*
+
+/**
+ * 通知图标适配推送通知类
+ *
+ * 这个类需要在 [HookEntry] 中调用
+ */
+object IconAdaptationTool {
+
+    /** 当前模块的包名 */
+    private const val MODULE_PACKAGE_NAME = BuildConfig.APPLICATION_ID
+
+    /** 推送通知的渠道名称 */
+    private const val NOTIFY_CHANNEL = "notifyRuleSupportId"
+
+    /** 已过期的日期 */
+    private val outDateLimits = HashSet<String>()
+
+    /**
+     * 使用的小图标
+     * @return [Bitmap]
+     */
+    private val smallIcon by lazy {
+        ("iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAACXBIWXMAAAsTAAALEwEAmpwYAAAG\n" +
+                "x2lUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkP\n" +
+                "SJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG\n" +
+                "9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNi4wLWMwMDYgNzkuZGF\n" +
+                "iYWNiYiwgMjAyMS8wNC8xNC0wMDozOTo0NCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6\n" +
+                "cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gP\n" +
+                "HJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYW\n" +
+                "RvYmUuY29tL3hhcC8xLjAvIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1\n" +
+                "lbnRzLzEuMS8iIHhtbG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90\n" +
+                "b3Nob3AvMS4wLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuM\n" +
+                "C9tbS8iIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cG\n" +
+                "UvUmVzb3VyY2VFdmVudCMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIDI\n" +
+                "yLjQgKE1hY2ludG9zaCkiIHhtcDpDcmVhdGVEYXRlPSIyMDIyLTAzLTIzVDAyOjU1OjM2\n" +
+                "KzA4OjAwIiB4bXA6TW9kaWZ5RGF0ZT0iMjAyMi0wMy0yM1QwMzowMDoyMSswODowMCIge\n" +
+                "G1wOk1ldGFkYXRhRGF0ZT0iMjAyMi0wMy0yM1QwMzowMDoyMSswODowMCIgZGM6Zm9ybW\n" +
+                "F0PSJpbWFnZS9wbmciIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBob3Rvc2hvcDpJQ0N\n" +
+                "Qcm9maWxlPSJzUkdCIElFQzYxOTY2LTIuMSIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlp\n" +
+                "ZDpiZGY1YWY2NS1lYjYxLTRiOGUtOTk1NS01OTE5OThkN2ExNDAiIHhtcE1NOkRvY3VtZ\n" +
+                "W50SUQ9ImFkb2JlOmRvY2lkOnBob3Rvc2hvcDo2MDFlYjQ1OC01ZTdlLWFjNDYtODA0Mi\n" +
+                "1iNWJmYTFhYWQwNGMiIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDpjYTU\n" +
+                "4YTA1ZS04OTU1LTQyNzItODg2NC0xNmI5MWI0YzcxMmUiPiA8eG1wTU06SGlzdG9yeT4g\n" +
+                "PHJkZjpTZXE+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJjcmVhdGVkIiBzdEV2dDppbnN0Y\n" +
+                "W5jZUlEPSJ4bXAuaWlkOmNhNThhMDVlLTg5NTUtNDI3Mi04ODY0LTE2YjkxYjRjNzEyZS\n" +
+                "Igc3RFdnQ6d2hlbj0iMjAyMi0wMy0yM1QwMjo1NTozNiswODowMCIgc3RFdnQ6c29mdHd\n" +
+                "hcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIDIyLjQgKE1hY2ludG9zaCkiLz4gPHJkZjps\n" +
+                "aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjg5Y\n" +
+                "mIxNTI1LWVjYmMtNGY2NC1iZTRlLWU1N2EyNjQ1NDE1YyIgc3RFdnQ6d2hlbj0iMjAyMi\n" +
+                "0wMy0yM1QwMjo1NzoxMCswODowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGh\n" +
+                "vdG9zaG9wIDIyLjQgKE1hY2ludG9zaCkiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPHJkZjps\n" +
+                "aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOmJkZ\n" +
+                "jVhZjY1LWViNjEtNGI4ZS05OTU1LTU5MTk5OGQ3YTE0MCIgc3RFdnQ6d2hlbj0iMjAyMi\n" +
+                "0wMy0yM1QwMzowMDoyMSswODowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGh\n" +
+                "vdG9zaG9wIDIyLjQgKE1hY2ludG9zaCkiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPC9yZGY6\n" +
+                "U2VxPiA8L3htcE1NOkhpc3Rvcnk+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+I\n" +
+                "DwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+QdGsggAAA35JREFUaIHtmE2IVW\n" +
+                "Ucxn9z0Ukm7cMSo1AxUwjNIclLRVSL0CAoyD5oYwS1iogWGW0rwQpcJNjCRdKmTR+SBhF\n" +
+                "BWWZlZllmOgsT/EqHKRuqMVv8XJy5zPGd95x75hyh03Ae+C/O//2/z3Oee97P26MyGdD6\n" +
+                "r1/gQqExUjc0RuqGxkjd0BipGxojdcOkMTKlS/tCYBXQBvqBWcA/wI/AD8AW4NML9C79w\n" +
+                "APAYmAOcCUwCBwCvgTeB37J7K3Goq1utRgG1NUZPEXibnVnQa231CUxnhjxmoKkId5WWx\n" +
+                "M08XpJrSe7GXmlJHEH36l9oUgketRPKmqtS3P2OHaxWgO8HBl9vwPbgM+AU8B0YAnJ3Fk\n" +
+                "Uqd8HLAfO5MyHz4HbIvkh4ENgJ/Dn6DxZCdxFfGF6GngtPUeuz3D9qnpZzi/7mDoS6fe9\n" +
+                "Oi1SP0XdnqH1vDo9Q2eeujmj33WmhtbuSMFTOQbSsUg9Gem/3/HDbEuk7ox6c0GtZyP9d\n" +
+                "3WMLIg0vlGQuBPz1cEIzx51aqouxN/qsglqvRnhWYj6UpAcVnsnSN75/MciIntTfC+m8r\n" +
+                "+qi0vo9Kp/BBrrUD8KkutLkHdijvpbxMy3jn2Z1eoL6uUVdDYE/NtRjwfJ+yoIoF6rnoi\n" +
+                "Y2VORNx33B9wHWsDMYEk7m7NsFsEhYBlwMsjfCOwFplbkBzgdPPe2gOEg2e38VQQnSMwM\n" +
+                "BvmlwBfAtIr8FwXPIy1gf5BsVxS5ieTQd5zEzFDQvhzYBfRU0OgPnk/j+GPJYMlx26d+P\n" +
+                "MpxNjXX5hlfmneYbJBltAYCrk2YnCZDnHeOKRAXqz8FHMOp9mtMltsQu0uYeTzC085yqL\n" +
+                "qqIPFMdV+k/46gbr7xpflrz98086Kt/hv0P6JjR5RbIwKqz5h/NF/p+OVb9bA6O1I/N6P\n" +
+                "+Z/WWLiYezXjHO9JGMBlOMRxW16r3mhwn7jS5D2Rdho6ps3JeKGuYaXKnedhkL5qhLlWf\n" +
+                "UL/KqN/Y4Q1FNmd0KIqj6tU5JtJmjnThGu7S/k6aMyayvpSF5FfL+xJhXKF+U1JrU8iXJ\n" +
+                "bLC7M8Z4pTJXJrIypOO59ShgloH1YdiPOkbYgy3A48ANwBXAZcCIyQ79gDwAfAe8FeFzQ\n" +
+                "3gEuBB4B5gATAb6BvlPUpy63wX2JpF0M3I/waT5g+6xkjd0BipGxojdUNjpG5ojNQNjZG\n" +
+                "64Rx5J7QeMy++3AAAAABJRU5ErkJggg==").bitmap
+    }
+
+    /**
+     * 推送新 APP 安装适配通知
+     * @param context 实例
+     * @param packageName 安装的 APP 包名
+     */
+    fun pushNewAppSupportNotify(context: Context, packageName: String) {
+        if (context.isAppDebuggable(packageName)) return
+        context.getSystemService(NotificationManager::class.java)?.apply {
+            createNotificationChannel(
+                NotificationChannel(
+                    NOTIFY_CHANNEL, "通知图标优化适配",
+                    NotificationManager.IMPORTANCE_DEFAULT
+                ).apply { enableLights(false) }
+            )
+            notify(packageName.hashCode(), Notification.Builder(context, NOTIFY_CHANNEL).apply {
+                setShowWhen(true)
+                setContentTitle("您已安装 ${context.findAppName(packageName)}")
+                setContentText("尚未适配此应用，点按打开在线规则。")
+                setColor(0xFF2993F0.toInt())
+                setAutoCancel(true)
+                setSmallIcon(Icon.createWithBitmap(smallIcon))
+                setLargeIcon(context.findAppIcon(packageName)?.toBitmap())
+                setContentIntent(
+                    PendingIntent.getActivity(
+                        context, packageName.hashCode(),
+                        Intent().apply {
+                            component = ComponentName(
+                                MODULE_PACKAGE_NAME,
+                                "${MODULE_PACKAGE_NAME}.ui.activity.ConfigureActivity"
+                            )
+                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                        }.apply {
+                            putExtra("isNewAppSupport", true)
+                            putExtra("appName", context.findAppName(packageName))
+                            putExtra("pkgName", packageName)
+                        }, if (Build.VERSION.SDK_INT < 31) PendingIntent.FLAG_UPDATE_CURRENT else PendingIntent.FLAG_IMMUTABLE
+                    )
+                )
+            }.build())
+        }
+    }
+
+    /**
+     * 检测 APP 卸载后移除相关通知
+     * @param context 实例
+     * @param packageName 卸载的 APP 包名
+     */
+    fun removeNewAppSupportNotify(context: Context, packageName: String) = runInSafe {
+        context.getSystemService(NotificationManager::class.java)?.cancel(packageName.hashCode())
+    }
+
+    /**
+     * 自动更新通知图标优化在线规则
+     *
+     * 一天执行一次
+     * @param context 实例
+     * @param timeSet 设定的时间
+     */
+    fun prepareAutoUpdateIconRule(context: Context, timeSet: String) = runInSafe {
+        System.currentTimeMillis().also {
+            if (it.stampToDate(format = "HH:mm") == timeSet && (outDateLimits.isEmpty() || outDateLimits.none { each ->
+                    each == it.stampToDate(format = "yyyy-MM-dd")
+                })) {
+                outDateLimits.add(it.stampToDate(format = "yyyy-MM-dd"))
+                context.startActivity(
+                    Intent().apply {
+                        component = ComponentName(
+                            MODULE_PACKAGE_NAME,
+                            "${MODULE_PACKAGE_NAME}.ui.activity.auto.NotifyIconRuleUpdateActivity"
+                        )
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    }
+                )
+            }
+        }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/IconRuleManagerTool.kt

@@ -0,0 +1,457 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/2/25.
+ */
+@file:Suppress("TrustAllX509TrustManager", "CustomX509TrustManager", "IMPLICIT_CAST_TO_ANY")
+
+package com.fankes.miui.notify.utils.tool
+
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.NotificationCompat
+import androidx.core.content.getSystemService
+import androidx.core.view.isVisible
+import androidx.core.widget.doOnTextChanged
+import com.fankes.miui.notify.R
+import com.fankes.miui.notify.data.DataConst
+import com.fankes.miui.notify.databinding.DiaSourceFromBinding
+import com.fankes.miui.notify.databinding.DiaSourceFromStringBinding
+import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_1
+import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_2
+import com.fankes.miui.notify.hook.HookConst.TYPE_SOURCE_SYNC_WAY_3
+import com.fankes.miui.notify.params.IconPackParams
+import com.fankes.miui.notify.ui.activity.ConfigureActivity
+import com.fankes.miui.notify.utils.factory.safeOfNull
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.fankes.miui.notify.utils.factory.snake
+import com.highcapable.yukihookapi.hook.factory.modulePrefs
+import com.highcapable.yukihookapi.hook.log.loggerD
+import okhttp3.*
+import java.io.IOException
+import java.security.SecureRandom
+import java.security.cert.X509Certificate
+import javax.net.ssl.*
+
+/**
+ * 通知图标在线规则管理类
+ */
+object IconRuleManagerTool {
+
+    /** 推送通知的渠道名称 */
+    private const val NOTIFY_CHANNEL = "notifyRuleUpdateId"
+
+    /** 当前规则的系统名称 */
+    private const val OS_TAG = "MIUI"
+
+    /** 当前规则的通知图标颜色 */
+    private const val OS_COLOR = 0xFFE06818
+
+    /**
+     * 从在线地址手动同步规则
+     * @param context 实例
+     * @param callback 成功后回调
+     */
+    fun syncByHand(context: Context, callback: () -> Unit) =
+        context.showDialog {
+            title = "同步列表"
+            var sourceType = context.modulePrefs.get(DataConst.SOURCE_SYNC_WAY)
+            var customUrl = context.modulePrefs.get(DataConst.SOURCE_SYNC_WAY_CUSTOM_URL)
+            bind<DiaSourceFromBinding>().apply {
+                diaSfText.apply {
+                    if (customUrl.isNotBlank()) {
+                        setText(customUrl)
+                        setSelection(customUrl.length)
+                    }
+                    doOnTextChanged { text, _, _, _ -> customUrl = text.toString() }
+                }
+                diaSfTextLin.isVisible = sourceType == TYPE_SOURCE_SYNC_WAY_3
+                diaSfRd1.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_1
+                diaSfRd2.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_2
+                diaSfRd3.isChecked = sourceType == TYPE_SOURCE_SYNC_WAY_3
+                diaSfRd1.setOnClickListener {
+                    diaSfRd2.isChecked = false
+                    diaSfRd3.isChecked = false
+                    diaSfTextLin.isVisible = false
+                    sourceType = TYPE_SOURCE_SYNC_WAY_1
+                }
+                diaSfRd2.setOnClickListener {
+                    diaSfRd1.isChecked = false
+                    diaSfRd3.isChecked = false
+                    diaSfTextLin.isVisible = false
+                    sourceType = TYPE_SOURCE_SYNC_WAY_2
+                }
+                diaSfRd3.setOnClickListener {
+                    diaSfRd1.isChecked = false
+                    diaSfRd2.isChecked = false
+                    diaSfTextLin.isVisible = true
+                    sourceType = TYPE_SOURCE_SYNC_WAY_3
+                }
+            }
+            confirmButton {
+                context.modulePrefs.put(DataConst.SOURCE_SYNC_WAY, sourceType)
+                context.modulePrefs.put(DataConst.SOURCE_SYNC_WAY_CUSTOM_URL, customUrl)
+                sync(context, sourceType, customUrl, callback)
+            }
+            cancelButton()
+            neutralButton(text = "自定义规则") {
+                context.showDialog {
+                    title = "自定义规则(调试)"
+                    val editText = bind<DiaSourceFromStringBinding>().diaSfsInputEdit.apply {
+                        requestFocus()
+                        invalidate()
+                    }
+                    IconPackParams(context).also { params ->
+                        confirmButton(text = "合并") {
+                            editText.text.toString().also { jsonString ->
+                                when {
+                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> context.snake(msg = "不是有效的 JSON 数据")
+                                    jsonString.isNotBlank() -> {
+                                        params.save(
+                                            params.splicingJsonArray(
+                                                dataJson1 = params.storageDataJson ?: "[]",
+                                                dataJson2 = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]"
+                                            )
+                                        )
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> context.snake(msg = "请输入有效内容")
+                                }
+                            }
+                        }
+                        cancelButton(text = "覆盖") {
+                            editText.text.toString().also { jsonString ->
+                                when {
+                                    jsonString.isNotBlank() && params.isNotVaildJson(jsonString) -> context.snake(msg = "不是有效的 JSON 数据")
+                                    jsonString.isNotBlank() -> {
+                                        params.save(dataJson = jsonString.takeIf { params.isJsonArray(it) } ?: "[$jsonString]")
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> context.snake(msg = "请输入有效内容")
+                                }
+                            }
+                        }
+                    }
+                    neutralButton(text = "取消")
+                }
+            }
+        }
+
+    /**
+     * 从在线地址同步规则
+     * @param context 实例
+     * @param sourceType 同步地址类型 - 默认自动获取已存储的键值
+     * @param customUrl 自定义同步地址 - 默认自动获取已存储的键值
+     * @param callback 成功后回调
+     */
+    fun sync(
+        context: Context,
+        sourceType: Int = context.modulePrefs.get(DataConst.SOURCE_SYNC_WAY),
+        customUrl: String = context.modulePrefs.get(DataConst.SOURCE_SYNC_WAY_CUSTOM_URL),
+        callback: () -> Unit
+    ) {
+        when (sourceType) {
+            TYPE_SOURCE_SYNC_WAY_1 ->
+                onRefreshing(context, url = "https://raw.fastgit.org/fankes/AndroidNotifyIconAdapt/main", callback)
+            TYPE_SOURCE_SYNC_WAY_2 ->
+                onRefreshing(context, url = "https://raw.githubusercontent.com/fankes/AndroidNotifyIconAdapt/main", callback)
+            TYPE_SOURCE_SYNC_WAY_3 ->
+                if (customUrl.isNotBlank())
+                    if (customUrl.startsWith("http://") || customUrl.startsWith("https://"))
+                        onRefreshingCustom(context, customUrl, callback)
+                    else context.snakeOrNotify(title = "同步失败", msg = "同步地址不是一个合法的 URL")
+                else context.snakeOrNotify(title = "同步失败", msg = "同步地址不能为空")
+            else -> context.snakeOrNotify(title = "同步异常", msg = "同步类型错误")
+        }
+    }
+
+    /**
+     * 开始更新数据
+     * @param context 实例
+     * @param url
+     * @param callback 成功后回调
+     */
+    private fun onRefreshing(context: Context, url: String, callback: () -> Unit) = checkingInternetConnect(context) {
+        fun doParse(result: (Boolean) -> Unit = {}) {
+            wait(context, url = "$url/OS/$OS_TAG/NotifyIconsSupportConfig.json") { isDone1, ctOS ->
+                result(true)
+                wait(context, url = "$url/APP/NotifyIconsSupportConfig.json") { isDone2, ctAPP ->
+                    result(false)
+                    IconPackParams(context).also { params ->
+                        when {
+                            isDone1 && isDone2 -> params.splicingJsonArray(ctOS, ctAPP).also {
+                                when {
+                                    params.isHackString(it) ->
+                                        context.snakeOrNotify(title = "同步错误", msg = "请求需要验证，请尝试魔法上网或关闭魔法")
+                                    params.isNotVaildJson(it) ->
+                                        context.snakeOrNotify(title = "同步错误", msg = "目标地址不是有效的 JSON 数据")
+                                    params.isCompareDifferent(it) -> {
+                                        params.save(it)
+                                        pushNotify(context, title = "同步完成", msg = "已更新通知图标优化名单，点击查看")
+                                        notifyRefresh(context)
+                                        callback()
+                                    }
+                                    else -> (if (context is AppCompatActivity) context.snake(msg = "列表数据已是最新"))
+                                }
+                            }
+                            context is AppCompatActivity ->
+                                context.showDialog {
+                                    title = "连接失败"
+                                    msg = "连接失败，错误如下：\n${if (isDone1.not()) ctOS else ctAPP}"
+                                    confirmButton(text = "再试一次") { syncByHand(context, callback) }
+                                    cancelButton()
+                                }
+                            else -> pushNotify(context, title = "同步地址不可用", msg = if (isDone1.not()) ctOS else ctAPP)
+                        }
+                    }
+                }
+            }
+        }
+        if (context is AppCompatActivity)
+            context.showDialog {
+                title = "同步中"
+                progressContent = "正在同步 OS 数据"
+                noCancelable()
+                doParse { if (it) progressContent = "正在同步 APP 数据" else cancel() }
+            }
+        else doParse()
+    }
+
+    /**
+     * 开始更新数据
+     * @param context 实例
+     * @param url
+     * @param callback 成功后回调
+     */
+    private fun onRefreshingCustom(context: Context, url: String, callback: () -> Unit) = checkingInternetConnect(context) {
+        fun doParse(result: () -> Unit = {}) {
+            wait(context, url) { isDone, content ->
+                result()
+                IconPackParams(context).also { params ->
+                    when {
+                        isDone -> when {
+                            params.isHackString(content) ->
+                                context.snakeOrNotify(title = "同步错误", msg = "请求需要验证，请尝试魔法上网或关闭魔法")
+                            params.isNotVaildJson(content) ->
+                                context.snakeOrNotify(title = "同步错误", msg = "目标地址不是有效的 JSON 数据")
+                            params.isCompareDifferent(content) -> {
+                                params.save(content)
+                                pushNotify(context, title = "同步完成", msg = "已更新通知图标优化名单，点击查看")
+                                notifyRefresh(context)
+                                callback()
+                            }
+                            else -> (if (context is AppCompatActivity) context.snake(msg = "列表数据已是最新"))
+                        }
+                        context is AppCompatActivity ->
+                            context.showDialog {
+                                title = "连接失败"
+                                msg = "连接失败，错误如下：\n$content"
+                                confirmButton(text = "我知道了")
+                            }
+                        else -> pushNotify(context, title = "同步地址不可用", msg = content)
+                    }
+                }
+            }
+        }
+        if (context is AppCompatActivity)
+            context.showDialog {
+                title = "同步中"
+                progressContent = "正在通过自定义地址同步数据"
+                noCancelable()
+                doParse { cancel() }
+            }
+        else doParse()
+    }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param callback 已连接回调
+     */
+    private fun checkingInternetConnect(context: Context, callback: () -> Unit) =
+        if (context is AppCompatActivity) context.showDialog {
+            title = "准备中"
+            progressContent = "正在检查网络连接情况"
+            noCancelable()
+            baseCheckingInternetConnect(context) { isDone ->
+                cancel()
+                if (isDone) callback() else
+                    context.showDialog {
+                        title = "网络不可用"
+                        msg = "无法连接到互联网，请检查你当前的设备是否可以上网，且没有在手机管家中禁用本模块的联网权限。"
+                        confirmButton(text = "检查设置") {
+                            runCatching {
+                                context.startActivity(Intent().apply {
+                                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                                    action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+                                    data = Uri.fromParts("package", context.packageName, null)
+                                })
+                            }.onFailure { context.snake(msg = "启动应用信息页面失败") }
+                        }
+                        cancelButton()
+                    }
+            }
+        } else baseCheckingInternetConnect(context) { isDone ->
+            if (isDone) callback() else pushNotify(context, title = "网络不可用", msg = "无法连接到互联网，无法更新通知图标规则")
+        }
+
+    /**
+     * 检查网络连接情况
+     * @param context 实例
+     * @param result 已连接回调
+     */
+    private fun baseCheckingInternetConnect(context: Context, result: (Boolean) -> Unit) =
+        wait(context, url = "https://www.baidu.com") { isDone, _ -> result(isDone) }
+
+    /**
+     * 发送 GET 请求内容并等待
+     * @param context 实例
+     * @param url 请求地址
+     * @param result 回调 - ([Boolean] 是否成功,[String] 成功的内容或失败消息)
+     */
+    private fun wait(context: Context, url: String, result: (Boolean, String) -> Unit) = runCatching {
+        OkHttpClient().newBuilder().apply {
+            SSLSocketClient.sSLSocketFactory?.let { sslSocketFactory(it, SSLSocketClient.trustManager) }
+            hostnameVerifier(SSLSocketClient.hostnameVerifier)
+        }.build().newCall(
+            Request.Builder()
+                .url(url)
+                .get()
+                .build()
+        ).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                (context as? Activity?)?.runOnUiThread { result(false, e.toString()) } ?: result(false, e.toString())
+            }
+
+            override fun onResponse(call: Call, response: Response) {
+                val bodyString = response.body?.string() ?: ""
+                (context as? Activity?)?.runOnUiThread { result(true, bodyString) } ?: result(true, bodyString)
+            }
+        })
+    }.onFailure { result(false, "URL 无效") }
+
+    /**
+     * 推送通知图标更新通知
+     * @param context 实例
+     */
+    private fun notifyRefresh(context: Context) {
+        if (context !is AppCompatActivity) return
+        SystemUITool.refreshSystemUI(context) { context.snake(msg = "通知图标优化名单已完成同步") }
+    }
+
+    /**
+     * 根据实例类型决定推送通知还是弹出提示
+     * @param title 标题 - 仅对通知生效
+     * @param msg 消息内容
+     */
+    private fun Context.snakeOrNotify(title: String, msg: String) {
+        if (this !is AppCompatActivity)
+            pushNotify(context = this, title, msg)
+        else snake(msg)
+    }
+
+    /**
+     * 推送通知
+     * @param context 实例 - 类型为 [AppCompatActivity] 时将不会推送通知
+     * @param title 通知标题
+     * @param msg 通知消息
+     */
+    private fun pushNotify(context: Context, title: String, msg: String) {
+        if (context !is AppCompatActivity)
+            context.getSystemService<NotificationManager>()?.apply {
+                createNotificationChannel(
+                    NotificationChannel(
+                        NOTIFY_CHANNEL, "通知图标优化规则",
+                        NotificationManager.IMPORTANCE_DEFAULT
+                    )
+                )
+                notify(0, NotificationCompat.Builder(context, NOTIFY_CHANNEL).apply {
+                    setContentTitle(title)
+                    setContentText(msg)
+                    color = OS_COLOR.toInt()
+                    setAutoCancel(true)
+                    setSmallIcon(R.drawable.ic_nf_icon_update)
+                    setSound(null)
+                    setDefaults(NotificationCompat.DEFAULT_ALL)
+                    setContentIntent(
+                        PendingIntent.getActivity(
+                            context, msg.hashCode(),
+                            Intent(context, ConfigureActivity::class.java).apply { putExtra("isShowUpdDialog", false) },
+                            if (Build.VERSION.SDK_INT < 31) PendingIntent.FLAG_UPDATE_CURRENT else PendingIntent.FLAG_IMMUTABLE
+                        )
+                    )
+                }.build())
+            }
+    }
+
+    /**
+     * 自动信任 SSL 证书
+     *
+     * 放行全部加密 SSL 请求
+     */
+    private object SSLSocketClient {
+
+        /**
+         * 格式化实例
+         * @return [SSLSocketFactory] or null
+         */
+        val sSLSocketFactory
+            get() = safeOfNull {
+                SSLContext.getInstance("TLS").let {
+                    it.init(null, arrayOf<TrustManager>(trustManager), SecureRandom())
+                    it.socketFactory
+                }
+            }
+
+        /**
+         * 使用的实例
+         * @return [HostnameVerifier]
+         */
+        val hostnameVerifier get() = HostnameVerifier { _, _ -> true }
+
+        /**
+         * 信任管理者
+         * @return [X509TrustManager]
+         */
+        val trustManager
+            get() = object : X509TrustManager {
+
+                override fun checkClientTrusted(chain: Array<X509Certificate?>?, authType: String?) {
+                    loggerD(msg = "TrustX509 --> $authType")
+                }
+
+                override fun checkServerTrusted(chain: Array<X509Certificate?>?, authType: String?) {
+                    loggerD(msg = "TrustX509 --> $authType")
+                }
+
+                override fun getAcceptedIssuers() = arrayOf<X509Certificate>()
+            }
+    }
+}

app/src/main/java/com/fankes/miui/notify/utils/tool/SystemUITool.kt

@@ -23,18 +23,44 @@
 package com.fankes.miui.notify.utils.tool
 
 import android.content.Context
-import com.fankes.miui.notify.utils.factory.execShellSu
-import com.fankes.miui.notify.utils.factory.showDialog
-import com.fankes.miui.notify.utils.factory.snake
-import com.fankes.miui.notify.utils.factory.toast
+import com.fankes.miui.notify.hook.HookConst.SYSTEMUI_PACKAGE_NAME
+import com.fankes.miui.notify.utils.factory.*
 import com.google.android.material.snackbar.Snackbar
-import com.highcapable.yukihookapi.hook.xposed.YukiHookModuleStatus
+import com.highcapable.yukihookapi.YukiHookAPI
+import com.highcapable.yukihookapi.hook.factory.dataChannel
+import com.highcapable.yukihookapi.hook.param.PackageParam
+import com.highcapable.yukihookapi.hook.xposed.channel.data.ChannelData
 
 /**
  * 系统界面工具
  */
 object SystemUITool {
 
+    private val CALL_HOST_REFRESH_CACHING = ChannelData("call_host_refresh_caching", false)
+    private val CALL_MODULE_REFRESH_RESULT = ChannelData("call_module_refresh_result", false)
+
+    /**
+     * 宿主注册监听
+     */
+    object Host {
+
+        /**
+         * 监听系统界面刷新改变
+         * @param param 实例
+         * @param result 回调 - ([Boolean] 是否成功)
+         */
+        fun onRefreshSystemUI(param: PackageParam, result: (Boolean) -> Boolean) {
+            param.dataChannel.with { wait(CALL_HOST_REFRESH_CACHING) { put(CALL_MODULE_REFRESH_RESULT, result(it)) } }
+        }
+    }
+
+    /**
+     * 检查模块是否激活
+     * @param context 实例
+     * @param result 成功后回调
+     */
+    fun checkingActivated(context: Context, result: (Boolean) -> Unit) = context.dataChannel(SYSTEMUI_PACKAGE_NAME).checkingVersionEquals(result)
+
     /**
      * 重启系统界面
      * @param context 实例
@@ -43,32 +69,66 @@ object SystemUITool {
         context.showDialog {
             title = "重启系统界面"
             msg = "你确定要立即重启系统界面吗？\n\n" +
-                    "部分 MIUI 系统使用了状态栏主题可能会发生主题失效的情况，这种情况请再重启一次即可。"
+                    "部分 MIUI 内测和开发版中使用了状态栏主题可能会发生主题失效的情况，这种情况请再重启一次即可。\n\n" +
+                    "重启过程会黑屏并等待进入锁屏重新解锁。"
             confirmButton {
-                execShellSu(cmd = "pgrep systemui").also { pid ->
+                execShell(cmd = "pgrep systemui").also { pid ->
                     if (pid.isNotBlank())
-                        execShellSu(cmd = "kill -9 $pid")
+                        execShell(cmd = "kill -9 $pid")
                     else toast(msg = "ROOT 权限获取失败")
                 }
             }
             cancelButton()
         }
 
+    /**
+     * 刷新系统界面状态栏与通知图标
+     * @param context 实例
+     * @param isRefreshCacheOnly 仅刷新缓存不刷新图标和通知改变 - 默认：否
+     * @param callback 成功后回调
+     */
+    fun refreshSystemUI(context: Context? = null, isRefreshCacheOnly: Boolean = false, callback: () -> Unit = {}) = runInSafe {
+        if (YukiHookAPI.Status.isXposedModuleActive)
+            context?.showDialog {
+                title = "请稍后"
+                progressContent = "正在等待系统界面刷新"
+                /** 是否等待成功 */
+                var isWaited = false
+                /** 设置等待延迟 */
+                delayedRun(ms = 5000) {
+                    if (isWaited) return@delayedRun
+                    cancel()
+                    context.snake(msg = "预计响应超时，建议重启系统界面", actionText = "立即重启") { restartSystemUI(context) }
+                }
+                checkingActivated(context) { isValied ->
+                    when {
+                        isValied.not() -> {
+                            cancel()
+                            isWaited = true
+                            context.snake(msg = "请重启系统界面以生效模块更新", actionText = "立即重启") { restartSystemUI(context) }
+                        }
+                        else -> context.dataChannel(SYSTEMUI_PACKAGE_NAME).with {
+                            wait(CALL_MODULE_REFRESH_RESULT) {
+                                cancel()
+                                isWaited = true
+                                callback()
+                                if (it.not()) context.snake(msg = "刷新失败，建议重启系统界面", actionText = "立即重启") { restartSystemUI(context) }
+                            }
+                            put(CALL_HOST_REFRESH_CACHING, isRefreshCacheOnly)
+                        }
+                    }
+                }
+                noCancelable()
+            }
+        else context?.snake(msg = "模块没有激活，更改不会生效")
+    }
+
     /**
      * 显示需要重启系统界面的 [Snackbar]
      * @param context 实例
      */
     fun showNeedRestartSnake(context: Context) =
-        if (YukiHookModuleStatus.isActive())
+        if (YukiHookAPI.Status.isXposedModuleActive)
             context.snake(msg = "设置需要重启系统界面才能生效", actionText = "立即重启") { restartSystemUI(context) }
         else context.snake(msg = "模块没有激活，更改不会生效")
-
-    /**
-     * 显示更新数据后需要重启系统界面的 [Snackbar]
-     * @param context 实例
-     */
-    fun showNeedUpdateApplySnake(context: Context) =
-        if (YukiHookModuleStatus.isActive())
-            context.snake(msg = "数据已更新，请重启系统界面使更改生效", actionText = "立即重启") { restartSystemUI(context) }
-        else context.snake(msg = "模块没有激活，更改不会生效")
 }

app/src/main/java/com/fankes/miui/notify/utils/tool/YukiPromoteTool.kt

@@ -0,0 +1,59 @@
+/*
+ * MIUINativeNotifyIcon - Fix the native notification bar icon function abandoned by the MIUI development team.
+ * Copyright (C) 2019-2022 Fankes Studio(qzmmcn@163.com)
+ * https://github.com/fankes/MIUINativeNotifyIcon
+ *
+ * This software is non-free but opensource software: you can redistribute it
+ * and/or modify it under the terms of the GNU Affero General Public License
+ * as published by the Free Software Foundation; either
+ * version 3 of the License, or any later version.
+ * <p>
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * and eula along with this software.  If not, see
+ * <https://www.gnu.org/licenses/>
+ *
+ * This file is Created by fankes on 2022/5/30.
+ */
+package com.fankes.miui.notify.utils.tool
+
+import android.content.Context
+import com.fankes.miui.notify.utils.factory.openBrowser
+import com.fankes.miui.notify.utils.factory.showDialog
+import com.highcapable.yukihookapi.YukiHookAPI
+import com.highcapable.yukihookapi.hook.factory.modulePrefs
+import com.highcapable.yukihookapi.hook.xposed.prefs.data.PrefsData
+
+/**
+ * [YukiHookAPI] 的自动推广工具类
+ */
+object YukiPromoteTool {
+
+    /** 推广已读存储键值 */
+    private val YUKI_PROMOTE_READED = PrefsData("yuki_promote_readed", false)
+
+    /**
+     * 显示推广对话框
+     * @param context 实例
+     */
+    fun promote(context: Context) {
+        fun saveReaded() = context.modulePrefs.put(YUKI_PROMOTE_READED, value = true)
+        if (context.modulePrefs.get(YUKI_PROMOTE_READED).not())
+            context.showDialog {
+                title = "面向开发者的推广"
+                msg = "你想快速拥有一个自己的 Xposed 模块吗，你只需要拥有基础的 Android 开发经验以及使用 Kotlin 编程语言即可。\n\n" +
+                        "快来体验 YukiHookAPI，这是一个使用 Kotlin 重新构建的高效 Xposed Hook API，助你的开发变得更轻松。"
+                confirmButton(text = "去看看") {
+                    context.openBrowser(url = "https://github.com/fankes/YukiHookAPI")
+                    saveReaded()
+                }
+                cancelButton(text = "我不是开发者") { saveReaded() }
+                noCancelable()
+            }
+    }
+}

app/src/main/res/drawable/bg_orange_round.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="#FF7043" />
+    <corners android:radius="15dp" />
+</shape>

app/src/main/res/drawable/ic_nf_icon_update.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="@color/white"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M19.35,10.04C18.67,6.59 15.64,4 12,4 9.11,4 6.6,5.64 5.35,8.04 2.34,8.36 0,10.91 0,14c0,3.31 2.69,6 6,6h13c2.76,0 5,-2.24 5,-5 0,-2.64 -2.05,-4.78 -4.65,-4.96zM14,13v4h-4v-4H7l5,-5 5,5h-3z" />
+</vector>

app/src/main/res/drawable/ic_notify_icon.xml

@@ -3,7 +3,8 @@
     android:height="150dp"
     android:viewportWidth="1024"
     android:viewportHeight="1024">
-  <path
-      android:fillColor="#FF000000"
-      android:pathData="M192,736 L192,416C192,261.2 302,132.1 448,102.4L448,64C448,28.6 476.6,0 512,0 547.4,0 576,28.6 576,64L576,102.4C722,132.1 832,261.2 832,416L832,736 864.1,736C899.4,736 928,764.4 928,800 928,835.4 899.4,864 864.1,864L159.9,864C124.6,864 96,835.6 96,800 96,764.6 124.6,736 159.9,736L192,736ZM608,928C608,981 565,1024 512,1024 459,1024 416,981 416,928L608,928Z"/>
+
+    <path
+        android:fillColor="@color/white"
+        android:pathData="M192,736 L192,416C192,261.2 302,132.1 448,102.4L448,64C448,28.6 476.6,0 512,0 547.4,0 576,28.6 576,64L576,102.4C722,132.1 832,261.2 832,416L832,736 864.1,736C899.4,736 928,764.4 928,800 928,835.4 899.4,864 864.1,864L159.9,864C124.6,864 96,835.6 96,800 96,764.6 124.6,736 159.9,736L192,736ZM608,928C608,981 565,1024 512,1024 459,1024 416,981 416,928L608,928Z" />
 </vector>

app/src/main/res/drawable/ic_system_clock.xml

@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="@color/white"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M11.99,2C6.47,2 2,6.48 2,12s4.47,10 9.99,10C17.52,22 22,17.52 22,12S17.52,2 11.99,2zM15.29,16.71L11,12.41V7h2v4.59l3.71,3.71L15.29,16.71z" />
+</vector>

app/src/main/res/layout/activity_config.xml

@@ -5,7 +5,7 @@
     android:layout_height="match_parent"
     android:background="@color/colorThemeBackground"
     android:orientation="vertical"
-    tools:context=".ui.MainActivity"
+    tools:context=".ui.activity.MainActivity"
     tools:ignore="HardcodedText,UseCompoundDrawables,ContentDescription">
 
     <LinearLayout
@@ -24,7 +24,7 @@
             android:layout_width="20dp"
             android:layout_height="20dp"
             android:layout_marginStart="10dp"
-            android:layout_marginEnd="25dp"
+            android:layout_marginEnd="20dp"
             android:src="@mipmap/ic_back"
             android:tint="@color/colorTextGray"
             android:tooltipText="返回" />
@@ -32,7 +32,7 @@
         <LinearLayout
             android:layout_width="0dp"
             android:layout_height="wrap_content"
-            android:layout_marginEnd="10dp"
+            android:layout_marginEnd="2.5dp"
             android:layout_weight="1"
             android:gravity="center|start"
             android:orientation="vertical">
@@ -54,7 +54,7 @@
                 android:singleLine="true"
                 android:text="适配列表正在等待装载"
                 android:textColor="@color/colorTextDark"
-                android:textSize="12sp" />
+                android:textSize="11.5sp" />
         </LinearLayout>
 
         <androidx.constraintlayout.utils.widget.ImageFilterView

app/src/main/res/layout/activity_main.xml

@@ -6,8 +6,8 @@
     android:layout_height="match_parent"
     android:background="@color/colorThemeBackground"
     android:orientation="vertical"
-    tools:context=".ui.MainActivity"
-    tools:ignore="HardcodedText,UseCompoundDrawables,ContentDescription">
+    tools:context=".ui.activity.MainActivity"
+    tools:ignore="HardcodedText,UseCompoundDrawables,ContentDescription,TooManyViews">
 
     <LinearLayout
         android:layout_width="match_parent"
@@ -29,27 +29,27 @@
             android:textSize="25sp"
             android:textStyle="bold" />
 
-        <androidx.constraintlayout.utils.widget.ImageFilterView
-            android:id="@+id/title_github_icon"
-            style="?android:attr/selectableItemBackgroundBorderless"
-            android:layout_width="27dp"
-            android:layout_height="27dp"
-            android:layout_marginEnd="15dp"
-            android:alpha="0.85"
-            android:src="@mipmap/ic_github"
-            android:tint="@color/colorTextGray"
-            android:tooltipText="项目地址" />
-
         <androidx.constraintlayout.utils.widget.ImageFilterView
             android:id="@+id/title_restart_icon"
             style="?android:attr/selectableItemBackgroundBorderless"
             android:layout_width="28dp"
             android:layout_height="28dp"
-            android:layout_marginEnd="5dp"
+            android:layout_marginEnd="15dp"
             android:alpha="0.85"
             android:src="@mipmap/ic_restart"
             android:tint="@color/colorTextGray"
             android:tooltipText="重启系统界面" />
+
+        <androidx.constraintlayout.utils.widget.ImageFilterView
+            android:id="@+id/title_github_icon"
+            style="?android:attr/selectableItemBackgroundBorderless"
+            android:layout_width="27dp"
+            android:layout_height="27dp"
+            android:layout_marginEnd="5dp"
+            android:alpha="0.85"
+            android:src="@mipmap/ic_github"
+            android:tint="@color/colorTextGray"
+            android:tooltipText="项目地址" />
     </LinearLayout>
 
     <LinearLayout
@@ -87,28 +87,71 @@
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_marginBottom="5dp"
+                android:ellipsize="end"
+                android:singleLine="true"
                 android:text="模块状态未知"
                 android:textColor="@color/white"
                 android:textSize="18sp" />
 
-            <TextView
-                android:id="@+id/main_text_version"
+            <LinearLayout
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_marginBottom="5dp"
-                android:alpha="0.8"
-                android:text="模块版本：%1"
-                android:textColor="@color/white"
-                android:textSize="13sp" />
+                android:gravity="center|start"
+                android:orientation="horizontal">
+
+                <TextView
+                    android:id="@+id/main_text_version"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:alpha="0.8"
+                    android:ellipsize="end"
+                    android:singleLine="true"
+                    android:text="模块版本：%1"
+                    android:textColor="@color/white"
+                    android:textSize="13sp" />
+
+                <TextView
+                    android:id="@+id/main_text_release_version"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginStart="5dp"
+                    android:background="@drawable/bg_orange_round"
+                    android:ellipsize="end"
+                    android:paddingLeft="5dp"
+                    android:paddingTop="2dp"
+                    android:paddingRight="5dp"
+                    android:paddingBottom="2dp"
+                    android:singleLine="true"
+                    android:text="点击更新 %1"
+                    android:textColor="@color/white"
+                    android:textSize="11sp"
+                    android:visibility="gone" />
+            </LinearLayout>
 
             <TextView
                 android:id="@+id/main_text_miui_version"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:alpha="0.8"
+                android:ellipsize="end"
+                android:singleLine="true"
                 android:text="系统版本：%1"
                 android:textColor="@color/white"
                 android:textSize="13sp" />
+
+            <TextView
+                android:id="@+id/main_text_api_way"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="5dp"
+                android:alpha="0.6"
+                android:ellipsize="end"
+                android:singleLine="true"
+                android:text="%1"
+                android:textColor="@color/white"
+                android:textSize="11sp"
+                android:visibility="gone" />
         </LinearLayout>
     </LinearLayout>
 
@@ -169,9 +212,31 @@
                 android:gravity="center"
                 android:orientation="vertical"
                 android:paddingLeft="15dp"
+                android:paddingTop="15dp"
                 android:paddingRight="15dp">
 
-                <com.fankes.miui.notify.view.MaterialSwitch
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:gravity="center|start">
+
+                    <ImageView
+                        android:layout_width="15dp"
+                        android:layout_height="15dp"
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_basic" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:alpha="0.85"
+                        android:singleLine="true"
+                        android:text="基础设置"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
                     android:id="@+id/module_enable_switch"
                     android:layout_width="match_parent"
                     android:layout_height="40dp"
@@ -180,7 +245,7 @@
                     android:textColor="@color/colorTextGray"
                     android:textSize="15sp" />
 
-                <com.fankes.miui.notify.view.MaterialSwitch
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
                     android:id="@+id/module_enable_log_switch"
                     android:layout_width="match_parent"
                     android:layout_height="35dp"
@@ -201,7 +266,7 @@
             </LinearLayout>
 
             <LinearLayout
-                android:id="@+id/config_item_s_count_hook"
+                android:id="@+id/status_icon_count_item"
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
                 android:layout_marginLeft="15dp"
@@ -213,10 +278,32 @@
                 android:gravity="center"
                 android:orientation="vertical"
                 android:paddingLeft="15dp"
+                android:paddingTop="15dp"
                 android:paddingRight="15dp">
 
-                <com.fankes.miui.notify.view.MaterialSwitch
-                    android:id="@+id/config_status_icon_count_switch"
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:gravity="center|start">
+
+                    <ImageView
+                        android:layout_width="15dp"
+                        android:layout_height="15dp"
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_control" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:alpha="0.85"
+                        android:singleLine="true"
+                        android:text="功能调整"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
+                    android:id="@+id/status_icon_count_switch"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:text="解除状态栏通知图标个数限制"
@@ -234,7 +321,7 @@
                     android:textSize="12sp" />
 
                 <TextView
-                    android:id="@+id/config_warn_s_count_dis_tip"
+                    android:id="@+id/warn_s_count_dis_tip"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
@@ -245,7 +332,7 @@
                     android:textSize="12sp" />
 
                 <LinearLayout
-                    android:id="@+id/config_item_s_count_child_hook"
+                    android:id="@+id/status_icon_count_child_item"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
@@ -269,7 +356,7 @@
                         android:textSize="14sp" />
 
                     <TextView
-                        android:id="@+id/config_status_icon_count_text"
+                        android:id="@+id/status_icon_count_text"
                         android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         android:ellipsize="end"
@@ -294,7 +381,7 @@
                         android:textSize="14sp" />
 
                     <TextView
-                        android:id="@+id/config_status_icon_count_button"
+                        android:id="@+id/status_icon_count_button"
                         android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         android:background="@drawable/bg_button_round"
@@ -312,7 +399,7 @@
             </LinearLayout>
 
             <LinearLayout
-                android:id="@+id/config_item_color_hook"
+                android:id="@+id/color_icon_hook_item"
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
                 android:layout_marginLeft="15dp"
@@ -323,37 +410,39 @@
                 android:gravity="center"
                 android:orientation="vertical"
                 android:paddingLeft="15dp"
+                android:paddingTop="15dp"
                 android:paddingRight="15dp">
 
-                <com.fankes.miui.notify.view.MaterialSwitch
-                    android:id="@+id/color_icon_fix_switch"
+                <LinearLayout
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:text="忽略彩色通知图标"
-                    android:textColor="@color/colorTextGray"
-                    android:textSize="15sp" />
+                    android:gravity="center|start">
 
-                <TextView
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginBottom="10dp"
-                    android:alpha="0.6"
-                    android:lineSpacingExtra="6dp"
-                    android:text="此选项默认开启，开启后将自动对 APP 通知图标进行判断，保持高版本 API 的 APP 不规范的彩色图标不被着色为白、黑色块并对图标进行圆角优化，关闭后将按照 Android API 规范对 APP 通知进行图标着色，可能会出现着色为黑白、色块情况。"
-                    android:textColor="@color/colorTextDark"
-                    android:textSize="12sp" />
+                    <ImageView
+                        android:layout_width="15dp"
+                        android:layout_height="15dp"
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_modify" />
 
-                <com.fankes.miui.notify.view.MaterialSwitch
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:alpha="0.85"
+                        android:singleLine="true"
+                        android:text="图标调整"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
                     android:id="@+id/color_icon_compat_switch"
                     android:layout_width="match_parent"
-                    android:layout_height="35dp"
-                    android:layout_marginBottom="5dp"
+                    android:layout_height="wrap_content"
                     android:text="启用兼容模式"
                     android:textColor="@color/colorTextGray"
                     android:textSize="15sp" />
 
                 <TextView
-                    android:id="@+id/color_icon_compat_text"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
@@ -365,34 +454,58 @@
             </LinearLayout>
 
             <LinearLayout
-                android:id="@+id/config_item_notify"
+                android:id="@+id/notify_icon_config_item"
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
-                android:layout_marginLeft="10dp"
+                android:layout_marginLeft="15dp"
                 android:layout_marginTop="15dp"
-                android:layout_marginRight="10dp"
+                android:layout_marginRight="15dp"
                 android:animateLayoutChanges="true"
                 android:background="@drawable/bg_permotion_round"
                 android:elevation="0dp"
                 android:gravity="center"
                 android:orientation="vertical"
-                android:paddingLeft="15dp"
-                android:paddingRight="15dp">
+                android:paddingTop="15dp">
 
-                <com.fankes.miui.notify.view.MaterialSwitch
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
+                    android:gravity="center|start">
+
+                    <ImageView
+                        android:layout_width="15dp"
+                        android:layout_height="15dp"
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_notify" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:alpha="0.85"
+                        android:singleLine="true"
+                        android:text="图标优化"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
                     android:id="@+id/notify_icon_fix_switch"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:layout_marginLeft="5dp"
-                    android:layout_marginRight="5dp"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
                     android:text="启用通知图标优化"
                     android:textColor="@color/colorTextGray"
                     android:textSize="15sp" />
 
                 <TextView
-                    android:id="@+id/config_notify_app_button"
+                    android:id="@+id/notify_icon_fix_button"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
+                    android:layout_marginLeft="13dp"
+                    android:layout_marginRight="13dp"
                     android:layout_marginBottom="10dp"
                     android:background="@drawable/bg_button_round"
                     android:gravity="center"
@@ -405,26 +518,246 @@
                 <TextView
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:layout_marginLeft="5dp"
-                    android:layout_marginRight="5dp"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
                     android:layout_marginBottom="10dp"
                     android:alpha="0.6"
                     android:lineSpacingExtra="6dp"
-                    android:text="首次安装请打开名单列表从云端更新数据，后期适配的内容也请手动打开名单列表重新拉取数据以检查更新，数据更新后重启系统界面即可生效。"
+                    android:text="首次安装请打开名单列表从云端更新数据，后期适配的内容也请手动打开名单列表重新拉取数据以检查更新，数据更新后无需重启系统界面，实时生效。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
 
                 <TextView
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:layout_marginLeft="5dp"
-                    android:layout_marginRight="5dp"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
                     android:layout_marginBottom="10dp"
                     android:alpha="0.6"
                     android:lineSpacingExtra="6dp"
-                    android:text="此选项默认开启，开启后将对优化名单内的 APP 通知小图标使用单色调进行修复，特别是通过 MIPUSH 推送的通知，它们始终是 APP 默认图标(彩色的 APP 图标)，修复后使得它们的图标看起来更加符合 Android 原生的统一规范。"
+                    android:text="此选项默认开启，开启后将对优化名单内的 APP 通知小图标使用单色调进行修复，特别是通过系统级别推送的通知，它们始终是 APP 默认图标(彩色的 APP 图标)，修复后使得它们的图标看起来更加符合 Android 原生的统一规范。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
+
+                <LinearLayout
+                    android:id="@+id/notify_icon_custom_corner_item"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginBottom="10dp"
+                    android:orientation="vertical">
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="30dp"
+                        android:layout_marginLeft="15dp"
+                        android:layout_marginRight="15dp"
+                        android:layout_marginBottom="5dp"
+                        android:gravity="center|start"
+                        android:text="调整通知栏中的图标边框圆角大小"
+                        android:textAllCaps="false"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="15sp" />
+
+                    <androidx.appcompat.widget.AppCompatSeekBar
+                        android:id="@+id/notify_icon_custom_corner_seekbar"
+                        android:layout_width="match_parent"
+                        android:layout_height="40dp"
+                        android:layout_marginTop="5dp"
+                        android:max="15"
+                        android:min="0"
+                        android:paddingLeft="5dp"
+                        android:paddingRight="5dp"
+                        android:progress="15" />
+
+                    <LinearLayout
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginLeft="15dp"
+                        android:layout_marginRight="15dp"
+                        android:gravity="center"
+                        android:orientation="horizontal"
+                        android:paddingTop="5dp"
+                        android:paddingBottom="15dp">
+
+                        <TextView
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:layout_marginEnd="5dp"
+                            android:alpha="0.75"
+                            android:ellipsize="end"
+                            android:gravity="center"
+                            android:maxWidth="100dp"
+                            android:singleLine="true"
+                            android:text="当前"
+                            android:textColor="@color/colorTextGray"
+                            android:textSize="13.5sp" />
+
+                        <TextView
+                            android:id="@+id/notify_icon_custom_corner_text"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:ellipsize="end"
+                            android:gravity="center"
+                            android:maxWidth="100dp"
+                            android:singleLine="true"
+                            android:text="15 dp"
+                            android:textColor="@color/colorTextGray"
+                            android:textSize="15sp"
+                            android:textStyle="bold" />
+                    </LinearLayout>
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginLeft="15dp"
+                        android:layout_marginRight="15dp"
+                        android:alpha="0.6"
+                        android:lineSpacingExtra="6dp"
+                        android:text="你可以拖拽滑动条来调整通知栏中图标的边框圆角大小，仅支持 Android 12 风格以及 MIUI 经典样式的通知图标。"
+                        android:textColor="@color/colorTextDark"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:id="@+id/notify_icon_force_app_icon_item"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
+                    android:orientation="vertical">
+
+                    <com.fankes.miui.notify.ui.view.MaterialSwitch
+                        android:id="@+id/notify_icon_force_app_icon_switch"
+                        android:layout_width="match_parent"
+                        android:layout_height="30dp"
+                        android:layout_marginBottom="5dp"
+                        android:text="通知栏中的图标强制为 APP 图标"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="15sp" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginBottom="10dp"
+                        android:alpha="0.6"
+                        android:lineSpacingExtra="6dp"
+                        android:text="此选项默认关闭，开启后下拉通知栏中的通知图标将会被替换为 APP 自身图标，但是不会更改状态栏中的通知图标，这是一个破坏原生通知图标的行为，仅针对部分有需要的用户而添加，我们不推荐开启这个功能，请根据个人偏好进行选择是否需要开启。"
+                        android:textColor="@color/colorTextDark"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:id="@+id/notify_icon_fix_notify_item"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
+                    android:orientation="vertical">
+
+                    <com.fankes.miui.notify.ui.view.MaterialSwitch
+                        android:id="@+id/notify_icon_fix_notify_switch"
+                        android:layout_width="match_parent"
+                        android:layout_height="30dp"
+                        android:layout_marginBottom="5dp"
+                        android:text="提醒未适配通知图标的新安装应用"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="15sp" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginBottom="10dp"
+                        android:alpha="0.6"
+                        android:lineSpacingExtra="6dp"
+                        android:text="此选项默认开启，在通知图标优化名单有数据时将自动检查新安装的应用是否存在适配数据，若没有将会发送通知提醒，如果你了解日后新安装的应用通知图标是遵守原生单色图标规范的，可以关闭此提醒。"
+                        android:textColor="@color/colorTextDark"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <LinearLayout
+                    android:id="@+id/notify_icon_auto_sync_item"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginLeft="15dp"
+                    android:layout_marginRight="15dp"
+                    android:animateLayoutChanges="true"
+                    android:orientation="vertical">
+
+                    <com.fankes.miui.notify.ui.view.MaterialSwitch
+                        android:id="@+id/notify_icon_auto_sync_switch"
+                        android:layout_width="match_parent"
+                        android:layout_height="30dp"
+                        android:layout_marginBottom="5dp"
+                        android:text="启用通知图标优化名单自动更新"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="15sp" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginBottom="10dp"
+                        android:alpha="0.6"
+                        android:lineSpacingExtra="6dp"
+                        android:text="此选项默认开启，为确保名单内的数据为云端最新版本，你可以设置每天自动更新在线规则的时间，自动更新的地址为你最后一次成功设置的在线规则同步地址。\n请确保模块能够后台联网并不被阻止其它 APP 唤醒，否则自动同步可能会失败。\n模块无需保持在后台运行，到达同步时间后会自动启动，如果到达时间后模块正在运行则会自动取消本次计划任务。"
+                        android:textColor="@color/colorTextDark"
+                        android:textSize="12sp" />
+
+                    <LinearLayout
+                        android:id="@+id/notify_icon_auto_sync_child_item"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginBottom="10dp"
+                        android:gravity="center">
+
+                        <ImageView
+                            android:layout_width="17dp"
+                            android:layout_height="17dp"
+                            android:src="@drawable/ic_system_clock"
+                            app:tint="@color/colorTextGray" />
+
+                        <TextView
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:layout_marginStart="10dp"
+                            android:ellipsize="end"
+                            android:gravity="center"
+                            android:singleLine="true"
+                            android:text="每天"
+                            android:textColor="@color/colorTextGray"
+                            android:textSize="14sp" />
+
+                        <TextView
+                            android:id="@+id/notify_icon_auto_sync_text"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:layout_marginEnd="5dp"
+                            android:ellipsize="end"
+                            android:gravity="center"
+                            android:maxWidth="100dp"
+                            android:paddingLeft="5dp"
+                            android:paddingRight="5dp"
+                            android:singleLine="true"
+                            android:text="07:00"
+                            android:textColor="@color/colorTextGray"
+                            android:textSize="14sp" />
+
+                        <TextView
+                            android:id="@+id/notify_icon_auto_sync_button"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:background="@drawable/bg_button_round"
+                            android:ellipsize="end"
+                            android:gravity="center"
+                            android:paddingLeft="10dp"
+                            android:paddingTop="5dp"
+                            android:paddingRight="10dp"
+                            android:paddingBottom="5dp"
+                            android:singleLine="true"
+                            android:text="修改时间"
+                            android:textColor="@color/colorTextGray"
+                            android:textSize="14sp" />
+                    </LinearLayout>
+                </LinearLayout>
             </LinearLayout>
 
             <LinearLayout
@@ -438,9 +771,31 @@
                 android:gravity="center"
                 android:orientation="vertical"
                 android:paddingLeft="15dp"
+                android:paddingTop="15dp"
                 android:paddingRight="15dp">
 
-                <com.fankes.miui.notify.view.MaterialSwitch
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:gravity="center|start">
+
+                    <ImageView
+                        android:layout_width="15dp"
+                        android:layout_height="15dp"
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_home" />
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:alpha="0.85"
+                        android:singleLine="true"
+                        android:text="显示设置"
+                        android:textColor="@color/colorTextGray"
+                        android:textSize="12sp" />
+                </LinearLayout>
+
+                <com.fankes.miui.notify.ui.view.MaterialSwitch
                     android:id="@+id/hide_icon_in_launcher_switch"
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
@@ -457,6 +812,16 @@
                     android:text="隐藏模块图标后界面可能会被关闭，将不会再在桌面显示，你可以在 EdXposed、LSPosed 中找到模块设置并打开。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
+
+                <TextView
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginBottom="10dp"
+                    android:alpha="0.6"
+                    android:lineSpacingExtra="6dp"
+                    android:text="注意：请务必在 LSPosed 中关闭“强制显示桌面图标”功能"
+                    android:textColor="#FF5722"
+                    android:textSize="12sp" />
             </LinearLayout>
 
             <LinearLayout
@@ -469,28 +834,27 @@
                 android:elevation="0dp"
                 android:gravity="center"
                 android:orientation="vertical"
-                android:padding="15dp">
+                android:padding="15dp"
+                android:paddingTop="15dp">
 
                 <LinearLayout
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
-                    android:layout_marginBottom="10dp"
+                    android:layout_marginBottom="15dp"
                     android:gravity="center|start">
 
-                    <androidx.constraintlayout.utils.widget.ImageFilterView
+                    <ImageView
                         android:layout_width="15dp"
                         android:layout_height="15dp"
-                        android:layout_marginEnd="5dp"
-                        android:alpha="0.85"
-                        android:src="@mipmap/ic_about"
-                        android:tint="@color/colorTextGray" />
+                        android:layout_marginEnd="10dp"
+                        android:src="@mipmap/ic_help" />
 
                     <TextView
                         android:layout_width="match_parent"
                         android:layout_height="wrap_content"
                         android:alpha="0.85"
                         android:singleLine="true"
-                        android:text="使用帮助与说明"
+                        android:text="使用帮助&amp;说明"
                         android:textColor="@color/colorTextGray"
                         android:textSize="12sp" />
                 </LinearLayout>
@@ -500,7 +864,7 @@
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
                     android:alpha="0.8"
-                    android:lineSpacingExtra="6dp"
+                    android:lineSpacingExtra="10dp"
                     android:text="Q.这个模块是如何诞生的？\nA.这个模块诞生来源于 MIUI 的乱改和不规范，本来 MIUI 9 之后，官方给出了原生通知图标样式，后面由于用户反应通知栏经常出现黑白块。\n这当然不是系统的错，而是国内 APP 和 MIPUSH 的通知极其不规范的通知图标设计。\n但是呢，接到反馈后 MIUI 开发组选择直接忽略这个问题，在 2021-5-18 的开发版开始，把全部通知图标都改成了 APP 的彩色图标，使得之前拥有自有样式的原生图标也被破坏。\n对于 Android 开发者来说，官方文档中的 “setSmallIcon” 不再适用于魔改后的 MIUI，这将会严重破坏非常多的状态图标。\n当然，国内的手机生态除了 MIPUSH 的营销通知就是社交软件的通知，可能大部分人都不会在意这件事情。\n但是，这个模块就是为了修复被 MIUI 开发组忽略的图标问题才诞生的，并完美地给 MIUI 修复了黑白块图标的问题。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
@@ -510,7 +874,7 @@
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
                     android:alpha="0.8"
-                    android:lineSpacingExtra="6dp"
+                    android:lineSpacingExtra="10dp"
                     android:text="Q.如何使用？\nA.模块仅支持 LSPosed，EdXposed 也可以使用但随时停止支持，由于模块涉及到修改系统应用，不支持其它 Hook 框架，在 LSPosed 的作用域中，只需勾选“系统界面”(旧版本为“系统 UI”)即可，应用设置后需要重启系统界面。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
@@ -520,7 +884,7 @@
                     android:layout_height="wrap_content"
                     android:layout_marginBottom="10dp"
                     android:alpha="0.8"
-                    android:lineSpacingExtra="6dp"
+                    android:lineSpacingExtra="10dp"
                     android:text="Q.哪些是已知问题？\nA.以下是问题描述列表：\n(1) 动态小图标可能会在高版本系统中闪烁，这是 MIUI 自身就存在的问题，后期只能等官方修复。\n(2) 请始终保持最新版本的 LSPosed，旧版本可能会出现 Hook 不生效的问题，若最新版本依然不生效请在作用域中长按“系统界面”(“系统 UI”)选择重新优化。\n(3) 建议最低从 MIUI 12.5 “2021-5-18” 开发版以后开始使用，之前的版本可能或多或少存在 MIUI 自身 BUG 不生效、黑白块问题，将不再进行适配。"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
@@ -529,7 +893,7 @@
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:alpha="0.8"
-                    android:lineSpacingExtra="6dp"
+                    android:lineSpacingExtra="10dp"
                     android:text="Q.如何反馈问题？\nA.酷安关注 @星夜不荟"
                     android:textColor="@color/colorTextDark"
                     android:textSize="12sp" />
@@ -585,19 +949,34 @@
                     android:textSize="16sp" />
             </LinearLayout>
 
-            <TextView
+            <LinearLayout
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
                 android:layout_marginLeft="15dp"
                 android:layout_marginRight="15dp"
                 android:layout_marginBottom="10dp"
-                android:autoLink="web"
                 android:background="@drawable/bg_permotion_round"
-                android:lineSpacingExtra="6dp"
-                android:padding="10dp"
-                android:text="此模块使用 YukiHookAPI 构建。\n点击这里了解更多 https://github.com/fankes/YukiHookAPI"
-                android:textColor="@color/colorTextGray"
-                android:textSize="12sp" />
+                android:gravity="center|start"
+                android:orientation="horizontal"
+                android:padding="10dp">
+
+                <ImageView
+                    android:layout_width="35dp"
+                    android:layout_height="35dp"
+                    android:layout_marginEnd="10dp"
+                    android:src="@mipmap/ic_yukihookapi" />
+
+                <TextView
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:autoLink="web"
+                    android:ellipsize="end"
+                    android:lineSpacingExtra="6dp"
+                    android:maxLines="2"
+                    android:text="此模块使用 YukiHookAPI 构建。\n了解更多 https://github.com/fankes/YukiHookAPI"
+                    android:textColor="@color/colorTextGray"
+                    android:textSize="11sp" />
+            </LinearLayout>
         </LinearLayout>
     </androidx.core.widget.NestedScrollView>
 </LinearLayout>

app/src/main/res/layout/adapter_config.xml

@@ -68,7 +68,7 @@
         android:layout_height="wrap_content"
         android:orientation="vertical">
 
-        <com.fankes.miui.notify.view.MaterialSwitch
+        <com.fankes.miui.notify.ui.view.MaterialSwitch
             android:id="@+id/adp_app_open_switch"
             android:layout_width="wrap_content"
             android:layout_height="30dp"
@@ -77,7 +77,7 @@
             android:textColor="@color/colorTextGray"
             android:textSize="13sp" />
 
-        <com.fankes.miui.notify.view.MaterialSwitch
+        <com.fankes.miui.notify.ui.view.MaterialSwitch
             android:id="@+id/adp_app_all_switch"
             android:layout_width="wrap_content"
             android:layout_height="30dp"

app/src/main/res/layout/dia_source_from_string.xml

@@ -9,6 +9,17 @@
     android:paddingRight="15dp"
     tools:ignore="HardcodedText">
 
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="5dp"
+        android:layout_marginRight="5dp"
+        android:layout_marginBottom="17.5dp"
+        android:lineSpacingExtra="6dp"
+        android:text="此功能仅用于调试单条规则或多条规则，同步最新在线规则后这里的内容将会被覆盖清空。"
+        android:textColor="@color/colorTextDark"
+        android:textSize="13sp" />
+
     <com.google.android.material.textfield.TextInputLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content">

app/src/main/res/values-night/themes.xml

@@ -1,4 +1,4 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
+<resources>
     <!-- Base application theme. -->
     <style name="Theme.MIUINativeNotifyIcon" parent="Theme.Material3.DayNight">
         <!-- Primary brand color. -->
@@ -10,7 +10,7 @@
         <item name="colorSecondaryVariant">@color/teal_200</item>
         <item name="colorOnSecondary">@color/black</item>
         <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
+        <item name="android:statusBarColor">?attr/colorPrimaryVariant</item>
         <!-- Customize your theme here. -->
     </style>
 </resources>

app/src/main/res/values/array.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="module_scope">
+        <item>com.android.systemui</item>
+    </string-array>
+</resources>

app/src/main/res/values/strings.xml

@@ -1,3 +1,4 @@
 <resources>
     <string name="app_name">MIUI 原生通知图标</string>
+    <string name="tile_name">通知图标</string>
 </resources>

app/src/main/res/values/themes.xml

@@ -1,4 +1,4 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
+<resources>
     <!-- Base application theme. -->
     <style name="Theme.MIUINativeNotifyIcon" parent="Theme.Material3.DayNight">
         <!-- Primary brand color. -->
@@ -10,7 +10,7 @@
         <item name="colorSecondaryVariant">@color/teal_700</item>
         <item name="colorOnSecondary">@color/black</item>
         <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
+        <item name="android:statusBarColor">?attr/colorPrimaryVariant</item>
         <!-- Customize your theme here. -->
     </style>
 </resources>

build.gradle

@@ -1,12 +1,13 @@
 plugins {
-    id 'com.android.application' version '7.1.2' apply false
-    id 'com.android.library' version '7.1.2' apply false
-    id 'org.jetbrains.kotlin.android' version '1.6.10' apply false
+    id 'com.android.application' version '7.2.0' apply false
+    id 'com.android.library' version '7.2.0' apply false
+    id 'org.jetbrains.kotlin.android' version '1.6.21' apply false
 }
 
 ext {
-    appVersionName = "2.16"
-    appVersionCode = 26
+    appVersionName = "2.7"
+    appVersionCode = 32
+    enableR8 = true
 }
 
 task clean(type: Delete) {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Tue Feb 15 02:09:05 CST 2022
+#Wed May 25 04:36:53 CST 2022
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME