Settings 体系架构四 DashboardFragment

Settings中的DashboardFragment，是大多数页面的父类，该类里面实现了页面加载管理，数据交互等核心工作。

页面加载控制流程

onCreate()
onCreatePreferences() { // Preference列表创建完成
	refreshAllPreferences() { // 刷新所有的Preference
		displayResourceTiles() { // 显示Preference及加载处理相应的UI
			addPreferencesFromResource() // 加载PreferehceScreen -> setPreferenceScreen
			controller.displayPreference(screen) // 将Screen对象传递到Controller，由Controller管理UI
		}
		refreshDashboardTiles() // 更新需要由DashboardCategory管理的Preference
	}
}

页面更新

onCategoriesChanged() 
	refreshDashboardTiles()

onResume()
	updatePreferenceStates()
		controller.updateState(preference)

其它

/**
 * Base fragment for dashboard style UI containing a list of static and dynamic setting items.
 */
public abstract class DashboardFragment extends SettingsPreferenceFragment
        implements SettingsDrawerActivity.CategoryListener, Indexable,
        SummaryLoader.SummaryConsumer {
    private static final String TAG = "DashboardFragment";
    // PreferenceController键值对集合，用于处理页面中的Preference点击类事件。
    private final Map<Class, PreferenceController> mPreferenceControllers =
            new ArrayMap<>();
    private final Set<String> mDashboardTilePrefKeys = new ArraySet<>();

    protected ProgressiveDisclosureMixin mProgressiveDisclosureMixin;
    protected DashboardFeatureProvider mDashboardFeatureProvider;
    private DashboardTilePlaceholderPreferenceController mPlaceholderPreferenceController;
    private boolean mListeningToCategoryChange;
    private SummaryLoader mSummaryLoader;

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        mDashboardFeatureProvider =
                FeatureFactory.getFactory(context).getDashboardFeatureProvider(context);
        mProgressiveDisclosureMixin = mDashboardFeatureProvider
                .getProgressiveDisclosureMixin(context, this, getArguments());
        getLifecycle().addObserver(mProgressiveDisclosureMixin);
        // 获取PreferenceControllers，由子类实现返回
        List<PreferenceController> controllers = getPreferenceControllers(context);
        if (controllers == null) {
            controllers = new ArrayList<>();
        }
        mPlaceholderPreferenceController =
                new DashboardTilePlaceholderPreferenceController(context);
        controllers.add(mPlaceholderPreferenceController);
        // 重新以 key-values 形式保存 Controller
        for (PreferenceController controller : controllers) {
            addPreferenceController(controller); // 以 key-value 形式保存Controller。
        }
    }

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        // Set ComparisonCallback so we get better animation when list changes.
        // 设置比较监听器，优化动画。
        getPreferenceManager().setPreferenceComparisonCallback(
                new PreferenceManager.SimplePreferenceComparisonCallback());
    }

    @Override
    public void onCategoriesChanged() { // Category发生改变
        final DashboardCategory category =
                mDashboardFeatureProvider.getTilesForCategory(getCategoryKey());
        if (category == null) {
            return;
        }
        refreshDashboardTiles(getLogTag());
    }

    @Override // 创建Preference
    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
        super.onCreatePreferences(savedInstanceState, rootKey);
        refreshAllPreferences(getLogTag()); // 更新Preference
    }

    /**
     * 更新所有的Preference项, 包含从xml中加载的固定选项和从DashboardCategory中动态加载的选项。
     */
    private void refreshAllPreferences(final String TAG) {
        // First remove old preferences.
        if (getPreferenceScreen() != null) {
            getPreferenceScreen().removeAll();
        }

        // 显示ResourceTile，从ScreenResId中加载PreferenceScreen
        displayResourceTiles();

        mProgressiveDisclosureMixin.collapse(getPreferenceScreen());
        // 更新DashboardTile
        refreshDashboardTiles(TAG);
    }

    @Override
    public void onStart() {
        super.onStart();
        final DashboardCategory category =
                mDashboardFeatureProvider.getTilesForCategory(getCategoryKey());
        if (category == null) {
            return;
        }
        if (mSummaryLoader != null) {
            // SummaryLoader can be null when there is no dynamic tiles.
            mSummaryLoader.setListening(true);
        }
        final Activity activity = getActivity();
        if (activity instanceof SettingsDrawerActivity) {
            mListeningToCategoryChange = true;
            ((SettingsDrawerActivity) activity).addCategoryListener(this);
        }
    }

    @Override // 通知Summary发生改变
    public void notifySummaryChanged(Tile tile) {
        final String key = mDashboardFeatureProvider.getDashboardKeyForTile(tile);
        final Preference pref = mProgressiveDisclosureMixin.findPreference(
                getPreferenceScreen(), key);
        pref.setSummary(tile.summary);
    }

    @Override
    public void onResume() {
        super.onResume();
        updatePreferenceStates(); // 更新Preference的状态。
    }

    /**
     * Update state of each preference managed by PreferenceController.
     */
    protected void updatePreferenceStates() {
        Collection<PreferenceController> controllers = mPreferenceControllers.values();
        final PreferenceScreen screen = getPreferenceScreen();
        for (PreferenceController controller : controllers) {
            if (!controller.isAvailable()) {
                continue;
            }
            final String key = controller.getPreferenceKey();

            final Preference preference = mProgressiveDisclosureMixin.findPreference(screen, key);

            controller.updateState(preference);
        }
    }

    @Override
    public boolean onPreferenceTreeClick(Preference preference) {
        Collection<PreferenceController> controllers = mPreferenceControllers.values();
        // If preference contains intent, log it before handling.
        mMetricsFeatureProvider.logDashboardStartIntent(
                getContext(), preference.getIntent(), getMetricsCategory());
        // Give all controllers a chance to handle click.
        // 如果有Controller处理了点击事件并返回true，则不再向下执行。
        for (PreferenceController controller : controllers) {
            if (controller.handlePreferenceTreeClick(preference)) {
                return true;
            }
        }
        // 否则，交由父类处理，即默认的处理逻辑。
        return super.onPreferenceTreeClick(preference);
    }

    @Override
    public void onStop() {
        super.onStop();
        if (mSummaryLoader != null) {
            // SummaryLoader can be null when there is no dynamic tiles.
            mSummaryLoader.setListening(false);
        }
        if (mListeningToCategoryChange) {
            final Activity activity = getActivity();
            if (activity instanceof SettingsDrawerActivity) {
                ((SettingsDrawerActivity) activity).remCategoryListener(this);
            }
            mListeningToCategoryChange = false;
        }
    }

    // 通过Class对象从Map中获取PreferenceController。
    protected <T extends PreferenceController> T getPreferenceController(Class<T> clazz) {
        PreferenceController controller = mPreferenceControllers.get(clazz);
        return (T) controller;
    }

    // 添加键值对到Map
    protected void addPreferenceController(PreferenceController controller) {
        mPreferenceControllers.put(controller.getClass(), controller);
    }

    /**
     * 获取PreferenceScreen的资源Id，由子类实现
     */
    protected abstract int getPreferenceScreenResId();

    /**
     * 获取PreferenceController列表，由子类实现
     */
    protected abstract List<PreferenceController> getPreferenceControllers(Context context);

    /**
     * 是否显示Tile，默认为true
     */
    protected boolean displayTile(Tile tile) {
        return true;
    }

    /**
     * 显示ResourceTile，从ScreenResId中加载PreferenceScreen
     */
    private void displayResourceTiles() {
        final int resId = getPreferenceScreenResId();
        if (resId <= 0) {
            return;
        }
        // 从资源文件中添加Preferences。
        addPreferencesFromResource(resId);
        final PreferenceScreen screen = getPreferenceScreen();
        Collection<PreferenceController> controllers = mPreferenceControllers.values();
        // 交由PreferenceController去管理PreferenceScreen中相应的UI。
        for (PreferenceController controller : controllers) {
            controller.displayPreference(screen);
        }
    }

    /**
     * 更新由DashboardCategory管理支撑的Preference
     */
    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
    void refreshDashboardTiles(final String TAG) {
        final PreferenceScreen screen = getPreferenceScreen();
        // 获取DashboardCategory
        final DashboardCategory category =
                mDashboardFeatureProvider.getTilesForCategory(getCategoryKey());
        if (category == null) {
            Log.d(TAG, "NO dashboard tiles for " + TAG);
            return;
        }
        List<Tile> tiles = category.tiles;
        if (tiles == null) {
            return;
        }
        // Create a list to track which tiles are to be removed.
        final List<String> remove = new ArrayList<>(mDashboardTilePrefKeys);

        // There are dashboard tiles, so we need to install SummaryLoader.
        if (mSummaryLoader != null) {
            mSummaryLoader.release();
        }
        final Context context = getContext();
        mSummaryLoader = new SummaryLoader(getActivity(), getCategoryKey());
        mSummaryLoader.setSummaryConsumer(this);
        final TypedArray a = context.obtainStyledAttributes(new int[]{
                android.R.attr.colorControlNormal});
        final int tintColor = a.getColor(0, context.getColor(android.R.color.white));
        a.recycle();
        final String pkgName = context.getPackageName();
        // Install dashboard tiles.
        for (Tile tile : tiles) {
            final String key = mDashboardFeatureProvider.getDashboardKeyForTile(tile);
            if (TextUtils.isEmpty(key)) {
                continue;
            }
            if (!displayTile(tile)) {
                continue;
            }
            if (pkgName != null && tile.intent != null
                    && !pkgName.equals(tile.intent.getComponent().getPackageName())) {
                // If this drawable is coming from outside Settings, tint it to match the color.
                tile.icon.setTint(tintColor);
            }
            if (mDashboardTilePrefKeys.contains(key)) {
                // 更新UI视图
                final Preference preference = mProgressiveDisclosureMixin.findPreference(
                        screen, key);
                mDashboardFeatureProvider.bindPreferenceToTile(getActivity(), getMetricsCategory(),
                        preference, tile, key, mPlaceholderPreferenceController.getOrder());
            } else {
                // Don't have this key, add it.
                final Preference pref = new Preference(getPrefContext());
                mDashboardFeatureProvider.bindPreferenceToTile(getActivity(), getMetricsCategory(),
                        pref, tile, key, mPlaceholderPreferenceController.getOrder());
                mProgressiveDisclosureMixin.addPreference(screen, pref);
                mDashboardTilePrefKeys.add(key);
            }
            remove.remove(key);
        }
        // Finally remove tiles that are gone.
        for (String key : remove) {
            mDashboardTilePrefKeys.remove(key);
            mProgressiveDisclosureMixin.removePreference(screen, key);
        }
        mSummaryLoader.setListening(true);
    }
}