Android 8.1 Settings源码解析

前言：客制化开发的过程中接触Setting次数挺多的，但是在接触的过程中发现Setting和其他应用的逻辑很不一样，Setting到底是怎么在实现逻辑的，这个问题一直环绕着在我心里，趁现在有时间，决定写个博客记录一下，温故而知新。

---

从启动开始说起

进入setting的AndroidManifest.xml里看一看，找启动Activity

<activity-alias android:name="Settings"
                android:taskAffinity="com.android.settings"
                android:label="@string/settings_label_launcher"
                android:launchMode="singleTask"
                android:targetActivity="Settings">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    <meta-data android:name="android.app.shortcuts" android:resource="@xml/shortcuts"/>
</activity-alias>

发现启动Activity是Settings,但是前面的标签是activity-alias，所以这是另一个Activity的别名，然后它真实的启动Activity应该是targetActivity所标注的Settings。

---

走进Settings.java

public class Settings extends SettingsActivity {

    public static class AssistGestureSettingsActivity extends SettingsActivity { /* empty */}
    public static class BluetoothSettingsActivity extends SettingsActivity { /* empty */ }
    public static class SimSettingsActivity extends SettingsActivity { /* empty */ }
    public static class TetherSettingsActivity extends SettingsActivity { /* empty */ }
    public static class VpnSettingsActivity extends SettingsActivity { /* empty */ }
    public static class DateTimeSettingsActivity extends SettingsActivity { /* empty */ }
    public static class PrivateVolumeForgetActivity extends SettingsActivity { /* empty */ }
    public static class PrivateVolumeSettingsActivity extends SettingsActivity { /* empty */ }
    public static class PublicVolumeSettingsActivity extends SettingsActivity { /* empty */ }
    public static class WifiSettingsActivity extends SettingsActivity { /* empty */ }
    public static class WifiP2pSettingsActivity extends SettingsActivity { /* empty */ }
    public static class AvailableVirtualKeyboardActivity extends SettingsActivity { /* empty */ }
    public static class KeyboardLayoutPickerActivity extends SettingsActivity { /* empty */ }
    ...//代码省略

第一次打开Setting.java这个文件的时候我被吓到了，里面全是静态内部类，而且都是跟Settings一样，继承了SettingsActivity，但是所有的类内容都是empty，可想而知这里是使用了特殊的抽象才这样设计的，啥也没有，我们就需要去他们的父类去看了。

SettingsActivity

@Override
protected void onCreate(Bundle savedState) {
    ...
    final ComponentName cn = intent.getComponent();
    final String className = cn.getClassName();

    mIsShowingDashboard = className.equals(Settings.class.getName());
    setContentView(mIsShowingDashboard ?
                   R.layout.settings_main_dashboard :R.layout.settings_main_prefs);
    ...
    mContent = findViewById(R.id.main_content);
    ...
    if (savedState != null) {

       setTitleFromIntent(intent);

       ArrayList<DashboardCategory> categories =
                savedState.getParcelableArrayList(SAVE_KEY_CATEGORIES);
        if (categories != null) {
                mCategories.clear();
                mCategories.addAll(categories);
                setTitleFromBackStack();
        }

        mDisplayHomeAsUpEnabled = savedState.getBoolean(SAVE_KEY_SHOW_HOME_AS_UP);

    } else {
        launchSettingFragment(initialFragmentName, isSubSettings, intent);
    }
    ...//代码省略

正常第一次启动自然是进入launchSettingFragment了，

void launchSettingFragment(String initialFragmentName, boolean isSubSettings, Intent intent) {
        if (!mIsShowingDashboard && initialFragmentName != null) {
            // UP will be shown only if it is a sub settings
            if (mIsShortcut) {
                mDisplayHomeAsUpEnabled = isSubSettings;
            } else if (isSubSettings) {
                mDisplayHomeAsUpEnabled = true;
            } else {
                mDisplayHomeAsUpEnabled = false;
            }
            setTitleFromIntent(intent);

            Bundle initialArguments = intent.getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
            switchToFragment(initialFragmentName, initialArguments, true, false,
                mInitialTitleResId, mInitialTitle, false);
        } else {
            // Show search icon as up affordance if we are displaying the main Dashboard
            mDisplayHomeAsUpEnabled = true;
            mInitialTitleResId = R.string.dashboard_title;

            switchToFragment(DashboardSummary.class.getName(), null /* args */, false, false,
                mInitialTitleResId, mInitialTitle, false);
        }
    }

接着就去开启Fragment

private Fragment switchToFragment(String fragmentName, Bundle args, boolean validate,
            boolean addToBackStack, int titleResId, CharSequence title, boolean withTransition) {
        if (validate && !isValidFragment(fragmentName)) {
            throw new IllegalArgumentException("Invalid fragment for this activity: "
                    + fragmentName);
        }
        Fragment f = Fragment.instantiate(this, fragmentName, args);
        FragmentTransaction transaction = getFragmentManager().beginTransaction();
        transaction.replace(R.id.main_content, f);
        if (withTransition) {
            TransitionManager.beginDelayedTransition(mContent);
        }
        if (addToBackStack) {
            transaction.addToBackStack(SettingsActivity.BACK_STACK_PREFS);
        }
        if (titleResId > 0) {
            transaction.setBreadCrumbTitle(titleResId);
        } else if (title != null) {
            transaction.setBreadCrumbTitle(title);
        }
        transaction.commitAllowingStateLoss();
        getFragmentManager().executePendingTransactions();
        return f;
    }

可以看到，这里是直接初始化创建一个fragmentName指定的Fragment,

由于前面mIsShowingDashboard = className.equals(Settings.class.getName());

而第一次启动，当然是Settings.class，所以mIsShowingDashboard = true;

那么这里的初始化第一个Fragment就是DashboardSummary.class了

这样，第一次初始化就是打开Settings这个空Activity,然后加载DashboardSummary这个Fragment。

DashboardSummary

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        return inflater.inflate(R.layout.dashboard, container, false);
    }

dashboard.xml

<com.android.settings.dashboard.conditional.FocusRecyclerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/dashboard_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clipChildren="false"
    android:clipToPadding="false"
    android:focusable="false"
    android:paddingStart="@dimen/dashboard_padding_start"
    android:paddingEnd="@dimen/dashboard_padding_end"
    android:paddingTop="@dimen/dashboard_padding_top"
    android:paddingBottom="@dimen/dashboard_padding_bottom"
    android:scrollbars="vertical"/>

DashboardSummary的布局文件里，只有一个FocusRecyclerView，所有的视图内容都是加载到这个RecyclerView里的，这也是我们第一次打开Setting，看到的那个页面。

接着

