Camera SDK

dependencies {
    implementation 'com.nosmai:camera-sdk:1.0.0'
    implementation 'androidx.camera:camera-core:1.3.0'
    implementation 'androidx.camera:camera-camera2:1.3.0'
    implementation 'androidx.camera:camera-lifecycle:1.3.0'
    implementation 'androidx.camera:camera-view:1.3.0'
}

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url 'https://maven.nosmai.com' }
    }
}

import com.nosmai.camerasdk.CameraSDK

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        CameraSDK.initialize(this, "YOUR_API_KEY")
    }
}

import com.nosmai.camerasdk.CameraManager
import com.nosmai.camerasdk.CameraConfiguration
import com.nosmai.camerasdk.CameraCallback

class CameraActivity : AppCompatActivity() {
    private lateinit var cameraManager: CameraManager
    private lateinit var previewView: PreviewView
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_camera)
        
        previewView = findViewById(R.id.previewView)
        setupCamera()
    }
    
    private fun setupCamera() {
        cameraManager = CameraManager(this)
        
        val config = CameraConfiguration.Builder()
            .setResolution(CameraConfiguration.RESOLUTION_1080P)
            .setFrameRate(30)
            .setFlashMode(CameraConfiguration.FLASH_AUTO)
            .build()
        
        cameraManager.configure(config)
        cameraManager.startPreview(previewView)
    }
    
    private fun capturePhoto() {
        cameraManager.capturePhoto(object : CameraCallback<String> {
            override fun onSuccess(result: String) {
                // Handle captured photo path
                Log.d("Camera", "Photo saved to: $result")
            }
            
            override fun onError(error: Exception) {
                Log.e("Camera", "Capture failed", error)
            }
        })
    }
    
    override fun onDestroy() {
        super.onDestroy()
        cameraManager.release()
    }
}

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-feature android:name="android.hardware.camera" android:required="true" />
<uses-feature android:name="android.hardware.camera.autofocus" />

dependencies:
  nosmai_flutter: ^1.0.0
  permission_handler: ^11.0.0  # For camera permissions

flutter pub get

platform :ios, '11.0'
use_frameworks! :linkage => :static

target 'Runner' do
  use_frameworks!
  use_modular_headers!
  
  flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__))
end

