ESite Flutter Player

A professional, production-ready Flutter plugin for secure DRM-protected video playback on Android.

Built on Media3 ExoPlayer, this plugin provides enterprise-grade video streaming with comprehensive security features, making it ideal for premium content delivery, OTT platforms, and educational applications.

✨ Key Features

🔒 Enterprise Security

DRM Protection: Industry-standard Widevine and PlayReady DRM support
Screen Protection: Automatic screenshot and screen recording blocking (FLAG_SECURE)
Emulator Detection: Block playback on emulators to prevent piracy
Security Callbacks: Real-time security violation notifications
Configurable Levels: Maximum, custom, or disabled security modes

🎬 Professional Playback

Adaptive Streaming: Automatic quality adaptation for optimal viewing
Format Support: DASH (.mpd) and HLS (.m3u8) streaming protocols
Speed Control: Variable playback speed (0.5x to 4.0x)
Quality Selection: Manual video track/quality switching
Subtitle Support: Enable/disable subtitle tracks
Playlist Management: Navigate between media items

🎯 Production Ready

Memory Optimized: Efficient resource management
Thread Safe: Proper lifecycle and synchronization
Error Handling: User-friendly error messages with recovery guidance
Event Streams: Real-time state, DRM, and error notifications
Null Safety: Full Dart null-safety support

📱 Platform Support

Platform	Supported	Version
Android	✅	API 24+ (Android 7.0+)
iOS	⏳	Planned for future release

🎥 Supported Formats

DASH (.mpd) - Dynamic Adaptive Streaming over HTTP
HLS (.m3u8) - HTTP Live Streaming
DRM Schemes: Widevine, PlayReady

📦 Installation

Add this to your package's pubspec.yaml file:

dependencies:
  esite_flutter_player: ^0.1.0

Then run:

flutter pub get

🚀 Quick Start

1. Import the Package

import 'package:esite_flutter_player/esite_flutter_player.dart';

2. Create Player Configuration

final config = ESitePlayerConfig(
  sourceUrl: 'https://example.com/video.mpd',
  drm: ESiteDrmConfig(
    licenseUrl: 'https://drm-license-server.com/license',
    scheme: ESiteDrmScheme.widevine,
    licenseHeaders: {
      'Authorization': 'Bearer your_token_here',
    },
  ),
  autoPlay: false,
  // Security configuration (recommended)
  securityConfig: ESiteSecurityConfig.maximum(
    onSecurityViolation: (violation) {
      print('Security alert: ${violation.message}');
    },
  ),
);

3. Initialize Controller

final controller = ESitePlayerController(config);
await controller.initialize();

@override
Widget build(BuildContext context) {
  return ESitePlayerView(controller: controller);
}

5. Control Playback

// Play/Pause
await controller.play();
await controller.pause();

// Seek
await controller.seekTo(Duration(seconds: 30));
await controller.seekForward(Duration(seconds: 10));
await controller.seekBackward(Duration(seconds: 10));

// Speed control
await controller.setPlaybackSpeed(1.5); // 0.5x to 4.0x

// Volume
await controller.setVolume(0.8); // 0.0 to 1.0
await controller.setMuted(true);

// Quality selection
final tracks = await controller.getAvailableVideoTracks();
await controller.setVideoTrack(tracks[0]['id']);

// Subtitles
await controller.setSubtitleEnabled(true);

// Playlist navigation
if (await controller.hasNext()) {
  await controller.next();
}

6. Listen to Events

// Player state changes
controller.stateStream.listen((state) {
  print('State: $state');
  // States: idle, initializing, buffering, ready, 
  //         playing, paused, completed, error
});

// DRM events
controller.drmStream.listen((event) {
  print('DRM: ${event.type} - ${event.message}');
  // Types: licenseRequested, licenseAcquired, licenseFailed
});

// Error handling
controller.errorStream.listen((error) {
  print('Error: ${error.code} - ${error.message}');
  // Detailed, user-friendly error messages
});

7. Cleanup

@override
void dispose() {
  controller.dispose();
  super.dispose();
}

📖 Complete Example

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

class VideoPlayerPage extends StatefulWidget {
  @override
  _VideoPlayerPageState createState() => _VideoPlayerPageState();
}

