CyanogenMode主题模块解析(上)

public class ChooserDetailFragment extends Fragment implements LoaderManager.LoaderCallbacks<Cursor>, ThemeChangeListener {
...
private ThemeManager mService;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
...
mApply = (Button) v.findViewById(R.id.apply);
mApply.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
ThemeChangeRequest request = getThemeChangeRequestForSelectedComponents();
mService.requestThemeChange(request, true);//④
mApply.setText(R.string.applying);
}
});
...

mService = (ThemeManager) getActivity().getSystemService(Context.THEME_SERVICE);//①
}

@Override
public void onResume() {
super.onResume();
if (mService != null) {
mService.onClientResumed(this);//③
}
refreshApplyButton();
}

@Override
public void onPause() {
super.onPause();
if (mService != null) {
mService.onClientPaused(this);
}
}

@Override
public void onDestroy() {
super.onDestroy();
if (mService != null) {
mService.onClientDestroyed(this);
}
}

private ThemeChangeRequest getThemeChangeRequestForSelectedComponents() {
// Get all checked components
ThemeChangeRequest.Builder builder = new ThemeChangeRequest.Builder();
for (Map.Entry<String, CheckBox> entry : mComponentToCheckbox.entrySet()) {
String component = entry.getKey();
CheckBox checkbox = entry.getValue();
if (checkbox.isEnabled() && checkbox.isChecked()
&& !mAppliedComponents.contains(component)) {
builder.setComponent(component, mPkgName);//②
}
}
builder.setRequestType(RequestType.USER_REQUEST);
return builder.build();
}
...
}

static {
...
registerService(APPWIDGET_SERVICE, new ServiceFetcher() {
public Object createService(ContextImpl ctx) {
IBinder b = ServiceManager.getService(APPWIDGET_SERVICE);
return new AppWidgetManager(ctx, IAppWidgetService.Stub.asInterface(b));
}});

registerService(THEME_SERVICE, new ServiceFetcher() {
public Object createService(ContextImpl ctx) {
IBinder b = ServiceManager.getService(THEME_SERVICE);
IThemeService service = IThemeService.Stub.asInterface(b);
return new ThemeManager(ctx.getOuterContext(),
service);//①
}});

...
}

...
@Override
public Object getSystemService(String name) {
ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
return fetcher == null ? null : fetcher.getService(this);
}

3.路径:framework/base/core/java/android/content/res/ThemeManager.java

public class ThemeManager {
...
public void addClient(ThemeChangeListener listener) {
synchronized (mChangeListeners) {
if (mChangeListeners.contains(listener)) {
throw new IllegalArgumentException("Client was already added ");
}
if (mChangeListeners.size() == 0) {
try {
mService.requestThemeChangeUpdates(mThemeChangeListener);
} catch (RemoteException e) {
Log.w(TAG, "Unable to register listener", e);
}
}
mChangeListeners.add(listener);
}
}

public void removeClient(ThemeChangeListener listener) {
synchronized (mChangeListeners) {
mChangeListeners.remove(listener);
if (mChangeListeners.size() == 0) {
try {
mService.removeUpdates(mThemeChangeListener);
} catch (RemoteException e) {
Log.w(TAG, "Unable to remove listener", e);
}
}
}
}

public void onClientPaused(ThemeChangeListener listener) {
removeClient(listener);
}

public void onClientResumed(ThemeChangeListener listener) {
addClient(listener);
}

...

public void requestThemeChange(ThemeChangeRequest request, boolean removePerAppThemes) {
try {
mService.requestThemeChange(request, removePerAppThemes);
} catch (RemoteException e) {
logThemeServiceException(e);
}
}

...

}

public final class ThemeChangeRequest implements Parcelable {

public static class Builder {//一个建造者
Map<String, String> mThemeComponents = new HashMap<String, String>();
...
public Builder setComponent(String component, String pkgName) {
if (pkgName != null) {
mThemeComponents.put(component, pkgName);
} else {
mThemeComponents.remove(component);
}
return this;
}
...
}

}

public class ThemesContract {
...
/**
* 1 if theme modifies the launcher/homescreen else 0
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_LAUNCHER = "mods_homescreen";

/**
* 1 if theme modifies the lockscreen else 0
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_LOCKSCREEN = "mods_lockscreen";

/**
* 1 if theme modifies icons else 0
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_ICONS = "mods_icons";

/**
* 1 if theme modifies fonts
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_FONTS = "mods_fonts";

/**
* 1 if theme modifies boot animation
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_BOOT_ANIM = "mods_bootanim";

/**
* 1 if theme modifies notifications
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_NOTIFICATIONS = "mods_notifications";

/**
* 1 if theme modifies alarm sounds
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_ALARMS = "mods_alarms";

/**
* 1 if theme modifies ringtones
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_RINGTONES = "mods_ringtones";

/**
* 1 if theme has overlays
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_OVERLAYS = "mods_overlays";

/**
* 1 if theme has an overlay for SystemUI/StatusBar
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_STATUS_BAR = "mods_status_bar";

/**
* 1 if theme has an overlay for SystemUI/NavBar
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_NAVIGATION_BAR = "mods_navigation_bar";

/**
* 1 if theme has a live lock screen
* <P>Type: INTEGER</P>
* <P>Default: 0</P>
*/
public static final String MODIFIES_LIVE_LOCK_SCREEN = "mods_live_lock_screen";

...
}

