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

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();
      }
    } catch (e) {
      print('SDK initialization error: $e');
    }
  }

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

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

@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),
        ),
      ],
    ),
  );
}

List<dynamic> _filters = [];
int _selectedFilterIndex = -1;

Future<void> _loadFilters() async {
  try {
    final filters = await _nosmai.getFilters();
    setState(() {
      _filters = filters;
    });
    
    print('Loaded ${filters.length} filters');
    for (int i = 0; i < filters.length; i++) {
      final filter = filters[i];
      if (filter is NosmaiLocalFilter) {
        print('Local: ${filter.displayName}');
      } else if (filter is NosmaiCloudFilter) {
        print('Cloud: ${filter.displayName} (downloaded: ${filter.isDownloaded})');
      }
    }
  } catch (e) {
    print('Error loading filters: $e');
  }
}

Future<void> _applyFilter(int index) async {
  if (index < 0 || index >= _filters.length) return;

  try {
    final filter = _filters[index];

    if (filter is NosmaiLocalFilter) {
      // Apply local filter
      await _nosmai.applyEffect(filter.path);
      setState(() => _selectedFilterIndex = index);
      
    } else if (filter is NosmaiCloudFilter) {
      if (!filter.isDownloaded) {
        // Download cloud filter first
        await _downloadAndApplyCloudFilter(filter, index);
      } else {
        // Apply downloaded filter
        await _nosmai.applyEffect(filter.localPath!);
        setState(() => _selectedFilterIndex = index);
      }
    }
  } catch (e) {
    print('Error applying filter: $e');
  }
}

bool _isRecording = false;

Future<void> _toggleRecording() async {
  try {
    if (_isRecording) {
      final result = await _nosmai.stopRecording();
      
      setState(() => _isRecording = false);
      
      if (result.success && result.videoPath != null) {
        _showVideoSuccessDialog(result.videoPath!);
      }
    } else {
      final success = await _nosmai.startRecording();
      
      if (success) {
        setState(() => _isRecording = true);
      }
    }
  } catch (e) {
    print('Recording error: $e');
    setState(() => _isRecording = false);
  }
}

Future<void> _capturePhoto() async {
  try {
    final result = await _nosmai.capturePhoto();
    
    if (result.success) {
      _showPhotoSuccessDialog(result);
    } else {
      print('Photo capture failed: ${result.error}');
    }
  } catch (e) {
    print('Photo capture error: $e');
  }
}

<key>NSCameraUsageDescription</key>
<string>This app needs camera access to apply filters</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" />

// Switch between front/back camera
Future<void> _switchCamera() async {
  try {
    await _nosmai.switchCamera();
  } catch (e) {
    print('Camera switch error: $e');
  }
}

// Remove all applied filters
Future<void> _removeAllFilters() async {
  try {
    await _nosmai.removeAllFilters();
    setState(() => _selectedFilterIndex = -1);
  } catch (e) {
    print('Error removing filters: $e');
  }
}

// Lifecycle management
@override
void dispose() {
  // Always cleanup when disposing
  _nosmai.dispose();
  super.dispose();
}

class NosmaiErrorHandler {
  static void handleError(dynamic error, String context) {
    print('Nosmai Error in $context: $error');
    
    // Show user-friendly message
    if (error.toString().contains('license')) {
      _showError('License validation failed. Please check your license key.');
    } else if (error.toString().contains('permission')) {
      _showError('Camera permission is required to use filters.');
    } else if (error.toString().contains('network')) {
      _showError('Network error. Please check your connection.');
    } else {
      _showError('An unexpected error occurred. Please try again.');
    }
  }
  
  static void _showError(String message) {
    print('User Error: $message');
  }
}

// Handle app lifecycle changes
class _CameraScreenState extends State<CameraScreen> 
    with WidgetsBindingObserver {
  
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _initializeSDK();
  }
  
  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    _nosmai.dispose();
    super.dispose();
  }
  
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.paused:
        if (_isRecording) {
          _toggleRecording(); // Stop recording
        }
        break;
      case AppLifecycleState.resumed:
        // App came to foreground
        break;
      default:
        break;
    }
  }
}