diff --git a/androidtv/basetv/basetv.py b/androidtv/basetv/basetv.py
index 0f895890..8174d8ef 100644
--- a/androidtv/basetv/basetv.py
+++ b/androidtv/basetv/basetv.py
@@ -69,7 +69,14 @@ class BaseTV(object):  # pylint: disable=too-few-public-methods
     DEVICE_ENUM = constants.DeviceEnum.BASETV
 
     def __init__(
-        self, adb, host, port=5555, adbkey="", adb_server_ip="", adb_server_port=5037, state_detection_rules=None
+        self,
+        adb,
+        host,
+        port=5555,
+        adbkey="",
+        adb_server_ip="",
+        adb_server_port=5037,
+        state_detection_rules=None,
     ):
         self._adb = adb
         self.host = host
@@ -131,6 +138,14 @@ def _cmd_audio_state(self):
         # Is this an Android 11 device?
         if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
             return constants.CMD_AUDIO_STATE11
+
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_AUDIO_STATE11
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_AUDIO_STATE11
         return constants.CMD_AUDIO_STATE
 
     def _cmd_current_app(self):
@@ -157,6 +172,14 @@ def _cmd_current_app(self):
         if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
             return constants.CMD_CURRENT_APP11
 
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_CURRENT_APP12
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_CURRENT_APP13
+
         return constants.CMD_CURRENT_APP
 
     def _cmd_current_app_media_session_state(self):
@@ -183,6 +206,14 @@ def _cmd_current_app_media_session_state(self):
         if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
             return constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE11
 
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE12
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE13
+
         return constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE
 
     def _cmd_hdmi_input(self):
@@ -201,8 +232,39 @@ def _cmd_hdmi_input(self):
         if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
             return constants.CMD_HDMI_INPUT11
 
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_HDMI_INPUT11
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_HDMI_INPUT11
+
         return constants.CMD_HDMI_INPUT
 
+    def _cmd_volume_set(self):
+        """Get the command used to set volume for this device.
+
+        Returns
+        -------
+        str
+            The device-specific ADB shell command used to set volume
+
+        """
+        # Is this an Android 11 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
+            return constants.CMD_VOLUME_SET_COMMAND11
+
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_VOLUME_SET_COMMAND11
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_VOLUME_SET_COMMAND11
+
+        return constants.CMD_VOLUME_SET_COMMAND
+
     def _cmd_launch_app(self, app):
         """Get the command to launch the specified app for this device.
 
@@ -235,6 +297,14 @@ def _cmd_launch_app(self, app):
         if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "11":
             return constants.CMD_LAUNCH_APP11.format(app)
 
+        # Is this an Android 12 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "12":
+            return constants.CMD_LAUNCH_APP12.format(app)
+
+        # Is this an Android 13 device?
+        if self.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV and self.device_properties.get("sw_version", "") == "13":
+            return constants.CMD_LAUNCH_APP13.format(app)
+
         return constants.CMD_LAUNCH_APP.format(app)
 
     def _cmd_running_apps(self):
@@ -339,7 +409,12 @@ def _parse_device_properties(self, properties):
         ``'serialno'``, ``'manufacturer'``, ``'model'``, and ``'sw_version'``
 
         """
-        _LOGGER.debug("%s:%d `get_device_properties` response: %s", self.host, self.port, properties)
+        _LOGGER.debug(
+            "%s:%d `get_device_properties` response: %s",
+            self.host,
+            self.port,
+            properties,
+        )
 
         if not properties:
             self.device_properties = {}
@@ -353,7 +428,12 @@ def _parse_device_properties(self, properties):
         manufacturer, model, serialno, version = lines
 
         if not serialno.strip():
