本文还有配套的精品资源，点击获取

简介：在Android开发中，Dialog是用于显示临时信息或进行用户交互的重要UI组件。本文重点讲解如何创建“正在加载中”的自定义Dialog，以提升应用界面的个性化与用户体验。文章介绍了继承DialogFragment实现自定义加载对话框的方法，并结合XML布局设计加载界面，同时引入KProgressHUD第三方库实现更丰富的加载效果。通过异步任务控制Dialog的显示与隐藏，实现更友好的交互流程。本教程适合希望掌握Android Dialog自定义开发的初学者和中级开发者。

1. Android Dialog基础与加载提示的核心价值

在Android应用开发中， Dialog 作为一种基础交互组件，广泛应用于用户操作确认、信息提示以及状态反馈等场景。尤其在涉及网络请求、数据库加载或复杂计算时，适时显示“正在加载中…”提示，不仅能提升用户体验，还能增强应用的响应性感知。

系统自带的 ProgressDialog 虽然使用简单，但在现代应用设计中缺乏灵活性和美观性。因此，掌握自定义加载提示的实现方式，对于提升应用品质至关重要。本章将从 Dialog 的基础概念入手，深入探讨其在用户等待场景中的核心价值，并为后续章节的自定义实现打下理论基础。

2. DialogFragment类与自定义Dialog基础实现

在Android开发中，DialogFragment 是用于管理对话框生命周期的强大组件，它不仅提供了比传统 Dialog 更加灵活的使用方式，还能更好地处理屏幕旋转、配置变更等常见问题。本章将从 DialogFragment 的核心作用入手，深入讲解其生命周期、创建流程以及与 FragmentManager 的交互方式，并通过代码示例展示如何构建一个基础的自定义 Dialog。

2.1 DialogFragment的核心作用与生命周期

2.1.1 DialogFragment与传统Dialog的差异

在 Android 开发早期，开发者通常使用 Dialog 类来创建对话框。然而， Dialog 的生命周期管理较为复杂，尤其是在屏幕旋转或配置变更时，容易引发内存泄漏或状态丢失的问题。

对比维度	Dialog 类	DialogFragment 类
生命周期管理	需手动管理，易造成内存泄漏	由 FragmentManager 自动管理，生命周期可控
屏幕旋转支持	需要手动处理配置变更	自动保留实例（setRetainInstance）
弹窗显示方式	通过 show() 方法直接显示	通过 FragmentManager 的 show() 方法管理
可复用性	不易封装复用	可作为组件复用，结构清晰

使用 DialogFragment 而非 Dialog ，可以有效避免这些问题，特别是在现代 Android 开发中，推荐使用 DialogFragment 来构建和管理对话框。

2.1.2 DialogFragment的生命周期方法详解

DialogFragment 的生命周期与 Fragment 类似，主要包含以下几个关键方法：

• onCreate(Bundle savedInstanceState) ：初始化 Dialog 的配置，例如是否可取消。
• onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) ：用于返回自定义布局。
• onCreateDialog(Bundle savedInstanceState) ：用于创建并返回一个 Dialog 对象。
• onStart() ：在 Dialog 显示前调用，适合进行界面调整。
• onDismiss(DialogInterface dialog) ：当 Dialog 被关闭时调用。
• onCancel(DialogInterface dialog) ：当 Dialog 被取消时调用。

下面是一个 DialogFragment 生命周期的流程图：

graph TD
    A[onCreate] --> B[onCreateView or onCreateDialog]
    B --> C[onStart]
    C --> D[Dialog显示]
    D --> E[onDismiss / onCancel]
    E --> F[onDestroyView]

2.1.3 DialogFragment的创建与销毁流程

创建 DialogFragment 的典型流程如下：

1. 创建一个继承自 DialogFragment 的子类。
2. 重写 onCreateDialog() 或 onCreateView() 方法，返回 Dialog 或 View。
3. 通过 FragmentManager 的 beginTransaction().show() 或 show() 方法显示该 DialogFragment。
4. 在适当时机调用 dismiss() 方法关闭 DialogFragment。

销毁流程则由系统自动处理，但开发者可以通过 onDismiss() 和 onCancel() 方法进行资源释放或状态更新。

2.2 自定义Dialog的创建流程

2.2.1 继承DialogFragment并重写onCreateDialog方法

要创建一个自定义 Dialog，首先需要继承 DialogFragment 并重写 onCreateDialog() 方法。以下是一个基础示例：

public class CustomDialogFragment extends DialogFragment {
    @NonNull
    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle("提示")
               .setMessage("这是一个自定义加载对话框")
               .setPositiveButton("确定", (dialog, which) -> {
                   // 用户点击确定按钮
               })
               .setNegativeButton("取消", (dialog, which) -> {
                   // 用户点击取消按钮
               });
        return builder.create();
    }
}

代码解析：

• AlertDialog.Builder ：用于构建标准的对话框。
• setTitle() ：设置对话框标题。
• setMessage() ：设置对话框内容。
• setPositiveButton() ：添加确认按钮，并设置点击监听。
• setNegativeButton() ：添加取消按钮。
• create() ：最终生成 Dialog 实例。

2.2.2 使用AlertDialog.Builder构建基础样式

AlertDialog.Builder 是构建标准对话框的主要工具，支持设置标题、消息、按钮、图标等内容。开发者可以灵活组合这些元素，构建出符合业务需求的对话框。

public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new AlertDialog.Builder(requireContext())
        .setIcon(R.drawable.ic_alert)
        .setTitle("系统提示")
        .setMessage("是否确认退出？")
        .setPositiveButton("确认", (dialog, which) -> {
            // 处理确认逻辑
        })
        .setNegativeButton("取消", (dialog, which) -> {
            // 处理取消逻辑
        })
        .create();
}

2.2.3 自定义Dialog的主题与样式设置

为了统一 UI 风格，通常我们会为 Dialog 设置自定义主题。可以在 styles.xml 中定义：

<style name="CustomDialogTheme" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="android:textColorPrimary">@color/textColorPrimary</item>
</style>

然后在 onCreateDialog() 中使用该主题：

public CustomDialogFragment() {
    super(R.style.CustomDialogTheme);
}

也可以在构造函数中动态传入主题资源 ID。

2.3 DialogFragment的显示与管理