public class ThemeService extends IThemeService.Stub {

...
private class ThemeWorkerHandler extends Handler {
private static final int MESSAGE_CHANGE_THEME = 1;
private static final int MESSAGE_APPLY_DEFAULT_THEME = 2;
private static final int MESSAGE_REBUILD_RESOURCE_CACHE = 3;

public ThemeWorkerHandler(Looper looper) {
super(looper);
}

@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MESSAGE_CHANGE_THEME:
Log.i(TAG,"RECEIVE MESSAGE_CHANGE_THEME");
final ThemeChangeRequest request = (ThemeChangeRequest) msg.obj;
doApplyTheme(request, msg.arg1 == 1);
break;
case MESSAGE_APPLY_DEFAULT_THEME:
doApplyDefaultTheme();
break;
case MESSAGE_REBUILD_RESOURCE_CACHE:
doRebuildResourceCache();
break;
default:
Log.w(TAG, "Unknown message " + msg.what);
break;
}
}
}

...
private class ResourceProcessingHandler extends Handler {
private static final int MESSAGE_QUEUE_THEME_FOR_PROCESSING = 3;
private static final int MESSAGE_DEQUEUE_AND_PROCESS_THEME = 4;

public ResourceProcessingHandler(Looper looper) {
super(looper);
}

@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MESSAGE_QUEUE_THEME_FOR_PROCESSING:
String pkgName = (String) msg.obj;
synchronized (mThemesToProcessQueue) {
if (!mThemesToProcessQueue.contains(pkgName)) {
if (DEBUG) Log.d(TAG, "Adding " + pkgName + " for processing");
mThemesToProcessQueue.add(pkgName);//③
if (mThemesToProcessQueue.size() == 1) {
this.sendEmptyMessage(MESSAGE_DEQUEUE_AND_PROCESS_THEME);
}
}
}
break;
case MESSAGE_DEQUEUE_AND_PROCESS_THEME:
Log.i(TAG,"RECEIVE MESSAGE_DEQUEUE_AND_PROCESS_THEME");
synchronized (mThemesToProcessQueue) {
pkgName = mThemesToProcessQueue.get(0);
}
if (pkgName != null) {
if (DEBUG) Log.d(TAG, "Processing " + pkgName);
String name;
try {
PackageInfo pi = mPM.getPackageInfo(pkgName, 0);
name = getThemeName(pi);
} catch (PackageManager.NameNotFoundException e) {
name = null;
}

int result = mPM.processThemeResources(pkgName);//⑤
if (result < 0) {
postFailedThemeInstallNotification(name != null ? name : pkgName);
}
sendThemeResourcesCachedBroadcast(pkgName, result);

synchronized (mThemesToProcessQueue) {
mThemesToProcessQueue.remove(0);//④
if (mThemesToProcessQueue.size() > 0 &&
!hasMessages(MESSAGE_DEQUEUE_AND_PROCESS_THEME)) {
this.sendEmptyMessage(MESSAGE_DEQUEUE_AND_PROCESS_THEME);
}
}
postFinishedProcessing(pkgName);
}

Log.i(TAG,"RECEIVE MESSAGE_DEQUEUE_AND_PROCESS_THEME END");
break;
default:
Log.w(TAG, "Unknown message " + msg.what);
break;
}
}
}

...

public void systemRunning() {
...

processInstalledThemes();//①

...
}

...