class _VideoPlayerPageState extends State<VideoPlayerPage> {
  late ESitePlayerController controller;
  ESitePlayerState currentState = ESitePlayerState.idle;

  @override
  void initState() {
    super.initState();
    
    final config = ESitePlayerConfig(
      sourceUrl: 'https://media.axprod.net/TestVectors/Cmaf/protected_1080p_h264_cbcs/manifest.mpd',
      drm: ESiteDrmConfig(
        licenseUrl: 'https://drm-widevine-licensing.axprod.net/AcquireLicense?AxDrmMessage=...',
        scheme: ESiteDrmScheme.widevine,
        licenseHeaders: {},
      ),
      autoPlay: false,
      securityConfig: ESiteSecurityConfig.maximum(),
    );
    
    controller = ESitePlayerController(config);
    controller.initialize();
    
    controller.stateStream.listen((state) {
      setState(() => currentState = state);
    });
    
    controller.errorStream.listen((error) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Error: ${error.message}')),
      );
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Video Player')),
      body: Column(
        children: [
          Expanded(
            child: ESitePlayerView(controller: controller),
          ),
          Row(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              IconButton(
                icon: Icon(Icons.replay_10),
                onPressed: () => controller.seekBackward(Duration(seconds: 10)),
              ),
              IconButton(
                icon: Icon(
                  currentState == ESitePlayerState.playing 
                    ? Icons.pause 
                    : Icons.play_arrow,
                ),
                iconSize: 48,
                onPressed: () {
                  if (currentState == ESitePlayerState.playing) {
                    controller.pause();
                  } else {
                    controller.play();
                  }
                },
              ),
              IconButton(
                icon: Icon(Icons.forward_10),
                onPressed: () => controller.seekForward(Duration(seconds: 10)),
              ),
            ],
          ),
        ],
      ),
    );
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }
}

See the example app for a comprehensive implementation with:

10 test scenarios including:
- Valid authentication with DRM
- Error cases (expired auth, invalid URLs, network errors)
- Security scenarios (screen protection, emulator blocking)
Full UI controls (play, pause, seek, speed, volume)
Real-time event logging
Error handling with retry functionality
Quality selection interface
Security violation handling

🔒 Security Features

Screen Protection

The plugin provides comprehensive screen protection features:

✅ Screenshots blocked - Prevents screenshot capture
✅ Screen recording blocked - Prevents screen recording
✅ Recent apps protection - Blurs content in recent apps switcher

Using Security Configuration (Recommended):

final config = ESitePlayerConfig(
  sourceUrl: 'https://example.com/video.mpd',
  drm: ESiteDrmConfig(
    licenseUrl: 'https://license-server.com/license',
    scheme: ESiteDrmScheme.widevine,
  ),
  // Maximum security (default)
  securityConfig: ESiteSecurityConfig.maximum(
    onSecurityViolation: (violation) {
      print('Security violation: ${violation.message}');
    },
  ),
);

Security Configurations:

// Maximum security (recommended for production)
securityConfig: ESiteSecurityConfig.maximum()

// Custom configuration
securityConfig: ESiteSecurityConfig(
  blockEmulators: true,              // Block playback on emulators
  enableScreenProtection: true,       // Enable screen capture blocking
  onSecurityViolation: (violation) {  // Optional callback
    // Handle security violations
    switch (violation.type) {
      case SecurityViolationType.emulatorDetected:
        showError('Playback not supported on emulators');
        break;
      case SecurityViolationType.screenCaptureAttempt:
        showError('Screen recording is blocked');
        break;
    }
  },
)

// Development mode (all security disabled)
securityConfig: ESiteSecurityConfig.disabled()

Backward Compatibility:

The deprecated flags still work but use the new securityConfig instead:

// ❌ Deprecated (still works)
preventScreenshots: true,
preventScreenRecording: true,

// ✅ Recommended
securityConfig: ESiteSecurityConfig(
  enableScreenProtection: true,
)

Emulator Detection

Protect premium content by blocking playback on emulators:

securityConfig: ESiteSecurityConfig(
  blockEmulators: true,  // Will prevent playback on emulators
  onSecurityViolation: (violation) {
    if (violation.type == SecurityViolationType.emulatorDetected) {
      // Show user-friendly error message
      showDialog(
        context: context,
        builder: (context) => AlertDialog(
          title: Text('Device Not Supported'),
          content: Text('Playback is not available on emulators'),
        ),
      );
    }
  },
)

