Android 10.0 StatusBar—下拉菜单快捷方式

protected void makeStatusBarView() {
    //省略其他代码
   FragmentHostManager fragmentHostManager = FragmentHostManager.get(container);
            ExtensionFragmentListener.attachExtensonToFragment(container, QS.TAG, R.id.qs_frame,
                    mExtensionController
                            .newExtension(QS.class)
                            .withPlugin(QS.class)
                            .withDefault(this::createDefaultQSFragment)
                            .build());
            mBrightnessMirrorController = new BrightnessMirrorController(
                    mNotificationShadeWindowView,
                    mNotificationPanelViewController,
                    mNotificationShadeDepthControllerLazy.get(),
                    (visible) -> {
                        mBrightnessMirrorVisible = visible;
                        updateScrimController();
                    });
            fragmentHostManager.addTagListener(QS.TAG, (tag, f) -> {
                QS qs = (QS) f;
                if (qs instanceof QSFragment) {
                    mQSPanel = ((QSFragment) qs).getQsPanel();
                    mQSPanel.setBrightnessMirror(mBrightnessMirrorController);
                    mFooter = ((QSFragment) qs).getFooter();
                }
            });
    //省略其他代码
}

@Inject
    public QSFragment(RemoteInputQuickSettingsDisabler remoteInputQsDisabler,
            InjectionInflationController injectionInflater, QSTileHost qsTileHost,
            StatusBarStateController statusBarStateController, CommandQueue commandQueue,
            QSContainerImplController.Builder qsContainerImplControllerBuilder) {
        mRemoteInputQuickSettingsDisabler = remoteInputQsDisabler;
        mInjectionInflater = injectionInflater;
        mQSContainerImplControllerBuilder = qsContainerImplControllerBuilder;
        commandQueue.observe(getLifecycle(), this);
        mHost = qsTileHost;
        mStatusBarStateController = statusBarStateController;
    }

mainHandler.post(() -> {
            // This is technically a hack to avoid circular dependency of
            // QSTileHost -> XXXTile -> QSTileHost. Posting ensures creation
            // finishes before creating any tiles.
            tunerService.addTunable(this, TILES_SETTING);
            // AutoTileManager can modify mTiles so make sure mTiles has already been initialized.
            mAutoTiles = autoTiles.get();
        });

// 读取config.xml里的字符串（例如：nfc,wifi）
        String value = DejankUtils.whitelistIpcs(() -> Settings.Secure
                .getStringForUser(mContentResolver, key, mCurrentUser));
        tunable.onTuningChanged(key, value);

@Override
public void onTuningChanged(String key, String newValue) {
    if (!TILES_SETTING.equals(key)) {
        return;
    }
    if (DEBUG) Log.d(TAG, "Recreating tiles");
    if (newValue == null && UserManager.isDeviceInDemoMode(mContext)) {
        newValue = mContext.getResources().getString(R.string.quick_settings_tiles_retail_mode);
    }
    //调用 QSTileHost#loadTileSpecs，获得 config 里字符串信息
    final List<String> tileSpecs = loadTileSpecs(mContext, newValue);
    int currentUser = ActivityManager.getCurrentUser();
    if (tileSpecs.equals(mTileSpecs) && currentUser == mCurrentUser) return;
    //进行了过滤
    mTiles.entrySet().stream().filter(tile -> !tileSpecs.contains(tile.getKey())).forEach(
            tile -> {
                if (DEBUG) Log.d(TAG, "Destroying tile: " + tile.getKey());
                tile.getValue().destroy();
            });
    final LinkedHashMap<String, QSTile> newTiles = new LinkedHashMap<>();
    for (String tileSpec : tileSpecs) {
        QSTile tile = mTiles.get(tileSpec);
        if (tile != null && (!(tile instanceof CustomTile)
                || ((CustomTile) tile).getUser() == currentUser)) {
            if (tile.isAvailable()) {
                if (DEBUG) Log.d(TAG, "Adding " + tile);
                tile.removeCallbacks();
                if (!(tile instanceof CustomTile) && mCurrentUser != currentUser) {
                    tile.userSwitch(currentUser);
                }
                newTiles.put(tileSpec, tile);
            } else {
                tile.destroy();
            }
        } else {
            if (DEBUG) Log.d(TAG, "Creating tile: " + tileSpec);
            try {
                //这里通过 字符串 一个个实例化 Tile
                tile = createTile(tileSpec);
                if (tile != null) {
                    if (tile.isAvailable()) {
                        tile.setTileSpec(tileSpec);
                        newTiles.put(tileSpec, tile);
                    } else {
                        tile.destroy();
                    }
                }
            } catch (Throwable t) {
                Log.w(TAG, "Error creating tile for spec: " + tileSpec, t);
            }
        }
    }
    mCurrentUser = currentUser;
    mTileSpecs.clear();
    mTileSpecs.addAll(tileSpecs);
    mTiles.clear();
    mTiles.putAll(newTiles);
    for (int i = 0; i < mCallbacks.size(); i++) {
        //注册，当开发状态改变时回调
        mCallbacks.get(i).onTilesChanged();
    }
}

protected List<String> loadTileSpecs(Context context, String tileList) {
    final Resources res = context.getResources();
    final String defaultTileList = res.getString(R.string.quick_settings_tiles_default);
    if (tileList == null) {
        tileList = res.getString(R.string.quick_settings_tiles);
        if (DEBUG) Log.d(TAG, "Loaded tile specs from config: " + tileList);
    } else {
        if (DEBUG) Log.d(TAG, "Loaded tile specs from setting: " + tileList);
    }
    final ArrayList<String> tiles = new ArrayList<String>();
    boolean addedDefault = false;
    for (String tile : tileList.split(",")) {
        tile = tile.trim();
        if (tile.isEmpty()) continue;
        if (tile.equals("default")) {
            if (!addedDefault) {
                tiles.addAll(Arrays.asList(defaultTileList.split(",")));
                addedDefault = true;
            }
        } else {
            tiles.add(tile);
        }
    }
    return tiles;
}

