Move BT, NFC out of Conntection pref

Move BT, NFC preference out of Connection Preference,
To Connected devices page.
Because NFC and Android Beam are controlled by the same controller,
Create each controller for those preference and leave the sharing part.

Change-Id: I8bc303a5f487de9c667487119b49e1e4130aa80c
Fixes: 72458929
Test: manually test, make RunSettingsRoboTests

6 files changed, 397 insertions, 210 deletions

diff --git a/src/com/android/settings/nfc/AndroidBeamEnabler.java b/src/com/android/settings/nfc/AndroidBeamEnabler.java
new file mode 100644
index 0000000000..66e42b6418
--- /dev/null
+++ b/src/com/android/settings/nfc/AndroidBeamEnabler.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2018 The Android Open Source 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 com.android.settings.nfc;
+
+import android.content.Context;
+import android.nfc.NfcAdapter;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.RestrictedPreference;
+
+/**
+ * AndroidBeanEnabler is a helper to manage the Android Beam preference. It turns on/off
+ * Android Beam and ensures the summary of the preference reflects the current state.
+ */
+public class AndroidBeamEnabler extends BaseNfcEnabler {
+    private final boolean mBeamDisallowedBySystem;
+    private final RestrictedPreference mPreference;
+
+    public AndroidBeamEnabler(Context context, RestrictedPreference preference) {
+        super(context);
+
+        mPreference = preference;
+
+        mBeamDisallowedBySystem = RestrictedLockUtils.hasBaseUserRestriction(context,
+                UserManager.DISALLOW_OUTGOING_BEAM, UserHandle.myUserId());
+
+        if (!isNfcAvailable()) {
+            // NFC is not supported
+            mPreference.setEnabled(false);
+            return;
+        }
+
+        if (mBeamDisallowedBySystem) {
+            mPreference.setEnabled(false);
+        }
+    }
+
+    @Override
+    protected void handleNfcStateChanged(int newState) {
+        switch (newState) {
+            case NfcAdapter.STATE_OFF:
+                mPreference.setEnabled(false);
+                mPreference.setSummary(R.string.android_beam_disabled_summary);
+                break;
+            case NfcAdapter.STATE_ON:
+                if (mBeamDisallowedBySystem) {
+                    mPreference.setDisabledByAdmin(null);
+                    mPreference.setEnabled(false);
+                } else {
+                    mPreference.checkRestrictionAndSetDisabled(UserManager.DISALLOW_OUTGOING_BEAM);
+                }
+                if (mNfcAdapter.isNdefPushEnabled() && mPreference.isEnabled()) {
+                    mPreference.setSummary(R.string.android_beam_on_summary);
+                } else {
+                    mPreference.setSummary(R.string.android_beam_off_summary);
+                }
+                break;
+            case NfcAdapter.STATE_TURNING_ON:
+                mPreference.setEnabled(false);
+                break;
+            case NfcAdapter.STATE_TURNING_OFF:
+                mPreference.setEnabled(false);
+                break;
+        }
+    }
+}
diff --git a/src/com/android/settings/nfc/AndroidBeamPreferenceController.java b/src/com/android/settings/nfc/AndroidBeamPreferenceController.java
new file mode 100644
index 0000000000..6ae7fe5ccf
--- /dev/null
+++ b/src/com/android/settings/nfc/AndroidBeamPreferenceController.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2018 The Android Open Source 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 com.android.settings.nfc;
+
+import android.content.Context;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.RestrictedPreference;
+import com.android.settingslib.core.lifecycle.LifecycleObserver;
+import com.android.settingslib.core.lifecycle.events.OnPause;
+import com.android.settingslib.core.lifecycle.events.OnResume;
+
+public class AndroidBeamPreferenceController extends BaseNfcPreferenceController {
+
+    public static final String KEY_ANDROID_BEAM_SETTINGS = "android_beam_settings";
+
+    public AndroidBeamPreferenceController(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        if (!isAvailable()) {
+            return;
+        }
+
+        mNfcEnabler = new AndroidBeamEnabler(mContext, (RestrictedPreference) mPreference);
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_ANDROID_BEAM_SETTINGS;
+    }
+}
diff --git a/src/com/android/settings/nfc/BaseNfcEnabler.java b/src/com/android/settings/nfc/BaseNfcEnabler.java
new file mode 100644
index 0000000000..5c5f95ca7c
--- /dev/null
+++ b/src/com/android/settings/nfc/BaseNfcEnabler.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2018 The Android Open Source 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 com.android.settings.nfc;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.nfc.NfcAdapter;
+import android.support.v7.preference.Preference;
+
+/**
+ * BaseNfcEnabler is a abstract helper to manage the Nfc state for Nfc and Android Beam
+ * preference. It will receive intent and update state to ensure preference show correct state.
+ */
+public abstract class BaseNfcEnabler {
+    private final Context mContext;
+    protected final NfcAdapter mNfcAdapter;
+    private final IntentFilter mIntentFilter;
+
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+            if (NfcAdapter.ACTION_ADAPTER_STATE_CHANGED.equals(action)) {
+                handleNfcStateChanged(intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE,
+                        NfcAdapter.STATE_OFF));
+            }
+        }
+    };
+
+    public BaseNfcEnabler(Context context) {
+        mContext = context;
+        mNfcAdapter = NfcAdapter.getDefaultAdapter(context);
+
+        if (!isNfcAvailable()) {
+            // NFC is not supported
+            mIntentFilter = null;
+            return;
+        }
+        mIntentFilter = new IntentFilter(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED);
+    }
+
+    public void resume() {
+        if (!isNfcAvailable()) {
+            return;
+        }
+        handleNfcStateChanged(mNfcAdapter.getAdapterState());
+        mContext.registerReceiver(mReceiver, mIntentFilter);
+    }
+
+    public void pause() {
+        if (!isNfcAvailable()) {
+            return;
+        }
+        mContext.unregisterReceiver(mReceiver);
+    }
+
+    public boolean isNfcAvailable() {
+        return mNfcAdapter != null;
+    }
+
+    protected abstract void handleNfcStateChanged(int newState);
+}
diff --git a/src/com/android/settings/nfc/BaseNfcPreferenceController.java b/src/com/android/settings/nfc/BaseNfcPreferenceController.java
new file mode 100644
index 0000000000..b945738eab
--- /dev/null
+++ b/src/com/android/settings/nfc/BaseNfcPreferenceController.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2018 The Android Open Source 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 com.android.settings.nfc;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.nfc.NfcAdapter;
+import android.nfc.NfcManager;
+import android.os.Handler;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.core.AbstractPreferenceController;
+import com.android.settingslib.core.lifecycle.LifecycleObserver;
+import com.android.settingslib.core.lifecycle.events.OnPause;
+import com.android.settingslib.core.lifecycle.events.OnResume;
+
+import java.util.List;
+
+public abstract class BaseNfcPreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin, LifecycleObserver, OnResume, OnPause {
+
+    protected BaseNfcEnabler mNfcEnabler;
+    private NfcAdapter mNfcAdapter;
+    private int mAirplaneMode;
+    private AirplaneModeObserver mAirplaneModeObserver;
+    protected Preference mPreference;
+
+    public BaseNfcPreferenceController(Context context) {
+        super(context);
+        mNfcAdapter = NfcAdapter.getDefaultAdapter(context);
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        if (!isAvailable()) {
+            mNfcEnabler = null;
+            return;
+        }
+
+        mPreference = screen.findPreference(getPreferenceKey());
+
+        // Manually set dependencies for NFC when not toggleable.
+        if (!isToggleableInAirplaneMode(mContext)) {
+            mAirplaneModeObserver = new AirplaneModeObserver();
+            updateNfcPreference();
+        }
+    }
+
+    @Override
+    public void updateNonIndexableKeys(List<String> keys) {
+        if (isAvailable()) {
+            keys.add(getPreferenceKey());
+        }
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mNfcAdapter != null;
+    }
+
+    public abstract String getPreferenceKey();
+
+    @Override
+    public void onResume() {
+        if (mAirplaneModeObserver != null) {
+            mAirplaneModeObserver.register();
+        }
+        if (mNfcEnabler != null) {
+            mNfcEnabler.resume();
+        }
+    }
+
+    @Override
+    public void onPause() {
+        if (mAirplaneModeObserver != null) {
+            mAirplaneModeObserver.unregister();
+        }
+        if (mNfcEnabler != null) {
+            mNfcEnabler.pause();
+        }
+    }
+
+    private void updateNfcPreference() {
+        final int airplaneMode = Settings.Global.getInt(
+                mContext.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, mAirplaneMode);
+        if (airplaneMode == mAirplaneMode) {
+            return;
+        }
+        mAirplaneMode = airplaneMode;
+        boolean toggleable = mAirplaneMode != 1;
+        if (toggleable) {
+            mNfcAdapter.enable();
+        } else {
+            mNfcAdapter.disable();
+        }
+        mPreference.setEnabled(toggleable);
+    }
+
+    public static boolean isToggleableInAirplaneMode(Context context) {
+        String toggleable = Settings.Global.getString(context.getContentResolver(),
+                Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
+        return toggleable != null && toggleable.contains(Settings.Global.RADIO_NFC);
+    }
+
+    private final class AirplaneModeObserver extends ContentObserver {
+        private final Uri AIRPLANE_MODE_URI =
+                Settings.Global.getUriFor(Settings.Global.AIRPLANE_MODE_ON);
+
+        private AirplaneModeObserver() {
+            super(new Handler());
+        }
+
+        public void register() {
+            mContext.getContentResolver().registerContentObserver(AIRPLANE_MODE_URI, false, this);
+        }
+
+        public void unregister() {
+            mContext.getContentResolver().unregisterContentObserver(this);
+        }
+
+        @Override
+        public void onChange(boolean selfChange, Uri uri) {
+            super.onChange(selfChange, uri);
+            updateNfcPreference();
+        }
+    }
+
+}
diff --git a/src/com/android/settings/nfc/NfcEnabler.java b/src/com/android/settings/nfc/NfcEnabler.java
index 14ee779bed..29cef99355 100644
--- a/src/com/android/settings/nfc/NfcEnabler.java
+++ b/src/com/android/settings/nfc/NfcEnabler.java
@@ -16,90 +16,44 @@
 
 package com.android.settings.nfc;
 
-import android.content.BroadcastReceiver;
 import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
 import android.nfc.NfcAdapter;
-import android.os.UserHandle;
-import android.os.UserManager;
-import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
-import android.support.v7.preference.PreferenceScreen;
-
-import com.android.settings.R;
-import com.android.settingslib.RestrictedLockUtils;
-import com.android.settingslib.RestrictedPreference;
+import android.support.v14.preference.SwitchPreference;
 
 /**
- * NfcEnabler is a helper to manage the Nfc on/off checkbox preference. It is
- * turns on/off Nfc and ensures the summary of the preference reflects the
- * current state.
+ * NfcEnabler is a helper to manage the Nfc on/off checkbox preference. It turns on/off Nfc
+ * and ensures the summary of the preference reflects the current state.
  */
-public class NfcEnabler implements Preference.OnPreferenceChangeListener {
-    private final Context mContext;
-    private final SwitchPreference mSwitch;
-    private final RestrictedPreference mAndroidBeam;
-    private final NfcAdapter mNfcAdapter;
-    private final IntentFilter mIntentFilter;
-    private boolean mBeamDisallowedBySystem;
+public class NfcEnabler extends BaseNfcEnabler implements Preference.OnPreferenceChangeListener {
+    private final SwitchPreference mPreference;
 
-    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            String action = intent.getAction();
-            if (NfcAdapter.ACTION_ADAPTER_STATE_CHANGED.equals(action)) {
-                handleNfcStateChanged(intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE,
-                        NfcAdapter.STATE_OFF));
-            }
-        }
-    };
+    public NfcEnabler(Context context, SwitchPreference preference) {
+        super(context);
 
-    public NfcEnabler(Context context, SwitchPreference switchPreference,
-            RestrictedPreference androidBeam) {
-        mContext = context;
-        mSwitch = switchPreference;
-        mAndroidBeam = androidBeam;
-        mNfcAdapter = NfcAdapter.getDefaultAdapter(context);
-        mBeamDisallowedBySystem = RestrictedLockUtils.hasBaseUserRestriction(context,
-                UserManager.DISALLOW_OUTGOING_BEAM, UserHandle.myUserId());
-
-        if (mNfcAdapter == null) {
-            // NFC is not supported
-            mSwitch.setEnabled(false);
-            mAndroidBeam.setEnabled(false);
-            mIntentFilter = null;
-            return;
-        }
-        if (mBeamDisallowedBySystem) {
-            mAndroidBeam.setEnabled(false);
-        }
-        mIntentFilter = new IntentFilter(NfcAdapter.ACTION_ADAPTER_STATE_CHANGED);
+        mPreference = preference;
     }
 
     public void resume() {
-        if (mNfcAdapter == null) {
-            return;
+        super.resume();
+        if (isNfcAvailable()) {
+            mPreference.setOnPreferenceChangeListener(this);
         }
-        handleNfcStateChanged(mNfcAdapter.getAdapterState());
-        mContext.registerReceiver(mReceiver, mIntentFilter);
-        mSwitch.setOnPreferenceChangeListener(this);
     }
 
     public void pause() {
-        if (mNfcAdapter == null) {
-            return;
+        super.pause();
+        if (isNfcAvailable()) {
+            mPreference.setOnPreferenceChangeListener(null);
         }
-        mContext.unregisterReceiver(mReceiver);
-        mSwitch.setOnPreferenceChangeListener(null);
     }
 
     public boolean onPreferenceChange(Preference preference, Object value) {
         // Turn NFC on/off
 
         final boolean desiredState = (Boolean) value;
-        mSwitch.setChecked(desiredState);
-        mSwitch.setEnabled(false);
+        mPreference.setChecked(desiredState);
+        mPreference.setEnabled(false);
 
         if (desiredState) {
             mNfcAdapter.enable();
@@ -110,39 +64,25 @@ public class NfcEnabler implements Preference.OnPreferenceChangeListener {
         return false;
     }
 
-    private void handleNfcStateChanged(int newState) {
+    @Override
+    protected void handleNfcStateChanged(int newState) {
         switch (newState) {
-        case NfcAdapter.STATE_OFF:
-            mSwitch.setChecked(false);
-            mSwitch.setEnabled(true);
-            mAndroidBeam.setEnabled(false);
-            mAndroidBeam.setSummary(R.string.android_beam_disabled_summary);
-            break;
-        case NfcAdapter.STATE_ON:
-            mSwitch.setChecked(true);
-            mSwitch.setEnabled(true);
-            if (mBeamDisallowedBySystem) {
-                mAndroidBeam.setDisabledByAdmin(null);
-                mAndroidBeam.setEnabled(false);
-            } else {
-                mAndroidBeam.checkRestrictionAndSetDisabled(UserManager.DISALLOW_OUTGOING_BEAM);
-            }
-            if (mNfcAdapter.isNdefPushEnabled() && mAndroidBeam.isEnabled()) {
-                mAndroidBeam.setSummary(R.string.android_beam_on_summary);
-            } else {
-                mAndroidBeam.setSummary(R.string.android_beam_off_summary);
-            }
-            break;
-        case NfcAdapter.STATE_TURNING_ON:
-            mSwitch.setChecked(true);
-            mSwitch.setEnabled(false);
-            mAndroidBeam.setEnabled(false);
-            break;
-        case NfcAdapter.STATE_TURNING_OFF:
-            mSwitch.setChecked(false);
-            mSwitch.setEnabled(false);
-            mAndroidBeam.setEnabled(false);
-            break;
+            case NfcAdapter.STATE_OFF:
+                mPreference.setChecked(false);
+                mPreference.setEnabled(true);
+                break;
+            case NfcAdapter.STATE_ON:
+                mPreference.setChecked(true);
+                mPreference.setEnabled(true);
+                break;
+            case NfcAdapter.STATE_TURNING_ON:
+                mPreference.setChecked(true);
+                mPreference.setEnabled(false);
+                break;
+            case NfcAdapter.STATE_TURNING_OFF:
+                mPreference.setChecked(false);
+                mPreference.setEnabled(false);
+                break;
         }
     }
 }
diff --git a/src/com/android/settings/nfc/NfcPreferenceController.java b/src/com/android/settings/nfc/NfcPreferenceController.java
index 76977d24e2..a0678e0afa 100644
--- a/src/com/android/settings/nfc/NfcPreferenceController.java
+++ b/src/com/android/settings/nfc/NfcPreferenceController.java
@@ -16,146 +16,35 @@
 package com.android.settings.nfc;
 
 import android.content.Context;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.nfc.NfcAdapter;
-import android.nfc.NfcManager;
-import android.os.Handler;
-import android.provider.Settings;
-import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.PreferenceScreen;
+import android.support.v14.preference.SwitchPreference;
 
 import com.android.settings.core.PreferenceControllerMixin;
-import com.android.settingslib.RestrictedPreference;
-import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
 import com.android.settingslib.core.lifecycle.events.OnPause;
 import com.android.settingslib.core.lifecycle.events.OnResume;
 
-import java.util.List;
 
-public class NfcPreferenceController extends AbstractPreferenceController
-        implements PreferenceControllerMixin, LifecycleObserver, OnResume, OnPause {
+public class NfcPreferenceController extends BaseNfcPreferenceController {
 
     public static final String KEY_TOGGLE_NFC = "toggle_nfc";
-    public static final String KEY_ANDROID_BEAM_SETTINGS = "android_beam_settings";
-
-    private NfcEnabler mNfcEnabler;
-    private NfcAdapter mNfcAdapter;
-    private int mAirplaneMode;
-    private AirplaneModeObserver mAirplaneModeObserver;
-    private SwitchPreference mNfcPreference;
-    private RestrictedPreference mBeamPreference;
 
     public NfcPreferenceController(Context context) {
         super(context);
-        mNfcAdapter = NfcAdapter.getDefaultAdapter(context);
     }
 
     @Override
     public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
         if (!isAvailable()) {
-            setVisible(screen, KEY_TOGGLE_NFC, false /* visible */);
-            setVisible(screen, KEY_ANDROID_BEAM_SETTINGS, false /* visible */);
-            mNfcEnabler = null;
             return;
         }
-        mNfcPreference = (SwitchPreference) screen.findPreference(KEY_TOGGLE_NFC);
-        mBeamPreference = (RestrictedPreference) screen.findPreference(
-                KEY_ANDROID_BEAM_SETTINGS);
-        mNfcEnabler = new NfcEnabler(mContext, mNfcPreference, mBeamPreference);
-        // Manually set dependencies for NFC when not toggleable.
-        if (!isToggleableInAirplaneMode(mContext)) {
-            mAirplaneModeObserver = new AirplaneModeObserver();
-            updateNfcPreference();
-        }
-    }
-
-    @Override
-    public void updateNonIndexableKeys(List<String> keys) {
-        final NfcManager manager = (NfcManager) mContext.getSystemService(Context.NFC_SERVICE);
-        if (manager != null) {
-            NfcAdapter adapter = manager.getDefaultAdapter();
-            if (adapter == null) {
-                keys.add(KEY_TOGGLE_NFC);
-                keys.add(KEY_ANDROID_BEAM_SETTINGS);
-            }
-        }
-    }
 
-    @Override
-    public boolean isAvailable() {
-        return mNfcAdapter != null;
+        mNfcEnabler = new NfcEnabler(mContext, (SwitchPreference) mPreference);
     }
 
     @Override
     public String getPreferenceKey() {
-        return null;
-    }
-
-    public void onResume() {
-        if (mAirplaneModeObserver != null) {
-            mAirplaneModeObserver.register();
-        }
-        if (mNfcEnabler != null) {
-            mNfcEnabler.resume();
-        }
-    }
-
-    @Override
-    public void onPause() {
-        if (mAirplaneModeObserver != null) {
-            mAirplaneModeObserver.unregister();
-        }
-        if (mNfcEnabler != null) {
-            mNfcEnabler.pause();
-        }
+        return KEY_TOGGLE_NFC;
     }
-
-    private void updateNfcPreference() {
-        final int airplaneMode = Settings.Global.getInt(
-                mContext.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, mAirplaneMode);
-        if (airplaneMode == mAirplaneMode) {
-            return;
-        }
-        mAirplaneMode = airplaneMode;
-        boolean toggleable = mAirplaneMode != 1;
-        if (toggleable) {
-            mNfcAdapter.enable();
-        } else {
-            mNfcAdapter.disable();
-        }
-        mNfcPreference.setEnabled(toggleable);
-        mBeamPreference.setEnabled(toggleable);
-    }
-
-    public static boolean isToggleableInAirplaneMode(Context context) {
-        String toggleable = Settings.Global.getString(context.getContentResolver(),
-                Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
-        return toggleable != null && toggleable.contains(Settings.Global.RADIO_NFC);
-    }
-
-    private final class AirplaneModeObserver extends ContentObserver {
-        private final Uri AIRPLANE_MODE_URI =
-                Settings.Global.getUriFor(Settings.Global.AIRPLANE_MODE_ON);
-
-        private AirplaneModeObserver() {
-            super(new Handler());
-        }
-
-        public void register() {
-            mContext.getContentResolver().registerContentObserver(AIRPLANE_MODE_URI, false, this);
-        }
-
-        public void unregister() {
-            mContext.getContentResolver().unregisterContentObserver(this);
-        }
-
-        @Override
-        public void onChange(boolean selfChange, Uri uri) {
-            super.onChange(selfChange, uri);
-            updateNfcPreference();
-        }
-    }
-
 }