android {
    compileSdkVersion 34
    
    defaultConfig {
        minSdkVersion 21
        targetSdkVersion 34
    }
    
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

import 'package:nosmai_flutter/nosmai_flutter.dart';
import 'package:permission_handler/permission_handler.dart';

class CameraScreen extends StatefulWidget {
  @override
  _CameraScreenState createState() => _CameraScreenState();
}

class _CameraScreenState extends State<CameraScreen> {
  final NosmaiFlutter _nosmai = NosmaiFlutter.instance;
  bool _isInitialized = false;
  bool _isReady = false;

  @override
  void initState() {
    super.initState();
    _initializeSDK();
  }

  Future<void> _initializeSDK() async {
    // Request camera permission
    final status = await Permission.camera.request();
    if (status != PermissionStatus.granted) {
      print('Camera permission denied');
      return;
    }

    try {
      // Initialize with your license key
      final success = await _nosmai.initWithLicense(
        'YOUR_NOSMAI_LICENSE_KEY_HERE',
      );

      setState(() {
        _isInitialized = success;
      });

      if (success) {
        await _setupCamera();
      } else {
        print('Failed to initialize Nosmai SDK - check license key');
      }
    } catch (e) {
      print('SDK initialization error: $e');
    }
  }

  Future<void> _setupCamera() async {
    try {
      await _nosmai.configureCamera(
        position: NosmaiCameraPosition.front,
        sessionPreset: NosmaiSessionPreset.high,
        targetFrameRate: 30,
      );

      setState(() {
        _isReady = true;
      });
    } catch (e) {
      print('Camera setup error: $e');
    }
  }
}

<key>NSCameraUsageDescription</key>
<string>This app needs camera access to apply filters and effects</string>
<key>NSMicrophoneUsageDescription</key>
<string>This app needs microphone access for video recording</string>
<key>NSPhotoLibraryAddUsageDescription</key>
<string>This app needs photo library access to save photos and videos</string>

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-feature android:name="android.hardware.camera" android:required="true" />
<uses-feature android:name="android.hardware.camera.autofocus" />

@override
Widget build(BuildContext context) {
  return Scaffold(
    backgroundColor: Colors.black,
    body: _isReady
        ? Stack(
            children: [
              // Camera preview
              const Positioned.fill(
                child: NosmaiCameraPreview(
                  width: double.infinity,
                  height: double.infinity,
                ),
              ),
              
              // Controls overlay
              _buildControlsOverlay(),
            ],
          )
        : _buildLoadingScreen(),
  );
}

Widget _buildLoadingScreen() {
  return const Center(
    child: Column(
      mainAxisAlignment: MainAxisAlignment.center,
      children: [
        CircularProgressIndicator(),
        SizedBox(height: 20),
        Text(
          'Initializing camera...',
          style: TextStyle(color: Colors.white),
        ),
      ],
    ),
  );
}

Widget _buildControlsOverlay() {
  return Positioned(
    bottom: 0,
    left: 0,
    right: 0,
    child: Container(
      padding: EdgeInsets.all(20),
      decoration: BoxDecoration(
        gradient: LinearGradient(
          begin: Alignment.bottomCenter,
          end: Alignment.topCenter,
          colors: [Colors.black, Colors.transparent],
        ),
      ),
      child: Column(
        children: [
          _buildFilterSelector(),
          SizedBox(height: 20),
          _buildCaptureControls(),
        ],
      ),
    ),
  );
}

// Get all available local filters
List<NosmaiLocalFilter> localFilters = await _nosmai.getLocalFilters();

for (NosmaiLocalFilter filter in localFilters) {
  print('Local Filter: ${filter.displayName} -> ${filter.path}');
}

// Apply specific local filter
String filterPath = 'assets/filters/vintage.nosmai';
try {
  await _nosmai.applyEffect(filterPath);
  print('✅ Local filter applied successfully!');
} catch (e) {
  print('❌ Failed to apply filter: $e');
}

// Remove current filter
await _nosmai.removeAllFilters();
print('✅ All filters removed');

try {
  List<NosmaiCloudFilter> cloudFilters = await _nosmai.getCloudFilters();
  
  print('Found ${cloudFilters.length} cloud filters');
  
  for (NosmaiCloudFilter filter in cloudFilters) {
    print('Cloud Filter: ${filter.displayName}');
    print('  ID: ${filter.id}');
    print('  Downloaded: ${filter.isDownloaded}');
    print('  Thumbnail: ${filter.thumbnailUrl}');
  }
} catch (e) {
  print('❌ Failed to fetch cloud filters: $e');
}

// Download a specific cloud filter
String filterId = 'some_cloud_filter_id';

try {
  // Download with progress tracking
  await _nosmai.downloadCloudFilter(
    filterId,
    onProgress: (int percentage) {
      print('Download progress: $percentage%');
      // Update UI progress bar
    },
  );
  
  print('✅ Cloud filter downloaded successfully');
  
  // Apply the downloaded filter
  await _nosmai.applyCloudFilter(filterId);
  print('✅ Cloud filter applied!');
  
} catch (e) {
  print('❌ Failed to download/apply cloud filter: $e');
}

// Download and apply in one step
try {
  await _nosmai.downloadAndApplyCloudFilter(
    filterId,
    onProgress: (int percentage) {
      print('Downloading: $percentage%');
    },
  );
  print('✅ Cloud filter downloaded and applied!');
} catch (e) {
  print('❌ Failed: $e');
}

// FACE ENHANCEMENT
await _nosmai.applySkinSmoothing(0.7);     // 0.0 to 1.0 - Smooth skin texture
await _nosmai.applySkinWhitening(0.5);     // 0.0 to 1.0 - Natural skin brightening
await _nosmai.applyFaceSlimming(0.3);      // 0.0 to 1.0 - Subtle face contouring
await _nosmai.applyEyeEnlargement(0.4);    // 0.0 to 1.0 - Eye enhancement
await _nosmai.applyNoseSize(0.2);          // 0.0 to 1.0 - Nose refinement

// MAKEUP EFFECTS
await _nosmai.applyLipstick(0.6);          // 0.0 to 1.0 - Lipstick effect
await _nosmai.applyBlusher(0.4);           // 0.0 to 1.0 - Blusher effect

// COLOR & TONE ADJUSTMENTS
await _nosmai.applyBrightness(0.5);        // -1.0 to 1.0
await _nosmai.applyContrast(2.0);          // 0.0 to 4.0 (1.0 = normal)
await _nosmai.applyHue(180.0);             // 0-360 degrees
await _nosmai.applyExposure(1.5);          // -5.0 to 5.0
await _nosmai.applySaturation(1.5);        // 0.0 to 2.0 (1.0 = normal)
await _nosmai.applySharpen(0.8);           // 0.0 to 1.0
await _nosmai.applyWhiteBalance(5500.0, 10.0); // temp: 2000-8000K, tint: -100 to +100

// Enable/disable grayscale
await _nosmai.setGrayscaleEnabled(true);   // true/false

Future<void> _applyBeautyPackage() async {
  try {
    // Natural beauty enhancement package
    await _nosmai.applySkinSmoothing(0.6);     // Smooth skin
    await _nosmai.applySkinWhitening(0.3);     // Slight whitening
    await _nosmai.applyFaceSlimming(0.2);      // Subtle face slimming
    await _nosmai.applyEyeEnlargement(0.3);    // Bigger eyes
    await _nosmai.applyBrightness(0.1);        // Slightly brighter
    await _nosmai.applyContrast(1.2);          // Better contrast
    
    print('✅ Beauty package applied');
    // Show success message to user
  } catch (e) {
    print('❌ Beauty package failed: $e');
  }
}

// Remove all beauty effects
Future<void> _removeAllBeautyFilters() async {
  await _nosmai.removeAllBeautyFilters();
  print('✅ All beauty filters removed');
}

bool _isCapturing = false;

Future<void> _capturePhoto() async {
  if (_isCapturing) return;
  
  setState(() {
    _isCapturing = true;
  });
    
  try {
    final result = await _nosmai.capturePhoto();
    
    if (result.success) {
      print('✅ Photo captured successfully!');
      print('Photo dimensions: ${result.width}x${result.height}');
      print('Photo size: ${result.imageData.length} bytes');
      
      // Save to gallery
      await _savePhotoToGallery(result.imageData);
      
      // Show success message
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Text('📸 Photo saved to gallery!'),
          backgroundColor: Colors.green,
        ),
      );
    } else {
      print('❌ Photo capture failed: ${result.error}');
    }
  } catch (e) {
    print('❌ Photo capture error: $e');
  } finally {
    setState(() {
      _isCapturing = false;
    });
  }
}

