Java tutorial
/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php * * 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.ide.eclipse.adt.internal.preferences; import com.android.annotations.NonNull; import com.android.ide.common.xml.XmlAttributeSortOrder; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode; import com.android.prefs.AndroidLocation.AndroidLocationException; import com.android.sdklib.internal.build.DebugKeyProvider; import com.android.sdklib.internal.build.DebugKeyProvider.KeytoolException; import com.android.sdkstats.DdmsPreferenceStore; import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.util.PropertyChangeEvent; import java.io.File; import java.util.Locale; public final class AdtPrefs extends AbstractPreferenceInitializer { public final static String PREFS_SDK_DIR = AdtPlugin.PLUGIN_ID + ".sdk"; //$NON-NLS-1$ public final static String PREFS_BUILD_RES_AUTO_REFRESH = AdtPlugin.PLUGIN_ID + ".resAutoRefresh"; //$NON-NLS-1$ public final static String PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR = AdtPlugin.PLUGIN_ID + ".forceErrorNativeLibInJar"; //$NON-NLS-1$ public final static String PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE = AdtPlugin.PLUGIN_ID + ".skipPostCompileOnFileSave"; //$NON-NLS-1$ public final static String PREFS_BUILD_VERBOSITY = AdtPlugin.PLUGIN_ID + ".buildVerbosity"; //$NON-NLS-1$ public final static String PREFS_DEFAULT_DEBUG_KEYSTORE = AdtPlugin.PLUGIN_ID + ".defaultDebugKeyStore"; //$NON-NLS-1$ public final static String PREFS_CUSTOM_DEBUG_KEYSTORE = AdtPlugin.PLUGIN_ID + ".customDebugKeyStore"; //$NON-NLS-1$ public final static String PREFS_HOME_PACKAGE = AdtPlugin.PLUGIN_ID + ".homePackage"; //$NON-NLS-1$ public final static String PREFS_EMU_OPTIONS = AdtPlugin.PLUGIN_ID + ".emuOptions"; //$NON-NLS-1$ public final static String PREFS_MONITOR_DENSITY = AdtPlugin.PLUGIN_ID + ".monitorDensity"; //$NON-NLS-1$ public final static String PREFS_FORMAT_GUI_XML = AdtPlugin.PLUGIN_ID + ".formatXml"; //$NON-NLS-1$ public final static String PREFS_PREFER_XML = AdtPlugin.PLUGIN_ID + ".xmlEditor"; //$NON-NLS-1$ public final static String PREFS_USE_CUSTOM_XML_FORMATTER = AdtPlugin.PLUGIN_ID + ".androidForm"; //$NON-NLS-1$ public final static String PREFS_PALETTE_MODE = AdtPlugin.PLUGIN_ID + ".palette"; //$NON-NLS-1$ public final static String PREFS_USE_ECLIPSE_INDENT = AdtPlugin.PLUGIN_ID + ".eclipseIndent"; //$NON-NLS-1$ public final static String PREVS_REMOVE_EMPTY_LINES = AdtPlugin.PLUGIN_ID + ".removeEmpty"; //$NON-NLS-1$ public final static String PREFS_ONE_ATTR_PER_LINE = AdtPlugin.PLUGIN_ID + ".oneAttrPerLine"; //$NON-NLS-1$ public final static String PREFS_SPACE_BEFORE_CLOSE = AdtPlugin.PLUGIN_ID + ".spaceBeforeClose"; //$NON-NLS-1$ public final static String PREFS_FORMAT_ON_SAVE = AdtPlugin.PLUGIN_ID + ".formatOnSave"; //$NON-NLS-1$ public final static String PREFS_LINT_ON_SAVE = AdtPlugin.PLUGIN_ID + ".lintOnSave"; //$NON-NLS-1$ public final static String PREFS_LINT_ON_EXPORT = AdtPlugin.PLUGIN_ID + ".lintOnExport"; //$NON-NLS-1$ public final static String PREFS_ATTRIBUTE_SORT = AdtPlugin.PLUGIN_ID + ".attrSort"; //$NON-NLS-1$ public final static String PREFS_LINT_SEVERITIES = AdtPlugin.PLUGIN_ID + ".lintSeverities"; //$NON-NLS-1$ public final static String PREFS_FIX_LEGACY_EDITORS = AdtPlugin.PLUGIN_ID + ".fixLegacyEditors"; //$NON-NLS-1$ public final static String PREFS_SHARED_LAYOUT_EDITOR = AdtPlugin.PLUGIN_ID + ".sharedLayoutEditor"; //$NON-NLS-1$ public final static String PREFS_PREVIEWS = AdtPlugin.PLUGIN_ID + ".previews"; //$NON-NLS-1$ public final static String PREFS_SKIP_LINT_LIBS = AdtPlugin.PLUGIN_ID + ".skipLintLibs"; //$NON-NLS-1$ public final static String PREFS_AUTO_PICK_TARGET = AdtPlugin.PLUGIN_ID + ".autoPickTarget"; //$NON-NLS-1$ public final static String PREFS_REFACTOR_IDS = AdtPlugin.PLUGIN_ID + ".refactorIds"; //$NON-NLS-1$ /** singleton instance */ private final static AdtPrefs sThis = new AdtPrefs(); /** default store, provided by eclipse */ private IPreferenceStore mStore; /** cached location for the sdk folder */ private String mOsSdkLocation; /** Verbosity of the build */ private BuildVerbosity mBuildVerbosity = BuildVerbosity.NORMAL; private boolean mBuildForceResResfresh = false; private boolean mBuildForceErrorOnNativeLibInJar = true; private boolean mBuildSkipPostCompileOnFileSave = true; private float mMonitorDensity = 0.f; private String mPalette; private boolean mFormatGuiXml; private boolean mCustomXmlFormatter; private boolean mUseEclipseIndent; private boolean mRemoveEmptyLines; private boolean mOneAttributeOnFirstLine; private boolean mSpaceBeforeClose; private boolean mFormatOnSave; private boolean mLintOnSave; private boolean mLintOnExport; private XmlAttributeSortOrder mAttributeSort; private boolean mSharedLayoutEditor; private boolean mAutoPickTarget; private RenderPreviewMode mPreviewMode = RenderPreviewMode.NONE; private int mPreferXmlEditor; private boolean mSkipLibrariesFromLint; public static enum BuildVerbosity { /** Build verbosity "Always". Those messages are always displayed, even in silent mode */ ALWAYS(0), /** Build verbosity level "Normal" */ NORMAL(1), /** Build verbosity level "Verbose". Those messages are only displayed in verbose mode */ VERBOSE(2); private int mLevel; BuildVerbosity(int level) { mLevel = level; } public int getLevel() { return mLevel; } /** * Finds and returns a {@link BuildVerbosity} whose {@link #name()} matches a given name. * <p/>This is different from {@link Enum#valueOf(Class, String)} in that it returns null * if no matches are found. * * @param name the name to look up. * @return returns the matching enum or null of no match where found. */ public static BuildVerbosity find(String name) { for (BuildVerbosity v : values()) { if (v.name().equals(name)) { return v; } } return null; } } public static void init(IPreferenceStore preferenceStore) { sThis.mStore = preferenceStore; } public static AdtPrefs getPrefs() { return sThis; } public synchronized void loadValues(PropertyChangeEvent event) { // get the name of the property that changed, if any String property = event != null ? event.getProperty() : null; if (property == null || PREFS_SDK_DIR.equals(property)) { mOsSdkLocation = mStore.getString(PREFS_SDK_DIR); // Make it possible to override the SDK path using an environment variable. // The value will only be used if it matches an existing directory. // Useful for testing from Eclipse. // Note: this is a hack that does not change the preferences, so if the user // looks at Window > Preferences > Android, the path will be the preferences // one and not the overridden one. String override = System.getenv("ADT_TEST_SDK_PATH"); //$NON-NLS-1$ if (override != null && override.length() > 0 && new File(override).isDirectory()) { mOsSdkLocation = override; } // make sure it ends with a separator. Normally this is done when the preference // is set. But to make sure older version still work, we fix it here as well. if (mOsSdkLocation.length() > 0 && mOsSdkLocation.endsWith(File.separator) == false) { mOsSdkLocation = mOsSdkLocation + File.separator; } } if (property == null || PREFS_BUILD_VERBOSITY.equals(property)) { mBuildVerbosity = BuildVerbosity.find(mStore.getString(PREFS_BUILD_VERBOSITY)); if (mBuildVerbosity == null) { mBuildVerbosity = BuildVerbosity.NORMAL; } } if (property == null || PREFS_BUILD_RES_AUTO_REFRESH.equals(property)) { mBuildForceResResfresh = mStore.getBoolean(PREFS_BUILD_RES_AUTO_REFRESH); } if (property == null || PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR.equals(property)) { mBuildForceErrorOnNativeLibInJar = mStore.getBoolean(PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR); } if (property == null || PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE.equals(property)) { mBuildSkipPostCompileOnFileSave = mStore.getBoolean(PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE); } if (property == null || PREFS_MONITOR_DENSITY.equals(property)) { mMonitorDensity = mStore.getFloat(PREFS_MONITOR_DENSITY); } if (property == null || PREFS_FORMAT_GUI_XML.equals(property)) { mFormatGuiXml = mStore.getBoolean(PREFS_FORMAT_GUI_XML); } if (property == null || PREFS_PREFER_XML.equals(property)) { mPreferXmlEditor = mStore.getInt(PREFS_PREFER_XML); } if (property == null || PREFS_USE_CUSTOM_XML_FORMATTER.equals(property)) { mCustomXmlFormatter = mStore.getBoolean(PREFS_USE_CUSTOM_XML_FORMATTER); } if (property == null || PREFS_PALETTE_MODE.equals(property)) { mPalette = mStore.getString(PREFS_PALETTE_MODE); } if (property == null || PREFS_USE_ECLIPSE_INDENT.equals(property)) { mUseEclipseIndent = mStore.getBoolean(PREFS_USE_ECLIPSE_INDENT); } if (property == null || PREVS_REMOVE_EMPTY_LINES.equals(property)) { mRemoveEmptyLines = mStore.getBoolean(PREVS_REMOVE_EMPTY_LINES); } if (property == null || PREFS_ONE_ATTR_PER_LINE.equals(property)) { mOneAttributeOnFirstLine = mStore.getBoolean(PREFS_ONE_ATTR_PER_LINE); } if (property == null || PREFS_ATTRIBUTE_SORT.equals(property)) { String order = mStore.getString(PREFS_ATTRIBUTE_SORT); mAttributeSort = XmlAttributeSortOrder.LOGICAL; if (XmlAttributeSortOrder.ALPHABETICAL.key.equals(order)) { mAttributeSort = XmlAttributeSortOrder.ALPHABETICAL; } else if (XmlAttributeSortOrder.NO_SORTING.key.equals(order)) { mAttributeSort = XmlAttributeSortOrder.NO_SORTING; } } if (property == null || PREFS_SPACE_BEFORE_CLOSE.equals(property)) { mSpaceBeforeClose = mStore.getBoolean(PREFS_SPACE_BEFORE_CLOSE); } if (property == null || PREFS_FORMAT_ON_SAVE.equals(property)) { mFormatOnSave = mStore.getBoolean(PREFS_FORMAT_ON_SAVE); } if (property == null || PREFS_LINT_ON_SAVE.equals(property)) { mLintOnSave = mStore.getBoolean(PREFS_LINT_ON_SAVE); } if (property == null || PREFS_LINT_ON_EXPORT.equals(property)) { mLintOnExport = mStore.getBoolean(PREFS_LINT_ON_EXPORT); } if (property == null || PREFS_SHARED_LAYOUT_EDITOR.equals(property)) { mSharedLayoutEditor = mStore.getBoolean(PREFS_SHARED_LAYOUT_EDITOR); } if (property == null || PREFS_AUTO_PICK_TARGET.equals(property)) { mAutoPickTarget = mStore.getBoolean(PREFS_AUTO_PICK_TARGET); } if (property == null || PREFS_PREVIEWS.equals(property)) { mPreviewMode = RenderPreviewMode.NONE; String previewMode = mStore.getString(PREFS_PREVIEWS); if (previewMode != null && !previewMode.isEmpty()) { try { mPreviewMode = RenderPreviewMode.valueOf(previewMode.toUpperCase(Locale.US)); } catch (IllegalArgumentException iae) { // Ignore: Leave it as RenderPreviewMode.NONE } } } if (property == null || PREFS_SKIP_LINT_LIBS.equals(property)) { mSkipLibrariesFromLint = mStore.getBoolean(PREFS_SKIP_LINT_LIBS); } } /** * Returns the SDK folder. * Guaranteed to be terminated by a platform-specific path separator. */ public synchronized String getOsSdkFolder() { return mOsSdkLocation; } public synchronized BuildVerbosity getBuildVerbosity() { return mBuildVerbosity; } public boolean getBuildForceResResfresh() { return mBuildForceResResfresh; } /** * Should changes made by GUI editors automatically format the corresponding XML nodes * affected by the edit? * * @return true if the GUI editors should format affected XML regions */ public boolean getFormatGuiXml() { // The format-GUI-editors flag only applies when the custom formatter is used, // since the built-in formatter has problems editing partial documents return mFormatGuiXml && mCustomXmlFormatter; } /** * Should the XML formatter use a custom Android XML formatter (following * Android code style) or use the builtin Eclipse XML formatter? * * @return true if the Android formatter should be used instead of the * default Eclipse one */ public boolean getUseCustomXmlFormatter() { return mCustomXmlFormatter; } /** * Should the Android XML formatter use the Eclipse XML indentation settings * (usually one tab character) instead of the default 4 space character * indent? * * @return true if the Eclipse XML indentation settings should be use */ public boolean isUseEclipseIndent() { return mUseEclipseIndent; } /** * Should the Android XML formatter try to avoid inserting blank lines to * make the format as compact as possible (no blank lines between elements, * no blank lines surrounding comments, etc). * * @return true to remove blank lines */ public boolean isRemoveEmptyLines() { return mRemoveEmptyLines; } /** * Should the Android XML formatter attempt to place a single attribute on * the same line as the element open tag? * * @return true if single-attribute elements should place the attribute on * the same line as the element open tag */ public boolean isOneAttributeOnFirstLine() { return mOneAttributeOnFirstLine; } /** * Returns the sort order to be applied to the attributes (one of which can * be {@link com.android.ide.common.xml.XmlAttributeSortOrder#NO_SORTING}). * * @return the sort order to apply to the attributes */ public XmlAttributeSortOrder getAttributeSort() { if (mAttributeSort == null) { return XmlAttributeSortOrder.LOGICAL; } return mAttributeSort; } /** * Returns whether a space should be inserted before the closing {@code >} * character in open tags and before the closing {@code />} characters in * empty tag. Note that the {@link com.android.ide.common.xml.XmlFormatStyle#RESOURCE} style overrides * this setting to make it more compact for the {@code <item>} elements. * * @return true if an empty space should be inserted before {@code >} or * {@code />}. */ public boolean isSpaceBeforeClose() { return mSpaceBeforeClose; } /** * Returns whether the file should be automatically formatted on save. * * @return true if the XML files should be formatted on save. */ public boolean isFormatOnSave() { return mFormatOnSave; } public boolean isLintOnSave() { return mLintOnSave; } public void setLintOnSave(boolean on) { mLintOnSave = on; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_LINT_ON_SAVE, on); } public boolean isLintOnExport() { return mLintOnExport; } public void setLintOnExport(boolean on) { mLintOnExport = on; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_LINT_ON_EXPORT, on); } /** * Returns whether the layout editor is sharing a single editor for all variations * of a single resource. The default is false. * * @return true if the editor should be shared */ public boolean isSharedLayoutEditor() { return mSharedLayoutEditor; } /** * Sets whether the layout editor should share a single editor for all variations * of a single resource * * @param on if true, use a single editor */ public void setSharedLayoutEditor(boolean on) { mSharedLayoutEditor = on; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_SHARED_LAYOUT_EDITOR, on); // TODO: If enabling a shared editor, go and close all editors that are aliasing // the same resource except for one of them. } public boolean getBuildForceErrorOnNativeLibInJar() { return mBuildForceErrorOnNativeLibInJar; } public boolean getBuildSkipPostCompileOnFileSave() { return mBuildSkipPostCompileOnFileSave; } public String getPaletteModes() { return mPalette; } public void setPaletteModes(String palette) { mPalette = palette; // need to save this new value to the store IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_PALETTE_MODE, palette); } public float getMonitorDensity() { return mMonitorDensity; } public void setMonitorDensity(float density) { mMonitorDensity = density; // need to save this new value to the store IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_MONITOR_DENSITY, density); } /** * Sets the new location of the SDK * * @param location the location of the SDK */ public void setSdkLocation(File location) { mOsSdkLocation = location != null ? location.getPath() : null; // TODO: Also store this location in the .android settings directory // such that we can support using multiple workspaces without asking // over and over. if (mOsSdkLocation != null && mOsSdkLocation.length() > 0) { DdmsPreferenceStore ddmsStore = new DdmsPreferenceStore(); ddmsStore.setLastSdkPath(mOsSdkLocation); } // need to save this new value to the store IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_SDK_DIR, mOsSdkLocation); } @Override public void initializeDefaultPreferences() { IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); initializeStoreWithDefaults(store); } public void initializeStoreWithDefaults(IPreferenceStore store) { store.setDefault(PREFS_BUILD_RES_AUTO_REFRESH, true); store.setDefault(PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR, true); store.setDefault(PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE, true); store.setDefault(PREFS_BUILD_VERBOSITY, BuildVerbosity.ALWAYS.name()); store.setDefault(PREFS_HOME_PACKAGE, "android.process.acore"); //$NON-NLS-1$ store.setDefault(PREFS_MONITOR_DENSITY, 0.f); store.setDefault(PREFS_FORMAT_GUI_XML, true); store.setDefault(PREFS_USE_CUSTOM_XML_FORMATTER, true); store.setDefault(PREFS_ONE_ATTR_PER_LINE, true); store.setDefault(PREFS_SPACE_BEFORE_CLOSE, true); store.setDefault(PREFS_LINT_ON_SAVE, true); store.setDefault(PREFS_LINT_ON_EXPORT, true); store.setDefault(PREFS_AUTO_PICK_TARGET, true); // Defaults already handled; no need to write into map: //store.setDefault(PREFS_ATTRIBUTE_SORT, XmlAttributeSortOrder.LOGICAL.key); //store.setDefault(PREFS_USE_ECLIPSE_INDENT, false); //store.setDefault(PREVS_REMOVE_EMPTY_LINES, false); //store.setDefault(PREFS_FORMAT_ON_SAVE, false); //store.setDefault(PREFS_SHARED_LAYOUT_EDITOR, false); //store.setDefault(PREFS_SKIP_LINT_LIBS, false); try { store.setDefault(PREFS_DEFAULT_DEBUG_KEYSTORE, DebugKeyProvider.getDefaultKeyStoreOsPath()); } catch (KeytoolException e) { AdtPlugin.log(e, "Get default debug keystore path failed"); //$NON-NLS-1$ } catch (AndroidLocationException e) { AdtPlugin.log(e, "Get default debug keystore path failed"); //$NON-NLS-1$ } } /** * Returns whether the most recent page switch was to XML * * @param editorType the editor to check a preference for; corresponds to * one of the persistence class ids returned by * {@link AndroidXmlEditor#getPersistenceCategory} * @return whether the most recent page switch in the given editor was to * XML */ public boolean isXmlEditorPreferred(int editorType) { return (mPreferXmlEditor & editorType) != 0; } /** * Set whether the most recent page switch for a given editor type was to * XML * * @param editorType the editor to check a preference for; corresponds to * one of the persistence class ids returned by * {@link AndroidXmlEditor#getPersistenceCategory} * @param xml whether the last manual page switch in the given editor type * was to XML */ public void setXmlEditorPreferred(int editorType, boolean xml) { if (xml != isXmlEditorPreferred(editorType)) { if (xml) { mPreferXmlEditor |= editorType; } else { mPreferXmlEditor &= ~editorType; } assert ((mPreferXmlEditor & editorType) != 0) == xml; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); store.setValue(PREFS_PREFER_XML, xml); } } /** * Gets the {@link RenderPreviewMode} * * @return the preview mode */ @NonNull public RenderPreviewMode getRenderPreviewMode() { return mPreviewMode; } /** * Sets the {@link RenderPreviewMode} * * @param previewMode the preview mode */ public void setPreviewMode(@NonNull RenderPreviewMode previewMode) { mPreviewMode = previewMode; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); if (previewMode != RenderPreviewMode.NONE) { store.setValue(PREFS_PREVIEWS, previewMode.name().toLowerCase(Locale.US)); } else { store.setToDefault(PREFS_PREVIEWS); } } /** * Sets whether auto-pick render target mode is enabled. * * @return whether the layout editor should automatically pick the best render target */ public boolean isAutoPickRenderTarget() { return mAutoPickTarget; } /** * Sets whether auto-pick render target mode is enabled. * * @param autoPick if true, auto pick the best render target in the layout editor */ public void setAutoPickRenderTarget(boolean autoPick) { mAutoPickTarget = autoPick; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); if (autoPick) { store.setToDefault(PREFS_AUTO_PICK_TARGET); } else { store.setValue(PREFS_AUTO_PICK_TARGET, autoPick); } } /** * Sets whether libraries should be excluded when running lint on a project * * @param exclude if true, exclude library projects */ public void setSkipLibrariesFromLint(boolean exclude) { if (exclude != mSkipLibrariesFromLint) { mSkipLibrariesFromLint = exclude; IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); if (exclude) { store.setValue(PREFS_SKIP_LINT_LIBS, true); } else { store.setToDefault(PREFS_SKIP_LINT_LIBS); } } } /** * Returns whether libraries should be excluded when running lint on a project * * @return if true, exclude library projects */ public boolean getSkipLibrariesFromLint() { return mSkipLibrariesFromLint; } }