2.3.1 通过FragmentManager显示DialogFragment

要显示 DialogFragment ，需要通过 FragmentManager 来管理：

CustomDialogFragment dialog = new CustomDialogFragment();
dialog.show(getSupportFragmentManager(), "custom_dialog");

• getSupportFragmentManager() ：用于获取 FragmentManager。
• "custom_dialog" ：是 DialogFragment 的标签，用于后续查找或管理。

2.3.2 处理屏幕旋转与配置变更

屏幕旋转时，默认情况下 Dialog 会被销毁并重建。为了保持状态，可以使用以下方式：

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true); // 保留实例
}

注意： 使用 setRetainInstance(true) 时，不能同时使用 onCreateDialog() 和 onCreateView() ，否则会抛出异常。

2.3.3 DialogFragment的回调机制与通信方式

为了实现 Dialog 与宿主 Activity 或 Fragment 的通信，通常采用接口回调的方式：

定义接口：

public interface OnDialogActionListener {
    void onPositiveButtonClicked();
    void onNegativeButtonClicked();
}

在 DialogFragment 中声明接口变量：

private OnDialogActionListener listener;

@Override
public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    try {
        listener = (OnDialogActionListener) context;
    } catch (ClassCastException e) {
        throw new ClassCastException(context.toString() + " must implement OnDialogActionListener");
    }
}

在按钮点击时调用接口方法：

.setPositiveButton("确认", (dialog, which) -> {
    listener.onPositiveButtonClicked();
});

在 Activity 或 Fragment 中实现接口方法即可接收回调。

以上是本章内容的完整展开。通过本章的学习，开发者可以掌握如何使用 DialogFragment 构建自定义 Dialog，并掌握其生命周期、样式设置、显示管理以及与宿主组件的通信方式。下一章节将深入讲解自定义加载 Dialog 的 UI 设计与实现。

3. 自定义加载Dialog的布局设计与实现

3.1 加载Dialog的UI组件设计

3.1.1 TextView与ProgressBar的基础布局结构

在Android中，构建一个加载提示Dialog的核心组件通常包括一个 TextView 和一个 ProgressBar 。它们分别用于显示加载提示文本和表示加载进度的动画。这两个组件构成了加载提示的视觉核心。

• TextView ：用于展示“正在加载中…”、“请稍候”等用户提示信息。
• ProgressBar ：用于表示加载过程的进度。可以是不确定进度的循环动画，也可以是确定进度的条形进度条。

布局结构示例（XML）：

<!-- res/layout/dialog_loading.xml -->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="16dp"
    android:gravity="center">

    <ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="48dp"
        android:layout_height="48dp"
        android:indeterminate="true"
        android:layout_marginBottom="8dp"/>

    <TextView
        android:id="@+id/tvLoadingText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="正在加载中..."
        android:textSize="16sp"
        android:textColor="@android:color/black"/>
</LinearLayout>

参数说明：
- android:indeterminate="true" ：表示不确定进度的循环动画，适用于未知加载时间的场景。
- android:textSize ：设置字体大小，适配不同屏幕。
- android:gravity="center" ：使组件在父容器中居中。

布局结构图（Mermaid）：

graph TD
    A[LinearLayout] --> B[ProgressBar]
    A --> C[TextView]

3.1.2 布局文件的编写与资源引用

上述布局文件 dialog_loading.xml 应该放在 res/layout/ 目录下。为了在 DialogFragment 中引用它，可以使用 LayoutInflater 将其加载为视图。

在自定义的 DialogFragment 中，可以通过如下方式加载该布局：

public class LoadingDialogFragment extends DialogFragment {
    private View dialogView;

    @NonNull
    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
        dialogView = LayoutInflater.from(requireContext()).inflate(R.layout.dialog_loading, null);
        return new AlertDialog.Builder(requireContext())
                .setView(dialogView)
                .create();
    }
}

逻辑分析：
- LayoutInflater.from(requireContext()).inflate(R.layout.dialog_loading, null) ：将布局文件转换为实际的视图对象。
- setView(dialogView) ：将自定义视图设置为Dialog的内容。

3.1.3 使用ConstraintLayout优化布局结构

为了提高布局的灵活性和适配性，可以使用 ConstraintLayout 替代 LinearLayout ：

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="16dp">

    <ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="48dp"
        android:layout_height="48dp"
        android:indeterminate="true"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toTopOf="@+id/tvLoadingText"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"/>

    <TextView
        android:id="@+id/tvLoadingText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="正在加载中..."
        android:textSize="16sp"
        android:textColor="@android:color/black"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"/>
</androidx.constraintlayout.widget.ConstraintLayout>

优势：
- 更灵活的视图对齐方式。
- 适配各种屏幕尺寸。
- 减少嵌套层级，提高性能。

3.2 自定义ProgressDialog的实现步骤

3.2.1 ProgressDialog的样式定制

虽然 ProgressDialog 是系统提供的类，但其样式较为单一。为了提升用户体验，建议自定义样式的ProgressDialog。

可以通过设置Dialog的主题来实现样式定制：

public class CustomProgressDialog extends DialogFragment {
    @NonNull
    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
        LayoutInflater inflater = requireActivity().getLayoutInflater();
        View view = inflater.inflate(R.layout.dialog_custom_progress, null);

        return new AlertDialog.Builder(requireContext(), R.style.CustomDialogTheme)
                .setView(view)
                .create();
    }
}

样式定义（ res/values/styles.xml ） ：

<style name="CustomDialogTheme" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="colorPrimary">@color/purple_500</item>
    <item name="colorAccent">@color/teal_200</item>
    <item name="android:textColorPrimary">@color/black</item>
    <item name="android:windowBackground">@drawable/dialog_background</item>
</style>

3.2.2 设置加载文本与进度条动画

在Dialog中动态设置加载文本和进度条状态是提升交互性的关键。例如：

public class CustomProgressDialog extends DialogFragment {
    private TextView tvLoadingText;
    private ProgressBar progressBar;

    @NonNull
    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
        View view = LayoutInflater.from(requireContext()).inflate(R.layout.dialog_custom_progress, null);
        tvLoadingText = view.findViewById(R.id.tvLoadingText);
        progressBar = view.findViewById(R.id.progressBar);

        // 设置初始文本
        tvLoadingText.setText("正在加载数据...");