bool _isRecording = false;
String? _currentVideoPath;

Future<void> _toggleRecording() async {
  try {
    if (_isRecording) {
      // Stop recording
      final result = await _nosmai.stopRecording();
      
      setState(() {
        _isRecording = false;
      });
      
      if (result.success && result.videoPath != null) {
        print('✅ Video saved: ${result.videoPath}');
        print('Duration: ${result.duration} seconds');
        print('File size: ${result.fileSize} bytes');
        
        _currentVideoPath = result.videoPath;
        
        // Add to gallery
        await _saveVideoToGallery(result.videoPath!);
        
        // Show success message
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
            content: Text('🎬 Video saved to gallery!'),
            backgroundColor: Colors.green,
            duration: Duration(seconds: 3),
          ),
        );
      } else {
        print('❌ Recording failed: ${result.error}');
      }
    } else {
      // Start recording
      final success = await _nosmai.startRecording();
      
      if (success) {
        setState(() {
          _isRecording = true;
        });
        print('🎬 Recording started!');
      } else {
        print('❌ Failed to start recording');
      }
    }
  } catch (e) {
    print('❌ Recording error: $e');
    setState(() {
      _isRecording = false;
    });
  }
}

bool _isFrontCamera = true;

Future<void> _switchCamera() async {
  if (_nosmai == null) {
    print('❌ Camera not ready');
    return;
  }
  
  try {
    print('🔄 Switching camera...');
    
    // Switch camera
    await _nosmai.switchCamera();
    
    // Update camera state
    setState(() {
      _isFrontCamera = !_isFrontCamera;
    });
    
    String cameraType = _isFrontCamera ? 'Front' : 'Back';
    print('✅ Switched to $cameraType camera');
    
  } catch (e) {
    print('❌ Camera switch failed: $e');
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text('❌ Camera switch failed'),
        backgroundColor: Colors.red,
      ),
    );
  }
}

// Focus control
Future<void> _setFocusPoint(Offset point) async {
  try {
    await _nosmai.setFocusPoint(point);
    print('📱 Focus set to: $point');
  } catch (e) {
    print('❌ Focus failed: $e');
  }
}

