### Configure AdbFastScreenshots for High Quality and Low CPU Usage

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Illustrates how to instantiate the AdbFastScreenshots class with different configurations. The first example focuses on high-quality capture for detailed analysis, specifying higher resolution and bitrate. The second example prioritizes lower CPU usage for background monitoring by reducing resolution and bitrate, and adjusting the 'go_idle' parameter.

```python
from adbnativeblitz import AdbFastScreenshots

# High quality capture for detailed analysis
high_quality = AdbFastScreenshots(
    adb_path="/usr/bin/adb",                  # Path to ADB executable
    device_serial="emulator-5554",            # Device serial or IP:port
    time_interval=179,                        # Recording session length (max 180s)
    width=1920,                               # Capture width in pixels
    height=1080,                              # Capture height in pixels
    bitrate="30M",                            # Video bitrate (e.g., "20M" for 20Mbps)
    use_busybox=False,                        # Use BusyBox for base64 (some devices)
    connect_to_device=True,                   # Auto-connect via ADB
    screenshotbuffer=20,                      # Frame buffer size
    go_idle=0,                                # Idle time when no frames (0 = max FPS)
)

# Lower CPU usage configuration for background monitoring
low_cpu = AdbFastScreenshots(
    adb_path="/usr/bin/adb",
    device_serial="192.168.1.100:5555",
    time_interval=179,
    width=800,
    height=600,
    bitrate="5M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=5,
    go_idle=0.1,                              # Higher value = less FPS, less CPU
)
```

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

### Capture Android Screen with AdbFastScreenshots (Python)

Source: https://github.com/hansalemaos/adbnativeblitz/blob/main/README.MD

Demonstrates how to capture Android device screens using the AdbFastScreenshots class. This example shows initializing the class with various parameters, iterating through captured frames (as NumPy arrays), and displaying them using OpenCV. It also includes instructions for stopping the capture and closing the display window.

```python
import cv2
from adbnativeblitz import AdbFastScreenshots

with AdbFastScreenshots(
	adb_path=r"C:\\Android\\android-sdk\\platform-tools\\adb.exe",
	device_serial="127.0.0.1:5555",
	time_interval=179,
	width=1600,
	height=900,
	bitrate="20M",
	use_busybox=False,
	connect_to_device=True,
	screenshotbuffer=10,
	go_idle=0,
) as adbscreen:
	for image in adbscreen:
		cv2.imshow("CV2 WINDOW", image)
		if cv2.waitKey(1) & 0xFF == ord("q"):
			break
cv2.destroyAllWindows()
```

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

### AdbFastScreenshots Constructor Parameters

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Details the various parameters available for configuring the AdbFastScreenshots class, including device connection, video quality, and performance tuning options.

```APIDOC
## AdbFastScreenshots Constructor Parameters

### Description
These parameters allow fine-grained control over the screen capture process, affecting device connection, video resolution, bitrate, and CPU usage.

### Method
Constructor (`AdbFastScreenshots(...)`)

### Endpoint
N/A (Local library usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Constructor Parameters Details:
- **adb_path** (str) - Required - Path to the ADB executable.
- **device_serial** (str) - Required - Serial number or IP:port of the target Android device.
- **time_interval** (int) - Optional - Maximum duration in seconds for a single screen recording session (max 180). The session restarts automatically after this interval.
- **width** (int) - Optional - The desired width of the captured screen in pixels.
- **height** (int) - Optional - The desired height of the captured screen in pixels.
- **bitrate** (str) - Optional - The video bitrate for the screen recording (e.g., "20M" for 20 Mbps). Higher bitrates improve quality but increase data transfer.
- **use_busybox** (bool) - Optional - Whether to use BusyBox for base64 encoding. Set to `True` if your device has BusyBox installed and it's needed for `screenrecord`.
- **connect_to_device** (bool) - Optional - If `True`, the library will attempt to automatically connect to the device via ADB.
- **screenshotbuffer** (int) - Optional - The size of the internal buffer for storing captured frames.
- **go_idle** (float) - Optional - A value that balances frame rate against CPU usage. A higher value reduces frame rate and CPU load when no frames are being captured. Set to `0` for maximum FPS.

### Request Example (High Quality)
```python
from adbnativeblitz import AdbFastScreenshots

# High quality capture for detailed analysis
high_quality = AdbFastScreenshots(
    adb_path="/usr/bin/adb",                  # Path to ADB executable
    device_serial="emulator-5554",            # Device serial or IP:port
    time_interval=179,                        # Recording session length (max 180s)
    width=1920,                               # Capture width in pixels
    height=1080,                              # Capture height in pixels
    bitrate="30M",                            # Video bitrate (e.g., "20M" for 20Mbps)
    use_busybox=False,                        # Use BusyBox for base64 (some devices)
    connect_to_device=True,                   # Auto-connect via ADB
    screenshotbuffer=20,                      # Frame buffer size
    go_idle=0,                                # Idle time when no frames (0 = max FPS)
)
```

### Request Example (Low CPU Usage)
```python
from adbnativeblitz import AdbFastScreenshots

