@@ -17,7 +17,8 @@
 
 import click
 
-from kasa import TPLinkSmartHomeProtocol
+from kasa.cli import TYPE_TO_CLASS
+from kasa.credentials import Credentials
 
 Call = namedtuple("Call", "module method")
 
@@ -64,11 +65,34 @@ def default_to_regular(d):
 @click.command()
 @click.argument("host")
 @click.option("-d", "--debug", is_flag=True)
-def cli(host, debug):
+@click.option(
+    "-t",
+    "--type",
+    envvar="KASA_TYPE",
+    default="smartdevice",
+    type=click.Choice(list(TYPE_TO_CLASS), case_sensitive=False),
+)
+@click.option(
+    "--username",
+    default=None,
+    required=False,
+    envvar="TPLINK_CLOUD_USERNAME",
+    help="Username/email address to authenticate to device.",
+)
+@click.option(
+    "--password",
+    default=None,
+    required=False,
+    envvar="TPLINK_CLOUD_PASSWORD",
+    help="Password to use to authenticate to device.",
+)
+def cli(host, debug, type, username, password):
     """Generate devinfo file for given device."""
     if debug:
         logging.basicConfig(level=logging.DEBUG)
 
+    dev = TYPE_TO_CLASS[type](host, credentials=Credentials(username, password))
+
     items = [
         Call(module="system", method="get_sysinfo"),
         Call(module="emeter", method="get_realtime"),
@@ -86,8 +110,7 @@ def cli(host, debug):
     for test_call in items:
 
         async def _run_query(test_call):
-            protocol = TPLinkSmartHomeProtocol(host)
-            return await protocol.query({test_call.module: {test_call.method: None}})
+            return await dev.protocol.query({test_call.module: {test_call.method: {}}})
 
         try:
             click.echo(f"Testing {test_call}..", nl=False)
@@ -106,14 +129,13 @@ async def _run_query(test_call):
     final = defaultdict(defaultdict)
 
     for succ, resp in successes:
-        final_query[succ.module][succ.method] = None
+        final_query[succ.module][succ.method] = {}
         final[succ.module][succ.method] = resp
 
     final = default_to_regular(final)
 
     async def _run_final_query():
-        protocol = TPLinkSmartHomeProtocol(host)
-        return await protocol.query(final_query)
+        return await dev.protocol.query(final_query)
 
     try:
         final = asyncio.run(_run_final_query())
@@ -128,6 +150,8 @@ async def _run_final_query():
     click.echo(click.style("## device info file ##", bold=True))
 
     sysinfo = final["system"]["get_sysinfo"]
+    if "model" not in sysinfo:
+        sysinfo = sysinfo["system"]
     model = sysinfo["model"]
     hw_version = sysinfo["hw_ver"]
     sw_version = sysinfo["sw_ver"]
 
@@ -21,6 +21,7 @@
     SmartDeviceException,
     UnsupportedDeviceException,
 )
+from kasa.kasacamera import KasaCam
 from kasa.protocol import TPLinkSmartHomeProtocol
 from kasa.smartbulb import SmartBulb, SmartBulbPreset, TurnOnBehavior, TurnOnBehaviors
 from kasa.smartdevice import DeviceType, SmartDevice