        return new AlertDialog.Builder(requireContext())
                .setView(view)
                .create();
    }

    public void setLoadingText(String text) {
        if (tvLoadingText != null) {
            tvLoadingText.setText(text);
        }
    }

    public void showProgressBar(boolean show) {
        if (progressBar != null) {
            progressBar.setVisibility(show ? View.VISIBLE : View.GONE);
        }
    }
}

逻辑分析：
- setLoadingText() ：允许外部动态设置加载提示文本。
- showProgressBar() ：控制进度条的显示与隐藏。
- 在Dialog显示后，可以通过调用这些方法进行状态更新。

3.2.3 实现可取消与不可取消的加载提示

有时我们希望加载Dialog不能被用户取消（例如在执行关键操作时）。可以通过设置是否可取消：

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setCancelable(false); // 不可取消
}

或者动态控制：

public void setCancelable(boolean cancelable) {
    this.setCancelable(cancelable);
}

应用场景：
- 不可取消场景：例如数据库初始化、登录验证等。
- 可取消场景：例如加载非关键数据、可中断的网络请求等。

3.3 样式资源的定义与主题适配

3.3.1 定义自定义样式（style）与主题（theme）

为了统一应用中所有Dialog的视觉风格，可以在 styles.xml 中定义自定义样式，并通过 AlertDialog.Builder(context, style) 的方式应用：

<style name="CustomDialogStyle" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="android:textColor">@color/black</item>
    <item name="android:background">@drawable/dialog_bg</item>
    <item name="colorAccent">@color/teal_200</item>
</style>

使用方式：

new AlertDialog.Builder(requireContext(), R.style.CustomDialogStyle)
    .setView(dialogView)
    .create();

3.3.2 处理不同Android版本的兼容性问题

不同Android版本可能对Dialog的样式支持不同，因此需要通过资源目录限定符来适配：

• values-v21/styles.xml ：针对API 21及以上（Lollipop+）。
• values/styles.xml ：通用样式。

例如，Lollipop版本可以支持阴影、半透明背景等特性：

<style name="CustomDialogStyle" parent="Theme.AppCompat.Light.Dialog.Alert">
    <item name="android:windowElevation">8dp</item>
    <item name="android:background">@drawable/dialog_bg_v21</item>
</style>

3.3.3 使用矢量图形与动画资源增强视觉效果

为了提升视觉体验，可以使用矢量图形（SVG）或Lottie动画作为进度条替代。

使用矢量图形（XML）：

<ImageView
    android:id="@+id/ivLoadingIcon"
    android:layout_width="48dp"
    android:layout_height="48dp"
    android:src="@drawable/ic_loading_spinner"/>

ic_loading_spinner.xml ：

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path
        android:name="rotation"
        android:fillColor="#FF000000"
        android:pathData="M12,4V2C7,2 3,6 3,11H1L3,22L13,12H11C11,6.5 15.5,2 12,2z"/>
</vector>

使用Lottie动画：

Lottie是一个流行的动画库，支持从JSON加载动画资源：

implementation 'com.airbnb.android:lottie:6.1.0'

在布局中添加：

<com.airbnb.lottie.LottieAnimationView
    android:id="@+id/lottieLoading"
    android:layout_width="80dp"
    android:layout_height="80dp"
    app:lottie_fileName="loading.json"
    app:lottie_loop="true"
    app:lottie_autoPlay="true"/>

优点：
- 更生动的动画效果。
- 更高的定制化能力。
- 支持复杂路径动画。

小结（非总结性描述）：

在本章中，我们详细探讨了如何通过 TextView 和 ProgressBar 构建基础的加载提示布局，并通过 ConstraintLayout 提升布局的灵活性和适配性。接着介绍了如何自定义ProgressDialog的样式、动态控制加载文本与进度条状态，并实现了可取消与不可取消两种交互模式。最后，我们讨论了如何通过样式资源、主题适配以及矢量图形、Lottie动画等手段提升加载Dialog的视觉表现力，为后续章节的交互逻辑与动态控制打下基础。

4. 加载提示的动态控制与交互逻辑

在Android应用中，加载提示（Loading Dialog）不仅仅是一个静态的UI组件，它的核心价值在于 动态控制 与 交互逻辑 的设计。特别是在涉及异步任务、网络请求、数据加载等场景中，加载提示需要根据任务状态实时更新UI，并与用户进行有效沟通。本章将深入探讨如何通过TextView与ProgressBar实现状态更新、如何控制Dialog的显示与隐藏逻辑，以及如何与异步任务（如AsyncTask、Handler、ViewModel等）结合，构建高效的加载提示交互机制。

4.1 TextView与ProgressBar的状态更新

在加载提示中，TextView用于显示加载状态文字，而ProgressBar则用于表示加载进度。为了提升用户体验，我们需要在任务执行过程中动态更新这两个组件的状态。

4.1.1 动态设置文本内容与进度值

在DialogFragment中，我们可以通过获取Dialog的View对象来访问TextView和ProgressBar，并在任务执行过程中动态更新它们的值。

示例代码：动态更新TextView和ProgressBar

public class LoadingDialogFragment extends DialogFragment {
    private TextView mLoadingText;
    private ProgressBar mProgressBar;

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        View view = LayoutInflater.from(getActivity()).inflate(R.layout.dialog_loading, null);
        mLoadingText = view.findViewById(R.id.loading_text);
        mProgressBar = view.findViewById(R.id.progress_bar);

        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setView(view);
        return builder.create();
    }

    public void updateLoadingText(String text) {
        if (mLoadingText != null) {
            mLoadingText.setText(text);
        }
    }

    public void updateProgress(int progress) {
        if (mProgressBar != null) {
            mProgressBar.setProgress(progress);
        }
    }
}

逻辑分析：

• onCreateDialog() 方法中通过 LayoutInflater 加载了自定义的布局 dialog_loading.xml ，并初始化了TextView和ProgressBar。
• updateLoadingText() 方法用于更新加载提示文本。
• updateProgress() 方法用于更新进度条的进度值。

参数说明：

• R.layout.dialog_loading ：自定义的加载提示布局文件。
• R.id.loading_text ：TextView控件ID，用于展示加载状态文字。
• R.id.progress_bar ：ProgressBar控件ID，用于展示加载进度。

4.1.2 ProgressBar的样式切换与动画控制