# Lower CPU usage configuration for background monitoring
low_cpu = AdbFastScreenshots(
    adb_path="/usr/bin/adb",
    device_serial="192.168.1.100:5555",
    time_interval=179,
    width=800,
    height=600,
    bitrate="5M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=5,
    go_idle=0.1,                              # Higher value = less FPS, less CPU
)
```
```

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

### AdbFastScreenshots Class - Basic Usage

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Demonstrates the basic usage of the AdbFastScreenshots class as a context manager to capture and display frames from an Android device in real-time.

```APIDOC
## AdbFastScreenshots - Basic Usage

### Description
This example shows how to initialize and use the `AdbFastScreenshots` class within a `with` statement to capture frames from an Android device and display them using OpenCV. The context manager ensures proper cleanup of resources.

### Method
Context Manager (`with` statement)

### Endpoint
N/A (Local library usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import cv2
from adbnativeblitz import AdbFastScreenshots

# Basic usage with context manager - capture and display frames
with AdbFastScreenshots(
    adb_path=r"C:\\Android\\android-sdk\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1600,
    height=900,
    bitrate="20M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
) as adbscreen:
    for image in adbscreen:
        # image is a NumPy array in BGR format (OpenCV compatible)
        cv2.imshow("Android Screen", image)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

cv2.destroyAllWindows()
```

### Response
#### Success Response (Iterator)
- **image** (NumPy Array) - A NumPy array representing the captured screen frame in BGR format.

#### Response Example
(Displayed in a window using `cv2.imshow`)
```

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

### Capture and Display Android Screen with AdbFastScreenshots

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Demonstrates the basic usage of the AdbFastScreenshots class as a context manager to capture frames from an Android device and display them in real-time using OpenCV. It configures ADB path, device serial, and video quality settings. The loop breaks when the 'q' key is pressed.

```python
import cv2
from adbnativeblitz import AdbFastScreenshots

# Basic usage with context manager - capture and display frames
with AdbFastScreenshots(
    adb_path=r"C:\\Android\\android-sdk\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1600,
    height=900,
    bitrate="20M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
) as adbscreen:
    for image in adbscreen:
        # image is a NumPy array in BGR format (OpenCV compatible)
        cv2.imshow("Android Screen", image)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

cv2.destroyAllWindows()
```

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

### Manually Control Screen Capture with stop_capture()

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Shows how to use the AdbFastScreenshots class without a context manager and manually stop the capture process. Frames are captured and saved as PNG files until 100 frames are collected, at which point `stop_capture()` is called to gracefully terminate the session.

```python
import cv2
from adbnativeblitz import AdbFastScreenshots

# Manual capture control without context manager
adbscreen = AdbFastScreenshots(
    adb_path=r"C:\\Android\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1280,
    height=720,
    bitrate="15M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
)

# Start iteration and capture frames
frame_count = 0
for image in adbscreen:
    cv2.imwrite(f"frame_{frame_count:04d}.png", image)
    frame_count += 1

    # Stop after capturing 100 frames
    if frame_count >= 100:
        adbscreen.stop_capture()
        break

print(f"Captured {frame_count} frames")
```

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

### Timed Capture Control with Threads

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Demonstrates how to stop an active screen recording session after a specific delay using a separate thread and the stop_recording attribute.

```python
import threading
import time
import cv2
from adbnativeblitz import AdbFastScreenshots

def stop_after_delay(adbscreen, delay_seconds):
    time.sleep(delay_seconds)
    print("Stopping capture...")
    adbscreen.stop_recording = True

with AdbFastScreenshots(adb_path=r"C:\Android\platform-tools\adb.exe", device_serial="127.0.0.1:5555", time_interval=179, width=1600, height=900, bitrate="20M", use_busybox=False, connect_to_device=True, screenshotbuffer=10, go_idle=0) as adbscreen:
    timer = threading.Thread(target=stop_after_delay, args=(adbscreen, 10))
    timer.start()
    for image in adbscreen:
        cv2.imshow("Timed Capture", image)
        cv2.waitKey(1)
cv2.destroyAllWindows()
```

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

### Stop Recording After Delay

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Demonstrates how to stop screen recording after a specified delay using a separate thread.

```APIDOC
## Stop Recording After Delay

### Description
This example shows how to initiate screen recording and then stop it automatically after a set delay by using a separate thread.