Detection Methods:

Build properties analysis (product, model, brand, device)
Hardware identifiers (goldfish, ranchu)
Emulator-specific files (/dev/qemu_pipe, etc.)
System properties (ro.kernel.qemu, ro.hardware)
Known emulators (Genymotion, BlueStacks, NOX, Andy)

Security Behavior:

🟢 Enabled when playback starts
🔴 Disabled when playback pauses or ends
🔴 Disabled when player is disposed
🔍 Emulator check runs during initialization

This ensures security is active only during actual content playback.

DRM Protection

Widevine DRM support for encrypted content
PlayReady support
Secure license acquisition with custom headers
No DRM tokens or license details logged
Generic error messages to prevent information leakage

⚙️ Configuration Options

ESitePlayerConfig

Parameter	Type	Required	Default	Description
`sourceUrl`	`String`	Yes	-	Video source URL (.mpd or .m3u8)
`drm`	`ESiteDrmConfig`	Yes	-	DRM configuration
`securityConfig`	`ESiteSecurityConfig`	No	`ESiteSecurityConfig()`	Security settings
`headers`	`Map<String, String>?`	No	`null`	Custom HTTP headers for media requests
`autoPlay`	`bool`	No	`false`	Start playback automatically
`preventScreenshots`	`bool`	No	`false`	Deprecated Use `securityConfig` instead
`preventScreenRecording`	`bool`	No	`false`	Deprecated Use `securityConfig` instead

ESiteSecurityConfig

Parameter	Type	Default	Description
`blockEmulators`	`bool`	`true`	Block playback on emulators
`enableScreenProtection`	`bool`	`true`	Enable screen capture/recording protection
`onSecurityViolation`	`Function?`	`null`	Callback for security violations

ESiteDrmConfig

Parameter	Type	Required	Description
`licenseUrl`	`String`	Yes	DRM license server URL
`scheme`	`ESiteDrmScheme`	Yes	DRM scheme (widevine/playready)
`licenseHeaders`	`Map<String, String>?`	No	Custom headers for license requests

📊 API Reference

Controller Methods

Method	Return Type	Description
`initialize()`	`Future<void>`	Initialize player with configuration
`play()`	`Future<void>`	Start or resume playback
`pause()`	`Future<void>`	Pause playback
`seekTo(Duration)`	`Future<void>`	Seek to specific position
`seekForward(Duration)`	`Future<void>`	Seek forward by offset
`seekBackward(Duration)`	`Future<void>`	Seek backward by offset
`setPlaybackSpeed(double)`	`Future<void>`	Set speed (0.5-4.0)
`setVolume(double)`	`Future<void>`	Set volume (0.0-1.0)
`setMuted(bool)`	`Future<void>`	Mute/unmute audio
`isMuted()`	`Future<bool>`	Check if muted
`getVolume()`	`Future<double>`	Get current volume
`getAvailableVideoTracks()`	`Future<List<Map>>`	Get available quality tracks
`setVideoTrack(String)`	`Future<void>`	Select quality track
`setSubtitleEnabled(bool)`	`Future<void>`	Enable/disable subtitles
`isSubtitleEnabled()`	`Future<bool>`	Check subtitle status
`hasNext()`	`Future<bool>`	Check if next item exists
`hasPrevious()`	`Future<bool>`	Check if previous item exists
`next()`	`Future<void>`	Navigate to next item
`previous()`	`Future<void>`	Navigate to previous item
`dispose()`	`Future<void>`	Cleanup and release resources

Event Streams

Stream	Type	Description
`stateStream`	`Stream<ESitePlayerState>`	Player state changes
`drmStream`	`Stream<ESiteDrmEvent>`	DRM-related events
`errorStream`	`Stream<ESitePlayerError>`	Error events

Player States

idle - Initial state before initialization
initializing - Player is initializing
buffering - Loading content
ready - Ready to play
playing - Currently playing
paused - Playback paused
completed - Playback finished
error - Error occurred

DRM Event Types