private void processInstalledThemes() {

final String defaultTheme = ThemeUtils.getDefaultThemePackageName(mContext);
Message msg;
// Make sure the default theme is the first to get processed!
if (!ThemeConfig.SYSTEM_DEFAULT.equals(defaultTheme)) {
msg = mHandler.obtainMessage(
ResourceProcessingHandler.MESSAGE_QUEUE_THEME_FOR_PROCESSING,
0, 0, defaultTheme);
mResourceProcessingHandler.sendMessage(msg);
}
// Iterate over all installed packages and queue up the ones that are themes or icon packs
List<PackageInfo> packages = mPM.getInstalledPackages(0);
for (PackageInfo info : packages) {
if (!defaultTheme.equals(info.packageName) &&
(info.isThemeApk || info.isLegacyIconPackApk)) {
msg = mHandler.obtainMessage(
ResourceProcessingHandler.MESSAGE_QUEUE_THEME_FOR_PROCESSING,
0, 0, info.packageName);
mResourceProcessingHandler.sendMessage(msg);
}
}
...

@Override
public boolean processThemeResources(String themePkgName) throws RemoteException {
mContext.enforceCallingOrSelfPermission(
Manifest.permission.ACCESS_THEME_MANAGER, null);
try {
mPM.getPackageInfo(themePkgName, 0);
} catch (PackageManager.NameNotFoundException e) {
// Package doesn't exist so nothing to process
return false;
}
// Obtain a message and send it to the handler to process this theme
Message msg = mResourceProcessingHandler.obtainMessage(
ResourceProcessingHandler.MESSAGE_QUEUE_THEME_FOR_PROCESSING, 0, 0, themePkgName);
mResourceProcessingHandler.sendMessage(msg);
return true;
}

...
@Override
public void requestThemeChange(ThemeChangeRequest request, boolean removePerAppThemes)
throws RemoteException {
mContext.enforceCallingOrSelfPermission(
Manifest.permission.ACCESS_THEME_MANAGER, null);
Message msg;

/**
* Since the ThemeService handles compiling theme resource we need to make sure that any
* of the components we are trying to apply are either already processed or put to the
* front of the queue and handled before the theme change takes place.
*
* TODO: create a callback that can be sent to any ThemeChangeListeners to notify them that
* the theme will be applied once the processing is done.
*/
synchronized (mThemesToProcessQueue) {
Map<String, String> componentMap = request.getThemeComponentsMap();
for (Object key : componentMap.keySet()) {
if (ThemesColumns.MODIFIES_OVERLAYS.equals(key) ||
ThemesColumns.MODIFIES_NAVIGATION_BAR.equals(key) ||
ThemesColumns.MODIFIES_STATUS_BAR.equals(key) ||
ThemesColumns.MODIFIES_ICONS.equals(key)) {
String pkgName = (String) componentMap.get(key);
if (mThemesToProcessQueue.indexOf(pkgName) > 0) {//②
mThemesToProcessQueue.remove(pkgName);
mThemesToProcessQueue.add(0, pkgName);
// We want to make sure these resources are taken care of first so
// send the dequeue message and place it in the front of the queue
msg = mResourceProcessingHandler.obtainMessage(
ResourceProcessingHandler.MESSAGE_DEQUEUE_AND_PROCESS_THEME);
mResourceProcessingHandler.sendMessageAtFrontOfQueue(msg);
}
}
}
}
msg = Message.obtain();
msg.what = ThemeWorkerHandler.MESSAGE_CHANGE_THEME;
msg.obj = request;
msg.arg1 = removePerAppThemes ? 1 : 0;
mHandler.sendMessage(msg);
}

...

}

mActivityManagerService.systemReady(new Runnable() {
@Override
public void run() {
…
try {
// now that the system is up, apply default theme if applicable
if (themeServiceF != null) themeServiceF.systemRunning();
ThemeConfig themeConfig =
ThemeConfig.getBootTheme(context.getContentResolver());
String iconPkg = themeConfig.getIconPackPkgName();
mPackageManagerService.updateIconMapping(iconPkg);
} catch (Throwable e) {
reportWtf("Icon Mapping failed", e);
}
…
}
});

public class PackageManagerService extends IPackageManager.Stub {
...
class PackageHandler extends Handler {
...
void doHandleMessage(Message msg) {
...
POST_INSTALL: {
...
if(res.pkg.mIsThemeApk || res.pkg.mIsLegacyIconPackApk) {
processThemeResourcesInThemeService(res.pkg.packageName);
}
...
}
...
}
...
}
...

private void processThemeResourcesInThemeService(String pkgName) {
ThemeManager tm =
(ThemeManager) mContext.getSystemService(Context.THEME_SERVICE);
if (tm != null) {
tm.processThemeResources(pkgName);
}
}

...
}

@Override
public int processThemeResources(String themePkgName) {
mContext.enforceCallingOrSelfPermission(
Manifest.permission.ACCESS_THEME_MANAGER, null);
PackageParser.Package pkg = mPackages.get(themePkgName);
if (pkg == null) {
Log.w(TAG, "Unable to get pkg for processing " + themePkgName);
return 0;
}
//解析图标资源
// Process icons
if (isIconCompileNeeded(pkg)) {
try {
ThemeUtils.createCacheDirIfNotExists();
ThemeUtils.createIconDirIfNotExists(pkg.packageName);
compileIconPack(pkg);
} catch (Exception e) {
uninstallThemeForAllApps(pkg);
deletePackageX(themePkgName, getCallingUid(), PackageManager.DELETE_ALL_USERS);
return PackageManager.INSTALL_FAILED_THEME_AAPT_ERROR;
}
}

// Generate Idmaps and res tables if pkg is a theme
Iterator<String> iterator = pkg.mOverlayTargets.iterator();
while(iterator.hasNext()) {
String target = iterator.next();
Exception failedException = null;
try {
compileResourcesAndIdmapIfNeeded(mPackages.get(target), pkg);
} catch (IdmapException e) {
failedException = e;
} catch (AaptException e) {
failedException = e;
} catch (Exception e) {
failedException = e;
}

if (failedException != null) {
Slog.w(TAG, "Unable to process theme " + pkg.packageName + " for " + target,
failedException);
// remove target from mOverlayTargets
iterator.remove();
}
}

return 0;
}