# Sentinel (CCTV-Smartphone-AI-Monitoring): turn spare Android phones into LAN camera nodes

> Sentinel is a Python and Flask framework that repurposes unused Android devices as AI-monitored camera endpoints on a local network. It is a good fit for lab capture rigs and prototypes, not for anyone who wants an app-store install or cloud playback.

**suzuran0y/CCTV-Smartphone-AI-Monitoring** — 本地监控 + AI 视觉 — LAN-based smartphone-powered AI monitoring framework with structured event output for data acquisition and analysis.

- Repository: https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring
- Stars: 816 · Forks: 62
- Language: Python
- License: MIT
- Published: 2026-09-16 · Updated: 2026-09-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/suzuran0y-cctv-smartphone-ai-monitoring

## What Sentinel actually replaces, and for whom

Most people asking how to monitor a CCTV camera from a phone are shopping for a consumer product: an app, a cloud account, a subscription. Sentinel points somewhere else. It treats the phone as the sensor and the PC as the recorder and analyst, which means the hardware you already own becomes the camera fleet. A drawer full of retired Android handsets is the target inventory.

The README frames the project two ways: a lightweight local monitoring system, and an engineering prototype platform for visual data acquisition and intelligent analysis. The second framing is the honest one. There is no cloud service, no mobile push notification, and no vendor. What you get is a Flask server on a PC that accepts JPEG frames over HTTP from an Android client called CamFlow, shows them in a browser, writes them to disk, and optionally hands triggered frames to a vision model.

The people who benefit are those who want frames as data. If your goal is a searchable archive of structured events with timestamps and risk grades rather than a live video feed on your lock screen, the design makes sense. If your goal is to check on a house from another city, it does not, because everything here is LAN-bound by design.

## The three-layer architecture: JPEG frames over HTTP POST

Sentinel splits into a data acquisition layer (the Android app), a service processing layer (the PC Flask server), and a presentation layer (the browser dashboard). The data path is deliberately simple. CamFlow captures the phone camera, converts each frame to a single JPEG, and POSTs it to the server's /upload endpoint. The server keeps a FrameBuffer holding the latest frame, which the browser reads as an MJPEG stream over HTTP. No plugin, no WebRTC negotiation, no RTSP handshake.

That choice has consequences worth naming. MJPEG over HTTP is trivial to debug with a browser and trivial to extend with another client, but it is also bandwidth-hungry compared with an inter-frame codec, because every frame is a full image. On a quiet LAN this is fine. Across a congested Wi-Fi network with several phones, it is the first thing that will hurt.

The AI side is layered rather than continuous. The README describes a two-stage mechanism: traditional CV algorithms run first, and only when a trigger condition is met does the system call a vision model for semantic analysis. The stated purpose is to improve real-time performance and reduce compute and inference cost. This is the most defensible design decision in the project, because it means you are not paying a model provider for every empty frame of an empty room. The output of that stage is structured, with risk grading and event management, and the server writes AI event records and runtime logs locally for traceability.

## Installing Sentinel and getting a first frame through

The repository ships requirements.txt with four entries: flask>=2.2, numpy>=1.23, opencv-python>=4.8 and volcengine-python-sdk[ark]. Python 3.9 or newer is the stated requirement. Install the dependencies from the repository root.

```bash
pip install -r requirements.txt
```

The README notes that the PC prints the CamFlow address at startup, and that recent maintenance work made first-time setup use that printed address. Read it from the console rather than guessing your LAN IP.

The Android side is a separate deployment. The repository contains a PhoneCamSender/ directory and a CamFlow_UserGuide.md, and the README states the client requires Android 8.0 or newer. The client validates the address and offers a /ping connection test, which is the right first thing to run after typing the server address into the phone. Once the phone is uploading, open the dashboard in a browser on the PC. You should see the MJPEG preview updating, and the server should begin writing runtime logs under the log/ directory and any recordings under recordings/. If the preview stays blank, check the connection test first, then the server console, before touching anything else.

## Where the design pushes back: LAN-only, codec fallbacks and model reach

The most important limitation is stated plainly in the README: the system runs in a local LAN environment without relying on cloud services, but running multimodal models is better served by an online inference service. Those two facts pull in opposite directions. Your capture path is local and private. Your analysis path, if you enable it, likely leaves the network. Anyone adopting this for privacy reasons should read that sentence twice.

Recording has a portability wrinkle. The v1.1.3 maintenance notes describe a Windows-compatible recording codec fallback, which implies the codec selection is not uniform across platforms and that Windows needed special handling. If you plan long-running segmented recording in MP4 or AVI, test your platform's output before trusting it with an overnight run.