-            _LOGGER.warning("Could not obtain serialno for %s:%d, got: '%s'", self.host, self.port, serialno)
+            _LOGGER.warning(
+                "Could not obtain serialno for %s:%d, got: '%s'",
+                self.host,
+                self.port,
+                serialno,
+            )
             serialno = None
 
         self.device_properties = {
@@ -393,7 +473,11 @@ def _parse_mac_address(mac_response):
     #                                                                         #
     # ======================================================================= #
     def _custom_state_detection(
-        self, current_app=None, media_session_state=None, wake_lock_size=None, audio_state=None
+        self,
+        current_app=None,
+        media_session_state=None,
+        wake_lock_size=None,
+        audio_state=None,
     ):
         """Use the rules in ``self._state_detection_rules`` to determine the state.
 
@@ -670,7 +754,11 @@ def _parse_stream_music(stream_music_raw):
         if not stream_music_raw:
             return None
 
-        matches = re.findall(constants.STREAM_MUSIC_REGEX_PATTERN, stream_music_raw, re.DOTALL | re.MULTILINE)
+        matches = re.findall(
+            constants.STREAM_MUSIC_REGEX_PATTERN,
+            stream_music_raw,
+            re.DOTALL | re.MULTILINE,
+        )
         if matches:
             return matches[0]
 
@@ -747,7 +835,11 @@ def _volume(self, stream_music, audio_output_device):
             return None
 
         if not self.max_volume:
-            max_volume_matches = re.findall(constants.MAX_VOLUME_REGEX_PATTERN, stream_music, re.DOTALL | re.MULTILINE)
+            max_volume_matches = re.findall(
+                constants.MAX_VOLUME_REGEX_PATTERN,
+                stream_music,
+                re.DOTALL | re.MULTILINE,
+            )
             if max_volume_matches:
                 self.max_volume = float(max_volume_matches[0])
 
@@ -755,7 +847,9 @@ def _volume(self, stream_music, audio_output_device):
             return None
 
         volume_matches = re.findall(
-            audio_output_device + constants.VOLUME_REGEX_PATTERN, stream_music, re.DOTALL | re.MULTILINE
+            audio_output_device + constants.VOLUME_REGEX_PATTERN,
+            stream_music,
+            re.DOTALL | re.MULTILINE,
         )
         if volume_matches:
             return int(volume_matches[0])
@@ -899,7 +993,9 @@ def state_detection_rules_validator(rules, exc=KeyError):
                     if not isinstance(value, constants.VALID_PROPERTIES_TYPES[prop]):
                         raise exc(
                             "Conditional value for property '{0}' must be of type {1}, not {2}".format(
-                                prop, constants.VALID_PROPERTIES_TYPES[prop].__name__, type(value).__name__
+                                prop,
+                                constants.VALID_PROPERTIES_TYPES[prop].__name__,
+                                type(value).__name__,
                             )
                         )
 
diff --git a/androidtv/basetv/basetv_async.py b/androidtv/basetv/basetv_async.py
index e57198b7..b733fd87 100644
--- a/androidtv/basetv/basetv_async.py
+++ b/androidtv/basetv/basetv_async.py
@@ -830,7 +830,7 @@ async def set_volume_level(self, volume_level):
 
         new_volume = int(min(max(round(self.max_volume * volume_level), 0.0), self.max_volume))
 
-        await self._adb.shell("media volume --show --stream 3 --set {}".format(new_volume))
+        await self._adb.shell(self._cmd_volume_set().format(new_volume))
 
         # return the new volume level
         return new_volume / self.max_volume
diff --git a/androidtv/constants.py b/androidtv/constants.py
index 320a0df1..c1c20a67 100644
--- a/androidtv/constants.py
+++ b/androidtv/constants.py
@@ -89,7 +89,6 @@ class DeviceEnum(IntEnum):
 
 #: Parse current application for an Android 11 device
 CMD_PARSE_CURRENT_APP11 = "CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* }"
-
 #: Assign focused application identifier to ``CURRENT_APP`` variable
 CMD_DEFINE_CURRENT_APP_VARIABLE = (
     "CURRENT_APP=$(dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp') && " + CMD_PARSE_CURRENT_APP
@@ -99,6 +98,17 @@ class DeviceEnum(IntEnum):
     "CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'mInputMethod(Input)?Target') && " + CMD_PARSE_CURRENT_APP11
 )
 
+#: Assign focused application identifier to ``CURRENT_APP`` variable for an Android 12 device
+CMD_DEFINE_CURRENT_APP_VARIABLE12 = (
+    "CURRENT_APP=$(dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp|mObscuringWindow') && "
+    + CMD_PARSE_CURRENT_APP11
+)
+
+#: Assign focused application identifier to ``CURRENT_APP`` variable for an Android 13 device
+CMD_DEFINE_CURRENT_APP_VARIABLE13 = (
+    "CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'imeLayeringTarget|imeInputTarget|imeControlTarget') && "
+    + CMD_PARSE_CURRENT_APP11
+)
 
 #: Output identifier for current/focused application
 CMD_CURRENT_APP = CMD_DEFINE_CURRENT_APP_VARIABLE + " && echo $CURRENT_APP"
@@ -106,6 +116,12 @@ class DeviceEnum(IntEnum):
 #: Output identifier for current/focused application for an Android 11 device
 CMD_CURRENT_APP11 = CMD_DEFINE_CURRENT_APP_VARIABLE11 + " && echo $CURRENT_APP"
 
+#: Output identifier for current/focused application for an Android 12 device
+CMD_CURRENT_APP12 = CMD_DEFINE_CURRENT_APP_VARIABLE12 + " && echo $CURRENT_APP"
+
+#: Output identifier for current/focused application for an Android 13 device
+CMD_CURRENT_APP13 = CMD_DEFINE_CURRENT_APP_VARIABLE13 + " && echo $CURRENT_APP"
+
 #: Assign focused application identifier to ``CURRENT_APP`` variable (for a Google TV device)
 CMD_DEFINE_CURRENT_APP_VARIABLE_GOOGLE_TV = (
     "CURRENT_APP=$(dumpsys activity a . | grep mResumedActivity) && " + CMD_PARSE_CURRENT_APP
@@ -114,6 +130,12 @@ class DeviceEnum(IntEnum):
 #: Output identifier for current/focused application (for a Google TV device)
 CMD_CURRENT_APP_GOOGLE_TV = CMD_DEFINE_CURRENT_APP_VARIABLE_GOOGLE_TV + " && echo $CURRENT_APP"
 
+#: set volume
+CMD_VOLUME_SET_COMMAND = "media volume --show --stream 3 --set {}"
+
+#: set volume for an Android 11 & 12 & 13 device
+CMD_VOLUME_SET_COMMAND11 = "cmd media_session volume --show --stream 3 --set {}"
+
 #: Get the HDMI input
 CMD_HDMI_INPUT = (
     "dumpsys activity starter | grep -E -o '(ExternalTv|HDMI)InputService/HW[0-9]' -m 1 | grep -o 'HW[0-9]'"
@@ -145,6 +167,16 @@ class DeviceEnum(IntEnum):
     CMD_DEFINE_CURRENT_APP_VARIABLE11.replace("{", "{{").replace("}", "}}") + " && " + CMD_LAUNCH_APP_CONDITION
 )
 
+#: Launch an app if it is not already the current app on an Android 12 device
+CMD_LAUNCH_APP12 = (
+    CMD_DEFINE_CURRENT_APP_VARIABLE12.replace("{", "{{").replace("}", "}}") + " && " + CMD_LAUNCH_APP_CONDITION
+)
+
+#: Launch an app if it is not already the current app on an Android 11 device
+CMD_LAUNCH_APP13 = (
+    CMD_DEFINE_CURRENT_APP_VARIABLE13.replace("{", "{{").replace("}", "}}") + " && " + CMD_LAUNCH_APP_CONDITION
+)
+
 #: Launch an app on a Fire TV device
 CMD_LAUNCH_APP_FIRETV = (
     CMD_DEFINE_CURRENT_APP_VARIABLE.replace("{", "{{").replace("}", "}}") + " && " + CMD_LAUNCH_APP_CONDITION_FIRETV
@@ -164,6 +196,12 @@ class DeviceEnum(IntEnum):
 #: Determine the current app and get the state from ``dumpsys media_session`` for an Android 11 device
 CMD_CURRENT_APP_MEDIA_SESSION_STATE11 = CMD_CURRENT_APP11 + " && " + CMD_MEDIA_SESSION_STATE
 
+#: Determine the current app and get the state from ``dumpsys media_session`` for an Android 12 device
+CMD_CURRENT_APP_MEDIA_SESSION_STATE12 = CMD_CURRENT_APP12 + " && " + CMD_MEDIA_SESSION_STATE
+
+#: Determine the current app and get the state from ``dumpsys media_session`` for an Android 13 device
+CMD_CURRENT_APP_MEDIA_SESSION_STATE13 = CMD_CURRENT_APP13 + " && " + CMD_MEDIA_SESSION_STATE
+
 #: Determine the current app and get the state from ``dumpsys media_session`` for a Google TV device
 CMD_CURRENT_APP_MEDIA_SESSION_STATE_GOOGLE_TV = CMD_CURRENT_APP_GOOGLE_TV + " && " + CMD_MEDIA_SESSION_STATE
 
@@ -381,7 +419,11 @@ class DeviceEnum(IntEnum):
 VALID_PROPERTIES = VALID_STATE_PROPERTIES + ("wake_lock_size",)
 
 #: The required type for each entry in :py:const:`VALID_PROPERTIES` (used by :func:`~androidtv.basetv.state_detection_rules_validator`)
-VALID_PROPERTIES_TYPES = {"audio_state": str, "media_session_state": int, "wake_lock_size": int}
+VALID_PROPERTIES_TYPES = {
+    "audio_state": str,
+    "media_session_state": int,
+    "wake_lock_size": int,
+}
 
 # https://developer.android.com/reference/android/media/session/PlaybackState.html
 #: States for the :attr:`~androidtv.basetv.basetv.BaseTV.media_session_state` property
@@ -483,6 +525,7 @@ class DeviceEnum(IntEnum):
 APP_TWITCH_FIRETV = "tv.twitch.android.viewer"
 APP_VEVO = "com.vevo.tv"
 APP_VH1 = "com.mtvn.vh1android"
+APP_VIKI = "com.viki.android"
 APP_VIMEO = "com.vimeo.android.videoapp"
 APP_VLC = "org.videolan.vlc"
 APP_VOYO = "com.phonegap.voyo"
@@ -590,6 +633,7 @@ class DeviceEnum(IntEnum):
     APP_TWITCH_FIRETV: "Twitch (FireTV)",
     APP_VEVO: "Vevo",
     APP_VH1: "VH1",
+    APP_VIKI: "Rakuten Viki",
     APP_VIMEO: "Vimeo",
     APP_VLC: "VLC",
     APP_VOYO: "VOYO",
diff --git a/tests/generate_test_constants.py b/tests/generate_test_constants.py
index f1decd70..74e5769d 100644
--- a/tests/generate_test_constants.py
+++ b/tests/generate_test_constants.py
@@ -12,8 +12,12 @@
     "CMD_SUCCESS1_FAILURE0",
     "CMD_PARSE_CURRENT_APP",
     "CMD_PARSE_CURRENT_APP11",
+    "CMD_PARSE_CURRENT_APP12",
+    "CMD_PARSE_CURRENT_APP13",
     "CMD_DEFINE_CURRENT_APP_VARIABLE",
     "CMD_DEFINE_CURRENT_APP_VARIABLE11",
+    "CMD_DEFINE_CURRENT_APP_VARIABLE12",
+    "CMD_DEFINE_CURRENT_APP_VARIABLE13",
     "CMD_DEFINE_CURRENT_APP_VARIABLE_GOOGLE_TV",
     "CMD_LAUNCH_APP_CONDITION",
     "CMD_LAUNCH_APP_CONDITION_FIRETV",
diff --git a/tests/test_basetv_sync.py b/tests/test_basetv_sync.py
index d8babddd..073d676b 100644
--- a/tests/test_basetv_sync.py
+++ b/tests/test_basetv_sync.py
@@ -104,6 +104,24 @@
 WIFIMAC_SHIELD_TV_11 = "    link/ether 11:22:33:44:55:66 brd ff:ff:ff:ff:ff:ff"
 ETHMAC_SHIELD_TV_11 = "    link/ether ab:cd:ef:gh:ij:kl brd ff:ff:ff:ff:ff:ff"
 
+DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_12 = """NVIDIA
+SHIELD Android TV
+0123456789012
+12
+"""
+
+WIFIMAC_SHIELD_TV_12 = "    link/ether 11:22:33:44:55:66 brd ff:ff:ff:ff:ff:ff"
+ETHMAC_SHIELD_TV_12 = "    link/ether ab:cd:ef:gh:ij:kl brd ff:ff:ff:ff:ff:ff"
+
+DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_13 = """NVIDIA
+SHIELD Android TV
+0123456789012
+13
+"""
+
+WIFIMAC_SHIELD_TV_13 = "    link/ether 11:22:33:44:55:66 brd ff:ff:ff:ff:ff:ff"
+ETHMAC_SHIELD_TV_13 = "    link/ether ab:cd:ef:gh:ij:kl brd ff:ff:ff:ff:ff:ff"
+
 DEVICE_PROPERTIES_DICT_SHIELD_TV_11 = {
     "manufacturer": "NVIDIA",
     "model": "SHIELD Android TV",
@@ -113,6 +131,24 @@
     "ethmac": "ab:cd:ef:gh:ij:kl",
 }
 
+DEVICE_PROPERTIES_DICT_SHIELD_TV_12 = {
+    "manufacturer": "NVIDIA",
+    "model": "SHIELD Android TV",
+    "serialno": "0123456789012",
+    "sw_version": "12",
+    "wifimac": "11:22:33:44:55:66",
+    "ethmac": "ab:cd:ef:gh:ij:kl",
+}
+
+DEVICE_PROPERTIES_DICT_SHIELD_TV_13 = {
+    "manufacturer": "NVIDIA",
+    "model": "SHIELD Android TV",
+    "serialno": "0123456789012",
+    "sw_version": "13",
+    "wifimac": "11:22:33:44:55:66",
+    "ethmac": "ab:cd:ef:gh:ij:kl",
+}
+
 INSTALLED_APPS_OUTPUT_1 = """package:org.example.app
 package:org.example.launcher
 """
@@ -190,290 +226,350 @@ def test_keys(self):
 
             self.btv.space()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_SPACE)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_SPACE),
             )
 
             self.btv.key_0()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_0)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_0),
             )
 
             self.btv.key_1()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_1)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_1),
             )
 
             self.btv.key_2()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_2)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_2),
             )
 
             self.btv.key_3()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_3)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_3),
             )
 
             self.btv.key_4()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_4)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_4),
             )
 
             self.btv.key_5()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_5)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_5),
             )
 
             self.btv.key_6()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_6)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_6),
             )
 
             self.btv.key_7()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_7)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_7),
             )
 
             self.btv.key_8()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_8)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_8),
             )
 
             self.btv.key_9()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_9)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_9),
             )
 
             self.btv.key_a()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_A)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_A),
             )
 
             self.btv.key_b()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_B)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_B),
             )
 
             self.btv.key_c()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_C)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_C),
             )
 
             self.btv.key_d()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_D)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_D),
             )
 
             self.btv.key_e()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_E)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_E),
             )
 
             self.btv.key_f()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_F)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_F),
             )
 
             self.btv.key_g()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_G)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_G),
             )
 
             self.btv.key_h()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_H)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_H),
             )
 
             self.btv.key_i()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_I)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_I),
             )
 
             self.btv.key_j()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_J)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_J),
             )
 
             self.btv.key_k()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_K)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_K),
             )
 
             self.btv.key_l()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_L)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_L),
             )
 
             self.btv.key_m()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_M)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_M),
             )
 
             self.btv.key_n()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_N)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_N),
             )
 
             self.btv.key_o()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_O)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_O),
             )
 
             self.btv.key_p()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_P)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_P),
             )
 
             self.btv.key_q()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_Q)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_Q),
             )
 
             self.btv.key_r()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_R)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_R),
             )
 
             self.btv.key_s()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_S)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_S),
             )
 
             self.btv.key_t()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_T)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_T),
             )
 
             self.btv.key_u()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_U)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_U),
             )
 
             self.btv.key_v()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_V)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_V),
             )
 
             self.btv.key_w()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_W)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_W),
             )
 
             self.btv.key_x()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_X)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_X),
             )
 
             self.btv.key_y()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_Y)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_Y),
             )
 
             self.btv.key_z()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_Z)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_Z),
             )
 
             self.btv.power()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_POWER)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_POWER),
             )
 
             self.btv.sleep()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_SLEEP)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_SLEEP),
             )
 
             self.btv.home()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_HOME)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_HOME),
             )
 
             self.btv.up()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_UP)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_UP),
             )
 
             self.btv.down()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_DOWN)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_DOWN),
             )
 
             self.btv.left()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_LEFT)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_LEFT),
             )
 
             self.btv.right()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_RIGHT)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_RIGHT),
             )
 
             self.btv.enter()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_ENTER)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_ENTER),
             )
 
             self.btv.back()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_BACK)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_BACK),
             )
 
             self.btv.menu()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_MENU)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_MENU),
             )
 
             self.btv.mute_volume()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_MUTE)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_MUTE),
             )
 
             self.btv.media_play()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_PLAY)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_PLAY),
             )
 
             self.btv.media_pause()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_PAUSE)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_PAUSE),
             )
 
             self.btv.media_play_pause()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_PLAY_PAUSE)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_PLAY_PAUSE),
             )
 
             self.btv.media_stop()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_STOP)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_STOP),
             )
 
             self.btv.media_next_track()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_NEXT)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_NEXT),
             )
 
             self.btv.media_previous_track()
             self.assertEqual(
-                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd, "input keyevent {}".format(constants.KEY_PREVIOUS)
+                getattr(self.btv._adb, self.ADB_ATTR).shell_cmd,
+                "input keyevent {}".format(constants.KEY_PREVIOUS),
             )
 
     def test_get_device_properties(self):
         """Check that ``get_device_properties`` works correctly."""
         with patch.object(
-            self.btv._adb, "shell", side_effect=(DEVICE_PROPERTIES_OUTPUT1, ETHMAC_OUTPUT1, WIFIMAC_OUTPUT1)
+            self.btv._adb,
+            "shell",
+            side_effect=(DEVICE_PROPERTIES_OUTPUT1, ETHMAC_OUTPUT1, WIFIMAC_OUTPUT1),
         ):
             device_properties = self.btv.get_device_properties()
             self.assertDictEqual(DEVICE_PROPERTIES_DICT1, device_properties)
 
         with patch.object(
-            self.btv._adb, "shell", side_effect=(DEVICE_PROPERTIES_OUTPUT2, ETHMAC_OUTPUT1, WIFIMAC_OUTPUT1)
+            self.btv._adb,
+            "shell",
+            side_effect=(DEVICE_PROPERTIES_OUTPUT2, ETHMAC_OUTPUT1, WIFIMAC_OUTPUT1),
         ):
             device_properties = self.btv.get_device_properties()
             self.assertDictEqual(DEVICE_PROPERTIES_DICT2, device_properties)
 
         with patch.object(
-            self.btv._adb, "shell", side_effect=(DEVICE_PROPERTIES_OUTPUT3, ETHMAC_OUTPUT3, WIFIMAC_OUTPUT3)
+            self.btv._adb,
+            "shell",
+            side_effect=(DEVICE_PROPERTIES_OUTPUT3, ETHMAC_OUTPUT3, WIFIMAC_OUTPUT3),
         ):
             device_properties = self.btv.get_device_properties()
             self.assertDictEqual(DEVICE_PROPERTIES_DICT3, device_properties)
@@ -487,7 +583,9 @@ def test_get_device_properties(self):
             self.assertDictEqual({"ethmac": None, "wifimac": None}, device_properties)
 
         with patch.object(
-            self.btv._adb, "shell", side_effect=(DEVICE_PROPERTIES_GOOGLE_TV, ETHMAC_GOOGLE, WIFIMAC_GOOGLE)
+            self.btv._adb,
+            "shell",
+            side_effect=(DEVICE_PROPERTIES_GOOGLE_TV, ETHMAC_GOOGLE, WIFIMAC_GOOGLE),
         ):
             self.btv = AndroidTVSync.from_base(self.btv)
             device_properties = self.btv.get_device_properties()
@@ -496,12 +594,18 @@ def test_get_device_properties(self):
             self.assertEqual(self.btv.device_properties["manufacturer"], "Google")
             self.assertEqual(self.btv._cmd_current_app(), constants.CMD_CURRENT_APP_GOOGLE_TV)
             self.assertEqual(
-                self.btv._cmd_current_app_media_session_state(), constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE_GOOGLE_TV
+                self.btv._cmd_current_app_media_session_state(),
+                constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE_GOOGLE_TV,
+            )
+            self.assertEqual(
+                self.btv._cmd_launch_app("TEST"),
+                constants.CMD_LAUNCH_APP_GOOGLE_TV.format("TEST"),
             )
-            self.assertEqual(self.btv._cmd_launch_app("TEST"), constants.CMD_LAUNCH_APP_GOOGLE_TV.format("TEST"))
 
         with patch.object(
-            self.btv._adb, "shell", side_effect=(DEVICE_PROPERTIES_OUTPUT_SONY_TV, ETHMAC_SONY, WIFIMAC_SONY)
+            self.btv._adb,
+            "shell",
+            side_effect=(DEVICE_PROPERTIES_OUTPUT_SONY_TV, ETHMAC_SONY, WIFIMAC_SONY),
         ):
             device_properties = self.btv.get_device_properties()
             self.assertDictEqual(DEVICE_PROPERTIES_DICT_SONY_TV, device_properties)
@@ -509,7 +613,11 @@ def test_get_device_properties(self):
         with patch.object(
             self.btv._adb,
             "shell",
-            side_effect=(DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_11, ETHMAC_SHIELD_TV_11, WIFIMAC_SHIELD_TV_11),
+            side_effect=(
+                DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_11,
+                ETHMAC_SHIELD_TV_11,
+                WIFIMAC_SHIELD_TV_11,
+            ),
         ):
             self.btv = AndroidTVSync.from_base(self.btv)
             device_properties = self.btv.get_device_properties()
@@ -518,16 +626,88 @@ def test_get_device_properties(self):
             self.assertDictEqual(DEVICE_PROPERTIES_DICT_SHIELD_TV_11, device_properties)
             # _cmd_audio_state
             self.assertEqual(self.btv._cmd_audio_state(), constants.CMD_AUDIO_STATE11)
+            # _cmd_volume_set
+            self.assertEqual(self.btv._cmd_volume_set(), constants.CMD_VOLUME_SET_COMMAND11)
             # _cmd_current_app
             self.assertEqual(self.btv._cmd_current_app(), constants.CMD_CURRENT_APP11)
             # _cmd_current_app_media_session_state
             self.assertEqual(
-                self.btv._cmd_current_app_media_session_state(), constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE11
+                self.btv._cmd_current_app_media_session_state(),
+                constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE11,
+            )
+            # _cmd_hdmi_input
+            self.assertEqual(self.btv._cmd_hdmi_input(), constants.CMD_HDMI_INPUT11)
+            # _cmd_launch_app
+            self.assertEqual(
+                self.btv._cmd_launch_app("TEST"),
+                constants.CMD_LAUNCH_APP11.format("TEST"),
+            )
+
+        with patch.object(
+            self.btv._adb,
+            "shell",
+            side_effect=(
+                DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_12,
+                ETHMAC_SHIELD_TV_12,
+                WIFIMAC_SHIELD_TV_12,
+            ),
+        ):
+            self.btv = AndroidTVSync.from_base(self.btv)
+            device_properties = self.btv.get_device_properties()
+            assert self.btv.device_properties.get("sw_version", "") == "12"
+            assert self.btv.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV
+            self.assertDictEqual(DEVICE_PROPERTIES_DICT_SHIELD_TV_12, device_properties)
+            # _cmd_audio_state
+            self.assertEqual(self.btv._cmd_audio_state(), constants.CMD_AUDIO_STATE11)
+            # _cmd_volume_set
+            self.assertEqual(self.btv._cmd_volume_set(), constants.CMD_VOLUME_SET_COMMAND11)
+            # _cmd_current_app
+            self.assertEqual(self.btv._cmd_current_app(), constants.CMD_CURRENT_APP12)
+            # _cmd_current_app_media_session_state
+            self.assertEqual(
+                self.btv._cmd_current_app_media_session_state(),
+                constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE12,
+            )
+            # _cmd_hdmi_input
+            self.assertEqual(self.btv._cmd_hdmi_input(), constants.CMD_HDMI_INPUT11)
+            # _cmd_launch_app
+            self.assertEqual(
+                self.btv._cmd_launch_app("TEST"),
+                constants.CMD_LAUNCH_APP12.format("TEST"),
+            )
+
+        with patch.object(
+            self.btv._adb,
+            "shell",
+            side_effect=(
+                DEVICE_PROPERTIES_OUTPUT_SHIELD_TV_13,
+                ETHMAC_SHIELD_TV_13,
+                WIFIMAC_SHIELD_TV_13,
+            ),
+        ):
+            self.btv = AndroidTVSync.from_base(self.btv)
+            device_properties = self.btv.get_device_properties()
+            assert self.btv.device_properties.get("sw_version", "") == "13"
+            assert self.btv.DEVICE_ENUM == constants.DeviceEnum.ANDROIDTV
+            self.assertDictEqual(DEVICE_PROPERTIES_DICT_SHIELD_TV_13, device_properties)
+            # _cmd_audio_state
+            self.assertEqual(self.btv._cmd_audio_state(), constants.CMD_AUDIO_STATE11)
+            # _cmd_volume_set
+            self.assertEqual(self.btv._cmd_volume_set(), constants.CMD_VOLUME_SET_COMMAND11)
+            # _cmd_current_app
+            self.assertEqual(self.btv._cmd_current_app(), constants.CMD_CURRENT_APP13)
+            # _cmd_current_app_media_session_state
+            self.assertEqual(
+                self.btv._cmd_current_app_media_session_state(),
+                constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE13,
             )
             # _cmd_hdmi_input
             self.assertEqual(self.btv._cmd_hdmi_input(), constants.CMD_HDMI_INPUT11)
             # _cmd_launch_app
-            self.assertEqual(self.btv._cmd_launch_app("TEST"), constants.CMD_LAUNCH_APP11.format("TEST"))
+            self.assertEqual(
+                self.btv._cmd_launch_app("TEST"),
+                constants.CMD_LAUNCH_APP13.format("TEST"),
+            )
 
     def test_get_installed_apps(self):
         """ "Check that `get_installed_apps` works correctly."""
@@ -632,9 +812,12 @@ def test_screen_on_awake_wake_lock_size(self):
         with patchers.patch_shell("11Wake Locks: size=2")[self.PATCH_KEY]:
             self.assertTupleEqual(self.btv.screen_on_awake_wake_lock_size(), (True, True, 2))
 
-        with patchers.patch_shell(["Failed to write while dumping serviceWake Locks: size=2", "11Wake Locks: size=2"])[
-            self.PATCH_KEY
-        ]:
+        with patchers.patch_shell(
+            [
+                "Failed to write while dumping serviceWake Locks: size=2",
+                "11Wake Locks: size=2",
+            ]
+        )[self.PATCH_KEY]:
             self.assertTupleEqual(self.btv.screen_on_awake_wake_lock_size(), (True, True, 2))
 
     def test_state_detection_rules_validator(self):
@@ -649,37 +832,114 @@ def test_state_detection_rules_validator(self):
 
             # Make sure that an error is raised when the state detection rules are invalid
             self.assertRaises(
-                TypeError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID1
+                TypeError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID1,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID2
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID2,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID3
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID3,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID4
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID4,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID5
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID5,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID6
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID6,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID7
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID7,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID8
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID8,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID9
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID9,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID10
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID10,
             )
             self.assertRaises(
-                KeyError, BaseTVSync, "HOST", 5555, "", "", 5037, state_detection_rules=STATE_DETECTION_RULES_INVALID11
+                KeyError,
+                BaseTVSync,
+                "HOST",
+                5555,
+                "",
+                "",
+                5037,
+                state_detection_rules=STATE_DETECTION_RULES_INVALID11,
             )
 
     def test_wake_lock_size(self):
diff --git a/tests/test_constants.py b/tests/test_constants.py
index 8093b012..ec9a5d16 100644
--- a/tests/test_constants.py
+++ b/tests/test_constants.py
@@ -89,6 +89,18 @@ def test_constants(self):
             r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'mInputMethod(Input)?Target') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP",
         )
 