	@Override
    public void onViewCreated(View view, Bundle bundle) {
        long startTime = System.currentTimeMillis();
        mDashboard = view.findViewById(R.id.dashboard_container);
        mLayoutManager = new LinearLayoutManager(getContext());
        mLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        if (bundle != null) {
            int scrollPosition = bundle.getInt(EXTRA_SCROLL_POSITION);
            mLayoutManager.scrollToPosition(scrollPosition);
        }
        mDashboard.setLayoutManager(mLayoutManager);
        mDashboard.setHasFixedSize(true);
        mDashboard.setListener(this);
        mDashboard.setDetachListener(this);
        mAdapter = new DashboardAdapter(getContext(), bundle,mConditionManager.getConditions(),
            mSuggestionParser, this /* SuggestionDismissController.Callback */);
        mDashboard.setAdapter(mAdapter);
        mDashboard.setItemAnimator(new DashboardItemAnimator());
        mSummaryLoader.setSummaryConsumer(mAdapter);
        ActionBarShadowController.attachToRecyclerView(
             getActivity().findViewById(R.id.search_bar_container), getLifecycle(), mDashboard);

        rebuildUI();
    }

在onViewCreated里，处理了Recyclerview的数据加载，其中mDashboard就是Recyclerview，然后我们需要去看

它的setAdapter，这个mAdapter就是DashboardAdapter。

DashboardAdapter

public class DashboardAdapter extends RecyclerView.Adapter<DashboardAdapter.DashboardItemHolder>

构造方法

public DashboardAdapter(Context context, Bundle savedInstanceState,
            List<Condition> conditions, SuggestionParser suggestionParser,
            SuggestionDismissController.Callback callback) {
        List<Tile> suggestions = null;
        DashboardCategory category = null;
        int suggestionConditionMode = DashboardData.HEADER_MODE_DEFAULT;

        mContext = context;
        final FeatureFactory factory = FeatureFactory.getFactory(context);
        mMetricsFeatureProvider = factory.getMetricsFeatureProvider();
        mDashboardFeatureProvider = factory.getDashboardFeatureProvider(context);
        mSuggestionFeatureProvider = factory.getSuggestionFeatureProvider(context);
        mCache = new IconCache(context);
        mSuggestionParser = suggestionParser;
        mCallback = callback;

        setHasStableIds(true);

        if (savedInstanceState != null) {
            suggestions = savedInstanceState.getParcelableArrayList(STATE_SUGGESTION_LIST);
            category = savedInstanceState.getParcelable(STATE_CATEGORY_LIST);
            suggestionConditionMode = savedInstanceState.getInt(
                    STATE_SUGGESTION_CONDITION_MODE, suggestionConditionMode);
            mSuggestionsShownLogged = savedInstanceState.getStringArrayList(
                    STATE_SUGGESTIONS_SHOWN_LOGGED);
        } else {
            mSuggestionsShownLogged = new ArrayList<>();
        }

        mDashboardData = new DashboardData.Builder()
                .setConditions(conditions)
                .setSuggestions(suggestions)
                .setCategory(category)
                .setSuggestionConditionMode(suggestionConditionMode)
                .build();
    }

其中数据的初始化来自于mDashboardData，这里使用的是建造者模式，builder构造。

其中，设置了三个参数setConditions，setSuggestions，setCategory。

    public DashboardData build() {
        return new DashboardData(this);
    }

    private DashboardData(Builder builder) {
        mCategory = builder.mCategory;
        mConditions = builder.mConditions;
        mSuggestions = builder.mSuggestions;
        mSuggestionConditionMode = builder.mSuggestionConditionMode;

        mItems = new ArrayList<>();

        buildItemsData();
    }

private void buildItemsData() {
        final boolean hasSuggestions = sizeOf(mSuggestions) > 0;
        final List<Condition> conditions = getConditionsToShow(mConditions);
        final boolean hasConditions = sizeOf(conditions) > 0;

        final List<Tile> suggestions = getSuggestionsToShow(mSuggestions);
        final int hiddenSuggestion =
                hasSuggestions ? sizeOf(mSuggestions) - sizeOf(suggestions) : 0;

        final boolean hasSuggestionAndCollapsed = hasSuggestions
                && mSuggestionConditionMode == HEADER_MODE_COLLAPSED;
        final boolean onlyHasConditionAndCollapsed = !hasSuggestions
                && hasConditions
                && mSuggestionConditionMode != HEADER_MODE_FULLY_EXPANDED;

        /* Top suggestion/condition header. This will be present when there is any suggestion
         * and the mode is collapsed */
        addToItemList(new SuggestionConditionHeaderData(conditions, hiddenSuggestion),
                R.layout.suggestion_condition_header,
                STABLE_ID_SUGGESTION_CONDITION_TOP_HEADER, hasSuggestionAndCollapsed);

        /* Use mid header if there is only condition & it's in collapsed mode */
        addToItemList(new SuggestionConditionHeaderData(conditions, hiddenSuggestion),
                R.layout.suggestion_condition_header,
                STABLE_ID_SUGGESTION_CONDITION_MIDDLE_HEADER, onlyHasConditionAndCollapsed);

        /* Suggestion container. This is the card view that contains the list of suggestions.
         * This will be added whenever the suggestion list is not empty */
        addToItemList(suggestions, R.layout.suggestion_condition_container,
                STABLE_ID_SUGGESTION_CONTAINER, sizeOf(suggestions) > 0);

        /* Second suggestion/condition header. This will be added when there is at least one
         * suggestion or condition that is not currently displayed, and the user can expand the
         * section to view more items. */
        addToItemList(new SuggestionConditionHeaderData(conditions, hiddenSuggestion),
                R.layout.suggestion_condition_header,
                STABLE_ID_SUGGESTION_CONDITION_MIDDLE_HEADER,
                mSuggestionConditionMode != HEADER_MODE_COLLAPSED
                        && mSuggestionConditionMode != HEADER_MODE_FULLY_EXPANDED
                        && (hiddenSuggestion > 0 || hasConditions && hasSuggestions));

            /* Condition container. This is the card view that contains the list of conditions.
             * This will be added whenever the condition list is not empty */
        addToItemList(conditions, R.layout.suggestion_condition_container,
                STABLE_ID_CONDITION_CONTAINER,
                hasConditions && mSuggestionConditionMode == HEADER_MODE_FULLY_EXPANDED);

            /* Suggestion/condition footer. This will be present when the section is fully expanded
             * or when there is no conditions and no hidden suggestions */
        addToItemList(null /* item */, R.layout.suggestion_condition_footer,
                STABLE_ID_SUGGESTION_CONDITION_FOOTER,
                (hasConditions || hasSuggestions)
                        && mSuggestionConditionMode == HEADER_MODE_FULLY_EXPANDED
                        || hasSuggestions
                        && !hasConditions
                        && hiddenSuggestion == 0);

        if(mCategory != null) {
            for (int j = 0; j < mCategory.tiles.size(); j++) {
                final Tile tile = mCategory.tiles.get(j);
                addToItemList(tile, R.layout.dashboard_tile, Objects.hash(tile.title),
                        true /* add */);
            }
        }
    }

这里加载了很多tile，然后全都调用了addToItemList，

