### macOS App Integration with Notifications and UI Updates (Swift)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Demonstrates integrating `is-camera-on` into a macOS application. It requests notification permissions, monitors camera status changes using Swift concurrency, updates the UI (menu bar icon and window title), and sends user notifications when the camera becomes active. Includes functions for starting and stopping monitoring.

```swift
import IsCameraOn
import AppKit
import UserNotifications

class CameraMonitorApp {
    private var monitorTask: Task<Void, Never>?

    func startMonitoring() {
        // Request notification permissions
        UNUserNotificationCenter.current().requestAuthorization(
            options: [.alert, .sound]
        ) { granted, error in
            if granted {
                print("Notifications enabled")
            }
        }

        // Start monitoring
        monitorTask = Task { @MainActor in
            for await isOn in cameraStatusChanges(includeExternal: true) {
                updateUI(cameraActive: isOn)

                if isOn {
                    sendNotification(
                        title: "Camera Active",
                        body: "Your camera is now being used"
                    )
                }
            }
        }
    }

    @MainActor
    func updateUI(cameraActive: Bool) {
        // Update menu bar icon
        let iconName = cameraActive ? "camera.fill" : "camera"
        statusItem.button?.image = NSImage(systemSymbolName: iconName, accessibilityDescription: nil)

        // Update window if visible
        mainWindow?.title = cameraActive ? "Camera: Active" : "Camera: Inactive"
    }

    func sendNotification(title: String, body: String) {
        let content = UNMutableNotificationContent()
        content.title = title
        content.body = body
        content.sound = .default

        let request = UNNotificationRequest(
            identifier: UUID().uuidString,
            content: content,
            trigger: nil
        )

        UNUserNotificationCenter.current().add(request)
    }

    func stopMonitoring() {
        monitorTask?.cancel()
        monitorTask = nil
    }

    // Required: Keep references to these
    private var statusItem: NSStatusItem!
    private var mainWindow: NSWindow? 
}

// Usage
let app = CameraMonitorApp()
app.startMonitoring()

// Stop when app terminates
// app.stopMonitoring()
```

--------------------------------

### Command-Line Utility for Camera Status Checks (Swift)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Provides a command-line interface (CLI) tool using Swift to interact with camera status. It supports a one-time check (`--check`) that prints 'ON' or 'OFF' and exits with a status code, and continuous monitoring (`--monitor`) that logs timestamped status changes to the terminal. Leverages Swift concurrency for monitoring.

```swift
import Foundation
import IsCameraOn

// Simple one-time check
func checkCameraStatus() {
    let status = isCameraOn(includeExternal: true)
    print(status ? "ON" : "OFF")
    exit(status ? 0 : 1)
}

// Continuous monitoring with formatted output
func monitorCamera() async {
    print("Monitoring camera status (press Ctrl+C to stop)...")
    print("Time                 | Status | Type")
    print("--------------------|--------|----------")

    for await isOn in cameraStatusChanges(includeExternal: true) {
        let formatter = DateFormatter()
        formatter.timeStyle = .medium
        let time = formatter.string(from: Date())

        let status = isOn ? "  ON  " : " OFF  "
        let indicator = isOn ? "🔴" : "⚫"

        print("\(time) | \(status) | \(indicator)")
    }
}

// CLI entry point
@main
struct CameraStatusCLI {
    static func main() async {
        let arguments = CommandLine.arguments

        if arguments.contains("--monitor") {
            await monitorCamera()
        } else if arguments.contains("--check") {
            checkCameraStatus()
        } else {
            print("Usage:")
            print("  --check    Check current status (exit 0 if ON, 1 if OFF)")
            print("  --monitor  Continuously monitor status changes")
        }
    }
}
```

--------------------------------

### Monitor camera status changes asynchronously

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Returns an AsyncStream that yields real-time camera status updates without polling, using property listeners for instant notifications.

```APIDOC
## cameraStatusChanges()

### Description
Returns an AsyncStream that yields real-time camera status updates without polling, using property listeners for instant notifications.

### Method
`cameraStatusChanges(includeExternal: Bool = false)`

### Parameters
#### Query Parameters
- **includeExternal** (Boolean) - Optional - Whether to include external physical cameras (USB, Thunderbolt, Continuity Camera) in the monitoring. Defaults to `false` (monitors only built-in cameras).

### Request Example
```swift
import IsCameraOn
import Foundation

