flet-media-scanner 0.86.0__tar.gz

flet_media_scanner-0.86.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: flet-media-scanner
+Version: 0.86.0
+Summary: Flet extension for Android MediaStore — scan, save, list, and delete videos in the Gallery
+Author-email: Fazi-Gondal <nextinpk@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/fazi-gondal/Vidsaver
+Project-URL: Repository, https://github.com/fazi-gondal/Vidsaver
+Project-URL: Bug Tracker, https://github.com/fazi-gondal/Vidsaver/issues
+Keywords: flet,android,media,mediascanner,gallery,flutter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.86.0
+
+# flet-media-scanner
+
+A [Flet](https://flet.dev) extension for Android **MediaStore** integration — save, list, and delete videos in the device Gallery without requiring broad storage permissions.
+
+## Requirements
+
+- **Platform**: Android only (no-op on other platforms)
+- **Android**: API 23+ (minSdk 23)
+- **Flet**: >= 0.86.0
+
+## Installation
+
+```bash
+pip install flet-media-scanner
+```
+
+## Setup
+
+Register the extension in your `pyproject.toml`:
+
+```toml
+[tool.flet.extensions]
+flet_media_scanner = "flet_media_scanner.Extension"
+```
+
+## Usage
+
+```python
+import flet as ft
+from flet_media_scanner import MediaScanner, SaveResult
+
+async def main(page: ft.Page):
+    scanner = MediaScanner()
+    page.services.append(scanner)
+    page.update()
+
+    # Save a video to the Gallery (Movies/MyApp folder)
+    result: SaveResult = await scanner.save_video(
+        "/data/user/0/com.example.app/cache/video.mp4",
+        file_name="my_video.mp4",
+        album="MyApp",
+    )
+    if result.success:
+        print(f"Saved: {result.content_uri}")
+    else:
+        print(f"Error: {result.error}")
+
+    # List videos in the album
+    videos = await scanner.list_videos(album="MyApp")
+    for v in videos:
+        print(v["display_name"], v["content_uri"])
+
+    # Delete a video by content URI
+    deleted = await scanner.delete_video("content://media/external/video/media/123")
+    print("Deleted:", deleted)
+
+ft.run(main)
+```
+
+## API
+
+### `MediaScanner` (Service)
+
+Add to `page.services` before calling any methods.
+
+#### `await save_video(file_path, file_name=None, album="MyApp") → SaveResult`
+
+Copies a private app file into Android MediaStore (`Movies/<album>`). Works on Android 10+ without broad storage permissions.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `file_path` | `str` | Absolute path to the source video file |
+| `file_name` | `str \| None` | Display name in Gallery (defaults to basename) |
+| `album` | `str` | Subfolder inside `Movies/` |
+
+#### `await list_videos(album="MyApp") → list[dict]`
+
+Returns all videos previously saved to the album. Each dict contains: `display_name`, `content_uri`, `mime_type`, `relative_path`, `size`, `date_added`.
+
+#### `await delete_video(content_uri) → bool`
+
+Deletes a MediaStore item by its `content://` URI.
+
+#### `await scan_media(file_path) → bool`
+
+*(Legacy)* Triggers a media scan for a file that already exists in public storage. Use `save_video()` for new downloads instead.
+
+---
+
+### `SaveResult` (dataclass)
+
+| Field | Type | Description |
+|---|---|---|
+| `success` | `bool` | Whether the operation succeeded |
+| `content_uri` | `str` | MediaStore `content://` URI |
+| `display_name` | `str` | File name as shown in Gallery |
+| `mime_type` | `str` | e.g. `video/mp4` |
+| `relative_path` | `str` | e.g. `Movies/MyApp/` |
+| `size` | `int` | File size in bytes |
+| `error` | `str` | Error message if `success=False` |
+
+## License
+
+MIT

flet_media_scanner-0.86.0/README.md

@@ -0,0 +1,104 @@
+# flet-media-scanner
+
+A [Flet](https://flet.dev) extension for Android **MediaStore** integration — save, list, and delete videos in the device Gallery without requiring broad storage permissions.
+
+## Requirements
+
+- **Platform**: Android only (no-op on other platforms)
+- **Android**: API 23+ (minSdk 23)
+- **Flet**: >= 0.86.0
+
+## Installation
+
+```bash
+pip install flet-media-scanner
+```
+
+## Setup
+
+Register the extension in your `pyproject.toml`:
+
+```toml
+[tool.flet.extensions]
+flet_media_scanner = "flet_media_scanner.Extension"
+```
+
+## Usage
+
+```python
+import flet as ft
+from flet_media_scanner import MediaScanner, SaveResult
+
+async def main(page: ft.Page):
+    scanner = MediaScanner()
+    page.services.append(scanner)
+    page.update()
+
+    # Save a video to the Gallery (Movies/MyApp folder)
+    result: SaveResult = await scanner.save_video(
+        "/data/user/0/com.example.app/cache/video.mp4",
+        file_name="my_video.mp4",
+        album="MyApp",
+    )
+    if result.success:
+        print(f"Saved: {result.content_uri}")
+    else:
+        print(f"Error: {result.error}")
+
+    # List videos in the album
+    videos = await scanner.list_videos(album="MyApp")
+    for v in videos:
+        print(v["display_name"], v["content_uri"])
+
+    # Delete a video by content URI
+    deleted = await scanner.delete_video("content://media/external/video/media/123")
+    print("Deleted:", deleted)
+
+ft.run(main)
+```
+
+## API
+
+### `MediaScanner` (Service)
+
+Add to `page.services` before calling any methods.
+
+#### `await save_video(file_path, file_name=None, album="MyApp") → SaveResult`
+
+Copies a private app file into Android MediaStore (`Movies/<album>`). Works on Android 10+ without broad storage permissions.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `file_path` | `str` | Absolute path to the source video file |
+| `file_name` | `str \| None` | Display name in Gallery (defaults to basename) |
+| `album` | `str` | Subfolder inside `Movies/` |
+
+#### `await list_videos(album="MyApp") → list[dict]`
+
+Returns all videos previously saved to the album. Each dict contains: `display_name`, `content_uri`, `mime_type`, `relative_path`, `size`, `date_added`.
+
+#### `await delete_video(content_uri) → bool`
+
+Deletes a MediaStore item by its `content://` URI.
+
+#### `await scan_media(file_path) → bool`
+
+*(Legacy)* Triggers a media scan for a file that already exists in public storage. Use `save_video()` for new downloads instead.
+
+---
+
+### `SaveResult` (dataclass)
+
+| Field | Type | Description |
+|---|---|---|
+| `success` | `bool` | Whether the operation succeeded |
+| `content_uri` | `str` | MediaStore `content://` URI |
+| `display_name` | `str` | File name as shown in Gallery |
+| `mime_type` | `str` | e.g. `video/mp4` |
+| `relative_path` | `str` | e.g. `Movies/MyApp/` |
+| `size` | `int` | File size in bytes |
+| `error` | `str` | Error message if `success=False` |
+
+## License
+
+MIT

flet_media_scanner-0.86.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "flet-media-scanner"
+version = "0.86.0"
+description = "Flet extension for Android MediaStore — scan, save, list, and delete videos in the Gallery"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+authors = [
+    { name = "Fazi-Gondal", email = "nextinpk@gmail.com" }
+]
+keywords = ["flet", "android", "media", "mediascanner", "gallery", "flutter"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "flet>=0.86.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/fazi-gondal/Vidsaver"
+Repository = "https://github.com/fazi-gondal/Vidsaver"
+"Bug Tracker" = "https://github.com/fazi-gondal/Vidsaver/issues"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["flet_media_scanner", "flutter.flet_media_scanner"]
+
+[tool.setuptools.package-data]
+"flutter.flet_media_scanner" = ["**/*"]

flet_media_scanner-0.86.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flet_media_scanner-0.86.0/src/flet_media_scanner/__init__.py

@@ -0,0 +1,3 @@
+from flet_media_scanner.media_scanner import MediaScanner, SaveResult
+
+__all__ = ["MediaScanner", "SaveResult"]

flet_media_scanner-0.86.0/src/flet_media_scanner/media_scanner.py

@@ -0,0 +1,124 @@
+from dataclasses import dataclass
+import json
+import os
+from typing import Any, Optional
+
+import flet as ft
+
+
+@dataclass
+class SaveResult:
+    success: bool = False
+    content_uri: str = ""
+    display_name: str = ""
+    mime_type: str = ""
+    relative_path: str = ""
+    source_path: str = ""
+    size: int = 0
+    error: str = ""
+
+
+@ft.control("MediaScanner")
+class MediaScanner(ft.Service):
+    """
+    Android media service for publishing videos through MediaStore.
+
+    New downloads should use save_video(). scan_media() is kept only for
+    legacy files that already exist in public storage and need Gallery indexing.
+    """
+
+    on_saved: Optional[ft.EventHandler[Any]] = None
+    on_scanned: Optional[ft.EventHandler[Any]] = None
+
+    async def save_video(
+        self,
+        file_path: str,
+        file_name: str | None = None,
+        album: str = "Vidsaver",
+    ) -> SaveResult:
+        """
+        Copy an app-private video into Android MediaStore.Video.
+
+        On Android 10+ this publishes to Movies/<album> without requiring
+        broad storage permissions or a media scan.
+        """
+        if not file_path or not os.path.exists(file_path):
+            return SaveResult(error=f"file does not exist: {file_path}")
+
+        try:
+            result = await self._invoke_method(
+                "save_video",
+                {
+                    "path": file_path,
+                    "file_name": file_name or os.path.basename(file_path),
+                    "album": album,
+                },
+                timeout=60.0,
+            )
+            payload = json.loads(result) if result else {}
+            return SaveResult(
+                success=bool(payload.get("success")),
+                content_uri=str(payload.get("content_uri") or ""),
+                display_name=str(payload.get("display_name") or ""),
+                mime_type=str(payload.get("mime_type") or ""),
+                relative_path=str(payload.get("relative_path") or ""),
+                source_path=str(payload.get("source_path") or file_path),
+                size=int(payload.get("size") or 0),
+                error=str(payload.get("error") or ""),
+            )
+        except Exception as e:
+            return SaveResult(error=str(e), source_path=file_path)
+
+    async def scan_media(self, file_path: str) -> bool:
+        """
+        Scan a legacy public media file so it appears in Gallery/Photos.
+
+        New downloads should use save_video() instead; MediaStore inserts do
+        not need this scan.
+        """
+        if not file_path or not os.path.exists(file_path):
+            print(f"[MediaScanner] scan_media: file does not exist: {file_path}")
+            return False
+        try:
+            result = await self._invoke_method(
+                "scan_media",
+                {"path": file_path},
+                timeout=15.0,
+            )
+            success = result == "true"
+            print(f"[MediaScanner] scan_media: {file_path} -> result={result} success={success}")
+            return success
+        except Exception as e:
+            print(f"[MediaScanner] scan_media error: {file_path}: {e}")
+            return False
+
+    async def delete_video(self, content_uri: str) -> bool:
+        """Delete a MediaStore item by its content URI."""
+        if not content_uri:
+            return False
+        try:
+            result = await self._invoke_method(
+                "delete_video",
+                {"content_uri": content_uri},
+                timeout=15.0,
+            )
+            payload = json.loads(result) if result else {}
+            return bool(payload.get("success"))
+        except Exception as e:
+            print(f"[MediaScanner] delete_video error: {content_uri}: {e}")
+            return False
+
+    async def list_videos(self, album: str = "Vidsaver") -> list[dict]:
+        """List videos previously saved to the MediaStore album."""
+        try:
+            result = await self._invoke_method(
+                "list_videos",
+                {"album": album},
+                timeout=15.0,
+            )
+            payload = json.loads(result) if result else {}
+            videos = payload.get("videos") or []
+            return videos if isinstance(videos, list) else []
+        except Exception as e:
+            print(f"[MediaScanner] list_videos error: {e}")
+            return []

flet_media_scanner-0.86.0/src/flet_media_scanner.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: flet-media-scanner
+Version: 0.86.0
+Summary: Flet extension for Android MediaStore — scan, save, list, and delete videos in the Gallery
+Author-email: Fazi-Gondal <nextinpk@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/fazi-gondal/Vidsaver
+Project-URL: Repository, https://github.com/fazi-gondal/Vidsaver
+Project-URL: Bug Tracker, https://github.com/fazi-gondal/Vidsaver/issues
+Keywords: flet,android,media,mediascanner,gallery,flutter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.86.0
+
+# flet-media-scanner
+
+A [Flet](https://flet.dev) extension for Android **MediaStore** integration — save, list, and delete videos in the device Gallery without requiring broad storage permissions.
+
+## Requirements
+
+- **Platform**: Android only (no-op on other platforms)
+- **Android**: API 23+ (minSdk 23)
+- **Flet**: >= 0.86.0
+
+## Installation
+
+```bash
+pip install flet-media-scanner
+```
+
+## Setup
+
+Register the extension in your `pyproject.toml`:
+
+```toml
+[tool.flet.extensions]
+flet_media_scanner = "flet_media_scanner.Extension"
+```
+
+## Usage
+
+```python
+import flet as ft
+from flet_media_scanner import MediaScanner, SaveResult
+
+async def main(page: ft.Page):
+    scanner = MediaScanner()
+    page.services.append(scanner)
+    page.update()
+
+    # Save a video to the Gallery (Movies/MyApp folder)
+    result: SaveResult = await scanner.save_video(
+        "/data/user/0/com.example.app/cache/video.mp4",
+        file_name="my_video.mp4",
+        album="MyApp",
+    )
+    if result.success:
+        print(f"Saved: {result.content_uri}")
+    else:
+        print(f"Error: {result.error}")
+
+    # List videos in the album
+    videos = await scanner.list_videos(album="MyApp")
+    for v in videos:
+        print(v["display_name"], v["content_uri"])
+
+    # Delete a video by content URI
+    deleted = await scanner.delete_video("content://media/external/video/media/123")
+    print("Deleted:", deleted)
+
+ft.run(main)
+```
+
+## API
+
+### `MediaScanner` (Service)
+
+Add to `page.services` before calling any methods.
+
+#### `await save_video(file_path, file_name=None, album="MyApp") → SaveResult`
+
+Copies a private app file into Android MediaStore (`Movies/<album>`). Works on Android 10+ without broad storage permissions.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `file_path` | `str` | Absolute path to the source video file |
+| `file_name` | `str \| None` | Display name in Gallery (defaults to basename) |
+| `album` | `str` | Subfolder inside `Movies/` |
+
+#### `await list_videos(album="MyApp") → list[dict]`
+
+Returns all videos previously saved to the album. Each dict contains: `display_name`, `content_uri`, `mime_type`, `relative_path`, `size`, `date_added`.
+
+#### `await delete_video(content_uri) → bool`
+
+Deletes a MediaStore item by its `content://` URI.
+
+#### `await scan_media(file_path) → bool`
+
+*(Legacy)* Triggers a media scan for a file that already exists in public storage. Use `save_video()` for new downloads instead.
+
+---
+
+### `SaveResult` (dataclass)
+
+| Field | Type | Description |
+|---|---|---|
+| `success` | `bool` | Whether the operation succeeded |
+| `content_uri` | `str` | MediaStore `content://` URI |
+| `display_name` | `str` | File name as shown in Gallery |
+| `mime_type` | `str` | e.g. `video/mp4` |
+| `relative_path` | `str` | e.g. `Movies/MyApp/` |
+| `size` | `int` | File size in bytes |
+| `error` | `str` | Error message if `success=False` |
+
+## License
+
+MIT

flet_media_scanner-0.86.0/src/flet_media_scanner.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/flet_media_scanner/__init__.py
+src/flet_media_scanner/media_scanner.py
+src/flet_media_scanner.egg-info/PKG-INFO
+src/flet_media_scanner.egg-info/SOURCES.txt
+src/flet_media_scanner.egg-info/dependency_links.txt
+src/flet_media_scanner.egg-info/requires.txt
+src/flet_media_scanner.egg-info/top_level.txt
+src/flutter/flet_media_scanner/pubspec.yaml
+src/flutter/flet_media_scanner/android/build.gradle
+src/flutter/flet_media_scanner/android/src/main/AndroidManifest.xml
+src/flutter/flet_media_scanner/android/src/main/kotlin/com/example/flet_media_scanner/FletMediaScannerPlugin.kt
+src/flutter/flet_media_scanner/lib/flet_media_scanner.dart
+src/flutter/flet_media_scanner/lib/src/extension.dart
+src/flutter/flet_media_scanner/lib/src/media_scanner_service.dart

flet_media_scanner-0.86.0/src/flet_media_scanner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flet_media_scanner-0.86.0/src/flet_media_scanner.egg-info/requires.txt

@@ -0,0 +1 @@
+flet>=0.86.0

flet_media_scanner-0.86.0/src/flet_media_scanner.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+flet_media_scanner
+flutter

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/android/build.gradle

@@ -0,0 +1,46 @@
+group 'com.example.flet_media_scanner'
+version '1.0'
+
+buildscript {
+    ext.kotlin_version = '1.8.22'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.3.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.example.flet_media_scanner"
+    compileSdkVersion 33
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
+    defaultConfig {
+        minSdkVersion 21
+    }
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+}

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/android/src/main/kotlin/com/example/flet_media_scanner/FletMediaScannerPlugin.kt

@@ -0,0 +1,252 @@
+package com.example.flet_media_scanner
+
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.util.Log
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import io.flutter.plugin.common.MethodChannel.MethodCallHandler
+import io.flutter.plugin.common.MethodChannel.Result
+import java.io.File
+import java.io.FileInputStream
+import java.net.URLConnection
+
+class FletMediaScannerPlugin : FlutterPlugin, MethodCallHandler {
+    private lateinit var channel: MethodChannel
+    private lateinit var context: Context
+
+    companion object {
+        private const val TAG = "FletMediaScanner"
+        private const val CHANNEL = "flet_media_scanner/scan"
+    }
+
+    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        context = binding.applicationContext
+        channel = MethodChannel(binding.binaryMessenger, CHANNEL)
+        channel.setMethodCallHandler(this)
+        Log.d(TAG, "onAttachedToEngine: channel registered")
+    }
+
+    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+        channel.setMethodCallHandler(null)
+        Log.d(TAG, "onDetachedFromEngine")
+    }
+
+    override fun onMethodCall(call: MethodCall, result: Result) {
+        when (call.method) {
+            "saveVideo" -> saveVideo(call, result)
+            "deleteVideo" -> deleteVideo(call, result)
+            "listVideos" -> listVideos(call, result)
+            else -> result.notImplemented()
+        }
+    }
+
+    private fun saveVideo(call: MethodCall, result: Result) {
+        val path = call.argument<String>("path")
+        val requestedFileName = call.argument<String>("fileName")
+        val album = call.argument<String>("album")
+            ?.trim()
+            ?.trim('/')
+            ?.takeIf { it.isNotBlank() }
+            ?: "Vidsaver"
+
+        if (path.isNullOrBlank()) {
+            result.error("INVALID_ARGUMENT", "path must not be null or empty", null)
+            return
+        }
+
+        val source = File(path)
+        if (!source.isFile) {
+            result.error("FILE_NOT_FOUND", "source file does not exist: $path", null)
+            return
+        }
+
+        val displayName = requestedFileName
+            ?.trim()
+            ?.takeIf { it.isNotBlank() }
+            ?: source.name
+        val mimeType = URLConnection.guessContentTypeFromName(displayName) ?: "video/mp4"
+        val relativePath = "${Environment.DIRECTORY_MOVIES}/$album"
+        val resolver = context.contentResolver
+        val collection = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+        } else {
+            MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+        }
+
+        var uri: Uri? = null
+        try {
+            val values = ContentValues().apply {
+                put(MediaStore.Video.Media.DISPLAY_NAME, displayName)
+                put(MediaStore.Video.Media.MIME_TYPE, mimeType)
+                put(MediaStore.Video.Media.DATE_ADDED, System.currentTimeMillis() / 1000)
+                put(MediaStore.Video.Media.DATE_MODIFIED, source.lastModified() / 1000)
+                put(MediaStore.Video.Media.SIZE, source.length())
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    put(MediaStore.Video.Media.RELATIVE_PATH, relativePath)
+                    put(MediaStore.Video.Media.IS_PENDING, 1)
+                }
+            }
+
+            uri = resolver.insert(collection, values)
+                ?: throw IllegalStateException("MediaStore insert returned null")
+
+            resolver.openOutputStream(uri)?.use { output ->
+                FileInputStream(source).use { input ->
+                    input.copyTo(output)
+                }
+            } ?: throw IllegalStateException("Unable to open MediaStore output stream")
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val publishedValues = ContentValues().apply {
+                    put(MediaStore.Video.Media.IS_PENDING, 0)
+                    put(MediaStore.Video.Media.SIZE, source.length())
+                }
+                resolver.update(uri, publishedValues, null, null)
+            }
+
+            result.success(
+                mapOf(
+                    "success" to true,
+                    "content_uri" to uri.toString(),
+                    "display_name" to displayName,
+                    "mime_type" to mimeType,
+                    "relative_path" to relativePath,
+                    "source_path" to path,
+                    "size" to source.length(),
+                )
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "saveVideo: exception: ${e.message}", e)
+            uri?.let {
+                try {
+                    resolver.delete(it, null, null)
+                } catch (deleteError: Exception) {
+                    Log.w(TAG, "saveVideo: failed to delete incomplete item: $deleteError")
+                }
+            }
+            result.error("SAVE_ERROR", e.message, e.toString())
+        }
+    }
+
+    private fun deleteVideo(call: MethodCall, result: Result) {
+        val contentUri = call.argument<String>("contentUri")
+        if (contentUri.isNullOrBlank()) {
+            result.error("INVALID_ARGUMENT", "contentUri must not be null or empty", null)
+            return
+        }
+
+        try {
+            val uri = Uri.parse(contentUri)
+            val deletedRows = context.contentResolver.delete(uri, null, null)
+            result.success(
+                mapOf(
+                    "success" to (deletedRows > 0),
+                    "content_uri" to contentUri,
+                    "deleted_rows" to deletedRows,
+                )
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "deleteVideo: exception: ${e.message}", e)
+            result.error("DELETE_ERROR", e.message, e.toString())
+        }
+    }
+
+    private fun listVideos(call: MethodCall, result: Result) {
+        val album = call.argument<String>("album")
+            ?.trim()
+            ?.trim('/')
+            ?.takeIf { it.isNotBlank() }
+            ?: "Vidsaver"
+        val resolver = context.contentResolver
+        val collection = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+        } else {
+            MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+        }
+
+        val projection = mutableListOf(
+            MediaStore.Video.Media._ID,
+            MediaStore.Video.Media.DISPLAY_NAME,
+            MediaStore.Video.Media.MIME_TYPE,
+            MediaStore.Video.Media.SIZE,
+            MediaStore.Video.Media.DATE_ADDED,
+            MediaStore.Video.Media.DATE_MODIFIED,
+        )
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            projection.add(MediaStore.Video.Media.RELATIVE_PATH)
+        }
+
+        val selection: String?
+        val selectionArgs: Array<String>?
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            selection = "${MediaStore.Video.Media.RELATIVE_PATH} LIKE ?"
+            selectionArgs = arrayOf("${Environment.DIRECTORY_MOVIES}/$album%")
+        } else {
+            selection = null
+            selectionArgs = null
+        }
+
+        val videos = mutableListOf<Map<String, Any?>>()
+        try {
+            resolver.query(
+                collection,
+                projection.toTypedArray(),
+                selection,
+                selectionArgs,
+                "${MediaStore.Video.Media.DATE_ADDED} DESC"
+            )?.use { cursor ->
+                val idIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID)
+                val nameIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME)
+                val mimeIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.MIME_TYPE)
+                val sizeIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE)
+                val addedIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_ADDED)
+                val modifiedIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_MODIFIED)
+                val relativePathIndex = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    cursor.getColumnIndex(MediaStore.Video.Media.RELATIVE_PATH)
+                } else {
+                    -1
+                }
+
+                while (cursor.moveToNext()) {
+                    val id = cursor.getLong(idIndex)
+                    val uri = ContentUris.withAppendedId(collection, id)
+                    val displayName = cursor.getString(nameIndex) ?: continue
+                    val relativePath = if (relativePathIndex >= 0) {
+                        cursor.getString(relativePathIndex) ?: ""
+                    } else {
+                        "${Environment.DIRECTORY_MOVIES}/$album"
+                    }
+
+                    videos.add(
+                        mapOf(
+                            "content_uri" to uri.toString(),
+                            "display_name" to displayName,
+                            "mime_type" to (cursor.getString(mimeIndex) ?: "video/mp4"),
+                            "relative_path" to relativePath.trimEnd('/'),
+                            "size" to cursor.getLong(sizeIndex),
+                            "date_added" to cursor.getLong(addedIndex),
+                            "date_modified" to cursor.getLong(modifiedIndex),
+                        )
+                    )
+                }
+            }
+
+            result.success(
+                mapOf(
+                    "success" to true,
+                    "videos" to videos,
+                )
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "listVideos: exception: ${e.message}", e)
+            result.error("LIST_ERROR", e.message, e.toString())
+        }
+    }
+}

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/lib/flet_media_scanner.dart