Android提供了多种样式的ProgressBar，包括水平进度条和环形进度条。我们可以通过XML配置或代码动态切换进度条样式。

示例代码：设置环形进度条

<ProgressBar
    android:id="@+id/progress_bar"
    style="?android/progressBarStyleHorizontal"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:max="100"
    android:progress="0"
    android:indeterminate="false"/>

逻辑分析：

• style="?android/progressBarStyleHorizontal" ：设置为水平进度条样式。
• android:indeterminate="false" ：关闭不确定模式，使用确定的进度值。

动画控制示例：

ObjectAnimator animator = ObjectAnimator.ofInt(mProgressBar, "progress", 0, 100);
animator.setDuration(3000);
animator.start();

• 此代码使用 ObjectAnimator 实现从0到100的进度动画，持续3秒。

4.1.3 在Fragment与Activity中更新UI状态

在实际开发中，加载提示的UI状态更新通常需要在Fragment或Activity中进行。为了实现这一点，可以通过接口回调或LiveData等方式实现通信。

示例代码：通过接口回调更新UI

public interface LoadingDialogListener {
    void onLoadingTextUpdate(String text);
    void onProgressUpdate(int progress);
}

public class LoadingDialogFragment extends DialogFragment {
    private LoadingDialogListener mListener;

    public void setListener(LoadingDialogListener listener) {
        mListener = listener;
    }

    public void simulateLoading() {
        new Handler(Looper.getMainLooper()).postDelayed(() -> {
            mListener.onLoadingTextUpdate("正在解析数据...");
            mListener.onProgressUpdate(50);
        }, 1000);
    }
}

在Activity中实现接口：

public class MainActivity extends AppCompatActivity implements LoadingDialogListener {
    private LoadingDialogFragment loadingDialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadingDialog = new LoadingDialogFragment();
        loadingDialog.setListener(this);
        loadingDialog.show(getSupportFragmentManager(), "LoadingDialog");

        loadingDialog.simulateLoading();
    }

    @Override
    public void onLoadingTextUpdate(String text) {
        loadingDialog.updateLoadingText(text);
    }

    @Override
    public void onProgressUpdate(int progress) {
        loadingDialog.updateProgress(progress);
    }
}

逻辑分析：

• 通过定义接口 LoadingDialogListener ，实现Fragment与Activity之间的通信。
• 在Activity中调用 updateLoadingText() 和 updateProgress() 方法更新UI状态。

4.2 Dialog的显示与隐藏控制逻辑

加载提示的显示与隐藏控制是交互逻辑中非常关键的一环。合理的控制逻辑可以避免重复显示、提升用户体验，并防止内存泄漏。

4.2.1 控制Dialog的显示时机与生命周期

加载提示通常在异步任务开始时显示，在任务完成后隐藏。我们可以结合生命周期方法来控制Dialog的显示逻辑。

示例代码：在AsyncTask中控制Dialog显示

private class LoadDataTask extends AsyncTask<Void, Integer, String> {
    private LoadingDialogFragment loadingDialog;

    public LoadDataTask(LoadingDialogFragment dialog) {
        this.loadingDialog = dialog;
    }

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        if (!loadingDialog.isVisible()) {
            loadingDialog.show(getSupportFragmentManager(), "LoadingDialog");
        }
    }

    @Override
    protected String doInBackground(Void... voids) {
        for (int i = 0; i <= 100; i += 10) {
            publishProgress(i);
            SystemClock.sleep(500);
        }
        return "加载完成";
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        loadingDialog.updateProgress(values[0]);
    }

    @Override
    protected void onPostExecute(String result) {
        loadingDialog.dismiss();
        Toast.makeText(MainActivity.this, result, Toast.LENGTH_SHORT).show();
    }
}

逻辑分析：

• onPreExecute() ：任务开始前显示Dialog。
• doInBackground() ：模拟耗时任务，通过 publishProgress() 更新进度。
• onProgressUpdate() ：接收进度值并更新UI。
• onPostExecute() ：任务完成后隐藏Dialog。

4.2.2 实现Dialog的自动隐藏机制

在某些场景中，加载提示可能需要在一定时间后自动隐藏。例如，网络请求失败或超时后自动关闭Dialog。

示例代码：自动隐藏Dialog

Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(() -> {
    if (loadingDialog != null && loadingDialog.isVisible()) {
        loadingDialog.dismiss();
    }
}, 5000); // 5秒后自动隐藏

逻辑分析：

• 使用 Handler 在主线程中延时执行dismiss操作。
• 避免Dialog长时间显示，提升用户体验。

4.2.3 防止重复显示与内存泄漏问题

在实际开发中，频繁调用Dialog的 show() 方法可能导致多个Dialog重复显示，甚至引发崩溃。此外，未正确释放Dialog引用也可能导致内存泄漏。

最佳实践建议：

问题	解决方案
重复显示	在显示前判断Dialog是否已显示
内存泄漏	在onDestroy中释放Dialog引用
空指针异常	使用非空判断避免崩溃

示例代码：防止重复显示

if (loadingDialog == null || !loadingDialog.isVisible()) {
    loadingDialog = new LoadingDialogFragment();
    loadingDialog.show(getSupportFragmentManager(), "LoadingDialog");
}

4.3 与异步任务结合的交互策略

加载提示通常需要与异步任务结合使用，以确保在任务执行期间提供良好的用户体验。Android提供了多种异步处理机制，包括AsyncTask、Handler、Runnable、ViewModel、LiveData等。

4.3.1 在AsyncTask中使用DialogFragment

AsyncTask是Android中较早的异步处理方式，虽然已被弃用，但在老项目中仍广泛使用。

示例代码：在AsyncTask中集成DialogFragment

private class NetworkTask extends AsyncTask<Void, Void, String> {
    private LoadingDialogFragment dialog;

    public NetworkTask(LoadingDialogFragment dialog) {
        this.dialog = dialog;
    }

    @Override
    protected void onPreExecute() {
        dialog.show(getSupportFragmentManager(), "LoadingDialog");
    }

    @Override
    protected String doInBackground(Void... voids) {
        // 模拟网络请求
        SystemClock.sleep(3000);
        return "网络数据加载完成";
    }