There is also an operational ceiling. The architecture is a single Flask server receiving frames from one or more phones. The README does not document horizontal scaling, load balancing, or what happens as phone count grows. Treat the phone count as something you determine empirically on your own hardware rather than something the documentation answers.

Finally, the configuration surface is real but thin in the README. The v1.1.0 release is titled Configurable Upload Settings, and v1.1.3 mentions redacting API keys in configuration logs and protecting upload size. Those are sensible hardening steps, but the README itself does not walk through every configuration key, so expect to read the source for the full set.

## Sentinel against a consumer AI camera

The obvious alternative is a consumer AI camera from a vendor such as Hikvision, which is what most search traffic around AI CCTV monitoring is actually about. The difference in approach is not incremental, it is structural.

A consumer camera is a closed appliance. You buy the sensor, the firmware, and the mobile app together. Setup is a QR code. Motion events arrive as push notifications, video lives in the vendor's cloud or on an SD card, and the AI features are whatever the vendor shipped. You cannot change the trigger algorithm, you cannot change the output schema, and you cannot point the event stream at your own database.

Sentinel inverts every one of those. You supply the sensor (a phone), you run the server, you own the frames, and the event output is structured for downstream analysis rather than for a notification shade. The cost is that you also own the deployment, the network, the storage, and the failure modes. There is no support line. The README does not document rollback, and there is no upgrade path beyond pulling the repository again.

The honest comparison is that a consumer camera is a product and Sentinel is a framework. If you want to watch a room, buy the product. If you want frames and events you can query, the framework is the only one of the two that will let you.

## Maintenance, licence and the cost of staying current

The last push to the default branch was on 2026-08-19, and v1.1.1 was tagged the same day. That is recent enough that the project is not abandoned, and the release history shows a steady cadence: v1.0.0-beta in February 2026, v1.1.0 in March, v1.1.1 in August. The README also links an ongoing v1.1.3 update dated 2026-08-20 that the tagged releases do not yet cover, which is worth knowing before you pin to a tag.

Upgrade cost is low but manual. There is no package on PyPI and no installer. You pull the repository, reinstall requirements.txt if it changed, and restart the server. The dependency list is short, but one entry stands out: volcengine-python-sdk[ark], which is the model inference client. That dependency ties the AI path to a specific provider's SDK, and it will pull its own transitive dependencies into your environment.

The licence is MIT, which is permissive and places few obligations on how you use or redistribute the code. It does not cover the model provider's terms, which are separate and which you should read on their side. It also does not cover the Android client's distribution, since CamFlow is not on an app store according to the repository layout. This is not legal advice; check the LICENSE file and the provider's terms for your own situation.

## Conclusion

Adopt Sentinel if you have one or more idle Android phones, a PC that can stay on the same LAN, and a reason to capture frames as files rather than watch a consumer camera app. Skip it if you need an app-store install, remote access from outside the LAN, or a vendor answering support tickets. Before committing, verify three things yourself: that the Android client is compatible with your device, that your chosen vision model endpoint is reachable from the PC, and that the recording codec fallback behaves on your operating system. The PC side prints the CamFlow address at startup, so confirm that address matches the network your phone is on before debugging anything else.

## FAQ

### Can Sentinel's AI monitor security cameras?

The system performs AI-triggered monitoring, but the capture device is an Android phone running CamFlow rather than a conventional security camera. The README describes a two-stage mechanism where traditional CV algorithms trigger a vision model call only when conditions are met.

### How can I monitor my CCTV camera with my phone in Sentinel?

Sentinel works the other way round: the phone is the camera, not the viewer. The Android client CamFlow captures the camera feed and uploads single-frame JPEG images to the PC server, and the browser dashboard on the PC provides the live MJPEG preview.

### Which cameras support AI in Sentinel?

Sentinel does not depend on a camera model. It repurposes unused Android devices running Android 8.0 or newer as network camera nodes, and the AI analysis happens on the PC side after frames are uploaded.

## Sources

- [Issues](https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring/issues)
- [License: MIT](https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring/blob/main/LICENSE)
- [README](https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring/blob/main/README.md)
- [Releases](https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring/releases)
- [suzuran0y/CCTV-Smartphone-AI-Monitoring on GitHub](https://github.com/suzuran0y/CCTV-Smartphone-AI-Monitoring)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/suzuran0y-cctv-smartphone-ai-monitoring