<string name="quick_settings_tiles_default" translatable="false">
    wifi,bt,dnd,flashlight,rotation,battery,cell,airplane,cast
</string>

public QSTile createTile(String tileSpec) {
    for (int i = 0; i < mQsFactories.size(); i++) {
        QSTile t = mQsFactories.get(i).createTile(tileSpec);
        if (t != null) {
            return t;
        }
    }
    return null;
}

public QSTile createTile(String tileSpec) {
    QSTileImpl tile = createTileInternal(tileSpec);
    if (tile != null) {
        tile.handleStale(); // Tile was just created, must be stale.
    }
    return tile;
}
private QSTileImpl createTileInternal(String tileSpec) {
    // Stock tiles.
    switch (tileSpec) {
        case "wifi":
            return new WifiTile(mHost);
        case "bt":
            return new BluetoothTile(mHost);
        case "cell":
            return new CellularTile(mHost);
        case "dnd":
            return new DndTile(mHost);
        case "inversion":
            return new ColorInversionTile(mHost);
        case "airplane":
            return new AirplaneModeTile(mHost);
        case "work":
            return new WorkModeTile(mHost);
        case "rotation":
            return new RotationLockTile(mHost);
        case "flashlight":
            return new FlashlightTile(mHost);
        case "location":
            return new LocationTile(mHost);
        case "cast":
            return new CastTile(mHost);
        case "hotspot":
            return new HotspotTile(mHost);
        case "user":
            return new UserTile(mHost);
        case "battery":
            return new BatterySaverTile(mHost);
        case "saver":
            return new DataSaverTile(mHost);
        case "night":
            return new NightDisplayTile(mHost);
        case "nfc":
            return new NfcTile(mHost);
    }
    // Intent tiles.
    if (tileSpec.startsWith(IntentTile.PREFIX)) return IntentTile.create(mHost, tileSpec);
    if (tileSpec.startsWith(CustomTile.PREFIX)) return CustomTile.create(mHost, tileSpec);
    // Debug tiles.
    if (Build.IS_DEBUGGABLE) {
        if (tileSpec.equals(GarbageMonitor.MemoryTile.TILE_SPEC)) {
            return new GarbageMonitor.MemoryTile(mHost);
        }
    }
    // Broken tiles.
    Log.w(TAG, "Bad tile spec: " + tileSpec);
    return null;
}

@Override
protected void onAttachedToWindow() {
    super.onAttachedToWindow();
    final TunerService tunerService = Dependency.get(TunerService.class);
    tunerService.addTunable(this, QS_SHOW_BRIGHTNESS);
    if (mHost != null) {
        setTiles(mHost.getTiles());
    }
    if (mBrightnessMirrorController != null) {
        mBrightnessMirrorController.addCallback(this);
    }
}
public void setTiles(Collection<QSTile> tiles) {
    setTiles(tiles, false);
}
public void setTiles(Collection<QSTile> tiles, boolean collapsedView) {
    if (!collapsedView) {
        mQsTileRevealController.updateRevealedTiles(tiles);
    }
    for (TileRecord record : mRecords) {
        mTileLayout.removeTile(record);
        record.tile.removeCallback(record.callback);
    }
    mRecords.clear();
    for (QSTile tile : tiles) {
        addTile(tile, collapsedView);
    }
}
protected TileRecord addTile(final QSTile tile, boolean collapsedView) {
    final TileRecord r = new TileRecord();
    r.tile = tile;
    r.tileView = createTileView(tile, collapsedView);
    //省略其他代码
    r.tileView.init(r.tile);
    r.tile.refreshState();
    mRecords.add(r);
    if (mTileLayout != null) {
        mTileLayout.addTile(r);
    }
    return r;
}

@Override
public void addTile(TileRecord tile) {
    mTiles.add(tile);
    postDistributeTiles();
}
private void postDistributeTiles() {
    removeCallbacks(mDistribute);
    post(mDistribute);
}
private final Runnable mDistribute = new Runnable() {
    @Override
    public void run() {
        distributeTiles();
    }
};
private void distributeTiles() {
    if (DEBUG) Log.d(TAG, "Distributing tiles");
    final int NP = mPages.size();
    for (int i = 0; i < NP; i++) {
        mPages.get(i).removeAllViews();
    }
    int index = 0;
    final int NT = mTiles.size();
    for (int i = 0; i < NT; i++) {
        TileRecord tile = mTiles.get(i);
        if (mPages.get(index).isFull()) {
            if (++index == mPages.size()) {
                if (DEBUG) Log.d(TAG, "Adding page for "
                        + tile.tile.getClass().getSimpleName());
                mPages.add((TilePage) LayoutInflater.from(getContext())
                        .inflate(R.layout.qs_paged_page, this, false));
            }
        }
        if (DEBUG) Log.d(TAG, "Adding " + tile.tile.getClass().getSimpleName() + " to "
                + index);
        mPages.get(index).addTile(tile);
    }
    if (mNumPages != index + 1) {
        mNumPages = index + 1;
        while (mPages.size() > mNumPages) {
            mPages.remove(mPages.size() - 1);
        }
        if (DEBUG) Log.d(TAG, "Size: " + mNumPages);
        mPageIndicator.setNumPages(mNumPages);
        setAdapter(mAdapter);
        mAdapter.notifyDataSetChanged();
        setCurrentItem(0, false);
    }
}

@Override
    public int getMetricsCategory() {
        return MetricsEvent.QS_WIFI;
    }