    private void addToItemList(Object item, int type, int stableId, boolean add) {
        if (add) {
            mItems.add(new Item(item, type, stableId));
        }
    }

这个Item就是存储设置选项的信息

    static class Item {
        // valid types in field type
        private static final int TYPE_DASHBOARD_TILE = R.layout.dashboard_tile;
        private static final int TYPE_SUGGESTION_CONDITION_CONTAINER =
                R.layout.suggestion_condition_container;
        private static final int TYPE_SUGGESTION_CONDITION_HEADER =
                R.layout.suggestion_condition_header;
        private static final int TYPE_SUGGESTION_CONDITION_FOOTER =
                R.layout.suggestion_condition_footer;
        private static final int TYPE_DASHBOARD_SPACER = R.layout.dashboard_spacer;

        @IntDef({TYPE_DASHBOARD_TILE, TYPE_SUGGESTION_CONDITION_CONTAINER,
                TYPE_SUGGESTION_CONDITION_HEADER, TYPE_SUGGESTION_CONDITION_FOOTER,
                TYPE_DASHBOARD_SPACER})
        
        public Item(Object entity, @ItemTypes int type, int id) {
            this.entity = entity;
            this.type = type;
            this.id = id;
        }

这里的构造方法显示三个参数，其中根据不同的TYPE，存储不同的layout的ID，可以知道有五种类型的layout，分别是Tile，Container,Header,Footer,Space,我们在设置里能看到的就这几种条目类型。

我们最基础的类型就是TYPE_DASHBOARD_TILE了，

<LinearLayout>
	//省略细节
    <ImageView
        android:id="@android:id/icon"

    <LinearLayout

        <TextView android:id="@android:id/title"

        <TextView android:id="@android:id/summary"

    </LinearLayout>

</LinearLayout>

可以看到在普通的设置选项条目里，我们能看到的就是一个图标，一个标题，和一个摘要。

就像下面这样

上面Item的构造方法这里传入的其中一个参数是Object类型，但是我们需要知道到底这个Object的实例是什么。

看看前面的addToItemList，分别传入的是

“SuggestionConditionHeaderData”，

“List suggestions”，

“List conditions”，

DashboardCategory mCategory的“Tile”。

suggestions，conditions是在DashboardAdapter创建的时候传递的，我们看看这里的数据来源。

conditions

当时DashboardAdapter的第二个构造参数是

mConditionManager.getConditions()；

mConditionManager = ConditionManager.get(activity, false);

单例模式

    public static ConditionManager get(Context context, boolean loadConditionsNow) {
        if (sInstance == null) {
            sInstance = new ConditionManager(context.getApplicationContext(), loadConditionsNow);
        }
        return sInstance;
    }

    private ConditionManager(Context context, boolean loadConditionsNow) {
        mContext = context;
        mConditions = new ArrayList<>();
        if (loadConditionsNow) {
            Log.d(TAG, "conditions loading synchronously");
            ConditionLoader loader = new ConditionLoader();
            loader.onPostExecute(loader.doInBackground());
        } else {
            Log.d(TAG, "conditions loading asychronously");
            new ConditionLoader().execute();
        }
    }

new ConditionLoader().execute();

        protected ArrayList<Condition> doInBackground(Void... params) {
            Log.d(TAG, "loading conditions from xml");
            ArrayList<Condition> conditions = new ArrayList<>();
            mXmlFile = new File(mContext.getFilesDir(), FILE_NAME);
            if (mXmlFile.exists()) {
                readFromXml(mXmlFile, conditions);
            }
            addMissingConditions(conditions);
            return conditions;
        }
        @Override
        protected void onPostExecute(ArrayList<Condition> conditions) {
            Log.d(TAG, "conditions loaded from xml, refreshing conditions");
            mConditions.clear();
            mConditions.addAll(conditions);
            refreshAll();
        }

所以，mConditions来自这里，这里显示的却是readFromXml。从xml里去读吗？

private static final String FILE_NAME = "condition_state.xml";

然后很尴尬的发现系统里找不到这个文件，这样只能去看addMissingConditions了。

    private void addMissingConditions(ArrayList<Condition> conditions) {
        addIfMissing(AirplaneModeCondition.class, conditions);
        addIfMissing(HotspotCondition.class, conditions);
        addIfMissing(DndCondition.class, conditions);
        addIfMissing(BatterySaverCondition.class, conditions);
        addIfMissing(CellularDataCondition.class, conditions);
        addIfMissing(BackgroundDataCondition.class, conditions);
        addIfMissing(WorkModeCondition.class, conditions);
        addIfMissing(NightDisplayCondition.class, conditions);
        Collections.sort(conditions, CONDITION_COMPARATOR);
    }