licenseRequested - License acquisition started
licenseAcquired - License successfully obtained
licenseFailed - License acquisition failed

Error Codes

invalidSource - Invalid or inaccessible source URL
drmFailure - DRM license or provisioning failure
networkError - Network connection issues
playbackError - General playback errors
unknown - Unclassified errors

🧪 Testing

The plugin includes a comprehensive example app with 5 essential test scenarios:

cd example
flutter run

Test Scenarios:

✅ Valid Auth - No Security - Basic DRM playback without security (development mode)
✅ Valid Auth - Full Security - Production mode with complete security features
❌ Invalid Authentication - Network and authentication error handling
🚫 Emulator Detection - Tests emulator blocking (blocks on emulator, works on device)
🔒 Screenshot Protection - Tests screen capture prevention (try screenshot during playback)

Each scenario demonstrates proper error handling, security features, and user feedback.

Testing on Different Devices

On Android Emulator:

Scenarios 1, 2, 3, 5: Should work (with security active)
Scenario 4: Should block with error message

On Physical Device:

All scenarios should work
Scenario 4 proves emulator detection doesn't block real devices
Scenario 5 proves screenshot blocking works (try capturing screen during playback)

⚠️ Known Limitations

Android Emulator

DRM-protected content may not work properly on Android emulators due to:

Limited Widevine L3 support (L1 typically unavailable)
Missing hardware security features
Incomplete DRM stack implementation

Recommendation: Always test on physical Android devices for DRM functionality.

iOS Platform

iOS support is planned but not yet implemented. The plugin currently throws UnsupportedError on iOS platforms.

🔧 Troubleshooting

"No suitable media source factory found"

Cause: Missing DASH/HLS dependencies Solution: Plugin automatically includes required dependencies. If error persists:

cd example
flutter clean && rm -rf build/ .dart_tool/
flutter pub get

DRM License Acquisition Fails

Possible Causes:

Invalid or expired license token
Incorrect license URL
Missing required headers
Device DRM level incompatibility

Solutions:

Verify license URL and headers
Check token expiration
Test on L1/L3 compatible device
Review error messages in errorStream

Video Doesn't Play

Checklist:

✅ Internet connection available
✅ Source URL accessible
✅ DRM configuration correct
✅ Testing on physical device (not emulator)
✅ Listening to errorStream for details

Performance Issues

Optimization Tips:

Use appropriate quality tracks for device
Ensure good network connectivity
Avoid multiple player instances
Properly dispose controllers when done

🤝 Contributing

Contributions are welcome! Please:

Fork the repository
Create a feature branch
Make your changes with tests
Update documentation
Submit a pull request

Please follow:

Dart/Flutter style guidelines
Include tests for new features
Update README for API changes

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Built with Media3 ExoPlayer
DRM integration with Axinom
Test content provided by Axinom test vectors

📞 Support

For issues, questions, or contributions:

Made with ❤️ for secure video streaming in Flutter

✅ DRM Support: Widevine DRM via Axinom integration
✅ Security: Automatic screenshot and screen recording blocking (FLAG_SECURE)
✅ Playback Controls: Play, pause, seek, speed control (0.5x-4x)
✅ Track Selection: Video quality selection
✅ Subtitle Support: Enable/disable subtitles
✅ Volume Control: Volume adjustment and mute
✅ Playlist Support: Next/previous media item navigation
✅ Event Streams: Real-time playback state, DRM events, and error handling
✅ Production Ready: Secure, no DRM data logging, proper lifecycle management

Platform Support

✅ Android: Full support (Media3 ExoPlayer)
❌ iOS: Not yet implemented (planned for future release)

Installation

Add esite_flutter_player to your pubspec.yaml:

dependencies:
  esite_flutter_player: ^0.1.0

Then run:

flutter pub get

Quick Start

1. Basic Setup

import 'package:esite_flutter_player/esite_flutter_player.dart';

// Create player configuration
final config = ESitePlayerConfig(
  sourceUrl: 'https://your-cdn.com/video.mpd',
  drm: ESiteDrmConfig(
    licenseUrl: 'https://license.axinom.com/widevine',
    scheme: ESiteDrmScheme.widevine,
    licenseHeaders: {
      'X-AxDRM-Message': 'your-license-header',
    },
  ),
  autoPlay: false,
);

