diff --git a/app/src/main/java/org/exthmui/game/misc/Constants.java b/app/src/main/java/org/exthmui/game/misc/Constants.java
index b9cc259..7195d90 100644
--- a/app/src/main/java/org/exthmui/game/misc/Constants.java
+++ b/app/src/main/java/org/exthmui/game/misc/Constants.java
@@ -66,9 +66,6 @@
         // 请勿打扰模式
         public static final String DISABLE_RINGTONE = Settings.System.GAMING_MODE_DISABLE_RINGTONE;
 
-        // 屏蔽按键
-        public static final String DISABLE_HW_KEYS = Settings.System.GAMING_MODE_DISABLE_HW_KEYS;
-
         // 屏蔽手势
         public static final String DISABLE_GESTURE = Settings.System.GAMING_MODE_DISABLE_GESTURE;
 
@@ -102,9 +99,6 @@
         // 屏蔽手势
         public static final boolean DISABLE_GESTURE = true;
 
-        // 屏蔽按键
-        public static final boolean DISABLE_HW_KEYS = false;
-
         // 性能配置
         public static final boolean CHANGE_PERFORMANCE_LEVEL = true;
         public static final int PERFORMANCE_LEVEL = 5;
@@ -115,8 +109,6 @@
         public static final String SHOW_DANMAKU = ConfigKeys.SHOW_DANMAKU;
         // 请勿打扰模式
         public static final String DISABLE_RINGTONE = ConfigKeys.DISABLE_RINGTONE;
-        // 屏蔽按键
-        public static final String DISABLE_HW_KEYS = ConfigKeys.DISABLE_HW_KEYS;
         // 屏蔽手势
         public static final String DISABLE_GESTURE = ConfigKeys.DISABLE_GESTURE;
         // 自动亮度
diff --git a/app/src/main/java/org/exthmui/game/qs/LockHwKeysTile.java b/app/src/main/java/org/exthmui/game/qs/LockHwKeysTile.java
deleted file mode 100644
index 6649104..0000000
--- a/app/src/main/java/org/exthmui/game/qs/LockHwKeysTile.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2020 The exTHmUI 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 org.exthmui.game.qs;
-
-import android.content.Context;
-
-import org.exthmui.game.R;
-import org.exthmui.game.misc.Constants;
-
-public class LockHwKeysTile extends TileBase {
-    public LockHwKeysTile(Context context) {
-        super(context, context.getString(R.string.qs_lock_hw_keys), Constants.GamingActionTargets.DISABLE_HW_KEYS, R.drawable.ic_qs_disable_hw_key);
-    }
-}
diff --git a/app/src/main/java/org/exthmui/game/services/GamingService.java b/app/src/main/java/org/exthmui/game/services/GamingService.java
index 8c4a28e..6966d03 100644
--- a/app/src/main/java/org/exthmui/game/services/GamingService.java
+++ b/app/src/main/java/org/exthmui/game/services/GamingService.java
@@ -62,7 +62,7 @@
 import java.util.Arrays;
 import java.util.List;
 
-import com.android.internal.custom.hardware.LineageHardwareManager; 
+import com.android.internal.custom.hardware.LineageHardwareManager;
 
 public class GamingService extends Service {
 
@@ -117,8 +117,6 @@
                 setDisableAutoBrightness(intent.getBooleanExtra("value", Constants.ConfigDefaultValues.DISABLE_AUTO_BRIGHTNESS), false);
             } else if (Constants.GamingActionTargets.DISABLE_GESTURE.equals(target)) {
                 setDisableGesture(intent.getBooleanExtra("value", Constants.ConfigDefaultValues.DISABLE_GESTURE));
-            } else if (Constants.GamingActionTargets.DISABLE_HW_KEYS.equals(target)) {
-                setDisableHwKeys(intent.getBooleanExtra("value", Constants.ConfigDefaultValues.DISABLE_HW_KEYS), false);
             } else if (Constants.GamingActionTargets.DISABLE_RINGTONE.equals(target)) {
                 setDisableRingtone(intent.getBooleanExtra("value", Constants.ConfigDefaultValues.DISABLE_RINGTONE));
             } else if (Constants.GamingActionTargets.SHOW_DANMAKU.equals(target)) {
@@ -237,10 +235,8 @@
             mCurrentConfig.putInt(Constants.ConfigKeys.PERFORMANCE_LEVEL, performanceLevel);
         }
 