    @Override
    protected void onPostExecute(String result) {
        dialog.dismiss();
        Toast.makeText(MainActivity.this, result, Toast.LENGTH_SHORT).show();
    }
}

逻辑分析：

• 在 onPreExecute() 中显示加载Dialog。
• 在 doInBackground() 中执行耗时操作。
• 在 onPostExecute() 中隐藏Dialog并显示结果。

4.3.2 Handler与Runnable实现的加载控制

Handler和Runnable适用于简单的异步任务控制，尤其适合需要定时更新UI的场景。

示例代码：使用Handler更新进度条

Handler handler = new Handler(Looper.getMainLooper());
Runnable updateProgressRunnable = new Runnable() {
    int progress = 0;

    @Override
    public void run() {
        if (progress <= 100) {
            loadingDialog.updateProgress(progress);
            progress += 10;
            handler.postDelayed(this, 500);
        } else {
            loadingDialog.dismiss();
        }
    }
};

handler.post(updateProgressRunnable);

逻辑分析：

• 使用Runnable实现定时更新进度条。
• 当进度达到100%时自动隐藏Dialog。

4.3.3 使用ViewModel与LiveData进行状态同步

在MVVM架构中，推荐使用ViewModel和LiveData来管理UI状态，实现加载提示与异步任务的状态同步。

示例代码：ViewModel中管理加载状态

public class MainViewModel extends AndroidViewModel {
    private MutableLiveData<Integer> progressLiveData = new MutableLiveData<>();
    private MutableLiveData<Boolean> isLoading = new MutableLiveData<>();

    public LiveData<Integer> getProgressLiveData() {
        return progressLiveData;
    }

    public LiveData<Boolean> getIsLoading() {
        return isLoading;
    }

    public void startLoading() {
        isLoading.setValue(true);
        new Thread(() -> {
            for (int i = 0; i <= 100; i += 10) {
                progressLiveData.postValue(i);
                SystemClock.sleep(500);
            }
            isLoading.postValue(false);
        }).start();
    }
}

在Fragment中观察状态：

viewModel.getProgressLiveData().observe(getViewLifecycleOwner(), progress -> {
    loadingDialog.updateProgress(progress);
});

viewModel.getIsLoading().observe(getViewLifecycleOwner(), aBoolean -> {
    if (aBoolean) {
        loadingDialog.show(getChildFragmentManager(), "LoadingDialog");
    } else {
        loadingDialog.dismiss();
    }
});

逻辑分析：

• ViewModel中使用LiveData管理加载状态。
• Fragment中通过观察LiveData实现UI自动更新。

本章小结（非总结性描述）

通过本章内容，我们深入探讨了加载提示中TextView与ProgressBar的动态更新机制、Dialog的显示与隐藏控制逻辑，以及如何将其与异步任务结合使用。从基本的UI状态更新，到复杂的异步任务集成，再到现代架构组件（如ViewModel）的结合，展示了加载提示在不同开发场景下的灵活应用方式。下一章将继续深入，探讨加载提示在真实业务场景中的具体应用，如网络请求、数据库操作、文件读写等。

5. 异步任务中的加载提示应用场景

在Android应用开发中，异步任务的执行往往伴随着用户等待的场景，如网络请求、数据库查询、文件读取等。为了让用户感知应用的状态并提升交互体验，合理的加载提示机制是必不可少的。本章将围绕“加载提示”在不同异步任务场景中的集成方式展开深入探讨，结合实际开发场景，展示如何在Retrofit、Room数据库、文件读取等场景中优雅地集成和控制加载提示。

5.1 网络请求与加载提示的集成

网络请求是Android应用中最常见的异步操作之一，尤其在使用Retrofit与OkHttp构建网络请求框架时，如何在请求前后合理地控制加载提示，是提升用户体验的关键。

5.1.1 Retrofit+OkHttp请求中的Dialog管理

在Retrofit+OkHttp架构中，我们通常使用 Call 对象进行异步请求。为了在请求开始时显示加载提示，在请求结束时隐藏提示，我们可以将加载Dialog的显示与隐藏逻辑嵌入到 enqueue 回调中。

val dialog = ProgressDialogFragment.newInstance("正在加载数据...")
dialog.show(supportFragmentManager, "ProgressDialog")

val call = apiService.fetchData()
call.enqueue(object : Callback<ResponseBody> {
    override fun onResponse(call: Call<ResponseBody>, response: Response<ResponseBody>) {
        // 请求成功，隐藏加载提示
        dialog.dismiss()
        // 处理响应数据
    }

    override fun onFailure(call: Call<ResponseBody>, t: Throwable) {
        // 请求失败，同样隐藏加载提示
        dialog.dismiss()
        // 显示错误提示
    }
})

代码逻辑分析：
- 使用 ProgressDialogFragment 作为加载提示组件，通过 show() 方法展示；
- 在Retrofit的 enqueue 异步回调中，分别在 onResponse 和 onFailure 中调用 dismiss() 方法；
- 保证无论请求成功或失败，加载提示都会被关闭。

5.1.2 使用拦截器统一处理加载状态

为了进一步优化加载提示的管理，可以利用OkHttp的 Interceptor 机制，在请求开始与结束时统一处理UI逻辑。

class LoadingInterceptor(private val loadingCallback: (Boolean) -> Unit) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        loadingCallback(true) // 开始加载
        val response = chain.proceed(chain.request())
        loadingCallback(false) // 加载完成
        return response
    }
}

参数说明：
- loadingCallback 是一个函数参数，用于通知UI层加载状态的变化；
- 在拦截器中统一调用，避免每个请求手动添加加载逻辑；
- 示例中未处理异常情况，实际使用中可结合 try-catch 进行优化。

5.1.3 取消请求与Dialog的联动控制

在网络请求中，用户可能中途取消操作。为了同步取消加载提示，可以结合Retrofit的 Call.cancel() 方法。

val dialog = ProgressDialogFragment.newInstance("加载中...")
dialog.setOnDismissListener {
    call.cancel()
}
dialog.show(supportFragmentManager, "ProgressDialog")

逻辑分析：
- 当用户点击加载Dialog的“取消”按钮时，触发 setOnDismissListener ；
- 在监听器中调用 call.cancel() ，取消网络请求；
- 实现了用户操作与网络请求之间的联动控制。

5.2 数据库操作中的加载提示