@@ -0,0 +1,2 @@
+library flet_media_scanner;
+export 'src/extension.dart' show Extension;

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/lib/src/extension.dart

@@ -0,0 +1,17 @@
+import 'package:flet/flet.dart';
+import 'media_scanner_service.dart';
+
+class Extension extends FletExtension {
+  @override
+  void ensureInitialized() {}
+
+  @override
+  FletService? createService(Control control) {
+    switch (control.type) {
+      case "MediaScanner":
+        return MediaScannerService(control: control);
+      default:
+        return null;
+    }
+  }
+}

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/lib/src/media_scanner_service.dart

@@ -0,0 +1,186 @@
+import 'dart:convert';
+
+import 'package:flet/flet.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:media_scanner/media_scanner.dart';
+
+class MediaScannerService extends FletService {
+  static const MethodChannel _channel =
+      MethodChannel('flet_media_scanner/scan');
+
+  MediaScannerService({required super.control});
+
+  @override
+  void init() {
+    super.init();
+    control.addInvokeMethodListener(_onInvokeMethod);
+    debugPrint("MediaScannerService: initialized");
+  }
+
+  Future<dynamic> _onInvokeMethod(String methodName, dynamic args) async {
+    Map<String, dynamic> arguments = {};
+    if (args != null && args is Map) {
+      arguments = Map<String, dynamic>.from(args);
+    }
+
+    debugPrint(
+        "MediaScannerService._onInvokeMethod: $methodName args=$arguments");
+
+    return switch (methodName) {
+      "save_video" => await _saveVideo(arguments),
+      "delete_video" => await _deleteVideo(arguments),
+      "list_videos" => await _listVideos(arguments),
+      "scan_media" => await _scanMedia(arguments),
+      _ => throw Exception("MediaScannerService: unknown method '$methodName'"),
+    };
+  }
+
+  Future<String> _saveVideo(Map<String, dynamic> args) async {
+    final String? path = args["path"] as String?;
+    final String? fileName = args["file_name"] as String?;
+    final String album = args["album"] as String? ?? "Vidsaver";
+    if (path == null || path.isEmpty) {
+      return _encodeResult({
+        "success": false,
+        "error": "path is required",
+      });
+    }
+
+    try {
+      final result = await _channel.invokeMethod<Map<dynamic, dynamic>>(
+        'saveVideo',
+        {
+          'path': path,
+          'fileName': fileName,
+          'album': album,
+        },
+      );
+      final payload = Map<String, dynamic>.from(result ?? {});
+      control.triggerEvent("saved", payload);
+      return _encodeResult(payload);
+    } on PlatformException catch (e) {
+      final payload = {
+        "success": false,
+        "path": path,
+        "error": "${e.code}: ${e.message}",
+      };
+      control.triggerEvent("saved", payload);
+      return _encodeResult(payload);
+    } catch (error, stack) {
+      debugPrint("MediaScannerService._saveVideo: ERROR '$path': $error\n$stack");
+      final payload = {
+        "success": false,
+        "path": path,
+        "error": error.toString(),
+      };
+      control.triggerEvent("saved", payload);
+      return _encodeResult(payload);
+    }
+  }
+
+  Future<String> _scanMedia(Map<String, dynamic> args) async {
+    final String? path = args["path"] as String?;
+    if (path == null || path.isEmpty) {
+      debugPrint("MediaScannerService._scanMedia: path is null or empty");
+      control.triggerEvent(
+          "scanned", {"path": path ?? "", "success": "false", "error": "path is required"});
+      return "false";
+    }
+
+    debugPrint("MediaScannerService._scanMedia: scanning '$path'");
+
+    try {
+      await MediaScanner.loadMedia(path: path);
+      debugPrint(
+          "MediaScannerService._scanMedia: media_scanner completed path='$path'");
+      control.triggerEvent("scanned", {
+        "path": path,
+        "success": "true",
+        "result": "scanned",
+      });
+      return "true";
+    } catch (error, stack) {
+      debugPrint(
+          "MediaScannerService._scanMedia: ERROR '$path': $error\n$stack");
+      control.triggerEvent("scanned", {
+        "path": path,
+        "success": "false",
+        "error": error.toString(),
+      });
+      return "false";
+    }
+  }
+
+  Future<String> _deleteVideo(Map<String, dynamic> args) async {
+    final String? contentUri = args["content_uri"] as String?;
+    if (contentUri == null || contentUri.isEmpty) {
+      return _encodeResult({
+        "success": false,
+        "error": "content_uri is required",
+      });
+    }
+
+    try {
+      final result = await _channel.invokeMethod<Map<dynamic, dynamic>>(
+        'deleteVideo',
+        {'contentUri': contentUri},
+      );
+      final payload = Map<String, dynamic>.from(result ?? {});
+      control.triggerEvent("deleted", payload);
+      return _encodeResult(payload);
+    } on PlatformException catch (e) {
+      final payload = {
+        "success": false,
+        "content_uri": contentUri,
+        "error": "${e.code}: ${e.message}",
+      };
+      control.triggerEvent("deleted", payload);
+      return _encodeResult(payload);
+    } catch (error, stack) {
+      debugPrint("MediaScannerService._deleteVideo: ERROR '$contentUri': $error\n$stack");
+      final payload = {
+        "success": false,
+        "content_uri": contentUri,
+        "error": error.toString(),
+      };
+      control.triggerEvent("deleted", payload);
+      return _encodeResult(payload);
+    }
+  }
+
+  Future<String> _listVideos(Map<String, dynamic> args) async {
+    final String album = args["album"] as String? ?? "Vidsaver";
+
+    try {
+      final result = await _channel.invokeMethod<Map<dynamic, dynamic>>(
+        'listVideos',
+        {'album': album},
+      );
+      return _encodeResult(Map<String, dynamic>.from(result ?? {}));
+    } on PlatformException catch (e) {
+      return _encodeResult({
+        "success": false,
+        "videos": [],
+        "error": "${e.code}: ${e.message}",
+      });
+    } catch (error, stack) {
+      debugPrint("MediaScannerService._listVideos: ERROR '$album': $error\n$stack");
+      return _encodeResult({
+        "success": false,
+        "videos": [],
+        "error": error.toString(),
+      });
+    }
+  }
+
+  String _encodeResult(Map<String, dynamic> payload) {
+    return jsonEncode(payload);
+  }
+
+  @override
+  void dispose() {
+    debugPrint("MediaScannerService: disposed");
+    super.dispose();
+  }
+}

flet_media_scanner-0.86.0/src/flutter/flet_media_scanner/pubspec.yaml

@@ -0,0 +1,21 @@
+name: flet_media_scanner
+description: Flet extension for Android MediaStore saving with media scanner fallback.
+version: 0.85.3
+publish_to: none
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+  flutter: ">=3.0.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+  flet: ^0.85.0
+  media_scanner: ^2.2.1
+
+flutter:
+  plugin:
+    platforms:
+      android:
+        package: com.example.flet_media_scanner
+        pluginClass: FletMediaScannerPlugin