flutter_freedome_calibration 1.0.1

FreeDome calibration and system configuration

example/lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_freedome_calibration/flutter_freedome_calibration.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'FreeDome Calibration Example',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const MyHomePage(title: 'FreeDome Calibration Example'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key, required this.title});

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String _platformVersion = 'Unknown';
  bool _isInitialized = false;
  String? _currentCalibrationId;
  Map<String, dynamic>? _calibrationProgress;
  List<Map<String, dynamic>> _microphones = [];

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

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> initPlatformState() async {
    String platformVersion;
    bool isInitialized;

    try {
      platformVersion = await FlutterFreedomeCalibration.getPlatformVersion();
      isInitialized = await FlutterFreedomeCalibration.initialize();
    } catch (e) {
      platformVersion = 'Failed to get platform version: $e';
      isInitialized = false;
    }

    if (!mounted) return;

    setState(() {
      _platformVersion = platformVersion;
      _isInitialized = isInitialized;
    });
  }

  Future<void> _startAudioCalibration() async {
    try {
      final calibrationId =
          await FlutterFreedomeCalibration.startAudioCalibration(
        type: 'audioOnly',
        frequency: 1000.0,
        duration: 5.0,
      );
      setState(() {
        _currentCalibrationId = calibrationId;
      });
      _showSnackBar('Audio calibration started: $calibrationId');
    } catch (e) {
      _showSnackBar('Failed to start audio calibration: $e');
    }
  }

  Future<void> _startProjectorCalibration() async {
    try {
      final calibrationId =
          await FlutterFreedomeCalibration.startProjectorCalibration(
        type: 'videoOnly',
        brightness: 80,
        contrast: 75,
      );
      setState(() {
        _currentCalibrationId = calibrationId;
      });
      _showSnackBar('Projector calibration started: $calibrationId');
    } catch (e) {
      _showSnackBar('Failed to start projector calibration: $e');
    }
  }

  Future<void> _startFullCalibration() async {
    try {
      final calibrationId =
          await FlutterFreedomeCalibration.startFullCalibration();
      setState(() {
        _currentCalibrationId = calibrationId;
      });
      _showSnackBar('Full calibration started: $calibrationId');
    } catch (e) {
      _showSnackBar('Failed to start full calibration: $e');
    }
  }

  Future<void> _getCalibrationProgress() async {
    if (_currentCalibrationId == null) {
      _showSnackBar('No active calibration');
      return;
    }

    try {
      final progress = await FlutterFreedomeCalibration.getCalibrationProgress(
          _currentCalibrationId!);
      setState(() {
        _calibrationProgress = progress;
      });
      _showSnackBar('Progress updated');
    } catch (e) {
      _showSnackBar('Failed to get calibration progress: $e');
    }
  }

  Future<void> _generateTestSignal() async {
    try {
      final result = await FlutterFreedomeCalibration.generateTestSignal(
        signalType: 'tone',
        frequency: 1000.0,
        duration: 2.0,
      );
      _showSnackBar('Test signal generated: ${result['message']}');
    } catch (e) {
      _showSnackBar('Failed to generate test signal: $e');
    }
  }

  Future<void> _getMicrophonesStatus() async {
    try {
      final microphones =
          await FlutterFreedomeCalibration.getMicrophonesStatus();
      setState(() {
        _microphones = microphones;
      });
      _showSnackBar('Microphones status updated');
    } catch (e) {
      _showSnackBar('Failed to get microphones status: $e');
    }
  }

  Future<void> _pauseCalibration() async {
    if (_currentCalibrationId == null) {
      _showSnackBar('No active calibration');
      return;
    }

    try {
      final result = await FlutterFreedomeCalibration.pauseCalibration(
          _currentCalibrationId!);
      _showSnackBar(
          result ? 'Calibration paused' : 'Failed to pause calibration');
    } catch (e) {
      _showSnackBar('Failed to pause calibration: $e');
    }
  }

  Future<void> _resumeCalibration() async {
    if (_currentCalibrationId == null) {
      _showSnackBar('No active calibration');
      return;
    }

    try {
      final result = await FlutterFreedomeCalibration.resumeCalibration(
          _currentCalibrationId!);
      _showSnackBar(
          result ? 'Calibration resumed' : 'Failed to resume calibration');
    } catch (e) {
      _showSnackBar('Failed to resume calibration: $e');
    }
  }

  Future<void> _cancelCalibration() async {
    if (_currentCalibrationId == null) {
      _showSnackBar('No active calibration');
      return;
    }

    try {
      final result = await FlutterFreedomeCalibration.cancelCalibration(
          _currentCalibrationId!);
      if (result) {
        setState(() {
          _currentCalibrationId = null;
          _calibrationProgress = null;
        });
        _showSnackBar('Calibration cancelled');
      } else {
        _showSnackBar('Failed to cancel calibration');
      }
    } catch (e) {
      _showSnackBar('Failed to cancel calibration: $e');
    }
  }

  void _showSnackBar(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(message)),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            Card(
              child: Padding(
                padding: const EdgeInsets.all(16.0),
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text('Platform Version: $_platformVersion'),
                    const SizedBox(height: 8),
                    Text('Initialized: $_isInitialized'),
                    if (_currentCalibrationId != null)
                      Text('Current Calibration: $_currentCalibrationId'),
                  ],
                ),
              ),
            ),
            const SizedBox(height: 16),
            Text(
              'Calibration Controls',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 8),
            Wrap(
              spacing: 8,
              runSpacing: 8,
              children: [
                ElevatedButton(
                  onPressed: _isInitialized ? _startAudioCalibration : null,
                  child: const Text('Start Audio Calibration'),
                ),
                ElevatedButton(
                  onPressed: _isInitialized ? _startProjectorCalibration : null,
                  child: const Text('Start Projector Calibration'),
                ),
                ElevatedButton(
                  onPressed: _isInitialized ? _startFullCalibration : null,
                  child: const Text('Start Full Calibration'),
                ),
              ],
            ),
            const SizedBox(height: 16),
            Text(
              'Calibration Management',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 8),
            Wrap(
              spacing: 8,
              runSpacing: 8,
              children: [
                ElevatedButton(
                  onPressed:
                      _currentCalibrationId != null ? _pauseCalibration : null,
                  child: const Text('Pause'),
                ),
                ElevatedButton(
                  onPressed:
                      _currentCalibrationId != null ? _resumeCalibration : null,
                  child: const Text('Resume'),
                ),
                ElevatedButton(
                  onPressed:
                      _currentCalibrationId != null ? _cancelCalibration : null,
                  child: const Text('Cancel'),
                ),
                ElevatedButton(
                  onPressed: _getCalibrationProgress,
                  child: const Text('Get Progress'),
                ),
              ],
            ),
            const SizedBox(height: 16),
            Text(
              'Test Functions',
              style: Theme.of(context).textTheme.headlineSmall,
            ),
            const SizedBox(height: 8),
            Wrap(
              spacing: 8,
              runSpacing: 8,
              children: [
                ElevatedButton(
                  onPressed: _isInitialized ? _generateTestSignal : null,
                  child: const Text('Generate Test Signal'),
                ),
                ElevatedButton(
                  onPressed: _isInitialized ? _getMicrophonesStatus : null,
                  child: const Text('Get Microphones Status'),
                ),
              ],
            ),
            if (_calibrationProgress != null) ...[
              const SizedBox(height: 16),
              Card(
                child: Padding(
                  padding: const EdgeInsets.all(16.0),
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      Text(
                        'Calibration Progress',
                        style: Theme.of(context).textTheme.headlineSmall,
                      ),
                      const SizedBox(height: 8),
                      Text('ID: ${_calibrationProgress!['id']}'),
                      Text('Status: ${_calibrationProgress!['status']}'),
                      Text(
                          'Progress: ${(_calibrationProgress!['progress'] * 100).toStringAsFixed(1)}%'),
                      Text(
                          'Current Step: ${_calibrationProgress!['currentStep']}'),
                    ],
                  ),
                ),
              ),
            ],
            if (_microphones.isNotEmpty) ...[
              const SizedBox(height: 16),
              Card(
                child: Padding(
                  padding: const EdgeInsets.all(16.0),
                  child: Column(
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      Text(
                        'Microphones Status',
                        style: Theme.of(context).textTheme.headlineSmall,
                      ),
                      const SizedBox(height: 8),
                      ..._microphones.map((mic) => ListTile(
                            title: Text(mic['name'] ?? 'Unknown'),
                            subtitle: Text(
                                'Type: ${mic['type']}, Connected: ${mic['isConnected']}'),
                            trailing: mic['isCalibrated'] == true
                                ? const Icon(Icons.check_circle,
                                    color: Colors.green)
                                : const Icon(Icons.error, color: Colors.red),
                          )),
                    ],
                  ),
                ),
              ),
            ],
          ],
        ),
      ),
    );
  }
}