+        # CMD_CURRENT_APP12
+        self.assertCommand(
+            constants.CMD_CURRENT_APP12,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp|mObscuringWindow') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP",
+        )
+
+        # CMD_CURRENT_APP13
+        self.assertCommand(
+            constants.CMD_CURRENT_APP13,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'imeLayeringTarget|imeInputTarget|imeControlTarget') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP",
+        )
+
         # CMD_CURRENT_APP_GOOGLE_TV
         self.assertCommand(
             constants.CMD_CURRENT_APP_GOOGLE_TV,
@@ -107,6 +119,18 @@ def test_constants(self):
             r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'mInputMethod(Input)?Target') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP && dumpsys media_session | grep -A 100 'Sessions Stack' | grep -A 100 $CURRENT_APP | grep -m 1 'state=PlaybackState {'",
         )
 
+        # CMD_CURRENT_APP_MEDIA_SESSION_STATE12
+        self.assertCommand(
+            constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE12,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp|mObscuringWindow') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP && dumpsys media_session | grep -A 100 'Sessions Stack' | grep -A 100 $CURRENT_APP | grep -m 1 'state=PlaybackState {'",
+        )
+
+        # CMD_CURRENT_APP_MEDIA_SESSION_STATE13
+        self.assertCommand(
+            constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE13,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'imeLayeringTarget|imeInputTarget|imeControlTarget') && CURRENT_APP=${CURRENT_APP%%/*} && CURRENT_APP=${CURRENT_APP##* } && echo $CURRENT_APP && dumpsys media_session | grep -A 100 'Sessions Stack' | grep -A 100 $CURRENT_APP | grep -m 1 'state=PlaybackState {'",
+        )
+
         # CMD_CURRENT_APP_MEDIA_SESSION_STATE_GOOGLE_TV
         self.assertCommand(
             constants.CMD_CURRENT_APP_MEDIA_SESSION_STATE_GOOGLE_TV,
@@ -146,6 +170,18 @@ def test_constants(self):
             r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'mInputMethod(Input)?Target') && CURRENT_APP=${{CURRENT_APP%%/*}} && CURRENT_APP=${{CURRENT_APP##* }} && if [ $CURRENT_APP != '{0}' ]; then monkey -p {0} -c android.intent.category.LEANBACK_LAUNCHER --pct-syskeys 0 1; fi",
         )
 
+        # CMD_LAUNCH_APP12
+        self.assertCommand(
+            constants.CMD_LAUNCH_APP12,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp|mObscuringWindow') && CURRENT_APP=${{CURRENT_APP%%/*}} && CURRENT_APP=${{CURRENT_APP##* }} && if [ $CURRENT_APP != '{0}' ]; then monkey -p {0} -c android.intent.category.LEANBACK_LAUNCHER --pct-syskeys 0 1; fi",
+        )
+
+        # CMD_LAUNCH_APP13
+        self.assertCommand(
+            constants.CMD_LAUNCH_APP13,
+            r"CURRENT_APP=$(dumpsys window windows | grep -E -m 1 'imeLayeringTarget|imeInputTarget|imeControlTarget') && CURRENT_APP=${{CURRENT_APP%%/*}} && CURRENT_APP=${{CURRENT_APP##* }} && if [ $CURRENT_APP != '{0}' ]; then monkey -p {0} -c android.intent.category.LEANBACK_LAUNCHER --pct-syskeys 0 1; fi",
+        )
+
         # CMD_LAUNCH_APP_FIRETV
         self.assertCommand(
             constants.CMD_LAUNCH_APP_FIRETV,
@@ -227,6 +263,15 @@ def test_constants(self):
         # CMD_VERSION
         self.assertCommand(constants.CMD_VERSION, r"getprop ro.build.version.release")
 
+        # CMD_VOLUME_SET_COMMAND
+        self.assertCommand(constants.CMD_VOLUME_SET_COMMAND, r"media volume --show --stream 3 --set {}")
+
+        # CMD_VOLUME_SET_COMMAND11
+        self.assertCommand(
+            constants.CMD_VOLUME_SET_COMMAND11,
+            r"cmd media_session volume --show --stream 3 --set {}",
+        )
+
         # CMD_WAKE_LOCK_SIZE
         self.assertCommand(constants.CMD_WAKE_LOCK_SIZE, r"dumpsys power | grep Locks | grep 'size='")
 
@@ -238,7 +283,10 @@ def test_no_underscores(self):
         """Test that 'ANDROID_TV', 'BASE_TV', and 'FIRE_TV' do not appear in the code base."""
         cwd = os.path.join(os.path.dirname(__file__), "..")
         for underscore_name in ["ANDROID_TV", "BASE_TV", "FIRE_TV"]:
-            with subprocess.Popen(shlex.split("git grep -l {} -- androidtv/".format(underscore_name)), cwd=cwd) as p:
+            with subprocess.Popen(
+                shlex.split("git grep -l {} -- androidtv/".format(underscore_name)),
+                cwd=cwd,
+            ) as p:
                 self.assertEqual(p.wait(), 1)
 
     def test_current_app_extraction_atv_launcher(self):