// Create controller
final controller = ESitePlayerController(config);

// Initialize player
await controller.initialize();

2. Display Video Player

ESitePlayerView(controller: controller)

3. Control Playback

// Play
await controller.play();

// Pause
await controller.pause();

// Seek to position
await controller.seekTo(Duration(seconds: 30));

// Seek forward/backward
await controller.seekForward(Duration(seconds: 10));
await controller.seekBackward(Duration(seconds: 10));

// Set playback speed (0.5x to 4x)
await controller.setPlaybackSpeed(1.5);

// Volume control
await controller.setVolume(0.8);
await controller.setMuted(true);

// Track selection
final tracks = await controller.getAvailableVideoTracks();
await controller.setVideoTrack(tracks[0]['id']);

// Subtitle control
await controller.setSubtitleEnabled(true);

// Playlist navigation
if (await controller.hasNext()) {
  await controller.next();
}

4. Listen to Events

// Playback state
controller.stateStream.listen((state) {
  print('Player state: $state');
  // States: idle, initializing, buffering, ready, playing, paused, completed, error
});

// DRM events
controller.drmStream.listen((event) {
  print('DRM event: ${event.type}');
  // Types: licenseRequested, licenseAcquired, licenseFailed
});

// Errors
controller.errorStream.listen((error) {
  print('Error: ${error.code} - ${error.message}');
});

5. Cleanup

@override
void dispose() {
  controller.dispose();
  super.dispose();
}

📖 Complete Example

See the example app for a full implementation with 5 test scenarios:

✅ Valid Auth - No Security
✅ Valid Auth - Full Security
❌ Invalid Authentication
🚫 Emulator Detection
🔒 Screenshot Protection

🔒 Security Configuration

ESiteSecurityConfig

Configure security features to protect your premium content.

Security Options

Parameter	Type	Default	Description
`blockEmulators`	`bool`	`true`	Block playback on emulators
`enableScreenProtection`	`bool`	`true`	Enable screenshot/recording blocking
`onSecurityViolation`	`Function?`	`null`	Callback for security events

Security Presets

1. Maximum Security (Production)

ESitePlayerConfig(
  sourceUrl: videoUrl,
  drm: drmConfig,
  securityConfig: ESiteSecurityConfig.maximum(
    onSecurityViolation: (violation) {
      print('Security alert: ${violation.message}');
      analytics.logSecurityEvent(violation.type.name);
    },
  ),
)

✅ Emulator detection enabled
✅ Screenshot blocking enabled
✅ Security monitoring active

2. Custom Configuration

securityConfig: ESiteSecurityConfig(
  blockEmulators: true,              // Block emulators
  enableScreenProtection: true,      // Block screenshots
  onSecurityViolation: (violation) {
    // Handle security events
  },
)

3. Development Mode

securityConfig: ESiteSecurityConfig.disabled()  // All security off

4. Selective Security

// Emulator detection only
ESiteSecurityConfig(blockEmulators: true, enableScreenProtection: false)

// Screenshot protection only
ESiteSecurityConfig(blockEmulators: false, enableScreenProtection: true)

Screenshot & Screen Recording Protection

Automatically blocks screenshots and screen recording using Android's FLAG_SECURE.

What's Protected:

✅ Screenshots (Power + Volume Down)
✅ Screen recording apps
✅ Recent apps preview
✅ Display mirroring (some cases)

Security Lifecycle:

🟢 Enabled when playback starts
🔴 Disabled when paused or ended
🔴 Disabled when player disposed

Example:

ESitePlayerConfig(
  sourceUrl: videoUrl,
  drm: drmConfig,
  securityConfig: ESiteSecurityConfig(
    enableScreenProtection: true,
  ),
)

Emulator Detection

Multi-method emulator detection to prevent automated piracy.

Detection Methods:

Build properties analysis
Hardware identifier checks
Emulator-specific file detection
System property inspection
Known emulator signatures

Behavior:

On Emulator: Playback blocked with error
On Real Device: Plays normally

Configuration:

ESitePlayerConfig(
  sourceUrl: videoUrl,
  drm: drmConfig,
  securityConfig: ESiteSecurityConfig(
    blockEmulators: true,
    onSecurityViolation: (violation) {
      if (violation.type == SecurityViolationType.emulatorDetected) {
        showDialog('Playback not available on emulators');
      }
    },
  ),
)