### Method
N/A (Python script)

### Endpoint
N/A (Python script)

### Parameters
N/A

### Request Example
```python
import time
import threading
import cv2
from adbnativeblitz import AdbFastScreenshots

def stop_after_delay(adbscreen, delay_seconds):
    time.sleep(delay_seconds)
    print("Stopping capture...")
    adbscreen.stop_recording = True  # This triggers stop_capture() automatically

with AdbFastScreenshots(
    adb_path=r"C:\\Android\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1600,
    height=900,
    bitrate="20M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
) as adbscreen:
    # Start a timer thread to stop capture after 10 seconds
    timer = threading.Thread(target=stop_after_delay, args=(adbscreen, 10))
    timer.start()

    for image in adbscreen:
        cv2.imshow("Timed Capture", image)
        cv2.waitKey(1)

cv2.destroyAllWindows()
```

### Response
N/A (Python script)

### Response Example
N/A (Python script)
```

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

### stop_capture() Method

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Explains how to manually stop the screen capture session using the `stop_capture()` method, which gracefully terminates the ADB subprocess and cleans up resources.

```APIDOC
## stop_capture() Method

### Description
The `stop_capture()` method provides a way to manually halt the ongoing screen capture process. It sends a `CTRL+C` signal to the `screenrecord` subprocess and ensures all associated resources are released. This is useful when not using the context manager or when needing to stop capture programmatically based on certain conditions.

### Method
Instance Method (`stop_capture()`)

### Endpoint
N/A (Local library usage)

### Parameters
None

### Request Example
```python
import cv2
from adbnativeblitz import AdbFastScreenshots

# Manual capture control without context manager
adbscreen = AdbFastScreenshots(
    adb_path=r"C:\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1280,
    height=720,
    bitrate="15M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
)

# Start iteration and capture frames
frame_count = 0
for image in adbscreen:
    cv2.imwrite(f"frame_{frame_count:04d}.png", image)
    frame_count += 1

    # Stop after capturing 100 frames
    if frame_count >= 100:
        adbscreen.stop_capture()
        break

print(f"Captured {frame_count} frames")
```

### Response
None (The method performs an action and returns `None`)
```

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

### Integration with Image Processing Libraries

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Shows how to use captured frames (NumPy arrays) with OpenCV for image processing tasks like edge detection.

```APIDOC
## Integration with Image Processing

### Description
Frames are returned as NumPy arrays in BGR format, making them directly compatible with OpenCV and other image processing libraries. This enables real-time analysis, object detection, and automation workflows.

### Method
N/A (Python script)

### Endpoint
N/A (Python script)

### Parameters
N/A

### Request Example
```python
import cv2
import numpy as np
from adbnativeblitz import AdbFastScreenshots

def find_template(frame, template_path, threshold=0.8):
    """Find a template image within the captured frame."""
    template = cv2.imread(template_path)
    result = cv2.matchTemplate(frame, template, cv2.TM_CCOEFF_NORMED)
    locations = np.where(result >= threshold)
    return list(zip(*locations[::-1]))  # Returns list of (x, y) coordinates

with AdbFastScreenshots(
    adb_path=r"C:\\Android\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1080,
    height=1920,
    bitrate="20M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=5,
    go_idle=0.05,
) as adbscreen:
    for frame in adbscreen:
        # Convert to grayscale for processing
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        # Apply edge detection
        edges = cv2.Canny(gray, 50, 150)

        # Find contours
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        # Draw contours on original frame
        output = frame.copy()
        cv2.drawContours(output, contours, -1, (0, 255, 0), 2)

        cv2.imshow("Edge Detection", output)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

cv2.destroyAllWindows()
```

### Response
N/A (Python script)

### Response Example
N/A (Python script)
```

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

### Real-time Edge Detection and Image Processing

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Integrates captured frames with OpenCV to perform real-time edge detection and contour analysis on Android device screens.

```python
import cv2
import numpy as np
from adbnativeblitz import AdbFastScreenshots

with AdbFastScreenshots(adb_path=r"C:\Android\platform-tools\adb.exe", device_serial="127.0.0.1:5555", time_interval=179, width=1080, height=1920, bitrate="20M", use_busybox=False, connect_to_device=True, screenshotbuffer=5, go_idle=0.05) as adbscreen:
    for frame in adbscreen:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 50, 150)
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        output = frame.copy()
        cv2.drawContours(output, contours, -1, (0, 255, 0), 2)
        cv2.imshow("Edge Detection", output)
        if cv2.waitKey(1) & 0xFF == ord("q"): break
