diff options
Diffstat (limited to 'src/org/cyanogenmod/theme/chooser2/MyThemeFragment.java')
| -rw-r--r-- | src/org/cyanogenmod/theme/chooser2/MyThemeFragment.java | 707 |
1 files changed, 707 insertions, 0 deletions
diff --git a/src/org/cyanogenmod/theme/chooser2/MyThemeFragment.java b/src/org/cyanogenmod/theme/chooser2/MyThemeFragment.java new file mode 100644 index 0000000..490b568 --- /dev/null +++ b/src/org/cyanogenmod/theme/chooser2/MyThemeFragment.java @@ -0,0 +1,707 @@ +/* + * Copyright (C) 2016 Cyanogen, Inc. + * Copyright (C) 2016 The CyanogenMod 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 org.cyanogenmod.theme.chooser2; + +import android.app.WallpaperManager; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.res.Resources; +import android.database.Cursor; +import android.graphics.Bitmap; +import android.graphics.Typeface; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.media.MediaPlayer; +import android.media.Ringtone; +import android.media.RingtoneManager; +import android.net.Uri; +import android.os.Bundle; +import android.support.v4.content.Loader; +import android.util.Log; +import android.util.MutableLong; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.MenuItem; +import android.view.SurfaceView; +import android.view.View; +import android.view.ViewGroup; +import android.widget.FrameLayout; +import android.widget.ImageView; +import android.widget.TextView; + +import org.cyanogenmod.theme.util.AudioUtils; +import org.cyanogenmod.theme.util.CursorLoaderHelper; +import org.cyanogenmod.theme.util.PreferenceUtils; +import org.cyanogenmod.theme.util.ThemedTypefaceHelper; +import org.cyanogenmod.theme.util.TypefaceHelperCache; +import org.cyanogenmod.theme.util.Utils; + +import cyanogenmod.providers.ThemesContract; +import cyanogenmod.providers.ThemesContract.PreviewColumns; +import cyanogenmod.providers.ThemesContract.ThemesColumns; +import cyanogenmod.themes.ThemeChangeRequest; +import cyanogenmod.themes.ThemeChangeRequest.RequestType; +import cyanogenmod.themes.ThemeManager; + +import org.cyanogenmod.internal.util.ThemeUtils; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import static org.cyanogenmod.theme.util.CursorLoaderHelper.LOADER_ID_ALL; + +public class MyThemeFragment extends ThemeFragment { + private static final String TAG = MyThemeFragment.class.getSimpleName(); + + private static final String ARG_BASE_THEME_PACKAGE_NAME = "baseThemePkgName"; + private static final String ARG_BASE_THEME_NAME = "baseThemeName"; + private static final String ARG_BASE_THEME_AUTHOR = "baseThemeAuthor"; + + private String mBaseThemeName; + private String mBaseThemeAuthor; + + private SurfaceView mSurfaceView; + + static MyThemeFragment newInstance(String baseThemePkgName, String baseThemeName, + String baseThemeAuthor, boolean skipLoadingAnim, + boolean animateToLockScreenCard) { + MyThemeFragment f = new MyThemeFragment(); + Bundle args = new Bundle(); + args.putString(ARG_PACKAGE_NAME, CURRENTLY_APPLIED_THEME); + args.putString(ARG_BASE_THEME_PACKAGE_NAME, baseThemePkgName); + args.putString(ARG_BASE_THEME_NAME, baseThemeName); + args.putString(ARG_BASE_THEME_AUTHOR, baseThemeAuthor); + args.putBoolean(ARG_SKIP_LOADING_ANIM, skipLoadingAnim); + args.putBoolean(ARG_ANIMATE_TO_LOCK_SCREEN_CARD, animateToLockScreenCard); + f.setArguments(args); + return f; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + final Context context = getActivity(); + ThemedTypefaceHelper helper = sTypefaceHelperCache.getHelperForTheme(context, + getAppliedFontPackageName()); + mTypefaceNormal = helper.getTypeface(Typeface.NORMAL); + mBaseThemePkgName = getArguments().getString(ARG_BASE_THEME_PACKAGE_NAME); + mBaseThemeName = getArguments().getString(ARG_BASE_THEME_NAME); + mBaseThemeAuthor = getArguments().getString(ARG_BASE_THEME_AUTHOR); + mShowLockScreenSelectorAfterContentLoaded = getArguments().getBoolean( + ARG_ANIMATE_TO_LOCK_SCREEN_CARD); + mSurfaceView = createSurfaceView(); + populateBaseThemeSupportedComponents(mBaseThemePkgName); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View v = super.onCreateView(inflater, container, savedInstanceState); + mThemeTagLayout.setAppliedTagEnabled(true); + if (mBaseThemePkgName.equals(Utils.getDefaultThemePackageName(getActivity()))) { + mThemeTagLayout.setDefaultTagEnabled(true); + } + if (PreferenceUtils.hasThemeBeenUpdated(getActivity(), mBaseThemePkgName)) { + mThemeTagLayout.setUpdatedTagEnabled(true); + } + mDelete.setVisibility(View.GONE); + setCustomized(isThemeCustomized()); + return v; + } + + @Override + public void onResume() { + super.onResume(); + if (!mExpanded && getLoaderManager().getLoader(0) != null) { + getLoaderManager().restartLoader(0, null, this); + } + + IntentFilter filter = new IntentFilter(Intent.ACTION_WALLPAPER_CHANGED); + getActivity().registerReceiver(mWallpaperChangeReceiver, filter); + } + + @Override + public void onPause() { + getActivity().unregisterReceiver(mWallpaperChangeReceiver); + super.onPause(); + } + + @Override + public void setUserVisibleHint(boolean isVisibleToUser) { + super.setUserVisibleHint(isVisibleToUser); + if (mThemeTagLayout == null) return; + + if (!isVisibleToUser) { + if (PreferenceUtils.hasThemeBeenUpdated(getActivity(), mBaseThemePkgName)) { + mThemeTagLayout.setUpdatedTagEnabled(true); + } + } else { + if (PreferenceUtils.hasThemeBeenUpdated(getActivity(), mBaseThemePkgName)) { + PreferenceUtils.removeUpdatedTheme(getActivity(), mBaseThemePkgName); + } + } + } + + @Override + protected boolean onPopupMenuItemClick(MenuItem item) { + switch(item.getItemId()) { + case R.id.menu_reset: + resetTheme(); + return true; + } + + return super.onPopupMenuItemClick(item); + } + + @Override + public void collapse(boolean applyTheme) { + super.collapse(applyTheme); + if (mSurfaceView != null) mSurfaceView.setVisibility(View.VISIBLE); + } + + @Override + public void expand() { + super.expand(); + if (mSurfaceView != null && mShadowFrame.indexOfChild(mSurfaceView) >= 0) { + mSurfaceView.setVisibility(View.GONE); + mWallpaper.setVisibility(View.INVISIBLE); + } + } + + @Override + public void performClick(boolean clickedOnContent) { + if (clickedOnContent) { + showCustomizeResetLayout(); + } else { + if (isShowingCustomizeResetLayout()) { + hideCustomizeResetLayout(); + } else { + super.performClick(clickedOnContent); + } + } + } + + @Override + public void setCurrentTheme(Map<String, String> currentTheme, + MutableLong currentWallpaperComponentId) { + super.setCurrentTheme(currentTheme, currentWallpaperComponentId); + for (String key : currentTheme.keySet()) { + mSelectedComponentsMap.put(key, currentTheme.get(key)); + } + mSelectedWallpaperComponentId = currentWallpaperComponentId.value; + } + + @Override + public boolean componentsChanged() { + // If an external wallpaper/ls are set then something changed! + if (mExternalWallpaperUri != null || mExternalLockscreenUri != null) return true; + + for (String key : mSelectedComponentsMap.keySet()) { + String current = mCurrentTheme.get(key); + if (current == null || !current.equals(mSelectedComponentsMap.get(key))) { + return true; + } + if (ThemesColumns.MODIFIES_LAUNCHER.equals(key) && + mCurrentWallpaperComponentId.value != mSelectedWallpaperComponentId) { + return true; + } + } + return false; + } + + @Override + protected void applyThemeWhenPopulated(String pkgName, List<String> components) { + super.applyThemeWhenPopulated(pkgName, components); + populateComponentsToApply(pkgName, components); + } + + private void populateComponentsToApply(String pkgName, List<String> components) { + String selection = ThemesColumns.PKG_NAME + "=?"; + String[] selectionArgs = { pkgName }; + Cursor c = getActivity().getContentResolver().query(ThemesColumns.CONTENT_URI, + null, selection, selectionArgs, null); + if (c != null) { + if (c.getCount() > 0 && c.moveToFirst()) { + mSelectedComponentsMap.clear(); + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_ALARMS)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_ALARMS, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_BOOT_ANIM)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_BOOT_ANIM, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_FONTS)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_FONTS, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_ICONS)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_ICONS, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_LAUNCHER)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_LAUNCHER, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_LOCKSCREEN)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_LOCKSCREEN, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_NAVIGATION_BAR)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_NAVIGATION_BAR, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_NOTIFICATIONS)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_NOTIFICATIONS, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_OVERLAYS)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_OVERLAYS, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_RINGTONES)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_RINGTONES, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_STATUS_BAR)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_STATUS_BAR, pkgName); + } + if (c.getInt(c.getColumnIndex(ThemesColumns.MODIFIES_LIVE_LOCK_SCREEN)) == 1) { + mSelectedComponentsMap.put(ThemesColumns.MODIFIES_LIVE_LOCK_SCREEN, pkgName); + } + } + c.close(); + } + + // strip out any components that are not in the components list + if (components != null) { + Iterator<Map.Entry<String, String>> iterator = + mSelectedComponentsMap.entrySet().iterator(); + while (iterator.hasNext()) { + Map.Entry<String, String> entry = iterator.next(); + if (!components.contains(entry.getKey())) { + iterator.remove(); + } + } + } + } + + private void loadComponentsToApply() { + for (String component : mSelectedComponentsMap.keySet()) { + loadComponentFromPackage(mSelectedComponentsMap.get(component), component, + mSelectedWallpaperComponentId); + } + } + + private BroadcastReceiver mWallpaperChangeReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + // only update if we are the current visible fragment or if there is no theme + // being applied. + ThemeManager tm = getThemeManager(); + if (!tm.isThemeApplying() || getUserVisibleHint()) { + final WallpaperManager wm = WallpaperManager.getInstance(context); + if (wm.getWallpaperInfo() != null) { + addSurfaceView(mSurfaceView); + } else { + removeSurfaceView(mSurfaceView); + } + + Drawable wp = context == null ? null : wm.getDrawable(); + if (wp != null) { + mWallpaper.setImageDrawable(wp); + mWallpaperCard.setWallpaper(wp); + } + } + } + }; + + private void setCustomized(boolean customized) { + mReset.setVisibility(customized ? View.VISIBLE : View.GONE); + mThemeTagLayout.setCustomizedTagEnabled(customized); + } + + @Override + public Loader<Cursor> onCreateLoader(int id, Bundle args) { + switch (id) { + case LOADER_ID_ALL: + if (args != null) { + String pkgName = args.getString(ARG_PACKAGE_NAME); + if (pkgName != null) { + return super.onCreateLoader(id, args); + } + } + return CursorLoaderHelper.myThemeFragmentCursorLoader(getActivity(), id); + default: + // Only LOADER_ID_ALL differs for MyThemeFragment + return super.onCreateLoader(id, args); + } + } + + @Override + public void onLoadFinished(Loader<Cursor> loader, Cursor c) { + super.onLoadFinished(loader, c); + // if the theme is resetting, we need to apply these changes now that the supported + // theme components have been properly set. + if (loader.getId() == LOADER_ID_ALL) { + if (mThemeResetting) { + applyTheme(); + } else if (mApplyThemeOnPopulated) { + loadComponentsToApply(); + applyTheme(); + } else if (mSelectedComponentsMap.size() == 0) { + //Re-populates selected components with current theme. Why? + //We got here because the cursor was reloaded after the user pressed back and no + //changes were applied, causing the selected components map to be wiped out + mSelectedComponentsMap.putAll(mCurrentTheme); + } + } + } + + @Override + protected Map<String, String> fillMissingComponentsWithDefault( + Map<String, String> originalMap) { + // Only the ThemeFragment should be altering this, for the MyThemeFragment this is not + // desirable as it changes components the user did not even touch. + return originalMap; + } + + @Override + protected ThemeChangeRequest getThemeChangeRequestForComponents( + Map<String, String> componentMap) { + return getThemeChangeRequestForComponents(componentMap, RequestType.USER_REQUEST_MIXNMATCH); + } + + @Override + protected Map<String, String> getComponentsToApply() { + Map<String, String> componentsToApply = mThemeResetting + ? getEmptyComponentsMap() + : new HashMap<String, String>(); + if (mThemeResetting) { + final String pkgName = getThemePackageName(); + for (String component : mBaseThemeSupportedComponents) { + componentsToApply.put(component, pkgName); + } + } else { + // Only apply components that actually changed + for (String component : mSelectedComponentsMap.keySet()) { + String currentPkg = mCurrentTheme.get(component); + String selectedPkg = mSelectedComponentsMap.get(component); + if (currentPkg == null || mThemeResetting || !currentPkg.equals(selectedPkg) || + mCurrentWallpaperComponentId.value != mSelectedWallpaperComponentId) { + componentsToApply.put(component, selectedPkg); + } + } + if (mExternalLockscreenUri != null) { + if (mCurrentTheme.containsKey(ThemesColumns.MODIFIES_LIVE_LOCK_SCREEN)) { + componentsToApply.put(ThemesColumns.MODIFIES_LIVE_LOCK_SCREEN, LOCKSCREEN_NONE); + } + if (mCurrentTheme.containsKey(ThemesColumns.MODIFIES_LOCKSCREEN)) { + componentsToApply.put(ThemesColumns.MODIFIES_LOCKSCREEN, LOCKSCREEN_NONE); + } + } + } + return componentsToApply; + } + + @Override + protected void populateSupportedComponents(Cursor c) { + } + + @Override + protected Boolean shouldShowComponentCard(String component) { + return true; + } + + @Override + protected void loadTitle(Cursor c) { + mTitle.setText(mBaseThemeName); + mAuthor.setText(mBaseThemeAuthor); + } + + @Override + protected void loadWallpaper(Cursor c, boolean animate) { + mExternalWallpaperUri = null; + int pkgNameIdx = c.getColumnIndex(ThemesContract.ThemesColumns.PKG_NAME); + if (pkgNameIdx > -1) { + super.loadWallpaper(c, animate); + return; + } + Drawable overlay = null; + if (animate) { + overlay = getOverlayDrawable(mWallpaperCard, true); + } + + int wpIdx = c.getColumnIndex(PreviewColumns.WALLPAPER_PREVIEW); + final Resources res = getResources(); + final Context context = getActivity(); + final WallpaperManager wm = WallpaperManager.getInstance(context); + if (wm.getWallpaperInfo() != null) { + addSurfaceView(mSurfaceView); + } else { + removeSurfaceView(mSurfaceView); + } + + Drawable wp = context == null ? null : wm.getDrawable(); + if (wp == null) { + Bitmap bmp = Utils.loadBitmapBlob(c, wpIdx); + if (bmp != null) wp = new BitmapDrawable(res, bmp); + } + if (wp != null) { + mWallpaper.setImageDrawable(wp); + mWallpaperCard.setWallpaper(wp); + setCardTitle(mWallpaperCard, mCurrentTheme.get(ThemesColumns.MODIFIES_LAUNCHER), + getString(R.string.wallpaper_label)); + } else { + mWallpaperCard.clearWallpaper(); + mWallpaperCard.setEmptyViewEnabled(true); + setAddComponentTitle(mWallpaperCard, getString(R.string.wallpaper_label)); + } + + if (animate) { + animateContentChange(R.id.wallpaper_card, mWallpaperCard, overlay); + } + } + + @Override + protected void loadLockScreen(Cursor c, boolean animate) { + mExternalLockscreenUri = null; + int pkgNameIdx = c.getColumnIndex(ThemesContract.ThemesColumns.PKG_NAME); + if (pkgNameIdx > -1) { + super.loadLockScreen(c, animate); + return; + } + Drawable overlay = null; + if (animate) { + overlay = getOverlayDrawable(mLockScreenCard, true); + } + + //If the current theme includes a lock wallpaper, the WallpaperMgr will + //return a valid Drawable we can display in the card. However, if the user + //picked a LLS, we need to get the path from the provider and manually load the bitmap + int wpIdx = c.getColumnIndex(PreviewColumns.LIVE_LOCK_SCREEN_PREVIEW); + Drawable wp = null; + if (wpIdx >= 0) { + final Resources res = getResources(); + Bitmap bmp = Utils.loadBitmapBlob(c, wpIdx); + if (bmp != null) wp = new BitmapDrawable(res, bmp); + } else { + final Context context = getActivity(); + wp = context == null ? null : + WallpaperManager.getInstance(context).getFastKeyguardDrawable(); + } + if (wp != null) { + mLockScreenCard.setWallpaper(wp); + } else if (!mSelectedComponentsMap.containsKey(ThemesColumns.MODIFIES_LOCKSCREEN)) { + mLockScreenCard.clearWallpaper(); + mLockScreenCard.setEmptyViewEnabled(true); + setAddComponentTitle(mLockScreenCard, getString(R.string.lockscreen_label)); + } + + if (animate) { + animateContentChange(R.id.lockscreen_card, mLockScreenCard, overlay); + } + } + + @Override + protected void loadFont(Cursor c, boolean animate) { + int pkgNameIdx = c.getColumnIndex(ThemesContract.ThemesColumns.PKG_NAME); + if (pkgNameIdx > -1) { + super.loadFont(c, animate); + return; + } + Drawable overlay = null; + if (animate) { + overlay = getOverlayDrawable(mFontPreview, true); + } + setCardTitle(mFontCard, mCurrentTheme.get(ThemesColumns.MODIFIES_FONTS), + getString(R.string.font_label)); + + TypefaceHelperCache cache = TypefaceHelperCache.getInstance(); + ThemedTypefaceHelper helper = cache.getHelperForTheme(getActivity(), + getAppliedFontPackageName()); + mTypefaceNormal = helper.getTypeface(Typeface.NORMAL); + mFontPreview.setTypeface(mTypefaceNormal); + if (animate) { + animateContentChange(R.id.font_preview_container, mFontPreview, overlay); + } + } + + @Override + protected void loadAudible(int type, Cursor c, boolean animate) { + int pkgNameIdx = c.getColumnIndex(ThemesContract.ThemesColumns.PKG_NAME); + if (pkgNameIdx > -1) { + super.loadAudible(type, c, animate); + return; + } + ComponentCardView audibleContainer = null; + ImageView playPause = null; + String modsComponent = ""; + switch (type) { + case RingtoneManager.TYPE_RINGTONE: + audibleContainer = mRingtoneCard; + playPause = mRingtonePlayPause; + modsComponent = ThemesColumns.MODIFIES_RINGTONES; + break; + case RingtoneManager.TYPE_NOTIFICATION: + audibleContainer = mNotificationCard; + playPause = mNotificationPlayPause; + modsComponent = ThemesColumns.MODIFIES_NOTIFICATIONS; + break; + case RingtoneManager.TYPE_ALARM: + audibleContainer = mAlarmCard; + playPause = mAlarmPlayPause; + modsComponent = ThemesColumns.MODIFIES_ALARMS; + break; + } + if (audibleContainer == null) return; + + if (playPause == null) { + playPause = + (ImageView) audibleContainer.findViewById(R.id.play_pause); + } + TextView title = (TextView) audibleContainer.findViewById(R.id.audible_name); + MediaPlayer mp = mMediaPlayers.get(playPause); + if (mp == null) { + mp = new MediaPlayer(); + } + + final Context context = getActivity(); + Ringtone ringtone = null; + try { + Uri ringtoneUri = AudioUtils.loadDefaultAudible(context, type, mp); + if (ringtoneUri != null) ringtone = RingtoneManager.getRingtone(context, ringtoneUri); + } catch (IOException e) { + Log.w(TAG, "Unable to load default sound ", e); + } + + if (ringtone != null) { + title.setText(ringtone.getTitle(context)); + setCardTitle(audibleContainer, mCurrentTheme.get(modsComponent), + getAudibleLabel(type)); + } else { + title.setText(getString(R.string.audible_title_none)); + setAddComponentTitle(audibleContainer, getAudibleLabel(type)); + playPause.setVisibility(View.INVISIBLE); + audibleContainer.setEmptyViewEnabled(true); + } + + playPause.setTag(mp); + mMediaPlayers.put(playPause, mp); + playPause.setOnClickListener(mPlayPauseClickListener); + mp.setOnCompletionListener(mPlayCompletionListener); + } + + @Override + protected void loadStatusBar(Cursor c, boolean animate) { + super.loadStatusBar(c, animate); + setCardTitle(mStatusBarCard, mCurrentTheme.get(ThemesColumns.MODIFIES_STATUS_BAR), + getString(R.string.statusbar_label)); + } + + @Override + protected void loadIcons(Cursor c, boolean animate) { + super.loadIcons(c, animate); + setCardTitle(mIconCard, mCurrentTheme.get(ThemesColumns.MODIFIES_ICONS), + getString(R.string.icon_label)); + } + + @Override + protected void loadNavBar(Cursor c, boolean animate) { + super.loadNavBar(c, animate); + setCardTitle(mNavBarCard, mCurrentTheme.get(ThemesColumns.MODIFIES_NAVIGATION_BAR), + getString(R.string.navbar_label)); + } + + @Override + protected void loadStyle(Cursor c, boolean animate) { + super.loadStyle(c, animate); + setCardTitle(mStyleCard, mCurrentTheme.get(ThemesColumns.MODIFIES_OVERLAYS), + getString(R.string.style_label)); + } + + @Override + protected void loadBootAnimation(Cursor c) { + super.loadBootAnimation(c); + setCardTitle(mBootAnimationCard, mCurrentTheme.get(ThemesColumns.MODIFIES_BOOT_ANIM), + getString(R.string.boot_animation_label)); + } + + @Override + public String getThemePackageName() { + if (mBaseThemePkgName == null) { + // check if the package name is defined in the arguments bundle + Bundle bundle = getArguments(); + if (bundle != null) { + mBaseThemePkgName = bundle.getString(ARG_BASE_THEME_PACKAGE_NAME); + } + } + return mBaseThemePkgName; + } + + private SurfaceView createSurfaceView() { + final Context context = getActivity(); + if (context == null) return null; + + SurfaceView sv = new SurfaceView(context); + final Resources res = context.getResources(); + FrameLayout.LayoutParams params = new FrameLayout.LayoutParams( + res.getDimensionPixelSize(R.dimen.wallpaper_preview_width), + res.getDimensionPixelSize(R.dimen.theme_preview_height), + Gravity.CENTER_HORIZONTAL); + sv.setLayoutParams(params); + + return sv; + } + + private void addSurfaceView(SurfaceView sv) { + if (mShadowFrame.indexOfChild(mSurfaceView) < 0) { + int idx = mShadowFrame.indexOfChild(mWallpaper); + mShadowFrame.addView(sv, idx + 1); + } + } + + private void removeSurfaceView(SurfaceView sv) { + if (mShadowFrame.indexOfChild(mSurfaceView) >= 0) { + mShadowFrame.removeView(sv); + } + } + + /** + * Populates mBaseThemeSupportedComponents. + * @param pkgName Package name of the base theme used + */ + private void populateBaseThemeSupportedComponents(String pkgName) { + String selection = ThemesColumns.PKG_NAME + "=?"; + String[] selectionArgs = { pkgName }; + Cursor c = getActivity().getContentResolver().query(ThemesColumns.CONTENT_URI, + null, selection, selectionArgs, null); + if (c != null) { + if (c.moveToFirst()) { + List<String> components = ThemeUtils.getAllComponents(); + final String baseThemePackageName = getThemePackageName(); + for (String component : components) { + int pkgIdx = c.getColumnIndex(ThemesColumns.PKG_NAME); + int modifiesCompIdx = c.getColumnIndex(component); + + String pkg = pkgIdx >= 0 ? c.getString(pkgIdx) : null; + boolean supported = (modifiesCompIdx >= 0) && (c.getInt(modifiesCompIdx) == 1); + if (supported && baseThemePackageName.equals(pkg)) { + mBaseThemeSupportedComponents.add(component); + } + } + } + c.close(); + } + } +} |