// Monitor built-in camera status changes
Task {
    for await isOn in cameraStatusChanges() {
        let timestamp = Date()
        print("[\(timestamp)] Camera: \(isOn ? "ON" : "OFF")")

        // Take action on status change
        if isOn {
            print("🔴 Recording indicator should show")
        } else {
            print("⚫ Recording stopped")
        }
    }
}

// Monitor all cameras including external USB/Thunderbolt devices
Task {
    for await isOn in cameraStatusChanges(includeExternal: true) {
        print("Camera status: \(isOn ? "ACTIVE" : "INACTIVE")")

        // Example: Log to file when camera state changes
        if isOn {
            logEvent("Camera activated at \(Date())")
        }
    }
}

// Example: Monitor with timeout and cancellation
let monitorTask = Task {
    for await isOn in cameraStatusChanges() {
        print("Status: \(isOn)")
    }
}

// Cancel monitoring after 60 seconds
Task {
    try await Task.sleep(nanoseconds: 60_000_000_000)
    monitorTask.cancel()
    print("Monitoring stopped")
}
```

### Response
#### Success Response (AsyncStream<Bool>)
An `AsyncStream` that asynchronously yields `true` when a camera becomes active and `false` when it becomes inactive.

#### Response Example
(This is an asynchronous stream, no direct JSON response. The output below is an example of printed messages.)
```
[2023-10-27 10:00:00 +0000] Camera: OFF
[2023-10-27 10:05:15 +0000] Camera: ON
🔴 Recording indicator should show
```
```

--------------------------------

### Asynchronously Monitor Camera Status Changes (Swift)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

This function returns an AsyncStream that yields real-time camera status updates without polling, using property listeners for instant notifications. It requires the 'IsCameraOn' and 'Foundation' libraries. Callers can react to camera status changes in real-time.

```swift
import IsCameraOn
import Foundation

// Monitor built-in camera status changes
Task {
    for await isOn in cameraStatusChanges() {
        let timestamp = Date()
        print("[(timestamp)] Camera: (isOn ? "ON" : "OFF")")

        // Take action on status change
        if isOn {
            print("🔴 Recording indicator should show")
        } else {
            print("⚫ Recording stopped")
        }
    }
}

// Monitor all cameras including external USB/Thunderbolt devices
Task {
    for await isOn in cameraStatusChanges(includeExternal: true) {
        print("Camera status: (isOn ? "ACTIVE" : "INACTIVE")")

        // Example: Log to file when camera state changes
        if isOn {
            logEvent("Camera activated at (Date())")
        }
    }
}

// Example: Monitor with timeout and cancellation
let monitorTask = Task {
    for await isOn in cameraStatusChanges() {
        print("Status: (isOn)")
    }
}

// Cancel monitoring after 60 seconds
Task {
    try await Task.sleep(nanoseconds: 60_000_000_000)
    monitorTask.cancel()
    print("Monitoring stopped")
}
```

--------------------------------

### Camera Device Type Detection (Internal)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Internal utilities for identifying camera transport types and filtering physical vs virtual devices. This is for informational purposes on how the library operates.

```APIDOC
## CameraDevice Internals

### Description
Internal utilities for identifying camera transport types and filtering physical vs virtual devices. This is for informational purposes on how the library operates.

### Method
(Internal library classes and methods)

### Details
- **CameraDevice**: Represents a camera with properties like `deviceID`, `isBuiltIn`, `isPhysical`, `isRunning`.
- **Transport Types**: 
    - `.builtIn`: For FaceTime HD, iSight cameras.
    - `.usb`: For external cameras connected via USB, Thunderbolt, or Continuity Camera.
    - `.virtual`: For software-based virtual cameras (e.g., OBS), which are typically excluded from checks.

### Request Example
```swift
// Example of how library filters devices:
let device = CameraDevice(deviceID)

// Check if it's a built-in camera
if device.isBuiltIn {
    print("This is a FaceTime HD or iSight camera")
}