在使用Room数据库进行本地数据读取或写入操作时，尽管操作速度较快，但在初始化或首次加载数据时，仍可能出现短暂延迟。此时加入加载提示有助于提升用户体验。

5.2.1 Room数据库操作的异步处理

Room推荐使用 LiveData 或 RxJava 来处理异步查询。我们以 LiveData 为例，结合 ViewModel 统一管理UI状态。

class DataViewModel : ViewModel() {
    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> get() = _loading

    fun loadData() {
        _loading.postValue(true)
        viewModelScope.launch {
            val result = repository.fetchDataFromDatabase()
            _loading.postValue(false)
        }
    }
}

参数说明：
- _loading 用于通知UI显示或隐藏加载提示；
- viewModelScope 确保在ViewModel生命周期内安全地执行协程；
- 通过 LiveData 观察机制实现UI状态更新。

5.2.2 加载提示在数据初始化中的应用

当应用首次启动时，可能需要从数据库中加载大量初始数据，此时可使用加载Dialog提示用户等待。

val dialog = ProgressDialogFragment.newInstance("正在初始化数据...")
dialog.show(supportFragmentManager, "ProgressDialog")

viewModel.loadData()
viewModel.loading.observe(this, Observer {
    if (!it) {
        dialog.dismiss()
    }
})

逻辑说明：
- LiveData 观察 loading 状态，当变为 false 时隐藏Dialog；
- 保证加载提示的显示与数据加载状态同步。

5.2.3 数据加载完成后的状态反馈

加载完成后，除了关闭Dialog，还可以结合 Snackbar 或Toast提示用户操作结果。

Snackbar.make(binding.root, "数据加载完成", Snackbar.LENGTH_SHORT).show()

建议：
- 在数据加载成功后，适当反馈结果有助于用户确认操作状态；
- 若加载失败，应显示错误信息并提供重试机制。

5.3 文件读写与资源加载场景

文件读写操作在Android中同样属于异步行为，尤其是在处理大文件或图片资源时，加载提示的使用尤为必要。

5.3.1 文件读取过程中的加载提示

使用 FileInputStream 读取大文件时，可通过协程或线程异步处理，并在主线程更新UI。

fun readLargeFile(context: Context, filePath: String) {
    val dialog = ProgressDialogFragment.newInstance("正在读取文件...")
    dialog.show(supportFragmentManager, "ProgressDialog")

    viewModelScope.launch(Dispatchers.IO) {
        val file = File(filePath)
        val content = file.readText()
        withContext(Dispatchers.Main) {
            dialog.dismiss()
            binding.textView.text = content
        }
    }
}

逻辑分析：
- 使用协程在后台读取文件内容；
- 在主线程更新UI并关闭Dialog；
- 确保不会阻塞主线程，避免ANR问题。

5.3.2 图片加载框架中HUD的集成方式

在使用Glide或Coil加载图片时，可以通过设置加载占位符或自定义HUD提示。

Glide.with(context)
    .load(url)
    .placeholder(R.drawable.loading_spinner)
    .into(imageView)

扩展建议：
- 若需更复杂的提示（如带文本的Dialog），可结合 onLoadStarted() 与 onLoadFailed() 回调；
- 使用自定义DialogFragment在图片加载时显示详细提示。

5.3.3 大数据加载的进度反馈机制

当加载数据量较大时，应提供进度反馈以提升用户体验。可结合 ProgressBar 与异步任务更新进度。

val dialog = ProgressDialogFragment.newInstance("加载进度：0%")
dialog.show(supportFragmentManager, "ProgressDialog")

viewModelScope.launch {
    for (i in 0..100 step 10) {
        delay(300)
        withContext(Dispatchers.Main) {
            dialog.updateMessage("加载进度：$i%")
        }
    }
    dialog.dismiss()
}

逻辑说明：
- 使用协程模拟进度更新；
- ProgressDialogFragment 需支持动态更新提示内容；
- 这种方式适用于模拟加载进度或真实数据分段加载。

总结性建议：

场景	加载提示方式	是否支持取消	建议
网络请求	ProgressDialogFragment	✅	使用拦截器统一管理
数据库操作	LiveData + Dialog	❌	用于首次数据初始化
文件读取	Dialog + 协程	✅	防止主线程阻塞
图片加载	占位图 + Dialog	❌	提高用户感知
大数据加载	进度Dialog + 动态更新	✅	支持用户中断操作

流程图展示：

graph TD
    A[开始异步操作] --> B{是否需要加载提示?}
    B -->|是| C[显示ProgressDialogFragment]
    B -->|否| D[直接执行]
    C --> E[执行异步任务]
    E --> F{操作是否成功?}
    F -->|是| G[更新UI]
    F -->|否| H[显示错误提示]
    G --> I[隐藏Dialog]
    H --> I
    I --> J[结束]

通过本章内容，我们深入探讨了加载提示在各类异步任务中的应用场景，包括网络请求、数据库操作、文件读取等。结合代码示例与流程图，展示了如何在实际开发中实现加载提示的统一管理与灵活控制，为构建更高质量的Android应用提供实践支持。

6. 第三方加载提示库的集成与使用

在现代Android开发中，开发者常常借助第三方库来提升开发效率并实现更专业的UI交互体验。加载提示作为用户交互中不可忽视的一部分，许多优秀的开源库提供了开箱即用的解决方案。其中， KProgressHUD 是一个轻量级且功能丰富的HUD（Heads-Up Display）加载提示库，它可以帮助开发者快速实现美观、交互良好的加载提示。本章将深入讲解KProgressHUD的集成方式、样式定制、交互设置，以及如何将其与项目架构（如MVVM）进行整合，形成统一的调用策略。

6.1 KProgressHUD库的核心功能与优势

6.1.1 KProgressHUD的特点与使用场景

KProgressHUD 是由土耳其开发者Hasan Gürsoy开发的Android加载HUD库，其核心特点如下：

特性	描述
轻量级	仅依赖于AppCompat库，体积小
样式丰富	支持环形进度条、水平进度条、自定义图标等
易于集成	提供简洁的API，支持Kotlin和Java
可定制性高	支持自定义主题、动画、图标和文本
交互友好	支持点击取消、监听回调等行为

适用场景：
- 网络请求等待时的加载提示
- 文件上传/下载时的进度反馈
- 数据库操作、本地数据加载时的提示
- 异步任务中的状态同步

