@honem/native-video-compressor 0.1.0

package/HonemNativeVideoCompressor.podspec

@@ -0,0 +1,15 @@
+Pod::Spec.new do |s|
+  s.name = 'HonemNativeVideoCompressor'
+  s.version = '0.1.0'
+  s.summary = 'Capacitor plugin for video compression using native platform APIs'
+  s.license = 'MIT'
+  s.homepage = 'https://github.com/honem/native-video-compressor'
+  s.author = 'honem'
+  s.source = { :git => 'https://github.com/honem/native-video-compressor.git', :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+  s.static_framework = true
+end
+

package/README.md

@@ -0,0 +1,283 @@
+# @honem/native-video-compressor
+
+Capacitor plugin for video compression using native platform APIs (iOS AVFoundation, Android MediaCodec, Electron FFmpeg).
+
+## Features
+
+- ✅ **Native Performance**: Uses platform-native APIs for optimal performance
+- ✅ **Multiple Formats**: Supports MP4, MOV, M4V, 3GP, and WebM
+- ✅ **Configurable Quality**: Low, Medium, High, and Custom quality presets
+- ✅ **Progress Tracking**: Real-time compression progress callbacks
+- ✅ **Cross-Platform**: iOS, Android, and Electron support
+
+## Installation
+
+```bash
+npm install @honem/native-video-compressor
+npx cap sync
+```
+
+### Electron Setup
+
+For Electron apps, you also need to install FFmpeg dependencies:
+
+```bash
+npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
+```
+
+Then register the plugin in your Electron main process (see [Electron Setup](#electron-setup) below).
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { VideoCompressor } from '@honem/native-video-compressor';
+
+const result = await VideoCompressor.compressVideo({
+  inputPath: '/path/to/input/video.mp4',
+  quality: 'medium',
+  // Format will be auto-detected from input file (MOV → MOV, MP4 → MP4)
+  // format: 'mp4', // Optional: specify format to override auto-detection
+  onProgress: (progress) => {
+    console.log(`Compression progress: ${progress}%`);
+  }
+});
+
+console.log(`Compressed video saved to: ${result.outputPath}`);
+console.log(`Compression ratio: ${result.compressionRatio}x`);
+```
+
+### Quality Presets
+
+#### Low Quality
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'low', // 640x480, 500 kbps
+});
+```
+
+#### Medium Quality (Default)
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'medium', // 1280x720, 2 Mbps
+});
+```
+
+#### High Quality
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'high', // Original resolution, 8 Mbps
+});
+```
+
+#### Custom Quality
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'custom',
+  bitrate: 4000000, // 4 Mbps
+  width: 1920,
+  height: 1080,
+  format: 'mp4',
+});
+```
+
+### Progress Tracking
+
+**Note**: Progress callbacks (`onProgress`) are currently not supported on iOS and Android due to Capacitor's architecture limitations. Progress tracking would require implementing Capacitor's event system with `notifyListeners()`. For now, progress callbacks only work on Electron.
+
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'medium',
+  onProgress: (progress) => {
+    // Progress is a number from 0 to 100
+    // Currently only works on Electron
+    updateProgressBar(progress);
+  }
+});
+```
+
+### Custom Output Path
+
+```typescript
+await VideoCompressor.compressVideo({
+  inputPath: '/path/to/input/video.mp4',
+  outputPath: '/path/to/output/compressed.mp4',
+  quality: 'medium',
+});
+```
+
+If `outputPath` is not provided, the plugin will automatically generate a path by appending `_compressed` to the input filename.
+
+## API Reference
+
+### `compressVideo(options: CompressionOptions): Promise<CompressionResult>`
+
+Compresses a video file.
+
+#### Parameters
+
+**`options`** (CompressionOptions)
+
+- `inputPath` (string, required): Path to the input video file
+- `outputPath` (string, optional): Path for the output file. If not provided, will be generated automatically.
+- `quality` ('low' | 'medium' | 'high' | 'custom', optional): Quality preset. Default: 'medium'
+- `bitrate` (number, optional): Video bitrate in bits per second (only used when quality is 'custom')
+- `width` (number, optional): Output video width in pixels (only used when quality is 'custom')
+- `height` (number, optional): Output video height in pixels (only used when quality is 'custom')
+- `format` ('mp4' | 'mov' | 'm4v' | '3gp' | 'webm', optional): Output video format. If not specified, will be auto-detected from the input file extension (MOV → MOV, MP4 → MP4, etc.). Default: auto-detect from input file
+- `onProgress` ((progress: number) => void, optional): Callback function for progress updates (0-100)
+
+#### Returns
+
+**`Promise<CompressionResult>`**
+
+- `outputPath` (string): Path to the compressed video file
+- `originalSize` (number): Original file size in bytes
+- `compressedSize` (number): Compressed file size in bytes
+- `compressionRatio` (number): Compression ratio (originalSize / compressedSize)
+- `duration` (number): Duration of the compression process in milliseconds
+
+## Platform Support
+
+### iOS
+
+- **Framework**: AVFoundation
+- **Supported Formats**: MP4, MOV, M4V
+- **Hardware Acceleration**: Yes (VideoToolbox)
+- **Minimum iOS Version**: iOS 11.0+
+- **Progress Callbacks**: Not supported (Capacitor limitation - would require event listeners)
+
+### Android
+
+- **API**: MediaCodec, MediaMuxer
+- **Supported Formats**: MP4, 3GP, WebM
+- **Hardware Acceleration**: Yes (MediaCodec)
+- **Minimum Android Version**: API 21 (Android 5.0)+
+- **Progress Callbacks**: Not supported (Capacitor limitation - would require event listeners)
+
+### Electron
+
+- **Library**: FFmpeg (via fluent-ffmpeg)
+- **Supported Formats**: All formats supported by FFmpeg (MP4, MOV, M4V, 3GP, WebM, etc.)
+- **FFmpeg Source**: Bundled via @ffmpeg-installer/ffmpeg or system FFmpeg
+
+#### Electron Setup
+
+1. Install dependencies:
+```bash
+npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
+```
+
+2. The plugin works automatically with Capacitor's standard plugin system. No additional registration is required. Simply import and use:
+
+```typescript
+import { VideoCompressor } from '@honem/native-video-compressor';
+
+// Works automatically in Electron
+const result = await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'medium'
+});
+```
+
+**Note**: The plugin automatically detects the Electron platform and uses the FFmpeg-based implementation. Make sure FFmpeg is available (via `@ffmpeg-installer/ffmpeg` or system PATH).
+
+**Important**: This plugin does not require `@capacitor-community/electron`. It uses Capacitor's standard plugin system with `WebPlugin`, which is compatible with Capacitor 6.0.0+. If you encounter issues with plugin registration in Electron, you may need to manually register it in your Electron main process (see the [Electron README](./electron/README.md) for details).
+
+### Web
+
+- **Status**: Not supported
+- **Reason**: Video compression requires native APIs or FFmpeg, which are not available in web browsers
+- **Fallback**: Returns an error message directing users to use a native platform
+
+## Quality Presets
+
+| Preset | Resolution | Bitrate | Use Case |
+|--------|-----------|---------|----------|
+| Low | 640x480 | 500 kbps | Maximum compression, lowest quality |
+| Medium | 1280x720 | 2 Mbps | Balanced quality and file size (default) |
+| High | Original | 8 Mbps | High quality, larger file size |
+| Custom | User-defined | User-defined | Full control over compression parameters |
+
+## File Path Handling
+
+The plugin supports various path formats:
+
+- **Absolute paths**: `/path/to/video.mp4`
+- **File URLs**: `file:///path/to/video.mp4`
+- **Capacitor file paths**: `capacitor://localhost/_capacitor_file_/path/to/video.mp4`
+- **Relative paths**: Resolved from the platform's default document directory
+
+## Error Handling
+
+The plugin throws errors for:
+
+- Missing input file
+- Invalid file paths
+- Unsupported formats
+- Compression failures
+- Missing FFmpeg (Electron only)
+
+Always wrap compression calls in try-catch blocks:
+
+```typescript
+try {
+  const result = await VideoCompressor.compressVideo({
+    inputPath: '/path/to/video.mp4',
+    quality: 'medium',
+  });
+} catch (error) {
+  console.error('Compression failed:', error);
+}
+```
+
+## Examples
+
+See the [example app](../src/App.tsx) in the main project for a complete React implementation.
+
+## Development
+
+### Building the Plugin
+
+```bash
+cd zoobook-compressor-plugin
+npm install
+npm run build
+```
+
+### Project Structure
+
+```
+zoobook-compressor-plugin/
+├── src/                    # TypeScript source
+│   ├── definitions.ts      # Type definitions
+│   ├── index.ts           # Plugin registration
+│   └── web.ts             # Web implementation (fallback)
+├── ios/                    # iOS native code
+│   └── Plugin/
+│       ├── VideoCompressor.swift
+│       ├── VideoCompressorPlugin.swift
+│       └── Plugin.m
+├── android/                # Android native code
+│   └── src/main/java/com/honem/nativevideocompressor/
+│       ├── VideoCompressor.java
+│       └── VideoCompressorPlugin.java
+├── electron/               # Electron implementation
+│   └── src/
+│       └── video-compressor.ts
+└── package.json
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/android/build.gradle

@@ -0,0 +1,31 @@
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.honem.nativevideocompressor"
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 22
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+}
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.honem.nativevideocompressor">
+    
+    <!-- Permissions for file access -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" 
+        android:maxSdkVersion="32" />
+    
+    <!-- Hardware features for video encoding -->
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <uses-feature android:name="android.software.video.encoder" android:required="true" />
+    
+</manifest>
+