Testing:

Test on Android Studio emulator → Should block
Test on physical device → Should play

Security Violation Callbacks

Monitor security events in real-time:

securityConfig: ESiteSecurityConfig.maximum(
  onSecurityViolation: (SecurityViolation violation) {
    // Log security incident
    logger.warn('Security: ${violation.type} - ${violation.message}');
    
    // Track in analytics
    analytics.logEvent('security_violation', {
      'type': violation.type.name,
      'timestamp': violation.timestamp,
    });
    
    // Handle based on type
    switch (violation.type) {
      case SecurityViolationType.emulatorDetected:
        showError('Device not supported');
        break;
      case SecurityViolationType.screenCaptureAttempt:
        showWarning('Screen recording blocked');
        break;
    }
  },
)

Violation Types:

emulatorDetected - Playback blocked on emulator
screenCaptureAttempt - Screenshot/recording attempt
rootDetected - Rooted device (future)
tampering - App tampering (future)

Environment-Based Configuration

ESiteSecurityConfig getSecurityConfig() {
  if (kDebugMode) {
    return ESiteSecurityConfig.disabled();  // Development
  }
  if (environment == 'staging') {
    return ESiteSecurityConfig(
      blockEmulators: false,
      enableScreenProtection: true,
    );
  }
  return ESiteSecurityConfig.maximum();  // Production
}

Backward Compatibility

Old flags still work but use securityConfig instead:

// ❌ Deprecated (still works)
ESitePlayerConfig(
  preventScreenshots: true,
  preventScreenRecording: true,
)

// ✅ Recommended
ESitePlayerConfig(
  securityConfig: ESiteSecurityConfig(
    enableScreenProtection: true,
  ),
)

DRM Configuration

Axinom Widevine Setup

ESiteDrmConfig(
  licenseUrl: 'https://license.axinom.com/widevine',
  scheme: ESiteDrmScheme.widevine,
  licenseHeaders: {
    'X-AxDRM-Message': 'your-license-header',
    'Authorization': 'Bearer your-token',
  },
)

Supported DRM Schemes

ESiteDrmScheme.widevine - Widevine DRM (Axinom)

API Reference

ESitePlayerController

Main controller for video playback.

Methods

Future<void> initialize() - Initialize the player with configuration
Future<void> play() - Start playback
Future<void> pause() - Pause playback
Future<void> seekTo(Duration position) - Seek to specific position
Future<void> seekForward(Duration offset) - Seek forward by offset
Future<void> seekBackward(Duration offset) - Seek backward by offset
Future<void> setPlaybackSpeed(double speed) - Set speed (0.5-4.0)
Future<void> setVolume(double volume) - Set volume (0.0-1.0)
Future<void> setMuted(bool muted) - Mute/unmute
Future<bool> isMuted() - Check if muted
Future<double> getVolume() - Get current volume
Future<List<Map<String, dynamic>>> getAvailableVideoTracks() - Get video tracks
Future<void> setVideoTrack(String trackId) - Select video track
Future<void> setSubtitleEnabled(bool enabled) - Enable/disable subtitles
Future<bool> isSubtitleEnabled() - Check subtitle status
Future<bool> hasNext() - Check if next item available
Future<bool> hasPrevious() - Check if previous item available
Future<void> next() - Go to next media item
Future<void> previous() - Go to previous media item
Future<void> dispose() - Dispose player and cleanup

Properties

ESitePlayerState currentState - Current playback state
Stream<ESitePlayerState> stateStream - Playback state stream
Stream<ESiteDrmEvent> drmStream - DRM events stream
Stream<ESitePlayerError> errorStream - Error stream

ESitePlayerConfig

Player configuration.

ESitePlayerConfig({
  required String sourceUrl,
  required ESiteDrmConfig drm,
  Map<String, String>? headers,
  bool autoPlay = false,
  bool preventScreenshots = false,
  bool preventScreenRecording = false,
})

ESiteDrmConfig

DRM configuration.

ESiteDrmConfig({
  required String licenseUrl,
  required ESiteDrmScheme scheme,
  Map<String, String>? licenseHeaders,
})