6.1.2 库的引入与基本配置

在项目中集成KProgressHUD非常简单。以下是引入方式：

添加依赖（ build.gradle ）：

dependencies {
    implementation 'com.github.hasankucuk:kprogresshud:1.0.0'
}

同步项目并确保网络权限（如需联网）：

<uses-permission android:name="android.permission.INTERNET"/>

基础使用示例：

val hud = KProgressHUD.create(context)
    .setStyle(KProgressHUD.Style.SPIN_INDETERMINATE) // 设置样式
    .setLabel("加载中...") // 设置提示文本
    .setCancellable(true) // 是否可取消
    .show() // 显示HUD

// 2秒后隐藏
Handler(Looper.getMainLooper()).postDelayed({
    hud.dismiss()
}, 2000)

代码逻辑分析：
- KProgressHUD.create(context) ：创建HUD实例。
- setStyle(...) ：设置HUD样式，如SPIN_INDETERMINATE表示环形进度条。
- setLabel(...) ：设置加载提示文字。
- setCancellable(true) ：允许用户点击取消。
- show() ：显示HUD。
- dismiss() ：手动隐藏HUD。

6.1.3 快速构建与样式定制方法

KProgressHUD支持多种构建方式，可以通过链式调用快速设置：

快速构建代码：

KProgressHUD.create(activity)
    .setStyle(KProgressHUD.Style.PIE_DETERMINATE) // 固定进度条样式
    .setLabel("正在处理")
    .setDetailsLabel("请稍等")
    .setMaxProgress(100)
    .show()

自定义HUD样式：

可以通过 setAnimationSpeed(int speed) 、 setDimAmount(float amount) 等方法调整动画速度与背景暗度：

.setAnimationSpeed(2) // 动画速度为默认的2倍
.setDimAmount(0.5f) // 设置背景遮罩层透明度

参数说明：
- setAnimationSpeed ：控制进度条动画速度，数值越大越快。
- setDimAmount ：设置背景遮罩层的透明度，范围0~1，1为完全遮罩。

6.2 HUD加载提示的样式与交互设置

6.2.1 不同类型的HUD样式（环形、水平进度条等）

KProgressHUD支持多种进度样式，开发者可以根据需求选择：

样式	描述
SPIN_INDETERMINATE	环形无限旋转进度条
PIE_DETERMINATE	固定进度条（圆形）
BAR_DETERMINATE	水平进度条
INDICATOR	仅显示图标，不带进度条

示例代码（设置水平进度条）：

val hud = KProgressHUD.create(context)
    .setStyle(KProgressHUD.Style.BAR_DETERMINATE)
    .setLabel("下载进度")
    .setMaxProgress(100)
    .show()

// 模拟下载进度更新
for (i in 0..100 step 10) {
    Handler(Looper.getMainLooper()).postDelayed({
        hud.setProgress(i)
    }, (i * 50).toLong())
}

逻辑分析：
- 使用 setMaxProgress(100) 设置最大进度。
- setProgress(i) 用于更新当前进度值。
- 配合Handler模拟进度更新，适合实际网络或文件操作场景。

6.2.2 设置加载文本与自定义图标

KProgressHUD支持设置主提示文本（Label）、详细描述（DetailsLabel）以及自定义图标（Drawable）。

示例代码：

KProgressHUD.create(context)
    .setStyle(KProgressHUD.Style.SPIN_INDETERMINATE)
    .setLabel("连接服务器")
    .setDetailsLabel("正在建立连接，请稍候")
    .setCustomDrawable(ContextCompat.getDrawable(context, R.drawable.ic_custom_loading)) // 自定义图标
    .show()

参数说明：
- setLabel(...) ：主提示文本，显示在HUD中央。
- setDetailsLabel(...) ：副提示文本，显示在主文本下方。
- setCustomDrawable(...) ：设置自定义图标，可替换默认的加载动画。

6.2.3 HUD的交互行为与回调处理

KProgressHUD支持设置点击取消回调和取消监听器，增强用户交互体验。

示例代码：

val hud = KProgressHUD.create(context)
    .setStyle(KProgressHUD.Style.SPIN_INDETERMINATE)
    .setLabel("加载中...")
    .setCancellable(true)
    .setCancelListener(DialogInterface.OnCancelListener {
        // 用户点击取消时的回调
        Toast.makeText(context, "加载已取消", Toast.LENGTH_SHORT).show()
    })
    .show()

逻辑分析：
- setCancellable(true) ：允许用户点击HUD外部取消加载。
- setCancelListener(...) ：注册取消监听器，用于执行取消操作后的逻辑，如取消网络请求。

6.3 第三方库与项目架构的整合

6.3.1 封装KProgressHUD为通用组件

在实际项目中，直接使用KProgressHUD可能会导致代码重复和调用不一致。建议将其封装为一个通用的工具类或ViewModel。

封装示例（工具类）：

object LoadingHUD {
    private var hud: KProgressHUD? = null

    fun show(context: Context, message: String = "加载中...") {
        hud = KProgressHUD.create(context)
            .setStyle(KProgressHUD.Style.SPIN_INDETERMINATE)
            .setLabel(message)
            .setCancellable(true)
            .show()
    }

    fun dismiss() {
        hud?.dismiss()
        hud = null
    }

    fun setProgress(progress: Int) {
        hud?.setProgress(progress)
    }
}

使用方式：
kotlin LoadingHUD.show(context, "正在登录") // ... LoadingHUD.dismiss()

6.3.2 与MVVM架构的结合实践

在MVVM架构中，可以将HUD状态与ViewModel结合，实现更灵活的状态管理。

示例代码（ViewModel + LiveData）：

class MainViewModel : ViewModel() {
    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> = _loading

    fun fetchData() {
        _loading.value = true
        // 模拟异步任务
        viewModelScope.launch {
            delay(2000)
            _loading.value = false
        }
    }
}

在Fragment中观察状态并控制HUD：

viewModel.loading.observe(viewLifecycleOwner, Observer { isLoading ->
    if (isLoading) {
        LoadingHUD.show(requireContext())
    } else {
        LoadingHUD.dismiss()
    }
})

优势分析：
- 将加载状态抽象到ViewModel中，避免Fragment/Activity逻辑臃肿。
- 提高可测试性与可维护性。
- 与LiveData结合实现响应式UI控制。