    private void addIfMissing(Class<? extends Condition> clz, ArrayList<Condition> conditions) {
        if (getCondition(clz, conditions) == null) {
            if (DEBUG) Log.d(TAG, "Adding missing " + clz.getName());
            Condition condition = createCondition(clz);
            if (condition != null) {
                conditions.add(condition);
            }
        }
    }

好吧，原来是这些condition，那这些condition是什么呢？

举个例子，如果我们打开飞行模式，就会看到这个条目了。

condition已经搞明白了，剩下的还有suggestions和category了。

---

suggestions

suggestions是一个Tile的列表

在DashboardSummary的onViewCreated里，最后调用的rebuildUI

rebuildUI

   @VisibleForTesting
    void rebuildUI() {
        if (!mSuggestionFeatureProvider.isSuggestionEnabled(getContext())) {
            Log.d(TAG, "Suggestion feature is disabled, skipping suggestion entirely");
            updateCategoryAndSuggestion(null /* tiles */);
        } else {
            new SuggestionLoader().execute();
            // Set categories on their own if loading suggestions takes too long.
            mHandler.postDelayed(() -> {
                updateCategoryAndSuggestion(null /* tiles */);
            }, MAX_WAIT_MILLIS);
        }
    }

这里做了一个判断，isSuggestionEnabled就是建议是否开启，然后决定是否去加载Suggestion。

我们需要去看看isSuggestionEnabled是什么

mSuggestionFeatureProvider.isSuggestionEnabled(getContext())
----------------
private SuggestionFeatureProvider mSuggestionFeatureProvider;
----------------
public interface SuggestionFeatureProvider
----------------
public class SuggestionFeatureProviderImpl implements SuggestionFeatureProvider 

SuggestionFeatureProviderImpl是接口SuggestionFeatureProvider的实例，