// Check if it's a physical camera (excludes virtual)
if device.isPhysical {
    print("This is a real hardware camera")
}

// Check if camera is currently running
if device.isRunning {
    print("Camera is actively capturing video")
}
```

### Response
(No direct API response, these are internal checks used by the library.)
```

--------------------------------

### Monitor Mac Camera Status Changes with Swift

Source: https://github.com/sindresorhus/is-camera-on/blob/main/readme.md

Monitors for changes in the Mac camera's status using Swift's async/await capabilities. It emits the current status immediately and then only when changes occur, handling device hot-plugging automatically. Requires macOS 10.15+.

```swift
import IsCameraOn

// Monitor camera status changes with async/await
Task {
	for await isOn in cameraStatusChanges() {
		print("Camera status: (isOn ? "ON" : "OFF")")
	}
}
```

--------------------------------

### Internal Camera Device Filtering Logic (Swift)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Illustrates the internal logic used by the library to identify and filter camera devices based on their transport type. It distinguishes between built-in, external physical, and virtual cameras. This helps in understanding how the library excludes software-based cameras from status checks.

```swift
// Internal CameraDevice struct (used by library)
// Identifies camera by transport type:
// - Built-in: .builtIn (FaceTime HD, iSight)
// - External: .usb (USB, Thunderbolt, Continuity Camera)
// - Virtual: .virtual (OBS, software cameras - excluded from checks)

// Example of how library filters devices:
let device = CameraDevice(deviceID)

// Check if it's a built-in camera
if device.isBuiltIn {
    print("This is a FaceTime HD or iSight camera")
}

// Check if it's a physical camera (excludes virtual)
if device.isPhysical {
    print("This is a real hardware camera")
}

// Check if camera is currently running
if device.isRunning {
    print("Camera is actively capturing video")
}
```

--------------------------------

### Check if camera is currently on

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

Synchronously checks if any camera matching the specified criteria is currently active and returns a boolean result.

```APIDOC
## isCameraOn()

### Description
Synchronously checks if any camera matching the specified criteria is currently active and returns a boolean result.

### Method
`isCameraOn()`

### Parameters
#### Query Parameters
- **includeExternal** (Boolean) - Optional - Whether to include external physical cameras (USB, Thunderbolt, Continuity Camera) in the check. Defaults to `false` (checks only built-in cameras).

### Request Example
```swift
import IsCameraOn

// Check only built-in camera (default behavior)
let builtInActive = isCameraOn()
print("Built-in camera active: \(builtInActive)")

// Check all physical cameras (built-in + external)
let anyCameraActive = isCameraOn(includeExternal: true)
print("Any camera active: \(anyCameraActive)")
```

### Response
#### Success Response (Boolean)
- **true**: If at least one camera matching the criteria is currently active.
- **false**: If no cameras matching the criteria are currently active.

#### Response Example
```json
// For isCameraOn()
false

// For isCameraOn(includeExternal: true)
true
```
```

--------------------------------

### Check Mac Camera Status with Swift

Source: https://github.com/sindresorhus/is-camera-on/blob/main/readme.md

Checks the status of the Mac's built-in camera and optionally includes external physical cameras. This function returns a boolean indicating whether the camera is on. It requires macOS 10.15+.

```swift
import IsCameraOn

// Check built-in camera only (default)
print(isCameraOn())
//=> true

// Check both built-in and external physical cameras
print(isCameraOn(includeExternal: true))
//=> true
```

--------------------------------

### Synchronously Check Camera Status (Swift)

Source: https://context7.com/sindresorhus/is-camera-on/llms.txt

This function synchronously checks if any camera matching the specified criteria is currently active. It returns a boolean value indicating the camera's status. Dependencies include the 'IsCameraOn' library.

```swift
import IsCameraOn

// Check only built-in camera (default behavior)
let builtInActive = isCameraOn()
print("Built-in camera active: (builtInActive)")
// Output: Built-in camera active: false

// Check all physical cameras (built-in + external)
let anyCameraActive = isCameraOn(includeExternal: true)
print("Any camera active: (anyCameraActive)")
// Output: Any camera active: true

// Example: Send notification if camera turns on unexpectedly
if isCameraOn() {
    print("⚠️ Camera is active!")
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.