6.3.3 多模块项目中的统一调用策略

在多模块项目中，建议将HUD封装为一个 基础库模块（common-ui） ，并在各业务模块中引用该库。

模块结构示意图（Mermaid流程图）：

graph TD
    A[app模块] --> B(common-ui模块)
    C[feature模块1] --> B
    D[feature模块2] --> B
    B --> E[KProgressHUD封装类]

统一调用方式：
- 所有模块通过 LoadingHUD.show() 统一调用。
- 公共样式与主题统一定义在 common-ui 中。
- 业务模块无需关心HUD实现细节，降低耦合度。

小结

通过本章的学习，我们了解了KProgressHUD库的核心功能、样式配置与交互设置方式，并掌握了如何将其封装为通用组件，适配MVVM架构与多模块项目结构。使用第三方库不仅能提升开发效率，还能带来更专业的用户体验。在实际项目中，建议结合自身需求对HUD进行合理封装与统一管理，以实现高效、可维护的加载提示机制。

7. 完整自定义加载Dialog开发流程与最佳实践

在现代Android应用开发中，构建一个功能完整、可复用、易维护的自定义加载Dialog模块是提升用户体验和代码质量的重要一环。本章将从零开始，逐步引导开发者构建一个模块化的自定义加载Dialog系统，并通过测试、调试与实际应用中的最佳实践，帮助开发者掌握高效开发与维护技巧。

7.1 从零构建自定义加载Dialog模块

7.1.1 模块化设计与代码结构规划

在构建自定义Dialog前，合理的模块划分和代码结构设计至关重要。一个良好的设计应包括以下模块：

• UI组件层 ：包含Dialog的布局文件（XML）和样式定义。
• 逻辑控制层 ：封装Dialog的显示、隐藏、状态更新等核心逻辑。
• 接口封装层 ：对外提供统一的调用接口，提升复用性。
• 资源管理层 ：统一管理字符串、颜色、动画等资源。

graph TD
    A[自定义加载 Dialog 模块] --> B[UI组件]
    A --> C[逻辑控制]
    A --> D[接口封装]
    A --> E[资源管理]
    B --> F[XML布局]
    B --> G[动画资源]
    C --> H[DialogFragment]
    C --> I[状态管理]
    D --> J[对外API]
    D --> K[调用封装]

7.1.2 编写可复用的DialogFragment子类

通过继承 DialogFragment 并实现核心方法，我们可以构建一个可复用的自定义加载Dialog类。

public class LoadingDialogFragment extends DialogFragment {

    private String loadingMessage = "加载中...";
    private boolean cancelable = true;

    public static LoadingDialogFragment newInstance(String message, boolean cancelable) {
        LoadingDialogFragment fragment = new LoadingDialogFragment();
        Bundle args = new Bundle();
        args.putString("message", message);
        args.putBoolean("cancelable", cancelable);
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            loadingMessage = getArguments().getString("message");
            cancelable = getArguments().getBoolean("cancelable");
        }
        setCancelable(cancelable);
    }

    @NonNull
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder builder = new AlertDialog.Builder(requireContext());
        LayoutInflater inflater = requireActivity().getLayoutInflater();
        View view = inflater.inflate(R.layout.dialog_loading, null);

        TextView textView = view.findViewById(R.id.loading_text);
        textView.setText(loadingMessage);

        ProgressBar progressBar = view.findViewById(R.id.loading_progress);
        // 可以在这里设置进度条样式或动画

        builder.setView(view);
        return builder.create();
    }
}

7.1.3 构建统一的加载提示调用接口

为简化调用，建议封装一个工具类或接口，统一管理Dialog的显示与隐藏：

public class LoadingDialogManager {

    private static LoadingDialogFragment currentDialog;

    public static void showLoadingDialog(@NonNull FragmentManager fragmentManager, String message, boolean cancelable) {
        if (currentDialog != null && currentDialog.isVisible()) {
            return; // 防止重复显示
        }
        currentDialog = LoadingDialogFragment.newInstance(message, cancelable);
        currentDialog.show(fragmentManager, "loading_dialog");
    }

    public static void dismissLoadingDialog() {
        if (currentDialog != null && currentDialog.isVisible()) {
            currentDialog.dismiss();
        }
    }
}

7.2 测试与调试自定义Dialog

7.2.1 不同设备与分辨率的适配测试

使用Android Studio的 Layout Editor 和 Device Monitor 工具，可以在多种设备和屏幕尺寸下预览Dialog布局效果。确保TextView和ProgressBar在不同分辨率下显示正常。

设备类型	屏幕尺寸	适配结果
手机（普通）	5.5寸	✅
平板	10寸	✅
折叠屏	动态变化	✅

7.2.2 模拟网络延迟与加载场景

在测试中，可以使用 Handler 模拟异步加载场景：

LoadingDialogManager.showLoadingDialog(getSupportFragmentManager(), "正在加载数据...", false);

new Handler(Looper.getMainLooper()).postDelayed(() -> {
    // 模拟数据加载完成
    LoadingDialogManager.dismissLoadingDialog();
}, 3000); // 模拟3秒延迟

7.2.3 内存泄漏检测与性能优化

使用 LeakCanary 或Android Profiler工具检测Dialog是否引起内存泄漏。关键点包括：

• DialogFragment是否正确释放；
• 是否持有Context强引用；
• 是否正确移除未完成的Runnable。

建议在 onDismiss() 中移除所有回调与资源引用：

@Override
public void onDismiss(@NonNull DialogInterface dialog) {
    super.onDismiss(dialog);
    // 清理资源
    progressBar = null;
    textView = null;
}

本文还有配套的精品资源，点击获取

简介：在Android开发中，Dialog是用于显示临时信息或进行用户交互的重要UI组件。本文重点讲解如何创建“正在加载中”的自定义Dialog，以提升应用界面的个性化与用户体验。文章介绍了继承DialogFragment实现自定义加载对话框的方法，并结合XML布局设计加载界面，同时引入KProgressHUD第三方库实现更丰富的加载效果。通过异步任务控制Dialog的显示与隐藏，实现更友好的交互流程。本教程适合希望掌握Android Dialog自定义开发的初学者和中级开发者。

本文还有配套的精品资源，点击获取