    @Override
    public boolean isSuggestionEnabled(Context context) {
        final ActivityManager am =
                (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        return !am.isLowRamDevice();
    }

我们可以看到，这里决定是否isSuggestionEnabled的结果是判断当前设备是否是低Ram设备。

所以，如果我们是Ram低于512M的设备就返回false,如果是大于512M设备就返回true。

当前我们开发的设备是1G Ram的，所以返回True

new SuggestionLoader().execute();
// Set categories on their own if loading suggestions takes too long.
mHandler.postDelayed(() -> {
    updateCategoryAndSuggestion(null /* tiles */);
}, MAX_WAIT_MILLIS);

SuggestionLoader加载suggestions

@Override
        protected List<Tile> doInBackground(Void... params) {
            final Context context = getContext();
            boolean isSmartSuggestionEnabled =
                    mSuggestionFeatureProvider.isSmartSuggestionEnabled(context);
            final SuggestionList sl = mSuggestionParser.getSuggestions(isSmartSuggestionEnabled);
            final List<Tile> suggestions = sl.getSuggestions();

            if (isSmartSuggestionEnabled) {
                List<String> suggestionIds = new ArrayList<>(suggestions.size());
                for (Tile suggestion : suggestions) {
                    suggestionIds.add(mSuggestionFeatureProvider.getSuggestionIdentifier(
                            context, suggestion));
                }
                // TODO: create a Suggestion class to maintain the id and other info
                mSuggestionFeatureProvider.rankSuggestions(suggestions, suggestionIds);
            }
            for (int i = 0; i < suggestions.size(); i++) {
                Tile suggestion = suggestions.get(i);
                if (mSuggestionsChecks.isSuggestionComplete(suggestion)) {
                    suggestions.remove(i--);
                }
            }
            if (sl.isExclusiveSuggestionCategory()) {
                mSuggestionFeatureProvider.filterExclusiveSuggestions(suggestions);
            }
            return suggestions;
        }

其中

mSuggestionParser.getSuggestions(isSmartSuggestionEnabled);

public SuggestionList getSuggestions(boolean isSmartSuggestionEnabled) {
        final SuggestionList suggestionList = new SuggestionList();
        final int N = mSuggestionList.size();
        for (int i = 0; i < N; i++) {
            final SuggestionCategory category = mSuggestionList.get(i);
            if (category.exclusive && !isExclusiveCategoryExpired(category)) {
                final List<Tile> exclusiveSuggestions = new ArrayList<>();
                readSuggestions(category, exclusiveSuggestions, false );
                if (!exclusiveSuggestions.isEmpty()) {
                    final SuggestionList exclusiveList = new SuggestionList();
                    exclusiveList.addSuggestions(category, exclusiveSuggestions);
                    return exclusiveList;
                }
            } else {
                final List<Tile> suggestions = new ArrayList<>();
                readSuggestions(category, suggestions, isSmartSuggestionEnabled);
                suggestionList.addSuggestions(category, suggestions);
            }
        }
        return suggestionList;
    }

void readSuggestions(
            SuggestionCategory category, List<Tile> suggestions, boolean isSmartSuggestionEnabled) {
        int countBefore = suggestions.size();
        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.addCategory(category.category);
        if (category.pkg != null) {
            intent.setPackage(category.pkg);
        }
        TileUtils.getTilesForIntent(mContext, new UserHandle(UserHandle.myUserId()), intent,
                mAddCache, null, suggestions, true, false, false, true );
        filterSuggestions(suggestions, countBefore, isSmartSuggestionEnabled);
        if (!category.multiple && suggestions.size() > (countBefore + 1)) {

            Tile item = suggestions.remove(suggestions.size() - 1);
            while (suggestions.size() > countBefore) {
                Tile last = suggestions.remove(suggestions.size() - 1);
                if (last.priority > item.priority) {
                    item = last;
                }
            }
            if (!isCategoryDone(category.category)) {
                suggestions.add(item);
            }
        }
    }

其中就是从SuggestionCategory来加载Tile到suggestions，但是我们需要知道category是从哪里来的，

final SuggestionCategory category = mSuggestionList.get(i);

mSuggestionList = suggestionList;

在SuggestionParser的构造时候，传入了suggestionList，

(List<SuggestionCategory>) new SuggestionOrderInflater(context).parse(orderXml)

然后

public Object parse(int resource) {
            XmlPullParser parser = mContext.getResources().getXml(resource);
            final AttributeSet attrs = Xml.asAttributeSet(parser);
            try {
                int type;
                do {
                    type = parser.next();
                } while (type != XmlPullParser.START_TAG && type != XmlPullParser.END_DOCUMENT);

                if (type != XmlPullParser.START_TAG) {
                    throw new InflateException(parser.getPositionDescription()
                            + ": No start tag found!");
                }
                Object xmlRoot = onCreateItem(parser.getName(), attrs);

                rParse(parser, xmlRoot, attrs);
                return xmlRoot;
            } catch (XmlPullParserException | IOException e) {
                Log.w(TAG, "Problem parser resource " + resource, e);
                return null;
            }
        }

也是从xml里读取

继续找，发现前面传递的是 R.xml.suggestion_ordering

mSuggestionParser = new SuggestionParser(activity,
      mSuggestionFeatureProvider.getSharedPrefs(activity), R.xml.suggestion_ordering);

<optional-steps>
    <step category="com.android.settings.suggested.category.DEFERRED_SETUP"
        exclusive="true" />
    <step category="com.android.settings.suggested.category.LOCK_SCREEN" />
    <step category="com.android.settings.suggested.category.TRUST_AGENT" />
    <step category="com.android.settings.suggested.category.EMAIL" />
    <step category="com.android.settings.suggested.category.PARTNER_ACCOUNT"
        multiple="true" />
    <step category="com.android.settings.suggested.category.GESTURE" />
    <step category="com.android.settings.suggested.category.HOTWORD" />
    <step category="com.android.settings.suggested.category.DEFAULT"
        multiple="true" />
    <step category="com.android.settings.suggested.category.SETTINGS_ONLY"
        multiple="true" />
</optional-steps>

parse解析的过程里

rParse(parser, xmlRoot, attrs);

private void rParse(XmlPullParser parser, Object parent, final AttributeSet attrs)
                throws XmlPullParserException, IOException {
            final int depth = parser.getDepth();

            int type;
            while (((type = parser.next()) != XmlPullParser.END_TAG ||
                    parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
                if (type != XmlPullParser.START_TAG) {
                    continue;
                }
                final String name = parser.getName();
                Object item = onCreateItem(name, attrs);
                onAddChildItem(parent, item);
                rParse(parser, item, attrs);
            }
        }

protected Object onCreateItem(String name, AttributeSet attrs) {
    if (name.equals(TAG_LIST)) {
        return new ArrayList<SuggestionCategory>();
    } else if (name.equals(TAG_ITEM)) {
        SuggestionCategory category = new SuggestionCategory();
        category.category = attrs.getAttributeValue(null, ATTR_CATEGORY);
        category.pkg = attrs.getAttributeValue(null, ATTR_PACKAGE);
        String multiple = attrs.getAttributeValue(null, ATTR_MULTIPLE);
        category.multiple = !TextUtils.isEmpty(multiple) && Boolean.parseBoolean(multiple);
        String exclusive = attrs.getAttributeValue(null, ATTR_EXCLUSIVE);
        category.exclusive =
            !TextUtils.isEmpty(exclusive) && Boolean.parseBoolean(exclusive);
        String expireDaysAttr = attrs.getAttributeValue(null,ATTR_EXCLUSIVE_EXPIRE_DAYS);
        long expireDays = !TextUtils.isEmpty(expireDaysAttr)
            ? Integer.parseInt(expireDaysAttr)
            : -1;
        category.exclusiveExpireDaysInMillis = DateUtils.DAY_IN_MILLIS *expireDays;
        return category;
    } else {
        throw new IllegalArgumentException("Unknown item " + name);
    }
        }

当扫描到step的时候去创建SuggestionCategory，

所以这里的SuggestionCategory列表最后Item内容就是上面XML里的item内容。

我们仔细看这个category，发现很像我们在AndroidManifest.xml里定义的category。

那么前面mSuggestionList就是parse解析的结果new ArrayList()；

在前面readSuggestions的时候传入的就是携带这xml里step的category。

我们继续回到readSuggestions

        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.addCategory(category.category);
        if (category.pkg != null) {
            intent.setPackage(category.pkg);
        }
        TileUtils.getTilesForIntent(mContext, new UserHandle(UserHandle.myUserId()), intent,
                mAddCache, null, suggestions, true, false, false, true /* shouldUpdateTiles */);

这里把category的category给了Intent然后调用了addCategory

然后走到TileUtils.getTilesForIntent，去把对应的Tile加到maddCache里。

private final ArrayMap<Pair<String, String>, Tile> mAddCache = new ArrayMap<>();

找到完了suggestion，最后找category

---

category

在DashboardAdapter构造的时候category = null;一直到setCategory都是null,那么category到底是什么情况呢？

最后我们需要看看**DashboardAdapter的setCategory(category)**这里的category可是null无疑，

但是前面 SuggestionLoader().execute() 获取 suggestion完了，后面还有个post更新

mHandler.postDelayed(() -> {
    updateCategoryAndSuggestion(null /* tiles */);
}, MAX_WAIT_MILLIS);

updateCategoryAndSuggestion

看到上面传入的tiles 是NULL。

    @VisibleForTesting
    void updateCategoryAndSuggestion(List<Tile> suggestions) {
        final Activity activity = getActivity();
        if (activity == null) {
            return;
        }

        final DashboardCategory category = 				mDashboardFeatureProvider.getTilesForCategory(
                CategoryKey.CATEGO RY_HOMEPAGE);
        mSummaryLoader.updateSummaryToCache(category);
        if (suggestions != null) {
            mAdapter.setCategoriesAndSuggestions(category, suggestions);
        } else {
            mAdapter.setCategory(category);
        }
    }

DashboardCategory

mDashboardFeatureProvider.getTilesForCategory(CategoryKey.CATEGO RY_HOMEPAGE);

找到实例

@Override
public DashboardCategory getTilesForCategory(String key) {
    return mCategoryManager.getTilesByCategory(mContext, key);
}
---------------------------------------------
public synchronized DashboardCategory getTilesByCategory(Context context, String 		categoryKey) {
    return getTilesByCategory(context, categoryKey, TileUtils.SETTING_PKG);
}
---------------------------------------------
public synchronized DashboardCategory getTilesByCategory(Context context, String categoryKey,String settingPkg) {
    tryInitCategories(context, settingPkg); //

    return mCategoryByKeyMap.get(categoryKey);
}

在获取category的时候，有一个初始化的过程

private synchronized void tryInitCategories(Context context, String settingPkg) {
    tryInitCategories(context, false /* forceClearCache */, settingPkg);
}
---------------------------------------------
private synchronized void tryInitCategories(Context context, booleanforceClearCache,
   String settingPkg) {
    if (mCategories == null) {
        if (forceClearCache) {
            mTileByComponentCache.clear();
        }
        mCategoryByKeyMap.clear();
        mCategories = TileUtils.getCategories(context, mTileByComponentCache,
		false /* categoryDefinedInManifest */, mExtraAction, settingPkg);
        for (DashboardCategory category : mCategories) {
            mCategoryByKeyMap.put(category.key, category);
        }
        backwardCompatCleanupForCategory(mTileByComponentCache, mCategoryByKeyMap);
        sortCategories(context, mCategoryByKeyMap);
        filterDuplicateTiles(mCategoryByKeyMap);
    }
}

其关键在于mCategories当我们第一次去获取category的时候mCategories == null。

于是

mCategories = TileUtils.getCategories(context, mTileByComponentCache,false, mExtraAction, settingPkg);

TileUtils.getCategories

public static List<DashboardCategory> getCategories(Context context,
            Map<Pair<String, String>, Tile> cache, boolean categoryDefinedInManifest,
            String extraAction, String settingPkg) {
        final long startTime = System.currentTimeMillis();
        boolean setup = Global.getInt(context.getContentResolver(), Global.DEVICE_PROVISIONED, 0)!= 0;
        ArrayList<Tile> tiles = new ArrayList<>();
        UserManager userManager = (UserManager)context.getSystemService(Context.USER_SERVICE);
        for (UserHandle user : userManager.getUserProfiles()) {
            // TODO: Needs much optimization, too many PM queries going on here.
            if (user.getIdentifier() == ActivityManager.getCurrentUser()) {
                // Only add Settings for this user.
                getTilesForAction(context, user, SETTINGS_ACTION, cache, null, tiles,true, settingPkg);
                getTilesForAction(context, user, OPERATOR_SETTINGS, cache,
                        OPERATOR_DEFAULT_CATEGORY, tiles, false, true, settingPkg);
                getTilesForAction(context, user, MANUFACTURER_SETTINGS, cache,
                        MANUFACTURER_DEFAULT_CATEGORY, tiles, false, true, settingPkg);
            }
			...//省略
        }

        HashMap<String, DashboardCategory> categoryMap = new HashMap<>();
        for (Tile tile : tiles) {
            DashboardCategory category = categoryMap.get(tile.category);
            if (category == null) {
                category = createCategory(context, tile.category, categoryDefinedInManifest);
                if (category == null) {
                    Log.w(LOG_TAG, "Couldn't find category " + tile.category);
                    continue;
                }
                categoryMap.put(category.key, category);
            }
            category.addTile(tile);
        }
        ArrayList<DashboardCategory> categories = new ArrayList<>(categoryMap.values());
        for (DashboardCategory category : categories) {
            Collections.sort(category.tiles, TILE_COMPARATOR);
        }
        Collections.sort(categories, CATEGORY_COMPARATOR);
        return categories;
    }

我们发现，在初始化categories的时候，做了很多事情，

其中第一步是查询并填充ArrayList tiles，

通过

getTilesForAction(context, user, SETTINGS_ACTION, cache, null, tiles,true, settingPkg);
getTilesForAction(context, user, OPERATOR_SETTINGS, cache,
                  OPERATOR_DEFAULT_CATEGORY, tiles, false, true, settingPkg);
getTilesForAction(context, user, MANUFACTURER_SETTINGS, cache,
                  MANUFACTURER_DEFAULT_CATEGORY, tiles, false, true, settingPkg);

这三步去填充tiles，

然后再用for循环，创建category

for (Tile tile : tiles)
   。。。省略
   category = createCategory(context, tile.category, categoryDefinedInManifest);
   。。。

这里的category是DashboardCategory，

category.addTile(tile);

public void addTile(Tile tile) {
    tiles.add(tile);
}

/**
  * List of the category's children
  */
public List<Tile> tiles = new ArrayList<>();

所以，category.addTile的时候，是把Tile给加到了一个内部List里，这就说明，一个Category就是一些Tile的集合。

getTilesForAction

private static void getTilesForAction(Context context,
      UserHandle user, String action, Map<Pair<String, String>, Tile> addedCache,
      String defaultCategory, ArrayList<Tile> outTiles, boolean requireSettings,
      String settingPkg) {
    getTilesForAction(context, user, action, addedCache, defaultCategory, outTiles,
                      requireSettings, requireSettings, settingPkg);
}

    private static void getTilesForAction(Context context,
            UserHandle user, String action, Map<Pair<String, String>, Tile> addedCache,
            String defaultCategory, ArrayList<Tile> outTiles, boolean requireSettings,
            boolean usePriority, String settingPkg) {
        Intent intent = new Intent(action);
        if (requireSettings) {
            intent.setPackage(settingPkg);
        }
        getTilesForIntent(context, user, intent, addedCache, defaultCategory, outTiles,
                usePriority, true, true);
    }

然后走到了和前面获取suggestion一样的地方，都是getTilesForIntent，只不过这里的category和suggestion那里的xml的category不一样。

这里三个category分别是

    private static final String SETTINGS_ACTION =
            "com.android.settings.action.SETTINGS";
    private static final String OPERATOR_SETTINGS =
            "com.android.settings.OPERATOR_APPLICATION_SETTING";
    private static final String MANUFACTURER_SETTINGS =
            "com.android.settings.MANUFACTURER_APPLICATION_SETTING";

最后一起来看看是怎么获取Tile的。

TileUtils

public static void getTilesForIntent(
            Context context, UserHandle user, Intent intent,
            Map<Pair<String, String>, Tile> addedCache, String defaultCategory, List<Tile> outTiles,
            boolean usePriority, boolean checkCategory, boolean forceTintExternalIcon,
            boolean shouldUpdateTiles) {
        PackageManager pm = context.getPackageManager();
        List<ResolveInfo> results = pm.queryIntentActivitiesAsUser(intent,
                PackageManager.GET_META_DATA, user.getIdentifier());
        Map<String, IContentProvider> providerMap = new HashMap<>();
        for (ResolveInfo resolved : results) {
            if (!resolved.system && !ArrayUtils.contains(EXTRA_PACKAGE_WHITE_LIST,
                    resolved.activityInfo.packageName)) {
                continue;
            }
            ActivityInfo activityInfo = resolved.activityInfo;
            Bundle metaData = activityInfo.metaData;
            String categoryKey = defaultCategory;

            // Load category
            if (checkCategory && ((metaData == null) || !metaData.containsKey(EXTRA_CATEGORY_KEY))
                    && categoryKey == null) {
                Log.w(LOG_TAG, "Found " + resolved.activityInfo.name + " for intent "
                        + intent + " missing metadata "
                        + (metaData == null ? "" : EXTRA_CATEGORY_KEY));
                continue;
            } else {
                categoryKey = metaData.getString(EXTRA_CATEGORY_KEY);
                /// M: set default category when extra data not set category
                if (categoryKey == null) {
                    categoryKey = defaultCategory;
                }
            }

            Pair<String, String> key = new Pair<String, String>(activityInfo.packageName,
                    activityInfo.name);
            Tile tile = addedCache.get(key);
            if (tile == null) {
                tile = new Tile();
                tile.intent = new Intent().setClassName(
                        activityInfo.packageName, activityInfo.name);
                tile.category = categoryKey;
                /// M: white list could use priority
                tile.priority = usePriority || ArrayUtils.contains(EXTRA_PACKAGE_WHITE_LIST,
                        activityInfo.packageName) ? resolved.priority : 0;
                tile.metaData = activityInfo.metaData;
                /// M: Support priority in whitelist app
                if (tile.metaData.containsKey(META_DATA_KEY_PRIORITY) && ArrayUtils.contains(
                        EXTRA_PACKAGE_WHITE_LIST, activityInfo.packageName)) {
                        tile.priority = tile.metaData.getInt(META_DATA_KEY_PRIORITY);
                }
                updateTileData(context, tile, activityInfo, activityInfo.applicationInfo,
                        pm, providerMap, forceTintExternalIcon);
                if (DEBUG) Log.d(LOG_TAG, "Adding tile " + tile.title);
                addedCache.put(key, tile);
            } else if (shouldUpdateTiles) {
                updateSummaryAndTitle(context, providerMap, tile);
            }

            if (!tile.userHandle.contains(user)) {
                tile.userHandle.add(user);
            }
            if (!outTiles.contains(tile)) {
                outTiles.add(tile);
            }
        }
    }

List<ResolveInfo> results = pm.queryIntentActivitiesAsUser(intent,
                PackageManager.GET_META_DATA, user.getIdentifier());

这个Results是用PackageManager来query的结果，最后查询的结果是当前包里有相同的category的activity信息

ActivityInfo activityInfo = resolved.activityInfo;
Bundle metaData = activityInfo.metaData;
String categoryKey = defaultCategory;

然后我们看到了下面是创建Tile的过程

Tile tile = addedCache.get(key);
if (tile == null) {
    tile = new Tile();
    tile.intent = new Intent().setClassName(
        activityInfo.packageName, activityInfo.name);
    tile.category = categoryKey;
    /// M: white list could use priority
    tile.priority = usePriority || 
    ArrayUtils.contains(EXTRA_PACKAGE_WHITE_LIST,activityInfo.packageName) ? resolved.priority : 0;
    tile.metaData = activityInfo.metaData;
    /// M: Support priority in whitelist app
    if (tile.metaData.containsKey(META_DATA_KEY_PRIORITY) &&ArrayUtils.contains(
        EXTRA_PACKAGE_WHITE_LIST, activityInfo.packageName)) {
        tile.priority = tile.metaData.getInt(META_DATA_KEY_PRIORITY);
    }
    updateTileData(context, tile, activityInfo, activityInfo.applicationInfo,
                   pm, providerMap, forceTintExternalIcon);
    if (DEBUG) Log.d(LOG_TAG, "Adding tile " + tile.title);
    addedCache.put(key, tile);
} else if (shouldUpdateTiles) {
    updateSummaryAndTitle(context, providerMap, tile);
}

分别把activityInfo.packageName, activityInfo.name，categoryKey等这些信息赋值给Tile，然后把tile加入到addedCache，

private final ArrayMap<Pair<String, String>, Tile> mAddCache = new ArrayMap<>();

就这样通过不同的category来得到不同activity在xml里定义的信息。

三个类型，分别对应着

.setConditions(conditions)
.setSuggestions(suggestions)
.setCategory(category)

这就是DashboardAdapter在初始化的时候，获取的数据的过程。

这里有一点需要说明的是，我在使用suggestion_ordering.xml里的category去AndroidMannifest.xml找，没有找到一个对应的activity，而使用SETTINGS_ACTION却能找到许多acticity。

比如

<activity android:name=".Settings$NetworkDashboardActivity"
            android:taskAffinity="com.android.settings"
            android:label="@string/network_dashboard_title"
            android:icon="@drawable/ic_settings_wireless"
            android:parentActivityName="Settings">
            <intent-filter android:priority="1">
                <action android:name="android.settings.WIRELESS_SETTINGS" />
                <action android:name="android.settings.AIRPLANE_MODE_SETTINGS" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.VOICE_LAUNCH" />
            </intent-filter>
            <intent-filter android:priority="11">
                <action android:name="com.android.settings.action.SETTINGS"/>
            </intent-filter>
            <meta-data android:name="com.android.settings.category"
                android:value="com.android.settings.category.ia.homepage"/>
            <meta-data android:name="com.android.settings.FRAGMENT_CLASS"
                android:value="com.android.settings.network.NetworkDashboardFragment"/>
            <meta-data android:name="com.android.settings.PRIMARY_PROFILE_CONTROLLED"
                android:value="true" />
        </activity>

这里的NetworkDashboardActivity是在Setting里面定义了的。

这里可以看到，它其实是action。

而我们就是根据这个action来分门别类的找到对应的目录。

---

加载view

数据加载告一段落，回到DashboardAdapter的加载view的流程。

DashboardAdapter

构造ViewHolder，根据viewType不同来加载不同的viewType并创建Viewholder

这里的viewtype就是layoutID

    @Override
    public DashboardItemHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        final View view = LayoutInflater.from(parent.getContext()).inflate(viewType, parent, false);
        if (viewType == R.layout.suggestion_condition_header) {
            return new SuggestionAndConditionHeaderHolder(view);
        }
        if (viewType == R.layout.suggestion_condition_container) {
            return new SuggestionAndConditionContainerHolder(view);
        }
        return new DashboardItemHolder(view);
    }

默认ViewHolder就是DashboardItemHolder

public DashboardItemHolder(View itemView) {
    super(itemView);
    icon = itemView.findViewById(android.R.id.icon);
    title = itemView.findViewById(android.R.id.title);
    summary = itemView.findViewById(android.R.id.summary);
}

各个item的type就是前面说的那个layout的ID

    @Override
    public int getItemViewType(int position) {
        return mDashboardData.getItemTypeByPosition(position);
    }

------------------------
    public int getItemTypeByPosition(int position) {
        return mItems.get(position).type;
    }

然后我们看onBindViewHolder

@Override
public void onBindViewHolder(DashboardItemHolder holder, int position) {
    final int type = mDashboardData.getItemTypeByPosition(position);
    switch (type) {
        case R.layout.dashboard_tile:
            final Tile tile = (Tile)mDashboardData.getItemEntityByPosition(position);
            onBindTile(holder, tile);
            holder.itemView.setTag(tile);
            holder.itemView.setOnClickListener(mTileClickListener);
            break;
        case R.layout.suggestion_condition_container:
            onBindConditionAndSuggestion(
                (SuggestionAndConditionContainerHolder) holder, position);
            break;
        case R.layout.suggestion_condition_header:
            onBindSuggestionConditionHeader((SuggestionAndConditionHeaderHolder)holder,
            (SuggestionConditionHeaderData)mDashboardData.getItemEntityByPosition(position));
            break;
        case R.layout.suggestion_condition_footer:
            holder.itemView.setOnClickListener(v -> {
                mMetricsFeatureProvider.action(mContext,
			MetricsEvent.ACTION_SETTINGS_CONDITION_EXPAND, false);
                DashboardData prevData = mDashboardData;
                mDashboardData = new DashboardData.Builder(prevData).setSuggestionConditionMode(
                    DashboardData.HEADER_MODE_COLLAPSED).build();
                notifyDashboardDataChanged(prevData);
                mRecyclerView.scrollToPosition(SUGGESTION_CONDITION_HEADER_POSITION);
            });
            break;
    }
}

在Bindview的时候分别根据Tile,Container,header和footer来创建view。

看看onBindTile

    private void onBindTile(DashboardItemHolder holder, Tile tile) {
        if (tile.remoteViews != null) {
            final ViewGroup itemView = (ViewGroup) holder.itemView;
            itemView.removeAllViews();
            itemView.addView(tile.remoteViews.apply(itemView.getContext(), itemView));
        } else {
            holder.icon.setImageDrawable(mCache.getIcon(tile.icon));
            holder.title.setText(tile.title);
            if (!TextUtils.isEmpty(tile.summary)) {
                holder.summary.setText(tile.summary);
                holder.summary.setVisibility(View.VISIBLE);
            } else {
                holder.summary.setVisibility(View.GONE);
            }
        }
    }

就是这样，根据不同的layout，来加载不同的item，实现RecyclerView的填充。

点击事件

显示问题搞清楚了，接着我们看点击事件

holder.itemView.setTag(tile);
holder.itemView.setOnClickListener(mTileClickListener);

在bindview的时候设置了OnClickListener

private View.OnClickListener mTileClickListener = new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        mDashboardFeatureProvider.openTileIntent((Activity) mContext, (Tile) 					v.getTag());
    }
};

DashboardFeatureProviderImpl实现了DashboardFeatureProvider接口，这里是面向接口编程的思想。

@Override
    public void openTileIntent(Activity activity, Tile tile) {
        if (tile == null) {
            Intent intent = new Intent(Settings.ACTION_SETTINGS).addFlags(
                    Intent.FLAG_ACTIVITY_CLEAR_TASK);
            mContext.startActivity(intent);
            return;
        }
        if (tile.intent == null) {
            return;
        }
        final Intent intent = new Intent(tile.intent)
                .putExtra(SettingsActivity.EXTRA_SOURCE_METRICS_CATEGORY,
                        MetricsEvent.DASHBOARD_SUMMARY)
                .putExtra(SettingsDrawerActivity.EXTRA_SHOW_MENU, true)
                .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        launchIntentOrSelectProfile(activity, tile, intent,MetricsEvent.DASHBOARD_SUMMARY);
    }

在前面创建每个Tile的时候，Intent是这样的，

tile.intent = new Intent().setClassName(
    activityInfo.packageName, activityInfo.name);

里面包含了对应包名，activity的名字。