@@ -34,6 +35,7 @@
 
 __all__ = [
     "Discover",
+    "KasaCam",
     "TPLinkSmartHomeProtocol",
     "SmartBulb",
     "SmartBulbPreset",
 
@@ -13,6 +13,7 @@
 from kasa import (
     Credentials,
     Discover,
+    KasaCam,
     SmartBulb,
     SmartDevice,
     SmartDimmer,
@@ -47,6 +48,7 @@ def wrapper(message=None, *args, **kwargs):
     "bulb": SmartBulb,
     "dimmer": SmartDimmer,
     "strip": SmartStrip,
+    "kasacam": KasaCam,
     "lightstrip": SmartLightStrip,
 }
 
 
@@ -13,6 +13,7 @@
 from kasa.exceptions import UnsupportedDeviceException
 from kasa.json import dumps as json_dumps
 from kasa.json import loads as json_loads
+from kasa.kasacamera import KasaCam
 from kasa.protocol import TPLinkSmartHomeProtocol
 from kasa.smartbulb import SmartBulb
 from kasa.smartdevice import SmartDevice, SmartDeviceException
@@ -354,9 +355,13 @@ def _get_device_class(info: dict) -> Type[SmartDevice]:
             raise SmartDeviceException("No 'system' or 'get_sysinfo' in response")
 
         sysinfo = info["system"]["get_sysinfo"]
+        if "system" in sysinfo:
+            sysinfo = sysinfo["system"]
         type_ = sysinfo.get("type", sysinfo.get("mic_type"))
         if type_ is None:
-            raise SmartDeviceException("Unable to find the device type field!")
+            raise SmartDeviceException(
+                f"Unable to find the device type field in {sysinfo}"
+            )
 
         if "dev_name" in sysinfo and "Dimmer" in sysinfo["dev_name"]:
             return SmartDimmer
@@ -373,4 +378,7 @@ def _get_device_class(info: dict) -> Type[SmartDevice]:
 
             return SmartBulb
 
+        if "ipcamera" in type_.lower():
+            return KasaCam
+
         raise SmartDeviceException("Unknown device type: %s" % type_)
@@ -0,0 +1,130 @@
+"""Module for KasaCams (EC70)."""
+from typing import Any, Dict, Optional
+
+from .credentials import Credentials
+from .kasacamprotocol import KasaCamProtocol
+from .modules import PTZ, Cloud, Time
+from .modules.ptz import Direction, Position
+from .smartdevice import DeviceType, SmartDevice, requires_update
+
+
+class KasaCam(SmartDevice):
+    """Representation of a TP-Link Kasa Camera.
+
+    To initialize, you have to await :func:`update()` at least once.
+    This will allow accessing the properties using the exposed properties.
+
+    All changes to the device are done using awaitable methods,
+    which will not change the cached values, but you must await :func:`update()`
+    separately.
+
+    Errors reported by the device are raised as
+    :class:`SmartDeviceExceptions <kasa.exceptions.SmartDeviceException>`, and should be
+    handled by the user of the library.
+
+    Examples:
+        >>> import asyncio
+        >>> camera = KasaCam("127.0.0.1")
+        >>> asyncio.run(camera.update())
+        >>> print(camera.alias)
+        Camera2
+
+        Cameras, like any other supported devices, can be turned on and off:
+
+        >>> asyncio.run(camera.turn_off())
+        >>> asyncio.run(camera.turn_on())
+        >>> asyncio.run(camera.update())
+        >>> print(camera.is_on)
+        True
+    """
+
+    def __init__(
+        self,
+        host: str,
+        credentials: Credentials,
+        *,
+        port: Optional[int] = None,
+        timeout: Optional[int] = None,
+    ) -> None:
+        super().__init__(host, port=port, credentials=credentials, timeout=timeout)
+        self._device_type = DeviceType.KasaCam
+        self.protocol = KasaCamProtocol(
+            host, credentials=credentials, port=port, timeout=timeout
+        )
+        self.add_module("cloud", Cloud(self, "smartlife.cam.ipcamera.cloud"))
+        self.add_module("ptz", PTZ(self, "smartlife.cam.ipcamera.ptz"))
+        self.add_module("time", Time(self, "smartlife.cam.ipcamera.dateTime"))
+
+    def _create_request(
+        self,
+        target: str,
+        cmd: str,
+        arg: Optional[Dict] = None,
+        child_ids=None,
+    ):
+        # While most devices accept None for an empty arg, Kasa Cameras require {}
+        # all other devices seem to accept this as well
+        return {target: {cmd: {} if arg is None else arg}}
+
+    @property  # type: ignore
+    @requires_update
+    def is_on(self) -> bool:
+        """Return whether device is on."""
+        return self.sys_info["camera_switch"] == "on"
+
+    @property  # type: ignore
+    @requires_update
+    def state_information(self) -> Dict[str, Any]:
+        """Return camera-specific state information.
+
+        :return: Strip information dict, keys in user-presentable form.
+        """
+        return {
+            "Position": self.position,
+            "Patrolling": self.is_patrol_enabled,
+        }
+
+    @property
+    @requires_update
+    def position(self):
+        """The camera's current x,y position."""
+        return self.modules["ptz"].position
+
+    @property
+    @requires_update
+    def is_patrol_enabled(self):
+        """Whether patrol mode is currently enabled."""
+        return self.modules["ptz"].is_patrolling
+
+    async def turn_on(self, **kwargs):
+        """Turn the switch on."""
+        return await self._query_helper(
+            "smartlife.cam.ipcamera.switch", "set_is_enable", {"value": "on"}
+        )
+
+    async def turn_off(self, **kwargs):
+        """Turn the switch off."""
+        return await self._query_helper(
+            "smartlife.cam.ipcamera.switch", "set_is_enable", {"value": "off"}
+        )
+
+    async def go_to(
+        self,
+        position: Optional[Position] = None,
+        x: Optional[int] = None,
+        y: Optional[int] = None,
+    ):
+        """Send the camera to an x,y position."""
+        return await self.modules["ptz"].go_to(position=position, x=x, y=y)
+
+    async def stop(self):
+        """Stop the camera where it is."""
+        return await self.modules["ptz"].stop()
+
+    async def move(self, direction: Direction, speed: int):
+        """Move the camera a relative direction at a given speed."""
+        return await self.modules["ptz"].move(direction, speed)
+
+    async def set_enable_patrol(self, enabled: bool):
+        """Enable or disable Patrol mode."""
+        return await self.modules["ptz"].set_enable_patrol(enabled)
@@ -0,0 +1,114 @@
+"""Protocol implementation for controlling TP-Link Kasa Cam devices."""
+
+import errno
+import logging
+from base64 import b64decode, b64encode
+from pprint import pformat as pf
+from typing import Dict
+from urllib.parse import quote
+
+import httpx
+
+# When support for cpython older than 3.11 is dropped
+# async_timeout can be replaced with asyncio.timeout
+from async_timeout import timeout as asyncio_timeout
+
+from .exceptions import SmartDeviceException
+from .json import loads as json_loads
+from .protocol import TPLinkSmartHomeProtocol
+
+_LOGGER = logging.getLogger(__name__)
+_NO_RETRY_ERRORS = {errno.EHOSTDOWN, errno.EHOSTUNREACH, errno.ECONNREFUSED}
+
+
+class KasaCamProtocol(TPLinkSmartHomeProtocol):
+    """Implementation of the Kasa Cam protocol."""
+
+    DEFAULT_PORT = 10443
+
+    def __init__(self, *args, **kwargs) -> None:
+        self.credentials = kwargs.pop("credentials")
+        super().__init__(*args, **kwargs)
+        self.session: httpx.Client = None
+
+    async def _connect(self, timeout: int) -> None:
+        if self.session:
+            return
+
+        self.session = httpx.Client(
+            base_url=f"https://{self.host}:{self.port}",
+            auth=(
+                self.credentials.username,
+                b64encode(self.credentials.password.encode()),
+            ),
+            verify=False,  # noqa: S501 - Device certs are self-signed
+        )
+
+    async def _execute_query(self, request: str) -> Dict:
+        """Execute a query on the device and wait for the response."""
+        _LOGGER.debug("%s >> %s", self.host, request)
+        print("%s >> %s", self.host, request)
+
+        encrypted_cmd = self.encrypt(request)[4:]
+        b64_cmd = b64encode(encrypted_cmd).decode()
+        url_safe_cmd = quote(b64_cmd, safe="!~*'()")
+
+        r = self.session.post("/data/LINKIE.json", data=f"content={url_safe_cmd}")
+        json_payload = json_loads(self.decrypt(b64decode(r.read())))
+        _LOGGER.debug("%s << %s", self.host, pf(json_payload))
+        return json_payload
+
+    async def _query(self, request: str, retry_count: int, timeout: int) -> Dict:
+        for retry in range(retry_count + 1):
+            try:
+                await self._connect(timeout)
+            except ConnectionRefusedError as ex:
+                await self.close()
+                raise SmartDeviceException(
+                    f"Unable to connect to the device: {self.host}:{self.port}"
+                ) from ex
+            except OSError as ex:
+                await self.close()
+                if ex.errno in _NO_RETRY_ERRORS or retry >= retry_count:
+                    raise SmartDeviceException(
+                        f"Unable to connect to the device: {self.host}:{self.port}"
+                    ) from ex
+                continue
+            except Exception as ex:
+                await self.close()
+                if retry >= retry_count:
+                    _LOGGER.debug("Giving up on %s after %s retries", self.host, retry)
+                    raise SmartDeviceException(
+                        f"Unable to connect to the device: {self.host}:{self.port}"
+                    ) from ex
+                continue
+
+            try:
+                async with asyncio_timeout(timeout):
+                    return await self._execute_query(request)
+            except Exception as ex:
+                await self.close()
+                if retry >= retry_count:
+                    _LOGGER.debug("Giving up on %s after %s retries", self.host, retry)
+                    raise SmartDeviceException(
+                        f"Unable to query the device {self.host}:{self.port}: {ex}"
+                    ) from ex
+
+                _LOGGER.debug(
+                    "Unable to query the device %s, retrying: %s", self.host, ex
+                )
+        # Make Mypy happy
+        raise SmartDeviceException("Query reached the unreachable.")
+
+    def _reset(self) -> None:
+        """Clear any varibles that should not survive between loops."""
+        self.session = None
+
+    def __del__(self) -> None:
+        if self.session and self.loop and self.loop.is_running():
+            # Since __del__ will be called when python does
+            # garbage collection is can happen in the event loop thread
+            # or in another thread so we need to make sure the call to
+            # close is called safely with call_soon_threadsafe
+            self.loop.call_soon_threadsafe(self.session.close)
+        self._reset()