// Exposure control
Future<void> _setExposurePoint(Offset point) async {
  try {
    await _nosmai.setExposurePoint(point);
    print('🌞 Exposure set to: $point');
  } catch (e) {
    print('❌ Exposure failed: $e');
  }
}

// Zoom control
Future<void> _setZoomLevel(double zoomLevel) async {
  try {
    // Zoom level typically ranges from 1.0 to maxZoom
    await _nosmai.setZoomLevel(zoomLevel);
    print('🔍 Zoom set to: ${zoomLevel}x');
  } catch (e) {
    print('❌ Zoom failed: $e');
  }
}

// Flash control
Future<void> _toggleFlash() async {
  try {
    await _nosmai.toggleFlash();
    print('⚡ Flash toggled');
  } catch (e) {
    print('❌ Flash toggle failed: $e');
  }
}

// Pre-load frequently used filters
Future<void> _preloadCommonFilters() async {
  final commonFilters = [
    'assets/filters/beauty.nosmai',
    'assets/filters/vintage.nosmai',
    'assets/filters/natural.nosmai',
  ];
  
  try {
    print('🔄 Preloading common filters...');
    
    for (final filter in commonFilters) {
      // Preload by applying and then removing
      await _nosmai.applyEffect(filter);
      await Future.delayed(Duration(milliseconds: 100));
    }
    
    // Remove all filters after preloading
    await _nosmai.removeAllFilters();
    
    print('✅ Common filters preloaded successfully');
  } catch (e) {
    print('❌ Preloading failed: $e');
  }
}

// Efficient filter switching
String? _currentFilterPath;

Future<void> _switchFilter(String newFilterPath) async {
  try {
    // Skip if same filter
    if (_currentFilterPath == newFilterPath) {
      return;
    }
    
    // Remove previous filter first
    if (_currentFilterPath != null) {
      await _nosmai.removeAllFilters();
    }
    
    // Apply new filter
    if (newFilterPath.isNotEmpty && newFilterPath != 'none') {
      await _nosmai.applyEffect(newFilterPath);
      _currentFilterPath = newFilterPath;
      print('✅ Switched to filter: $newFilterPath');
    } else {
      _currentFilterPath = null;
      print('✅ All filters removed');
    }
    
  } catch (e) {
    print('❌ Filter switch failed: $e');
  }
}

class _CameraScreenState extends State<CameraScreen> with WidgetsBindingObserver {
  
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _initializeSDK();
  }
  
  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    _cleanup();
    super.dispose();
  }
  
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.paused:
        if (_isRecording) {
          _toggleRecording(); // Stop recording
        }
        _nosmai.pauseProcessing();
        break;
      case AppLifecycleState.resumed:
        _nosmai.resumeProcessing();
        break;
      default:
        break;
    }
  }
  
  Future<void> _cleanup() async {
    try {
      print('🧹 Performing final cleanup...');
      
      // Stop recording if active
      if (_isRecording) {
        await _nosmai.stopRecording();
      }
      
      // Remove all filters
      await _nosmai.removeAllFilters();
      await _nosmai.removeAllBeautyFilters();
      
      // Stop processing and cleanup
      await _nosmai.stopProcessing();
      await _nosmai.cleanup();
      
      print('✅ Cleanup completed');
    } catch (e) {
      print('❌ Cleanup failed: $e');
    }
  }
}

class NosmaiErrorHandler {
  static void handleError(dynamic error, String context) {
    print('Nosmai Error in $context: $error');
    
    // Categorize and handle different error types
    if (error.toString().contains('license')) {
      _handleLicenseError(error);
    } else if (error.toString().contains('permission')) {
      _handlePermissionError(error);
    } else if (error.toString().contains('network')) {
      _handleNetworkError(error);
    } else if (error.toString().contains('memory')) {
      _handleMemoryError(error);
    } else {
      _handleGenericError(error, context);
    }
  }
  
  static void _handleLicenseError(dynamic error) {
    print('License Error: Please check your license key');
  }
  
  static void _handlePermissionError(dynamic error) {
    print('Permission Error: Please grant camera permissions');
  }
  
  static void _handleNetworkError(dynamic error) {
    print('Network Error: Please check your internet connection');
  }
  
  static void _handleMemoryError(dynamic error) {
    print('Memory Error: Performing cleanup');
    // Trigger memory cleanup
  }
  
  static void _handleGenericError(dynamic error, String context) {
    print('Unexpected Error in $context: $error');
  }
}