36924659f5
Merged refreshAllPreferences into DashboardFragment. This hopefully makes it more modular to manage preference display logic in each dashboardFragment, and makes it more efficient to monitor category changes. Now subclasses needs to implement 2 methods: - displayResourceTiles(): for 'static' preferences from xml - getDashboardTiles(): returns a list of dashboard tiles and superclass will wire it up to preference screen. If getDashboardTiles() return null (aka no dashboardCategory available), the fragment will not attempt to monitor category change. The edge case is that if a package starts to provide a tile for this category, we will not be notified. I have not seen this case coming up. If we indeed need to handle this case, the category listener needs to have a way to monitor specific category rather than globally. Bug: 31781480 Test: make RunSettingsRoboTests -j40 Change-Id: Ia9f9541b95816214df0d0bb27e3e41078c36c5ca
289 lines
10 KiB
Java
289 lines
10 KiB
Java
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package com.android.settings.dashboard;
|
|
|
|
import android.app.Activity;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentName;
|
|
import android.content.IntentFilter;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.HandlerThread;
|
|
import android.os.Looper;
|
|
import android.os.Message;
|
|
import android.os.Process;
|
|
import android.util.ArrayMap;
|
|
import android.util.ArraySet;
|
|
import android.util.Log;
|
|
|
|
import com.android.settings.SettingsActivity;
|
|
import com.android.settings.overlay.FeatureFactory;
|
|
import com.android.settingslib.drawer.DashboardCategory;
|
|
import com.android.settingslib.drawer.SettingsDrawerActivity;
|
|
import com.android.settingslib.drawer.Tile;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class SummaryLoader {
|
|
private static final boolean DEBUG = DashboardSummary.DEBUG;
|
|
private static final String TAG = "SummaryLoader";
|
|
|
|
public static final String SUMMARY_PROVIDER_FACTORY = "SUMMARY_PROVIDER_FACTORY";
|
|
|
|
private final Activity mActivity;
|
|
private final ArrayMap<SummaryProvider, ComponentName> mSummaryMap = new ArrayMap<>();
|
|
private final List<Tile> mTiles = new ArrayList<>();
|
|
|
|
private final Worker mWorker;
|
|
private final Handler mHandler;
|
|
private final HandlerThread mWorkerThread;
|
|
|
|
private DashboardAdapter mAdapter;
|
|
private boolean mListening;
|
|
private boolean mWorkerListening;
|
|
private ArraySet<BroadcastReceiver> mReceivers = new ArraySet<>();
|
|
|
|
public SummaryLoader(Activity activity, List<DashboardCategory> categories) {
|
|
mHandler = new Handler();
|
|
mWorkerThread = new HandlerThread("SummaryLoader", Process.THREAD_PRIORITY_BACKGROUND);
|
|
mWorkerThread.start();
|
|
mWorker = new Worker(mWorkerThread.getLooper());
|
|
mActivity = activity;
|
|
for (int i = 0; i < categories.size(); i++) {
|
|
List<Tile> tiles = categories.get(i).tiles;
|
|
for (int j = 0; j < tiles.size(); j++) {
|
|
Tile tile = tiles.get(j);
|
|
mWorker.obtainMessage(Worker.MSG_GET_PROVIDER, tile).sendToTarget();
|
|
}
|
|
}
|
|
}
|
|
|
|
public SummaryLoader(Activity activity, DashboardCategory categories) {
|
|
mHandler = new Handler();
|
|
mWorkerThread = new HandlerThread("SummaryLoader", Process.THREAD_PRIORITY_BACKGROUND);
|
|
mWorkerThread.start();
|
|
mWorker = new Worker(mWorkerThread.getLooper());
|
|
mActivity = activity;
|
|
List<Tile> tiles = categories.tiles;
|
|
for (Tile tile :tiles) {
|
|
mWorker.obtainMessage(Worker.MSG_GET_PROVIDER, tile).sendToTarget();
|
|
}
|
|
}
|
|
|
|
public void release() {
|
|
mWorkerThread.quitSafely();
|
|
// Make sure we aren't listening.
|
|
setListeningW(false);
|
|
}
|
|
|
|
public void setAdapter(DashboardAdapter adapter) {
|
|
mAdapter = adapter;
|
|
}
|
|
|
|
public void setSummary(SummaryProvider provider, final CharSequence summary) {
|
|
final ComponentName component = mSummaryMap.get(provider);
|
|
mHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
// Since tiles are not always cached (like on locale change for instance),
|
|
// we need to always get the latest one.
|
|
if (!(mActivity instanceof SettingsDrawerActivity)) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Can't get category list.");
|
|
}
|
|
return;
|
|
}
|
|
final Tile tile;
|
|
final DashboardFeatureProvider dashboardFeatureProvider =
|
|
FeatureFactory.getFactory(mActivity).getDashboardFeatureProvider(mActivity);
|
|
if (dashboardFeatureProvider.isEnabled()) {
|
|
tile = getTileFromCategory(dashboardFeatureProvider.getTilesForHomepage(),
|
|
component);
|
|
} else {
|
|
tile = getTileFromCategory(
|
|
((SettingsDrawerActivity) mActivity).getDashboardCategories(),
|
|
component);
|
|
}
|
|
|
|
if (tile == null) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Can't find tile for " + component);
|
|
}
|
|
return;
|
|
}
|
|
if (DEBUG) {
|
|
Log.d(TAG, "setSummary " + tile.title + " - " + summary);
|
|
}
|
|
tile.summary = summary;
|
|
mAdapter.notifyChanged(tile);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Only call from the main thread.
|
|
*/
|
|
public void setListening(boolean listening) {
|
|
if (mListening == listening) return;
|
|
mListening = listening;
|
|
// Unregister listeners immediately.
|
|
for (int i = 0; i < mReceivers.size(); i++) {
|
|
mActivity.unregisterReceiver(mReceivers.valueAt(i));
|
|
}
|
|
mReceivers.clear();
|
|
mWorker.removeMessages(Worker.MSG_SET_LISTENING);
|
|
mWorker.obtainMessage(Worker.MSG_SET_LISTENING, listening ? 1 : 0, 0).sendToTarget();
|
|
}
|
|
|
|
private SummaryProvider getSummaryProvider(Tile tile) {
|
|
if (!mActivity.getPackageName().equals(tile.intent.getComponent().getPackageName())) {
|
|
// Not within Settings, can't load Summary directly.
|
|
// TODO: Load summary indirectly.
|
|
return null;
|
|
}
|
|
Bundle metaData = getMetaData(tile);
|
|
if (metaData == null) {
|
|
if (DEBUG) Log.d(TAG, "No metadata specified for " + tile.intent.getComponent());
|
|
return null;
|
|
}
|
|
String clsName = metaData.getString(SettingsActivity.META_DATA_KEY_FRAGMENT_CLASS);
|
|
if (clsName == null) {
|
|
if (DEBUG) Log.d(TAG, "No fragment specified for " + tile.intent.getComponent());
|
|
return null;
|
|
}
|
|
try {
|
|
Class<?> cls = Class.forName(clsName);
|
|
Field field = cls.getField(SUMMARY_PROVIDER_FACTORY);
|
|
SummaryProviderFactory factory = (SummaryProviderFactory) field.get(null);
|
|
return factory.createSummaryProvider(mActivity, this);
|
|
} catch (ClassNotFoundException e) {
|
|
if (DEBUG) Log.d(TAG, "Couldn't find " + clsName, e);
|
|
} catch (NoSuchFieldException e) {
|
|
if (DEBUG) Log.d(TAG, "Couldn't find " + SUMMARY_PROVIDER_FACTORY, e);
|
|
} catch (ClassCastException e) {
|
|
if (DEBUG) Log.d(TAG, "Couldn't cast " + SUMMARY_PROVIDER_FACTORY, e);
|
|
} catch (IllegalAccessException e) {
|
|
if (DEBUG) Log.d(TAG, "Couldn't get " + SUMMARY_PROVIDER_FACTORY, e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private Bundle getMetaData(Tile tile) {
|
|
return tile.metaData;
|
|
}
|
|
|
|
/**
|
|
* Registers a receiver and automatically unregisters it when the activity is stopping.
|
|
* This ensures that the receivers are unregistered immediately, since most summary loader
|
|
* operations are asynchronous.
|
|
*/
|
|
public void registerReceiver(final BroadcastReceiver receiver, final IntentFilter filter) {
|
|
mActivity.runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!mListening) {
|
|
return;
|
|
}
|
|
mReceivers.add(receiver);
|
|
mActivity.registerReceiver(receiver, filter);
|
|
}
|
|
});
|
|
}
|
|
|
|
private synchronized void setListeningW(boolean listening) {
|
|
if (mWorkerListening == listening) return;
|
|
mWorkerListening = listening;
|
|
if (DEBUG) Log.d(TAG, "Listening " + listening);
|
|
for (SummaryProvider p : mSummaryMap.keySet()) {
|
|
try {
|
|
p.setListening(listening);
|
|
} catch (Exception e) {
|
|
Log.d(TAG, "Problem in setListening", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private synchronized void makeProviderW(Tile tile) {
|
|
SummaryProvider provider = getSummaryProvider(tile);
|
|
if (provider != null) {
|
|
if (DEBUG) Log.d(TAG, "Creating " + tile);
|
|
mSummaryMap.put(provider, tile.intent.getComponent());
|
|
}
|
|
}
|
|
|
|
private Tile getTileFromCategory(List<DashboardCategory> categories, ComponentName component) {
|
|
if (categories == null) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Category is null, can't find tile");
|
|
}
|
|
return null;
|
|
}
|
|
final int categorySize = categories.size();
|
|
for (int i = 0; i < categorySize; i++) {
|
|
final DashboardCategory category = categories.get(i);
|
|
final Tile tile = getTileFromCategory(category, component);
|
|
if (tile != null) {
|
|
return tile;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private Tile getTileFromCategory(DashboardCategory category, ComponentName component) {
|
|
final int tileCount = category.tiles.size();
|
|
for (int j = 0; j < tileCount; j++) {
|
|
final Tile tile = category.tiles.get(j);
|
|
if (component.equals(tile.intent.getComponent())) {
|
|
return tile;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public interface SummaryProvider {
|
|
void setListening(boolean listening);
|
|
}
|
|
|
|
public interface SummaryProviderFactory {
|
|
SummaryProvider createSummaryProvider(Activity activity, SummaryLoader summaryLoader);
|
|
}
|
|
|
|
private class Worker extends Handler {
|
|
private static final int MSG_GET_PROVIDER = 1;
|
|
private static final int MSG_SET_LISTENING = 2;
|
|
|
|
public Worker(Looper looper) {
|
|
super(looper);
|
|
}
|
|
|
|
@Override
|
|
public void handleMessage(Message msg) {
|
|
switch (msg.what) {
|
|
case MSG_GET_PROVIDER:
|
|
Tile tile = (Tile) msg.obj;
|
|
makeProviderW(tile);
|
|
break;
|
|
case MSG_SET_LISTENING:
|
|
boolean listening = msg.arg1 != 0;
|
|
setListeningW(listening);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|