ESitePlayerState

Playback state enum:

idle - Initial state
initializing - Player initializing
buffering - Buffering content
ready - Ready to play
playing - Currently playing
paused - Paused
completed - Playback completed
error - Error occurred

ESiteDrmEvent

DRM event with type and optional message:

licenseRequested - License request initiated
licenseAcquired - License successfully acquired
licenseFailed - License acquisition failed

ESitePlayerError

Error with code and message:

invalidSource - Invalid source URL
drmFailure - DRM-related failure
networkError - Network error
playbackError - Playback error
unknown - Unknown error

Limitations

Emulator Support

DRM-protected content may not work on Android emulators due to:

Lack of Widevine L1 support
Missing hardware security features

Recommendation: Test on physical Android devices.

iOS Support

iOS support is planned for a future release. The plugin currently throws UnsupportedError on iOS.

Testing

This plugin includes comprehensive test coverage across multiple levels:

Running Tests

# Run all unit tests
flutter test

# Run with coverage report
flutter test --coverage

# Run integration tests (requires device/emulator)
cd example
flutter test integration_test/

# Run Android native tests
cd example/android
./gradlew test

# Generate HTML coverage report
genhtml coverage/lcov.info -o coverage/html
open coverage/html/index.html

Test Coverage

The plugin maintains high test coverage across:

✅ Unit Tests (70%): Controller, configuration, events, platform layer
✅ Widget Tests (20%): Player view and UI components
✅ Integration Tests (10%): End-to-end playback, DRM, security

Coverage Goals:

Overall: >85%
Controller: >95%
Configuration: 100%
Events/Errors: 100%

Troubleshooting

DRM License Fails

Verify license URL is correct
Check license headers (especially Axinom headers)
Ensure device supports Widevine L1 or L3
Test on physical device (not emulator)

Playback Doesn't Start

Check network connectivity
Verify source URL is accessible
Check DRM configuration
Monitor error stream for details

Security Not Working

Security (FLAG_SECURE) is only enabled during active playback
Ensure player is in playing state
Check that activity is properly attached

Contributing

Contributions are welcome! Please ensure:

Code follows Dart/Flutter style guidelines
Tests are included for new features
Documentation is updated

License

See LICENSE file for details.

Support

For issues and questions:

Open an issue on GitHub
Check the example app for usage patterns---Note: This plugin is designed for production use with secure DRM content. Always test thoroughly on physical devices before deploying.

ESite Flutter Player

✨ Key Features

🔒 Enterprise Security

🎬 Professional Playback

🎯 Production Ready

📱 Platform Support

🎥 Supported Formats

📦 Installation

🚀 Quick Start

1. Import the Package

2. Create Player Configuration

3. Initialize Controller

4. Add Player to Your Widget Tree

5. Control Playback

6. Listen to Events

7. Cleanup

📖 Complete Example

🔒 Security Features

Screen Protection

Emulator Detection

DRM Protection

⚙️ Configuration Options

ESitePlayerConfig

ESiteSecurityConfig

ESiteDrmConfig

📊 API Reference

Controller Methods

Event Streams

Player States

DRM Event Types

Error Codes

🧪 Testing

Testing on Different Devices

⚠️ Known Limitations

Android Emulator

iOS Platform

🔧 Troubleshooting

"No suitable media source factory found"

DRM License Acquisition Fails

Video Doesn't Play

Performance Issues

🤝 Contributing

📄 License

🙏 Acknowledgments

📞 Support

Platform Support

Installation

Quick Start

1. Basic Setup

2. Display Video Player

3. Control Playback

4. Listen to Events

5. Cleanup

📖 Complete Example

🔒 Security Configuration

ESiteSecurityConfig

Security Options

Security Presets

Screenshot & Screen Recording Protection

Emulator Detection

Security Violation Callbacks

Environment-Based Configuration

Backward Compatibility

DRM Configuration

Axinom Widevine Setup

Supported DRM Schemes

API Reference

ESitePlayerController

Methods

Properties

ESitePlayerConfig

ESiteDrmConfig

ESitePlayerState

ESiteDrmEvent

ESitePlayerError

Limitations

Emulator Support

iOS Support

Testing

Running Tests