Home | History | Annotate | Download | only in preferences 
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Eclipse Public License, Version 1.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.eclipse.org/org/documents/epl-v10.php
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.ide.eclipse.adt.internal.preferences;
     18 
     19 
     20 import com.android.annotations.NonNull;
     21 import com.android.ide.common.xml.XmlAttributeSortOrder;
     22 import com.android.ide.eclipse.adt.AdtPlugin;
     23 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
     24 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode;
     25 import com.android.prefs.AndroidLocation.AndroidLocationException;
     26 import com.android.sdklib.internal.build.DebugKeyProvider;
     27 import com.android.sdklib.internal.build.DebugKeyProvider.KeytoolException;
     28 import com.android.sdkstats.DdmsPreferenceStore;
     29 
     30 import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
     31 import org.eclipse.jface.preference.IPreferenceStore;
     32 import org.eclipse.jface.util.PropertyChangeEvent;
     33 
     34 import java.io.File;
     35 import java.util.Locale;
     36 
     37 public final class AdtPrefs extends AbstractPreferenceInitializer {
     38     public final static String PREFS_SDK_DIR = AdtPlugin.PLUGIN_ID + ".sdk"; //$NON-NLS-1$
     39 
     40     public final static String PREFS_BUILD_RES_AUTO_REFRESH = AdtPlugin.PLUGIN_ID + ".resAutoRefresh"; //$NON-NLS-1$
     41 
     42     public final static String PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR = AdtPlugin.PLUGIN_ID + ".forceErrorNativeLibInJar"; //$NON-NLS-1$
     43 
     44     public final static String PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE = AdtPlugin.PLUGIN_ID + ".skipPostCompileOnFileSave"; //$NON-NLS-1$
     45 
     46     public final static String PREFS_BUILD_VERBOSITY = AdtPlugin.PLUGIN_ID + ".buildVerbosity"; //$NON-NLS-1$
     47 
     48     public final static String PREFS_DEFAULT_DEBUG_KEYSTORE = AdtPlugin.PLUGIN_ID + ".defaultDebugKeyStore"; //$NON-NLS-1$
     49 
     50     public final static String PREFS_CUSTOM_DEBUG_KEYSTORE = AdtPlugin.PLUGIN_ID + ".customDebugKeyStore"; //$NON-NLS-1$
     51 
     52     public final static String PREFS_HOME_PACKAGE = AdtPlugin.PLUGIN_ID + ".homePackage"; //$NON-NLS-1$
     53 
     54     public final static String PREFS_EMU_OPTIONS = AdtPlugin.PLUGIN_ID + ".emuOptions"; //$NON-NLS-1$
     55 
     56     public final static String PREFS_MONITOR_DENSITY = AdtPlugin.PLUGIN_ID + ".monitorDensity"; //$NON-NLS-1$
     57 
     58     public final static String PREFS_FORMAT_GUI_XML = AdtPlugin.PLUGIN_ID + ".formatXml"; //$NON-NLS-1$
     59     public final static String PREFS_PREFER_XML = AdtPlugin.PLUGIN_ID + ".xmlEditor"; //$NON-NLS-1$
     60     public final static String PREFS_USE_CUSTOM_XML_FORMATTER = AdtPlugin.PLUGIN_ID + ".androidForm"; //$NON-NLS-1$
     61 
     62     public final static String PREFS_PALETTE_MODE = AdtPlugin.PLUGIN_ID + ".palette"; //$NON-NLS-1$
     63 
     64     public final static String PREFS_USE_ECLIPSE_INDENT = AdtPlugin.PLUGIN_ID + ".eclipseIndent"; //$NON-NLS-1$
     65     public final static String PREVS_REMOVE_EMPTY_LINES = AdtPlugin.PLUGIN_ID + ".removeEmpty"; //$NON-NLS-1$
     66     public final static String PREFS_ONE_ATTR_PER_LINE = AdtPlugin.PLUGIN_ID + ".oneAttrPerLine"; //$NON-NLS-1$
     67     public final static String PREFS_SPACE_BEFORE_CLOSE = AdtPlugin.PLUGIN_ID + ".spaceBeforeClose"; //$NON-NLS-1$
     68     public final static String PREFS_FORMAT_ON_SAVE = AdtPlugin.PLUGIN_ID + ".formatOnSave"; //$NON-NLS-1$
     69     public final static String PREFS_LINT_ON_SAVE = AdtPlugin.PLUGIN_ID + ".lintOnSave"; //$NON-NLS-1$
     70     public final static String PREFS_LINT_ON_EXPORT = AdtPlugin.PLUGIN_ID + ".lintOnExport"; //$NON-NLS-1$
     71     public final static String PREFS_ATTRIBUTE_SORT = AdtPlugin.PLUGIN_ID + ".attrSort"; //$NON-NLS-1$
     72     public final static String PREFS_LINT_SEVERITIES = AdtPlugin.PLUGIN_ID + ".lintSeverities"; //$NON-NLS-1$
     73     public final static String PREFS_FIX_LEGACY_EDITORS = AdtPlugin.PLUGIN_ID + ".fixLegacyEditors"; //$NON-NLS-1$
     74     public final static String PREFS_SHARED_LAYOUT_EDITOR = AdtPlugin.PLUGIN_ID + ".sharedLayoutEditor"; //$NON-NLS-1$
     75     public final static String PREFS_PREVIEWS = AdtPlugin.PLUGIN_ID + ".previews"; //$NON-NLS-1$
     76     public final static String PREFS_SKIP_LINT_LIBS = AdtPlugin.PLUGIN_ID + ".skipLintLibs"; //$NON-NLS-1$
     77     public final static String PREFS_AUTO_PICK_TARGET = AdtPlugin.PLUGIN_ID + ".autoPickTarget"; //$NON-NLS-1$
     78     public final static String PREFS_REFACTOR_IDS = AdtPlugin.PLUGIN_ID + ".refactorIds"; //$NON-NLS-1$
     79 
     80     /** singleton instance */
     81     private final static AdtPrefs sThis = new AdtPrefs();
     82 
     83     /** default store, provided by eclipse */
     84     private IPreferenceStore mStore;
     85 
     86     /** cached location for the sdk folder */
     87     private String mOsSdkLocation;
     88 
     89     /** Verbosity of the build */
     90     private BuildVerbosity mBuildVerbosity = BuildVerbosity.NORMAL;
     91 
     92     private boolean mBuildForceResResfresh = false;
     93     private boolean mBuildForceErrorOnNativeLibInJar = true;
     94     private boolean mBuildSkipPostCompileOnFileSave = true;
     95     private float mMonitorDensity = 0.f;
     96     private String mPalette;
     97 
     98     private boolean mFormatGuiXml;
     99     private boolean mCustomXmlFormatter;
    100     private boolean mUseEclipseIndent;
    101     private boolean mRemoveEmptyLines;
    102     private boolean mOneAttributeOnFirstLine;
    103     private boolean mSpaceBeforeClose;
    104     private boolean mFormatOnSave;
    105     private boolean mLintOnSave;
    106     private boolean mLintOnExport;
    107     private XmlAttributeSortOrder mAttributeSort;
    108     private boolean mSharedLayoutEditor;
    109     private boolean mAutoPickTarget;
    110     private RenderPreviewMode mPreviewMode = RenderPreviewMode.NONE;
    111     private int mPreferXmlEditor;
    112     private boolean mSkipLibrariesFromLint;
    113 
    114     public static enum BuildVerbosity {
    115         /** Build verbosity "Always". Those messages are always displayed, even in silent mode */
    116         ALWAYS(0),
    117         /** Build verbosity level "Normal" */
    118         NORMAL(1),
    119         /** Build verbosity level "Verbose". Those messages are only displayed in verbose mode */
    120         VERBOSE(2);
    121 
    122         private int mLevel;
    123 
    124         BuildVerbosity(int level) {
    125             mLevel = level;
    126         }
    127 
    128         public int getLevel() {
    129             return mLevel;
    130         }
    131 
    132         /**
    133          * Finds and returns a {@link BuildVerbosity} whose {@link #name()} matches a given name.
    134          * <p/>This is different from {@link Enum#valueOf(Class, String)} in that it returns null
    135          * if no matches are found.
    136          *
    137          * @param name the name to look up.
    138          * @return returns the matching enum or null of no match where found.
    139          */
    140         public static BuildVerbosity find(String name) {
    141             for (BuildVerbosity v : values()) {
    142                 if (v.name().equals(name)) {
    143                     return v;
    144                 }
    145             }
    146 
    147             return null;
    148         }
    149     }
    150 
    151     public static void init(IPreferenceStore preferenceStore) {
    152         sThis.mStore = preferenceStore;
    153     }
    154 
    155     public static AdtPrefs getPrefs() {
    156         return sThis;
    157     }
    158 
    159     public synchronized void loadValues(PropertyChangeEvent event) {
    160         // get the name of the property that changed, if any
    161         String property = event != null ? event.getProperty() : null;
    162 
    163         if (property == null || PREFS_SDK_DIR.equals(property)) {
    164             mOsSdkLocation = mStore.getString(PREFS_SDK_DIR);
    165 
    166             // Make it possible to override the SDK path using an environment variable.
    167             // The value will only be used if it matches an existing directory.
    168             // Useful for testing from Eclipse.
    169             // Note: this is a hack that does not change the preferences, so if the user
    170             // looks at Window > Preferences > Android, the path will be the preferences
    171             // one and not the overridden one.
    172             String override = System.getenv("ADT_TEST_SDK_PATH");   //$NON-NLS-1$
    173             if (override != null && override.length() > 0 && new File(override).isDirectory()) {
    174                 mOsSdkLocation = override;
    175             }
    176 
    177             // make sure it ends with a separator. Normally this is done when the preference
    178             // is set. But to make sure older version still work, we fix it here as well.
    179             if (mOsSdkLocation.length() > 0 && mOsSdkLocation.endsWith(File.separator) == false) {
    180                 mOsSdkLocation = mOsSdkLocation + File.separator;
    181             }
    182         }
    183 
    184         if (property == null || PREFS_BUILD_VERBOSITY.equals(property)) {
    185             mBuildVerbosity = BuildVerbosity.find(mStore.getString(PREFS_BUILD_VERBOSITY));
    186             if (mBuildVerbosity == null) {
    187                 mBuildVerbosity = BuildVerbosity.NORMAL;
    188             }
    189         }
    190 
    191         if (property == null || PREFS_BUILD_RES_AUTO_REFRESH.equals(property)) {
    192             mBuildForceResResfresh = mStore.getBoolean(PREFS_BUILD_RES_AUTO_REFRESH);
    193         }
    194 
    195         if (property == null || PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR.equals(property)) {
    196             mBuildForceErrorOnNativeLibInJar =
    197                     mStore.getBoolean(PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR);
    198         }
    199 
    200         if (property == null || PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE.equals(property)) {
    201             mBuildSkipPostCompileOnFileSave =
    202                 mStore.getBoolean(PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE);
    203         }
    204 
    205         if (property == null || PREFS_MONITOR_DENSITY.equals(property)) {
    206             mMonitorDensity = mStore.getFloat(PREFS_MONITOR_DENSITY);
    207         }
    208 
    209         if (property == null || PREFS_FORMAT_GUI_XML.equals(property)) {
    210             mFormatGuiXml = mStore.getBoolean(PREFS_FORMAT_GUI_XML);
    211         }
    212 
    213         if (property == null || PREFS_PREFER_XML.equals(property)) {
    214             mPreferXmlEditor = mStore.getInt(PREFS_PREFER_XML);
    215         }
    216 
    217         if (property == null || PREFS_USE_CUSTOM_XML_FORMATTER.equals(property)) {
    218             mCustomXmlFormatter = mStore.getBoolean(PREFS_USE_CUSTOM_XML_FORMATTER);
    219         }
    220 
    221         if (property == null || PREFS_PALETTE_MODE.equals(property)) {
    222             mPalette = mStore.getString(PREFS_PALETTE_MODE);
    223         }
    224 
    225         if (property == null || PREFS_USE_ECLIPSE_INDENT.equals(property)) {
    226             mUseEclipseIndent = mStore.getBoolean(PREFS_USE_ECLIPSE_INDENT);
    227         }
    228 
    229         if (property == null || PREVS_REMOVE_EMPTY_LINES.equals(property)) {
    230             mRemoveEmptyLines = mStore.getBoolean(PREVS_REMOVE_EMPTY_LINES);
    231         }
    232 
    233         if (property == null || PREFS_ONE_ATTR_PER_LINE.equals(property)) {
    234             mOneAttributeOnFirstLine = mStore.getBoolean(PREFS_ONE_ATTR_PER_LINE);
    235         }
    236 
    237         if (property == null || PREFS_ATTRIBUTE_SORT.equals(property)) {
    238             String order = mStore.getString(PREFS_ATTRIBUTE_SORT);
    239             mAttributeSort = XmlAttributeSortOrder.LOGICAL;
    240             if (XmlAttributeSortOrder.ALPHABETICAL.key.equals(order)) {
    241                 mAttributeSort = XmlAttributeSortOrder.ALPHABETICAL;
    242             } else if (XmlAttributeSortOrder.NO_SORTING.key.equals(order)) {
    243                 mAttributeSort = XmlAttributeSortOrder.NO_SORTING;
    244             }
    245         }
    246 
    247         if (property == null || PREFS_SPACE_BEFORE_CLOSE.equals(property)) {
    248             mSpaceBeforeClose = mStore.getBoolean(PREFS_SPACE_BEFORE_CLOSE);
    249         }
    250 
    251         if (property == null || PREFS_FORMAT_ON_SAVE.equals(property)) {
    252             mFormatOnSave = mStore.getBoolean(PREFS_FORMAT_ON_SAVE);
    253         }
    254 
    255         if (property == null || PREFS_LINT_ON_SAVE.equals(property)) {
    256             mLintOnSave = mStore.getBoolean(PREFS_LINT_ON_SAVE);
    257         }
    258 
    259         if (property == null || PREFS_LINT_ON_EXPORT.equals(property)) {
    260             mLintOnExport = mStore.getBoolean(PREFS_LINT_ON_EXPORT);
    261         }
    262 
    263         if (property == null || PREFS_SHARED_LAYOUT_EDITOR.equals(property)) {
    264             mSharedLayoutEditor = mStore.getBoolean(PREFS_SHARED_LAYOUT_EDITOR);
    265         }
    266 
    267         if (property == null || PREFS_AUTO_PICK_TARGET.equals(property)) {
    268             mAutoPickTarget = mStore.getBoolean(PREFS_AUTO_PICK_TARGET);
    269         }
    270 
    271         if (property == null || PREFS_PREVIEWS.equals(property)) {
    272             mPreviewMode = RenderPreviewMode.NONE;
    273             String previewMode = mStore.getString(PREFS_PREVIEWS);
    274             if (previewMode != null && !previewMode.isEmpty()) {
    275                 try {
    276                     mPreviewMode = RenderPreviewMode.valueOf(previewMode.toUpperCase(Locale.US));
    277                 } catch (IllegalArgumentException iae) {
    278                     // Ignore: Leave it as RenderPreviewMode.NONE
    279                 }
    280             }
    281         }
    282 
    283         if (property == null || PREFS_SKIP_LINT_LIBS.equals(property)) {
    284             mSkipLibrariesFromLint = mStore.getBoolean(PREFS_SKIP_LINT_LIBS);
    285         }
    286     }
    287 
    288     /**
    289      * Returns the SDK folder.
    290      * Guaranteed to be terminated by a platform-specific path separator.
    291      */
    292     public synchronized String getOsSdkFolder() {
    293         return mOsSdkLocation;
    294     }
    295 
    296     public synchronized BuildVerbosity getBuildVerbosity() {
    297         return mBuildVerbosity;
    298     }
    299 
    300     public boolean getBuildForceResResfresh() {
    301         return mBuildForceResResfresh;
    302     }
    303 
    304     /**
    305      * Should changes made by GUI editors automatically format the corresponding XML nodes
    306      * affected by the edit?
    307      *
    308      * @return true if the GUI editors should format affected XML regions
    309      */
    310     public boolean getFormatGuiXml() {
    311         // The format-GUI-editors flag only applies when the custom formatter is used,
    312         // since the built-in formatter has problems editing partial documents
    313         return mFormatGuiXml && mCustomXmlFormatter;
    314     }
    315 
    316     /**
    317      * Should the XML formatter use a custom Android XML formatter (following
    318      * Android code style) or use the builtin Eclipse XML formatter?
    319      *
    320      * @return true if the Android formatter should be used instead of the
    321      *         default Eclipse one
    322      */
    323     public boolean getUseCustomXmlFormatter() {
    324         return mCustomXmlFormatter;
    325     }
    326 
    327     /**
    328      * Should the Android XML formatter use the Eclipse XML indentation settings
    329      * (usually one tab character) instead of the default 4 space character
    330      * indent?
    331      *
    332      * @return true if the Eclipse XML indentation settings should be use
    333      */
    334     public boolean isUseEclipseIndent() {
    335         return mUseEclipseIndent;
    336     }
    337 
    338     /**
    339      * Should the Android XML formatter try to avoid inserting blank lines to
    340      * make the format as compact as possible (no blank lines between elements,
    341      * no blank lines surrounding comments, etc).
    342      *
    343      * @return true to remove blank lines
    344      */
    345     public boolean isRemoveEmptyLines() {
    346         return mRemoveEmptyLines;
    347     }
    348 
    349     /**
    350      * Should the Android XML formatter attempt to place a single attribute on
    351      * the same line as the element open tag?
    352      *
    353      * @return true if single-attribute elements should place the attribute on
    354      *         the same line as the element open tag
    355      */
    356     public boolean isOneAttributeOnFirstLine() {
    357         return mOneAttributeOnFirstLine;
    358     }
    359 
    360     /**
    361      * Returns the sort order to be applied to the attributes (one of which can
    362      * be {@link com.android.ide.common.xml.XmlAttributeSortOrder#NO_SORTING}).
    363      *
    364      * @return the sort order to apply to the attributes
    365      */
    366     public XmlAttributeSortOrder getAttributeSort() {
    367         if (mAttributeSort == null) {
    368             return XmlAttributeSortOrder.LOGICAL;
    369         }
    370         return mAttributeSort;
    371     }
    372 
    373     /**
    374      * Returns whether a space should be inserted before the closing {@code >}
    375      * character in open tags and before the closing {@code />} characters in
    376      * empty tag. Note that the {@link com.android.ide.common.xml.XmlFormatStyle#RESOURCE} style overrides
    377      * this setting to make it more compact for the {@code <item>} elements.
    378      *
    379      * @return true if an empty space should be inserted before {@code >} or
    380      *         {@code />}.
    381      */
    382     public boolean isSpaceBeforeClose() {
    383         return mSpaceBeforeClose;
    384     }
    385 
    386     /**
    387      * Returns whether the file should be automatically formatted on save.
    388      *
    389      * @return true if the XML files should be formatted on save.
    390      */
    391     public boolean isFormatOnSave() {
    392         return mFormatOnSave;
    393     }
    394 
    395     public boolean isLintOnSave() {
    396         return mLintOnSave;
    397     }
    398 
    399     public void setLintOnSave(boolean on) {
    400         mLintOnSave = on;
    401         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    402         store.setValue(PREFS_LINT_ON_SAVE, on);
    403     }
    404 
    405     public boolean isLintOnExport() {
    406         return mLintOnExport;
    407     }
    408 
    409     public void setLintOnExport(boolean on) {
    410         mLintOnExport = on;
    411         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    412         store.setValue(PREFS_LINT_ON_EXPORT, on);
    413     }
    414 
    415     /**
    416      * Returns whether the layout editor is sharing a single editor for all variations
    417      * of a single resource. The default is false.
    418      *
    419      * @return true if the editor should be shared
    420      */
    421     public boolean isSharedLayoutEditor() {
    422         return mSharedLayoutEditor;
    423     }
    424 
    425     /**
    426      * Sets whether the layout editor should share a single editor for all variations
    427      * of a single resource
    428      *
    429      * @param on if true, use a single editor
    430      */
    431     public void setSharedLayoutEditor(boolean on) {
    432         mSharedLayoutEditor = on;
    433         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    434         store.setValue(PREFS_SHARED_LAYOUT_EDITOR, on);
    435 
    436         // TODO: If enabling a shared editor, go and close all editors that are aliasing
    437         // the same resource except for one of them.
    438     }
    439 
    440 
    441     public boolean getBuildForceErrorOnNativeLibInJar() {
    442         return mBuildForceErrorOnNativeLibInJar;
    443     }
    444 
    445     public boolean getBuildSkipPostCompileOnFileSave() {
    446         return mBuildSkipPostCompileOnFileSave;
    447     }
    448 
    449     public String getPaletteModes() {
    450         return mPalette;
    451     }
    452 
    453     public void setPaletteModes(String palette) {
    454         mPalette = palette;
    455 
    456         // need to save this new value to the store
    457         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    458         store.setValue(PREFS_PALETTE_MODE, palette);
    459     }
    460 
    461     public float getMonitorDensity() {
    462         return mMonitorDensity;
    463     }
    464 
    465     public void setMonitorDensity(float density) {
    466         mMonitorDensity = density;
    467 
    468         // need to save this new value to the store
    469         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    470         store.setValue(PREFS_MONITOR_DENSITY, density);
    471     }
    472 
    473     /**
    474      * Sets the new location of the SDK
    475      *
    476      * @param location the location of the SDK
    477      */
    478     public void setSdkLocation(File location) {
    479         mOsSdkLocation = location != null ? location.getPath() : null;
    480 
    481         // TODO: Also store this location in the .android settings directory
    482         // such that we can support using multiple workspaces without asking
    483         // over and over.
    484         if (mOsSdkLocation != null && mOsSdkLocation.length() > 0) {
    485             DdmsPreferenceStore ddmsStore = new DdmsPreferenceStore();
    486             ddmsStore.setLastSdkPath(mOsSdkLocation);
    487         }
    488 
    489         // need to save this new value to the store
    490         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    491         store.setValue(PREFS_SDK_DIR, mOsSdkLocation);
    492     }
    493 
    494     @Override
    495     public void initializeDefaultPreferences() {
    496         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    497         initializeStoreWithDefaults(store);
    498     }
    499 
    500     public void initializeStoreWithDefaults(IPreferenceStore store) {
    501         store.setDefault(PREFS_BUILD_RES_AUTO_REFRESH, true);
    502         store.setDefault(PREFS_BUILD_FORCE_ERROR_ON_NATIVELIB_IN_JAR, true);
    503         store.setDefault(PREFS_BUILD_SKIP_POST_COMPILE_ON_FILE_SAVE, true);
    504 
    505         store.setDefault(PREFS_BUILD_VERBOSITY, BuildVerbosity.ALWAYS.name());
    506 
    507         store.setDefault(PREFS_HOME_PACKAGE, "android.process.acore"); //$NON-NLS-1$
    508 
    509         store.setDefault(PREFS_MONITOR_DENSITY, 0.f);
    510 
    511         store.setDefault(PREFS_FORMAT_GUI_XML, true);
    512         store.setDefault(PREFS_USE_CUSTOM_XML_FORMATTER, true);
    513         store.setDefault(PREFS_ONE_ATTR_PER_LINE, true);
    514         store.setDefault(PREFS_SPACE_BEFORE_CLOSE, true);
    515         store.setDefault(PREFS_LINT_ON_SAVE, true);
    516         store.setDefault(PREFS_LINT_ON_EXPORT, true);
    517         store.setDefault(PREFS_AUTO_PICK_TARGET, true);
    518 
    519         // Defaults already handled; no need to write into map:
    520         //store.setDefault(PREFS_ATTRIBUTE_SORT, XmlAttributeSortOrder.LOGICAL.key);
    521         //store.setDefault(PREFS_USE_ECLIPSE_INDENT, false);
    522         //store.setDefault(PREVS_REMOVE_EMPTY_LINES, false);
    523         //store.setDefault(PREFS_FORMAT_ON_SAVE, false);
    524         //store.setDefault(PREFS_SHARED_LAYOUT_EDITOR, false);
    525         //store.setDefault(PREFS_SKIP_LINT_LIBS, false);
    526 
    527         try {
    528             store.setDefault(PREFS_DEFAULT_DEBUG_KEYSTORE,
    529                     DebugKeyProvider.getDefaultKeyStoreOsPath());
    530         } catch (KeytoolException e) {
    531             AdtPlugin.log(e, "Get default debug keystore path failed"); //$NON-NLS-1$
    532         } catch (AndroidLocationException e) {
    533             AdtPlugin.log(e, "Get default debug keystore path failed"); //$NON-NLS-1$
    534         }
    535     }
    536 
    537     /**
    538      * Returns whether the most recent page switch was to XML
    539      *
    540      * @param editorType the editor to check a preference for; corresponds to
    541      *            one of the persistence class ids returned by
    542      *            {@link AndroidXmlEditor#getPersistenceCategory}
    543      * @return whether the most recent page switch in the given editor was to
    544      *         XML
    545      */
    546     public boolean isXmlEditorPreferred(int editorType) {
    547         return (mPreferXmlEditor & editorType) != 0;
    548     }
    549 
    550     /**
    551      * Set whether the most recent page switch for a given editor type was to
    552      * XML
    553      *
    554      * @param editorType the editor to check a preference for; corresponds to
    555      *            one of the persistence class ids returned by
    556      *            {@link AndroidXmlEditor#getPersistenceCategory}
    557      * @param xml whether the last manual page switch in the given editor type
    558      *            was to XML
    559      */
    560     public void setXmlEditorPreferred(int editorType, boolean xml) {
    561         if (xml != isXmlEditorPreferred(editorType)) {
    562             if (xml) {
    563                 mPreferXmlEditor |= editorType;
    564             } else {
    565                 mPreferXmlEditor &= ~editorType;
    566             }
    567             assert ((mPreferXmlEditor & editorType) != 0) == xml;
    568             IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    569             store.setValue(PREFS_PREFER_XML, xml);
    570         }
    571     }
    572 
    573     /**
    574      * Gets the {@link RenderPreviewMode}
    575      *
    576      * @return the preview mode
    577      */
    578     @NonNull
    579     public RenderPreviewMode getRenderPreviewMode() {
    580         return mPreviewMode;
    581     }
    582 
    583     /**
    584      * Sets the {@link RenderPreviewMode}
    585      *
    586      * @param previewMode the preview mode
    587      */
    588     public void setPreviewMode(@NonNull RenderPreviewMode previewMode) {
    589         mPreviewMode = previewMode;
    590         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    591         if (previewMode != RenderPreviewMode.NONE) {
    592             store.setValue(PREFS_PREVIEWS, previewMode.name().toLowerCase(Locale.US));
    593         } else {
    594             store.setToDefault(PREFS_PREVIEWS);
    595         }
    596     }
    597 
    598     /**
    599      * Sets whether auto-pick render target mode is enabled.
    600      *
    601      * @return whether the layout editor should automatically pick the best render target
    602      */
    603     public boolean isAutoPickRenderTarget() {
    604         return mAutoPickTarget;
    605     }
    606 
    607     /**
    608      * Sets whether auto-pick render target mode is enabled.
    609      *
    610      * @param autoPick if true, auto pick the best render target in the layout editor
    611      */
    612     public void setAutoPickRenderTarget(boolean autoPick) {
    613         mAutoPickTarget = autoPick;
    614         IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    615         if (autoPick) {
    616             store.setToDefault(PREFS_AUTO_PICK_TARGET);
    617         } else {
    618             store.setValue(PREFS_AUTO_PICK_TARGET, autoPick);
    619         }
    620     }
    621 
    622     /**
    623      * Sets whether libraries should be excluded when running lint on a project
    624      *
    625      * @param exclude if true, exclude library projects
    626      */
    627     public void setSkipLibrariesFromLint(boolean exclude) {
    628         if (exclude != mSkipLibrariesFromLint) {
    629             mSkipLibrariesFromLint = exclude;
    630             IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore();
    631             if (exclude) {
    632                 store.setValue(PREFS_SKIP_LINT_LIBS, true);
    633             } else {
    634                 store.setToDefault(PREFS_SKIP_LINT_LIBS);
    635             }
    636         }
    637     }
    638 
    639     /**
    640      * Returns whether libraries should be excluded when running lint on a project
    641      *
    642      * @return if true, exclude library projects
    643      */
    644     public boolean getSkipLibrariesFromLint() {
    645         return mSkipLibrariesFromLint;
    646     }
    647 }
    648