diff --git a/config/hiddenapi-light-greylist.txt b/config/hiddenapi-light-greylist.txt
index c8c5420..30fd814 100644
--- a/config/hiddenapi-light-greylist.txt
+++ b/config/hiddenapi-light-greylist.txt
@@ -1679,80 +1679,6 @@
 Landroid/os/WorkSource;->updateLocked(Landroid/os/WorkSource;ZZ)Z
 Landroid/os/ZygoteStartFailedEx;-><init>(Ljava/lang/String;)V
 Landroid/os/ZygoteStartFailedEx;-><init>(Ljava/lang/Throwable;)V
-Landroid/preference/DialogPreference;->mBuilder:Landroid/app/AlertDialog$Builder;
-Landroid/preference/DialogPreference;->mDialog:Landroid/app/Dialog;
-Landroid/preference/DialogPreference;->mDialogIcon:Landroid/graphics/drawable/Drawable;
-Landroid/preference/DialogPreference;->mDialogMessage:Ljava/lang/CharSequence;
-Landroid/preference/DialogPreference;->mDialogTitle:Ljava/lang/CharSequence;
-Landroid/preference/DialogPreference;->mNegativeButtonText:Ljava/lang/CharSequence;
-Landroid/preference/DialogPreference;->mPositiveButtonText:Ljava/lang/CharSequence;
-Landroid/preference/DialogPreference;->mWhichButtonClicked:I
-Landroid/preference/EditTextPreference;->mEditText:Landroid/widget/EditText;
-Landroid/preference/ListPreference;->mClickedDialogEntryIndex:I
-Landroid/preference/Preference;->getId()J
-Landroid/preference/Preference;->mLayoutResId:I
-Landroid/preference/Preference;->mSummary:Ljava/lang/CharSequence;
-Landroid/preference/Preference;->mWidgetLayoutResId:I
-Landroid/preference/Preference;->onKey(Landroid/view/View;ILandroid/view/KeyEvent;)Z
-Landroid/preference/Preference;->performClick(Landroid/preference/PreferenceScreen;)V
-Landroid/preference/Preference;->registerDependent(Landroid/preference/Preference;)V
-Landroid/preference/Preference;->setOnPreferenceChangeInternalListener(Landroid/preference/Preference$OnPreferenceChangeInternalListener;)V
-Landroid/preference/PreferenceActivity;->getHeaders()Ljava/util/List;
-Landroid/preference/PreferenceActivity;->mPreferenceManager:Landroid/preference/PreferenceManager;
-Landroid/preference/PreferenceActivity;->mPrefsContainer:Landroid/view/ViewGroup;
-Landroid/preference/PreferenceActivity;->postBindPreferences()V
-Landroid/preference/PreferenceActivity;->requirePreferenceManager()V
-Landroid/preference/PreferenceFragment;->getListView()Landroid/widget/ListView;
-Landroid/preference/PreferenceFragment;->mPreferenceManager:Landroid/preference/PreferenceManager;
-Landroid/preference/PreferenceManager;-><init>(Landroid/app/Activity;I)V
-Landroid/preference/PreferenceManager;-><init>(Landroid/content/Context;)V
-Landroid/preference/PreferenceManager;->dispatchActivityDestroy()V
-Landroid/preference/PreferenceManager;->dispatchActivityResult(IILandroid/content/Intent;)V
-Landroid/preference/PreferenceManager;->dispatchActivityStop()V
-Landroid/preference/PreferenceManager;->getActivity()Landroid/app/Activity;
-Landroid/preference/PreferenceManager;->getEditor()Landroid/content/SharedPreferences$Editor;
-Landroid/preference/PreferenceManager;->getFragment()Landroid/preference/PreferenceFragment;
-Landroid/preference/PreferenceManager;->getNextRequestCode()I
-Landroid/preference/PreferenceManager;->getPreferenceScreen()Landroid/preference/PreferenceScreen;
-Landroid/preference/PreferenceManager;->inflateFromIntent(Landroid/content/Intent;Landroid/preference/PreferenceScreen;)Landroid/preference/PreferenceScreen;
-Landroid/preference/PreferenceManager;->inflateFromResource(Landroid/content/Context;ILandroid/preference/PreferenceScreen;)Landroid/preference/PreferenceScreen;
-Landroid/preference/PreferenceManager;->mActivityDestroyListeners:Ljava/util/List;
-Landroid/preference/PreferenceManager;->mFragment:Landroid/preference/PreferenceFragment;
-Landroid/preference/PreferenceManager;->mOnPreferenceTreeClickListener:Landroid/preference/PreferenceManager$OnPreferenceTreeClickListener;
-Landroid/preference/PreferenceManager;->mSharedPreferences:Landroid/content/SharedPreferences;
-Landroid/preference/PreferenceManager;->registerOnActivityDestroyListener(Landroid/preference/PreferenceManager$OnActivityDestroyListener;)V
-Landroid/preference/PreferenceManager;->registerOnActivityResultListener(Landroid/preference/PreferenceManager$OnActivityResultListener;)V
-Landroid/preference/PreferenceManager;->registerOnActivityStopListener(Landroid/preference/PreferenceManager$OnActivityStopListener;)V
-Landroid/preference/PreferenceManager;->setFragment(Landroid/preference/PreferenceFragment;)V
-Landroid/preference/PreferenceManager;->setNoCommit(Z)V
-Landroid/preference/PreferenceManager;->setPreferences(Landroid/preference/PreferenceScreen;)Z
-Landroid/preference/PreferenceManager;->shouldCommit()Z
-Landroid/preference/PreferenceManager;->unregisterOnActivityDestroyListener(Landroid/preference/PreferenceManager$OnActivityDestroyListener;)V
-Landroid/preference/PreferenceManager;->unregisterOnActivityResultListener(Landroid/preference/PreferenceManager$OnActivityResultListener;)V
-Landroid/preference/PreferenceManager;->unregisterOnActivityStopListener(Landroid/preference/PreferenceManager$OnActivityStopListener;)V
-Landroid/preference/PreferenceScreen;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;)V
-Landroid/preference/PreferenceScreen;->mListView:Landroid/widget/ListView;
-Landroid/preference/PreferenceScreen;->mRootAdapter:Landroid/widget/ListAdapter;
-Landroid/preference/RingtonePreference;->mRequestCode:I
-Landroid/preference/SeekBarDialogPreference;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;)V
-Landroid/preference/SeekBarPreference;-><init>(Landroid/content/Context;)V
-Landroid/preference/SeekBarPreference;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;)V
-Landroid/preference/SeekBarPreference;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;I)V
-Landroid/preference/SeekBarVolumizer;-><init>(Landroid/content/Context;ILandroid/net/Uri;Landroid/preference/SeekBarVolumizer$Callback;)V
-Landroid/preference/SeekBarVolumizer;->mAudioManager:Landroid/media/AudioManager;
-Landroid/preference/SeekBarVolumizer;->mContext:Landroid/content/Context;
-Landroid/preference/SeekBarVolumizer;->mLastProgress:I
-Landroid/preference/SeekBarVolumizer;->mOriginalStreamVolume:I
-Landroid/preference/SeekBarVolumizer;->mRingtone:Landroid/media/Ringtone;
-Landroid/preference/SeekBarVolumizer;->mSeekBar:Landroid/widget/SeekBar;
-Landroid/preference/SeekBarVolumizer;->mStreamType:I
-Landroid/preference/SeekBarVolumizer;->stop()V
-Landroid/preference/SwitchPreference;->mListener:Landroid/preference/SwitchPreference$Listener;
-Landroid/preference/TwoStatePreference;->syncSummaryView(Landroid/view/View;)V
-Landroid/preference/VolumePreference$VolumeStore;->originalVolume:I
-Landroid/preference/VolumePreference$VolumeStore;->volume:I
-Landroid/preference/VolumePreference;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;)V
-Landroid/preference/VolumePreference;->mStreamType:I
 Landroid/R$styleable;->ActionBar:[I
 Landroid/R$styleable;->ActionBar_background:I
 Landroid/R$styleable;->ActionBar_backgroundSplit:I
diff --git a/core/java/android/preference/DialogPreference.java b/core/java/android/preference/DialogPreference.java
index 3d57b4d..534ef8d 100644
--- a/core/java/android/preference/DialogPreference.java
+++ b/core/java/android/preference/DialogPreference.java
@@ -20,6 +20,7 @@
 import android.annotation.CallSuper;
 import android.annotation.DrawableRes;
 import android.annotation.StringRes;
+import android.annotation.UnsupportedAppUsage;
 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.content.Context;
@@ -53,19 +54,27 @@
 public abstract class DialogPreference extends Preference implements
         DialogInterface.OnClickListener, DialogInterface.OnDismissListener,
         PreferenceManager.OnActivityDestroyListener {
+    @UnsupportedAppUsage
     private AlertDialog.Builder mBuilder;
     
+    @UnsupportedAppUsage
     private CharSequence mDialogTitle;
+    @UnsupportedAppUsage
     private CharSequence mDialogMessage;
+    @UnsupportedAppUsage
     private Drawable mDialogIcon;
+    @UnsupportedAppUsage
     private CharSequence mPositiveButtonText;
+    @UnsupportedAppUsage
     private CharSequence mNegativeButtonText;
     private int mDialogLayoutResId;
 
     /** The dialog, if it is showing. */
+    @UnsupportedAppUsage
     private Dialog mDialog;
 
     /** Which button was clicked. */
+    @UnsupportedAppUsage
     private int mWhichButtonClicked;
 
     public DialogPreference(
diff --git a/core/java/android/preference/EditTextPreference.java b/core/java/android/preference/EditTextPreference.java
index 9467c22..4d2ac67 100644
--- a/core/java/android/preference/EditTextPreference.java
+++ b/core/java/android/preference/EditTextPreference.java
@@ -17,6 +17,7 @@
 package android.preference;
 
 
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.res.TypedArray;
@@ -46,6 +47,7 @@
     /**
      * The edit text shown in the dialog.
      */
+    @UnsupportedAppUsage
     private EditText mEditText;
     
     private String mText;
diff --git a/core/java/android/preference/ListPreference.java b/core/java/android/preference/ListPreference.java
index 2700373..e7dec0e 100644
--- a/core/java/android/preference/ListPreference.java
+++ b/core/java/android/preference/ListPreference.java
@@ -17,6 +17,7 @@
 package android.preference;
 
 import android.annotation.ArrayRes;
+import android.annotation.UnsupportedAppUsage;
 import android.app.AlertDialog.Builder;
 import android.content.Context;
 import android.content.DialogInterface;
@@ -41,6 +42,7 @@
     private CharSequence[] mEntryValues;
     private String mValue;
     private String mSummary;
+    @UnsupportedAppUsage
     private int mClickedDialogEntryIndex;
     private boolean mValueSet;
 
diff --git a/core/java/android/preference/Preference.java b/core/java/android/preference/Preference.java
index 4306bc4..98b69a8 100644
--- a/core/java/android/preference/Preference.java
+++ b/core/java/android/preference/Preference.java
@@ -21,6 +21,7 @@
 import android.annotation.LayoutRes;
 import android.annotation.Nullable;
 import android.annotation.StringRes;
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
@@ -116,6 +117,7 @@
     private int mOrder = DEFAULT_ORDER;
     private CharSequence mTitle;
     private int mTitleRes;
+    @UnsupportedAppUsage
     private CharSequence mSummary;
     /**
      * mIconResId is overridden by mIcon, if mIcon is specified.
@@ -144,7 +146,9 @@
      */
     private boolean mShouldDisableView = true;
 
+    @UnsupportedAppUsage
     private int mLayoutResId = com.android.internal.R.layout.preference;
+    @UnsupportedAppUsage
     private int mWidgetLayoutResId;
 
     private OnPreferenceChangeInternalListener mListener;
@@ -974,6 +978,7 @@
      *
      * @return A unique ID for this Preference.
      */
+    @UnsupportedAppUsage
     long getId() {
         return mId;
     }
@@ -1126,6 +1131,7 @@
      *            processing). May be {@code null}.
      * @hide
      */
+    @UnsupportedAppUsage
     public void performClick(PreferenceScreen preferenceScreen) {
 
         if (!isEnabled()) {
@@ -1161,6 +1167,7 @@
      * @return True if the Preference handled the key. Returns false by default.
      * @hide
      */
+    @UnsupportedAppUsage
     public boolean onKey(View v, int keyCode, KeyEvent event) {
         return false;
     }
@@ -1281,6 +1288,7 @@
      * @param listener The listener.
      * @see #notifyChanged()
      */
+    @UnsupportedAppUsage
     final void setOnPreferenceChangeInternalListener(OnPreferenceChangeInternalListener listener) {
         mListener = listener;
     }
@@ -1399,6 +1407,7 @@
      * @param dependent The dependent Preference that will be enabled/disabled
      *            according to the state of this Preference.
      */
+    @UnsupportedAppUsage
     private void registerDependent(Preference dependent) {
         if (mDependents == null) {
             mDependents = new ArrayList<Preference>();
diff --git a/core/java/android/preference/PreferenceActivity.java b/core/java/android/preference/PreferenceActivity.java
index 02fa7ed..d163909 100644
--- a/core/java/android/preference/PreferenceActivity.java
+++ b/core/java/android/preference/PreferenceActivity.java
@@ -19,6 +19,7 @@
 import android.animation.LayoutTransition;
 import android.annotation.Nullable;
 import android.annotation.StringRes;
+import android.annotation.UnsupportedAppUsage;
 import android.annotation.XmlRes;
 import android.app.Fragment;
 import android.app.FragmentBreadCrumbs;
@@ -198,6 +199,7 @@
 
     private FrameLayout mListFooter;
 
+    @UnsupportedAppUsage
     private ViewGroup mPrefsContainer;
 
     // Backup of the original activity title. This is used when navigating back to the headers list
@@ -215,6 +217,7 @@
 
     // --- State for old mode when showing a single preference list
 
+    @UnsupportedAppUsage
     private PreferenceManager mPreferenceManager;
 
     private Bundle mSavedInstanceState;
@@ -739,6 +742,7 @@
      * Returns the Header list
      * @hide
      */
+    @UnsupportedAppUsage
     public List<Header> getHeaders() {
         return mHeaders;
     }
@@ -1441,6 +1445,7 @@
      * Binding late is preferred as any custom preference types created in
      * {@link #onCreate(Bundle)} are able to have their views recycled.
      */
+    @UnsupportedAppUsage
     private void postBindPreferences() {
         if (mHandler.hasMessages(MSG_BIND_PREFERENCES)) return;
         mHandler.obtainMessage(MSG_BIND_PREFERENCES).sendToTarget();
@@ -1469,6 +1474,7 @@
         return mPreferenceManager;
     }
 
+    @UnsupportedAppUsage
     private void requirePreferenceManager() {
         if (mPreferenceManager == null) {
             if (mAdapter == null) {
diff --git a/core/java/android/preference/PreferenceFragment.java b/core/java/android/preference/PreferenceFragment.java
index 4c556ef..548895e 100644
--- a/core/java/android/preference/PreferenceFragment.java
+++ b/core/java/android/preference/PreferenceFragment.java
@@ -17,6 +17,7 @@
 package android.preference;
 
 import android.annotation.Nullable;
+import android.annotation.UnsupportedAppUsage;
 import android.annotation.XmlRes;
 import android.app.Activity;
 import android.app.Fragment;
@@ -113,6 +114,7 @@
 
     private static final String PREFERENCES_TAG = "android:preferences";
 
+    @UnsupportedAppUsage
     private PreferenceManager mPreferenceManager;
     private ListView mList;
     private boolean mHavePrefs;
@@ -402,6 +404,7 @@
     }
 
     /** @hide */
+    @UnsupportedAppUsage
     public ListView getListView() {
         ensureList();
         return mList;
diff --git a/core/java/android/preference/PreferenceManager.java b/core/java/android/preference/PreferenceManager.java
index ea32dfd..b250b15 100644
--- a/core/java/android/preference/PreferenceManager.java
+++ b/core/java/android/preference/PreferenceManager.java
@@ -18,6 +18,7 @@
 
 import android.annotation.Nullable;
 import android.annotation.SystemApi;
+import android.annotation.UnsupportedAppUsage;
 import android.annotation.XmlRes;
 import android.app.Activity;
 import android.content.Context;
@@ -67,6 +68,7 @@
      * Fragment that owns this instance.
      */
     @Nullable
+    @UnsupportedAppUsage
     private PreferenceFragment mFragment;
 
     /**
@@ -90,6 +92,7 @@
      * Cached shared preferences.
      */
     @Nullable
+    @UnsupportedAppUsage
     private SharedPreferences mSharedPreferences;
 
     /**
@@ -152,6 +155,7 @@
      * List of activity destroy listeners.
      */
     @Nullable
+    @UnsupportedAppUsage
     private List<OnActivityDestroyListener> mActivityDestroyListeners;
 
     /**
@@ -161,11 +165,13 @@
     @Nullable
     private List<DialogInterface> mPreferencesScreens;
 
+    @UnsupportedAppUsage
     private OnPreferenceTreeClickListener mOnPreferenceTreeClickListener;
 
     /**
      * @hide
      */
+    @UnsupportedAppUsage
     public PreferenceManager(Activity activity, int firstRequestCode) {
         mActivity = activity;
         mNextRequestCode = firstRequestCode;
@@ -181,6 +187,7 @@
      * should be used ANY time a preference will be displayed, since some preference
      * types need an Activity for managed queries.
      */
+    @UnsupportedAppUsage
     /*package*/ PreferenceManager(Context context) {
         init(context);
     }
@@ -194,6 +201,7 @@
     /**
      * Sets the owning preference fragment
      */
+    @UnsupportedAppUsage
     void setFragment(PreferenceFragment fragment) {
         mFragment = fragment;
     }
@@ -202,6 +210,7 @@
      * Returns the owning preference fragment, if any.
      */
     @Nullable
+    @UnsupportedAppUsage
     PreferenceFragment getFragment() {
         return mFragment;
     }
@@ -260,6 +269,7 @@
      * @return The root hierarchy (if one was not provided, the new hierarchy's
      *         root).
      */
+    @UnsupportedAppUsage
     PreferenceScreen inflateFromIntent(Intent queryIntent, PreferenceScreen rootPreferences) {
         final List<ResolveInfo> activities = queryIntentActivities(queryIntent);
         final HashSet<String> inflatedRes = new HashSet<String>();
@@ -315,6 +325,7 @@
      *         root).
      * @hide
      */
+    @UnsupportedAppUsage
     public PreferenceScreen inflateFromResource(Context context, @XmlRes int resId,
             PreferenceScreen rootPreferences) {
         // Block commits
@@ -547,6 +558,7 @@
      * @return The {@link PreferenceScreen} object that is at the root of the hierarchy.
      */
     @Nullable
+    @UnsupportedAppUsage
     PreferenceScreen getPreferenceScreen() {
         return mPreferenceScreen;
     }
@@ -557,6 +569,7 @@
      * @param preferenceScreen The root {@link PreferenceScreen} of the preference hierarchy.
      * @return Whether the {@link PreferenceScreen} given is different than the previous.
      */
+    @UnsupportedAppUsage
     boolean setPreferences(PreferenceScreen preferenceScreen) {
         if (preferenceScreen != mPreferenceScreen) {
             mPreferenceScreen = preferenceScreen;
@@ -671,6 +684,7 @@
      *         has been set, this method returns {@code null}.
      * @see #shouldCommit()
      */
+    @UnsupportedAppUsage
     SharedPreferences.Editor getEditor() {
         if (mPreferenceDataStore != null) {
             return null;
@@ -696,10 +710,12 @@
      *
      * @return Whether the client should commit.
      */
+    @UnsupportedAppUsage
     boolean shouldCommit() {
         return !mNoCommit;
     }
 
+    @UnsupportedAppUsage
     private void setNoCommit(boolean noCommit) {
         if (!noCommit && mEditor != null) {
             try {
@@ -726,6 +742,7 @@
      * @see #mContext
      */
     @Nullable
+    @UnsupportedAppUsage
     Activity getActivity() {
         return mActivity;
     }
@@ -745,6 +762,7 @@
      *
      * @see OnActivityResultListener
      */
+    @UnsupportedAppUsage
     void registerOnActivityResultListener(OnActivityResultListener listener) {
         synchronized (this) {
             if (mActivityResultListeners == null) {
@@ -762,6 +780,7 @@
      *
      * @see OnActivityResultListener
      */
+    @UnsupportedAppUsage
     void unregisterOnActivityResultListener(OnActivityResultListener listener) {
         synchronized (this) {
             if (mActivityResultListeners != null) {
@@ -773,6 +792,7 @@
     /**
      * Called by the {@link PreferenceManager} to dispatch a subactivity result.
      */
+    @UnsupportedAppUsage
     void dispatchActivityResult(int requestCode, int resultCode, Intent data) {
         List<OnActivityResultListener> list;
 
@@ -795,6 +815,7 @@
      * @see OnActivityStopListener
      * @hide
      */
+    @UnsupportedAppUsage
     public void registerOnActivityStopListener(OnActivityStopListener listener) {
         synchronized (this) {
             if (mActivityStopListeners == null) {
@@ -813,6 +834,7 @@
      * @see OnActivityStopListener
      * @hide
      */
+    @UnsupportedAppUsage
     public void unregisterOnActivityStopListener(OnActivityStopListener listener) {
         synchronized (this) {
             if (mActivityStopListeners != null) {
@@ -825,6 +847,7 @@
      * Called by the {@link PreferenceManager} to dispatch the activity stop
      * event.
      */
+    @UnsupportedAppUsage
     void dispatchActivityStop() {
         List<OnActivityStopListener> list;
 
@@ -844,6 +867,7 @@
      *
      * @see OnActivityDestroyListener
      */
+    @UnsupportedAppUsage
     void registerOnActivityDestroyListener(OnActivityDestroyListener listener) {
         synchronized (this) {
             if (mActivityDestroyListeners == null) {
@@ -861,6 +885,7 @@
      *
      * @see OnActivityDestroyListener
      */
+    @UnsupportedAppUsage
     void unregisterOnActivityDestroyListener(OnActivityDestroyListener listener) {
         synchronized (this) {
             if (mActivityDestroyListeners != null) {
@@ -873,6 +898,7 @@
      * Called by the {@link PreferenceManager} to dispatch the activity destroy
      * event.
      */
+    @UnsupportedAppUsage
     void dispatchActivityDestroy() {
         List<OnActivityDestroyListener> list = null;
 
@@ -900,6 +926,7 @@
      * @return A unique request code that will never be used by anyone other
      *         than the caller of this method.
      */
+    @UnsupportedAppUsage
     int getNextRequestCode() {
         synchronized (this) {
             return mNextRequestCode++;
diff --git a/core/java/android/preference/PreferenceScreen.java b/core/java/android/preference/PreferenceScreen.java
index 2305b05..dd00a53 100644
--- a/core/java/android/preference/PreferenceScreen.java
+++ b/core/java/android/preference/PreferenceScreen.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.app.Dialog;
 import android.content.Context;
 import android.content.DialogInterface;
@@ -89,10 +90,12 @@
 public final class PreferenceScreen extends PreferenceGroup implements AdapterView.OnItemClickListener,
         DialogInterface.OnDismissListener {
 
+    @UnsupportedAppUsage
     private ListAdapter mRootAdapter;
     
     private Dialog mDialog;
 
+    @UnsupportedAppUsage
     private ListView mListView;
 
     private int mLayoutResId = com.android.internal.R.layout.preference_list_fragment;
@@ -103,6 +106,7 @@
      * Do NOT use this constructor, use {@link PreferenceManager#createPreferenceScreen(Context)}.
      * @hide-
      */
+    @UnsupportedAppUsage
     public PreferenceScreen(Context context, AttributeSet attrs) {
         super(context, attrs, com.android.internal.R.attr.preferenceScreenStyle);
 
diff --git a/core/java/android/preference/RingtonePreference.java b/core/java/android/preference/RingtonePreference.java
index a76bb09..cd751cd 100644
--- a/core/java/android/preference/RingtonePreference.java
+++ b/core/java/android/preference/RingtonePreference.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.Intent;
 import android.content.res.TypedArray;
@@ -49,6 +50,7 @@
     private boolean mShowDefault;
     private boolean mShowSilent;
     
+    @UnsupportedAppUsage
     private int mRequestCode;
 
     public RingtonePreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
diff --git a/core/java/android/preference/SeekBarDialogPreference.java b/core/java/android/preference/SeekBarDialogPreference.java
index eeb69a3..a8e5992 100644
--- a/core/java/android/preference/SeekBarDialogPreference.java
+++ b/core/java/android/preference/SeekBarDialogPreference.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
@@ -47,6 +48,7 @@
         this(context, attrs, defStyleAttr, 0);
     }
 
+    @UnsupportedAppUsage
     public SeekBarDialogPreference(Context context, AttributeSet attrs) {
         this(context, attrs, R.attr.seekBarDialogPreferenceStyle);
     }
diff --git a/core/java/android/preference/SeekBarPreference.java b/core/java/android/preference/SeekBarPreference.java
index 1fabf3d..cd35f3d 100644
--- a/core/java/android/preference/SeekBarPreference.java
+++ b/core/java/android/preference/SeekBarPreference.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.os.Parcel;
@@ -55,14 +56,17 @@
         setLayoutResource(layoutResId);
     }
 
+    @UnsupportedAppUsage
     public SeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr) {
         this(context, attrs, defStyleAttr, 0);
     }
 
+    @UnsupportedAppUsage
     public SeekBarPreference(Context context, AttributeSet attrs) {
         this(context, attrs, com.android.internal.R.attr.seekBarPreferenceStyle);
     }
 
+    @UnsupportedAppUsage
     public SeekBarPreference(Context context) {
         this(context, null);
     }
diff --git a/core/java/android/preference/SeekBarVolumizer.java b/core/java/android/preference/SeekBarVolumizer.java
index 0ed2526..07a3c9b 100644
--- a/core/java/android/preference/SeekBarVolumizer.java
+++ b/core/java/android/preference/SeekBarVolumizer.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.app.NotificationManager;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -54,12 +55,15 @@
         void onMuted(boolean muted, boolean zenMuted);
     }
 
+    @UnsupportedAppUsage
     private final Context mContext;
     private final H mUiHandler = new H();
     private final Callback mCallback;
     private final Uri mDefaultUri;
+    @UnsupportedAppUsage
     private final AudioManager mAudioManager;
     private final NotificationManager mNotificationManager;
+    @UnsupportedAppUsage
     private final int mStreamType;
     private final int mMaxStreamVolume;
     private boolean mAffectedByRingerMode;
@@ -68,15 +72,19 @@
 
     private Handler mHandler;
     private Observer mVolumeObserver;
+    @UnsupportedAppUsage
     private int mOriginalStreamVolume;
     private int mLastAudibleStreamVolume;
     // When the old handler is destroyed and a new one is created, there could be a situation where
     // this is accessed at the same time in different handlers. So, access to this field needs to be
     // synchronized.
     @GuardedBy("this")
+    @UnsupportedAppUsage
     private Ringtone mRingtone;
+    @UnsupportedAppUsage
     private int mLastProgress = -1;
     private boolean mMuted;
+    @UnsupportedAppUsage
     private SeekBar mSeekBar;
     private int mVolumeBeforeMute = -1;
     private int mRingerMode;
@@ -93,6 +101,7 @@
     private boolean mAllowMedia;
     private boolean mAllowRinger;
 
+    @UnsupportedAppUsage
     public SeekBarVolumizer(Context context, int streamType, Uri defaultUri, Callback callback) {
         mContext = context;
         mAudioManager = context.getSystemService(AudioManager.class);
@@ -258,6 +267,7 @@
         }
     }
 
+    @UnsupportedAppUsage
     public void stop() {
         if (mHandler == null) return;  // already stopped
         postStopSample();
diff --git a/core/java/android/preference/SwitchPreference.java b/core/java/android/preference/SwitchPreference.java
index aa8674e..1ec18bb 100644
--- a/core/java/android/preference/SwitchPreference.java
+++ b/core/java/android/preference/SwitchPreference.java
@@ -17,6 +17,7 @@
 package android.preference;
 
 import android.annotation.StringRes;
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.util.AttributeSet;
@@ -37,6 +38,7 @@
  * @attr ref android.R.styleable#SwitchPreference_disableDependentsState
  */
 public class SwitchPreference extends TwoStatePreference {
+    @UnsupportedAppUsage
     private final Listener mListener = new Listener();
 
     // Switch text for on and off states
diff --git a/core/java/android/preference/TwoStatePreference.java b/core/java/android/preference/TwoStatePreference.java
index 7037aca..2079a63 100644
--- a/core/java/android/preference/TwoStatePreference.java
+++ b/core/java/android/preference/TwoStatePreference.java
@@ -17,6 +17,7 @@
 package android.preference;
 
 import android.annotation.StringRes;
+import android.annotation.UnsupportedAppUsage;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.res.TypedArray;
@@ -193,6 +194,7 @@
      * Sync a summary view contained within view's subhierarchy with the correct summary text.
      * @param view View where a summary should be located
      */
+    @UnsupportedAppUsage
     void syncSummaryView(View view) {
         // Sync the summary view
         TextView summaryView = (TextView) view.findViewById(com.android.internal.R.id.summary);
diff --git a/core/java/android/preference/VolumePreference.java b/core/java/android/preference/VolumePreference.java
index 8a66c24..ea1d1eb 100644
--- a/core/java/android/preference/VolumePreference.java
+++ b/core/java/android/preference/VolumePreference.java
@@ -16,6 +16,7 @@
 
 package android.preference;
 
+import android.annotation.UnsupportedAppUsage;
 import android.app.Dialog;
 import android.content.Context;
 import android.content.res.TypedArray;
@@ -33,6 +34,7 @@
  */
 public class VolumePreference extends SeekBarDialogPreference implements
         PreferenceManager.OnActivityStopListener, View.OnKeyListener, SeekBarVolumizer.Callback {
+    @UnsupportedAppUsage
     private int mStreamType;
 
     /** May be null if the dialog isn't visible. */
@@ -52,6 +54,7 @@
         this(context, attrs, defStyleAttr, 0);
     }
 
+    @UnsupportedAppUsage
     public VolumePreference(Context context, AttributeSet attrs) {
         this(context, attrs, R.attr.seekBarDialogPreferenceStyle);
     }
@@ -196,7 +199,9 @@
     }
 
     public static class VolumeStore {
+        @UnsupportedAppUsage
         public int volume = -1;
+        @UnsupportedAppUsage
         public int originalVolume = -1;
     }
 