cv2.destroyAllWindows()
```

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

### Stop ADB Capture using stop_recording Attribute

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

This snippet illustrates how to use the `stop_recording` attribute to control the screen capture loop externally. While the full implementation is not shown, it sets up the necessary imports and the AdbFastScreenshots object, indicating that `stop_recording` would be set to `True` to halt the capture process, likely from another thread.

```python
import threading
import time
import cv2
from adbnativeblitz import AdbFastScreenshots

# The code here would typically involve starting the capture in one thread
# and setting adbscreen.stop_recording = True from another thread or event handler.
# For brevity, only the setup is shown as per the provided text.
```

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

### Motion Detection using Frame Buffers

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Utilizes the lastframes deque buffer to compare current and previous frames for motion detection, while tracking total frame counts.

```python
import cv2
import numpy as np
from adbnativeblitz import AdbFastScreenshots

with AdbFastScreenshots(adb_path=r"C:\Android\platform-tools\adb.exe", device_serial="127.0.0.1:5555", time_interval=179, width=1280, height=720, bitrate="20M", use_busybox=False, connect_to_device=True, screenshotbuffer=30, go_idle=0) as adbscreen:
    for current_frame in adbscreen:
        if len(adbscreen.lastframes) >= 2:
            prev_frame = adbscreen.lastframes[-2]
            diff = cv2.absdiff(current_frame, prev_frame)
            gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
            motion = np.sum(gray_diff) / gray_diff.size
            if motion > 10:
                print(f"Motion detected! Level: {motion:.2f}")
        print(f"Total frames captured: {adbscreen.framecounter}")
        cv2.imshow("Motion Detection", current_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"): break
cv2.destroyAllWindows()
```

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

### Frame Buffer Access and Motion Detection

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Utilizes the `lastframes` attribute to access previous frames for motion detection.

```APIDOC
## Frame Buffer Access

### Description
The `lastframes` attribute provides access to a deque containing the most recently captured frames. The buffer size is controlled by the `screenshotbuffer` parameter, allowing access to previous frames for motion analysis or frame comparison.

### Method
N/A (Python script)

### Endpoint
N/A (Python script)

### Parameters
N/A

### Request Example
```python
import cv2
import numpy as np
from adbnativeblitz import AdbFastScreenshots

with AdbFastScreenshots(
    adb_path=r"C:\\Android\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1280,
    height=720,
    bitrate="20M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=30,  # Keep last 30 frames
    go_idle=0,
) as adbscreen:
    for current_frame in adbscreen:
        # Access frame buffer for motion detection
        if len(adbscreen.lastframes) >= 2:
            prev_frame = adbscreen.lastframes[-2]
            diff = cv2.absdiff(current_frame, prev_frame)
            gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
            motion = np.sum(gray_diff) / gray_diff.size

            if motion > 10:  # Threshold for motion detection
                print(f"Motion detected! Level: {motion:.2f}")

        # Check frame counter for statistics
        print(f"Total frames captured: {adbscreen.framecounter}")

        cv2.imshow("Motion Detection", current_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break

cv2.destroyAllWindows()
```

### Response
N/A (Python script)

### Response Example
N/A (Python script)
```

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

### stop_recording Attribute

Source: https://context7.com/hansalemaos/adbnativeblitz/llms.txt

Describes the `stop_recording` attribute, a boolean flag that can be set to `True` to trigger a graceful stop of the screen capture session, often used for external control.

```APIDOC
## stop_recording Attribute

### Description
The `stop_recording` attribute acts as a control flag. When set to `True`, it signals the capture loop to terminate gracefully. This mechanism is particularly useful for stopping the capture from a different thread or external process, as it leverages a descriptor to automatically call `stop_capture()`.

### Method
Attribute Assignment (`instance.stop_recording = True`)

### Endpoint
N/A (Local library usage)

### Parameters
None

### Request Example
```python
import threading
import time
import cv2
from adbnativeblitz import AdbFastScreenshots

# Example demonstrating external control via stop_recording attribute
adbscreen = AdbFastScreenshots(
    adb_path=r"C:\\platform-tools\\adb.exe",
    device_serial="127.0.0.1:5555",
    time_interval=179,
    width=1280,
    height=720,
    bitrate="15M",
    use_busybox=False,
    connect_to_device=True,
    screenshotbuffer=10,
    go_idle=0,
)

def capture_frames():
    for image in adbscreen:
        # Process or save image
        print("Frame captured")
        time.sleep(0.1) # Simulate work

# Start capture in a separate thread
capture_thread = threading.Thread(target=capture_frames)
capture_thread.start()

# Let it run for a few seconds
time.sleep(5)

# Signal to stop the capture
print("Stopping capture...")
adbscreen.stop_recording = True

# Wait for the capture thread to finish
capture_thread.join()
print("Capture stopped.")
```

### Response
None (Setting the attribute triggers an internal stop process)
```

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