-        // hw keys & gesture
-        boolean disableHwKeys = getBooleanSetting(Constants.ConfigKeys.DISABLE_HW_KEYS, Constants.ConfigDefaultValues.DISABLE_HW_KEYS);
+        // gesture
         boolean disableGesture = getBooleanSetting(Constants.ConfigKeys.DISABLE_GESTURE, Constants.ConfigDefaultValues.DISABLE_GESTURE);
-        setDisableHwKeys(disableHwKeys, false);
         setDisableGesture(disableGesture);
 
         // quick-start apps
@@ -258,22 +254,6 @@
         LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
     }
 
-    private void setDisableHwKeys(boolean disable, boolean restore) {
-        if (mLineageHardware == null) return;
-        if (!mCurrentConfig.containsKey("old_disable_hw_keys")) {
-            boolean oldValue = mLineageHardware.get(LineageHardwareManager.FEATURE_KEY_DISABLE);
-            mCurrentConfig.putBoolean("old_disable_hw_keys", oldValue);
-        }
-        if (!restore) {
-            mCurrentConfig.putBoolean(Constants.ConfigKeys.DISABLE_HW_KEYS, disable);
-            mLineageHardware.set(LineageHardwareManager.FEATURE_KEY_DISABLE, disable);
-        } else {
-            boolean oldValue = mCurrentConfig.getBoolean("old_disable_hw_keys");
-            mCurrentConfig.putBoolean(Constants.ConfigKeys.DISABLE_HW_KEYS, oldValue);
-            mLineageHardware.set(LineageHardwareManager.FEATURE_KEY_DISABLE, oldValue);
-        }
-    }
-
     private void setDisableGesture(boolean disable) {
         mCurrentConfig.putBoolean(Constants.ConfigKeys.DISABLE_GESTURE, disable);
         try {
@@ -339,7 +319,6 @@
         stopServiceAsUser(mOverlayServiceIntent, UserHandle.CURRENT);
         mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
         setDisableGesture(false);
-        setDisableHwKeys(false, true);
         setDisableAutoBrightness(false, true);
         setDisableRingtone(false);
         setPerformanceLevel(-1);
diff --git a/app/src/main/java/org/exthmui/game/ui/QuickSettingsView.java b/app/src/main/java/org/exthmui/game/ui/QuickSettingsView.java
index 8655bda..41f3f29 100644
--- a/app/src/main/java/org/exthmui/game/ui/QuickSettingsView.java
+++ b/app/src/main/java/org/exthmui/game/ui/QuickSettingsView.java
@@ -28,7 +28,6 @@
 import org.exthmui.game.qs.DNDTile;
 import org.exthmui.game.qs.DanmakuTile;
 import org.exthmui.game.qs.LockGestureTile;
-import org.exthmui.game.qs.LockHwKeysTile;
 import org.exthmui.game.qs.ScreenCaptureTile;
 import org.exthmui.game.qs.ScreenRecordTile;
 import org.exthmui.game.qs.TileBase;
@@ -61,7 +60,6 @@
                 new ScreenRecordTile(context),
                 new DanmakuTile(context),
                 new DNDTile(context),
-                new LockHwKeysTile(context),
                 new LockGestureTile(context),
                 new AutoBrightnessTile(context)
         };
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 00515a9..e3b87a2 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -22,7 +22,6 @@
     <string name="qs_danmaku">Danmaku</string>
     <string name="qs_dnd">Do not disturb</string>
     <string name="qs_lock_gesture">Lock gesture</string>
-    <string name="qs_lock_hw_keys">Lock hardware keys</string>
     <string name="qs_screen_capture">Screen capture</string>
     <string name="qs_screen_record">Screen record</string>
     <string name="screenrecord_audio_label">Record audio</string>
@@ -35,4 +34,4 @@
     <string name="screenrecord_mic_label">Microphone</string>
     <!-- Label for an option to record audio from both device and microphone [CHAR LIMIT=NONE]-->
     <string name="screenrecord_device_audio_and_mic_label">Device audio and microphone</string>
-</resources>
\ No newline at end of file
+</resources>