    private void launchIntentOrSelectProfile(Activity activity, Tile tile, Intent intent,
            int sourceMetricCategory) {
        if (!isIntentResolvable(intent)) {
            Log.w(TAG, "Cannot resolve intent, skipping. " + intent);
            return;
        }
        ProfileSelectDialog.updateUserHandlesIfNeeded(mContext, tile);
        if (tile.userHandle == null) {
            mMetricsFeatureProvider.logDashboardStartIntent(mContext, intent, sourceMetricCategory);
            activity.startActivityForResult(intent, 0);
        } else if (tile.userHandle.size() == 1) {
            mMetricsFeatureProvider.logDashboardStartIntent(mContext, intent, sourceMetricCategory);
            activity.startActivityForResultAsUser(intent, 0, tile.userHandle.get(0));
        } else {
            ProfileSelectDialog.show(activity.getFragmentManager(), tile);
        }
    }

activity.startActivityForResultAsUser(intent, 0, tile.userHandle.get(0));

直接开启对应的activity,然后这里几乎所有activity都是继承自SettingsActivity，所有，就是启动它本身，换一个子类来显示。

然后在SettingsActivity的oncreate里，这时候的mIsShowingDashboard就是false,

就会显示R.layout.settings_main_prefs这个layout了，而且这时候的Intent是携带者具体要启动的activity信息的

final String initialFragmentName = intent.getStringExtra(EXTRA_SHOW_FRAGMENT);

然后就回到循环之中。

总结：Setting里所有的Activity都继承了SettingsActivity，通过action条目来统一管理加载，切换不同的activity实际也是调用它本身的不同子类，然后根据不同子类加载不同的fragment,所以说到底，Setting只有一个父Activity，所有的显示通过不同的Fragment来处理。实在是厉害。