Media Cast DLNA

https://pub.dev/packages/media_cast_dlna
Admin
Media Cast DLNA is a Flutter plugin that enables discovering and controlling DLNA/UPnP media devices...
Tokens:36,582
Snippets:322
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Volume Control Pattern Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Shows how to manage volume levels, including setting volume, getting volume info, and toggling mute.

```APIDOC
## Volume Control Pattern

```dart
// Set volume level
await _api.setVolume(deviceUdn, VolumeLevel(percentage: 75));

// Get current volume info
final volumeInfo = await _api.getVolumeInfo(deviceUdn);
print('Current volume: ${volumeInfo.level.percentage}%');
print('Is muted: ${volumeInfo.muteState.isMuted}');

// Toggle mute
await _api.setMute(deviceUdn, MuteOperation(shouldMute: true));
```
```

--------------------------------

### Install Package

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

After adding the dependency to `pubspec.yaml`, run this command in your terminal to install the package.

```bash
flutter pub get

```

--------------------------------

### Discovery Pattern Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Shows how to use the discovery pattern with event listeners for device discovery and management.

```APIDOC
## Discovery Pattern

```dart
final discoveryEvents = MediaCastDlnaDiscoveryEvents();

discoveryEvents.onDeviceFound.listen((device) {
  // Add or update device in your state
});

discoveryEvents.onDeviceLost.listen((deviceUdn) {
  // Remove device from your state
});

// Start discovery with typed options
await _api.startDiscovery(
  DiscoveryOptions(
    timeout: DiscoveryTimeout(seconds: 15),
    searchTarget: SearchTarget(target: 'upnp:rootdevice'),
  ),
);

// Stop discovery
await _api.stopDiscovery();

await discoveryEvents.dispose();
```
```

--------------------------------

### Complete DLNA Media Cast Example

Source: https://pub.dev/packages/media_cast_dlna

This is a full Flutter widget demonstrating DLNA media casting. It requires initializing the UpnpService, starting device discovery, and handling device events. Use this to integrate DLNA casting into your application.

```dart
import 'package:flutter/material.dart';
import 'package:media_cast_dlna/media_cast_dlna.dart';

class DlnaMediaCastDemo extends StatefulWidget {
  @override
  _DlnaMediaCastDemoState createState() => _DlnaMediaCastDemoState();
}

class _DlnaMediaCastDemoState extends State<DlnaMediaCastDemo> {
  final _api = MediaCastDlnaApi();
  MediaCastDlnaDiscoveryEvents? _discoveryEvents;
  List<DlnaDevice> _devices = [];
  DlnaDevice? _selectedRenderer;
  bool _isDiscovering = false;
  TransportState _currentState = TransportState.stopped;
  int _currentPosition = 0;
  int _duration = 0;
  
  @override
  void initState() {
    super.initState();
    _initializePlugin();
  }
  
  Future<void> _initializePlugin() async {
    try {
      await _api.initializeUpnpService();
      print('✅ Media Cast DLNA initialized successfully');
    } catch (e) {
      print('❌ Initialization failed: $e');
    }
  }
  
  Future<void> _startDiscovery() async {
    _discoveryEvents?.dispose();

    _discoveryEvents = MediaCastDlnaDiscoveryEvents();
    setState(() => _isDiscovering = true);

    _discoveryEvents!.onDeviceFound.listen((device) {
      if (!mounted) return;

      setState(() {
        final index = _devices.indexWhere((d) => d.udn.value == device.udn.value);
        if (index >= 0) {
          _devices[index] = device;
        } else {
          _devices.add(device);
        }
      });
    });

    _discoveryEvents!.onDeviceLost.listen((deviceUdn) {
      if (!mounted) return;

      setState(() {
        _devices.removeWhere((d) => d.udn.value == deviceUdn.value);
      });
    });
    
    try {
      await _api.startDiscovery(
        DiscoveryOptions(
          timeout: DiscoveryTimeout(seconds: 15),
          searchTarget: SearchTarget(target: 'upnp:rootdevice'),
        ),
      );

      // Discovery now runs through callbacks; no polling timer required.
      if (mounted) {
        setState(() => _isDiscovering = false);
      }
    } catch (e) {
      setState(() => _isDiscovering = false);
      _showError('Discovery failed: $e');
    }
  }
  
  Future<void> _castSampleVideo() async {
    if (_selectedRenderer == null) {
      _showError('Please select a renderer device first');
      return;
    }
    
    const sampleUrl = 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4';
    
    try {
      final metadata = VideoMetadata(
        title: 'Big Buck Bunny',
        duration: TimeDuration(seconds: 596),
        resolution: '1920x1080',
        genre: 'Animation',
        upnpClass: 'object.item.videoItem.movie',
      );
      
      await _api.setMediaUri(
        _selectedRenderer!.udn,
        Url(value: sampleUrl),
        metadata,
      );
      await _api.play(_selectedRenderer!.udn);
      
      _showSuccess('Video cast successfully!');
      _startStatusPolling();
      
    } catch (e) {
      _showError('Failed to cast video: $e');
    }
  }
  
  void _startStatusPolling() {
    Timer.periodic(Duration(seconds: 1), (timer) async {
      if (_selectedRenderer == null) {
        timer.cancel();
        return;
      }
      
      try {
        final state = await _api.getTransportState(_selectedRenderer!.udn);
        final position = await _api.getCurrentPosition(_selectedRenderer!.udn);
        final playbackInfo = await _api.getPlaybackInfo(_selectedRenderer!.udn);
        
        setState(() {
          _currentState = state;
          _currentPosition = position.seconds;
          _duration = playbackInfo.duration.seconds;
        });
        
        // Stop polling if not playing
        if (state == TransportState.stopped) {
          timer.cancel();
        }
      } catch (e) {
        print('Status update failed: $e');
      }
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Media Cast DLNA Demo'),
        backgroundColor: Colors.deepPurple,
      ),
      body: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // Discovery Section
            Card(
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  children: [
                    Text('Device Discovery', 
                         style: Theme.of(context).textTheme.titleLarge),
                    SizedBox(height: 8),
                    ElevatedButton(
                      onPressed: _isDiscovering ? null : _startDiscovery,
                      child: Text(_isDiscovering ? 'Discovering...' : 'Start Discovery'),
                    ),
                    SizedBox(height: 8),
                    Text('Found ${_devices.length} devices'),
                  ],
                ),
              ),
            ),
            
            // Device Selection and Casting Section
            Card(
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  children: [
                    Text('Device Control', 
                         style: Theme.of(context).textTheme.titleLarge),
                    SizedBox(height: 8),
                    DropdownButton<DlnaDevice>(
                      value: _selectedRenderer,
                      hint: Text('Select Renderer'),
                      onChanged: (DlnaDevice? newValue) {
                        setState(() {
                          _selectedRenderer = newValue;
                        });
                      },
                      items: _devices.map<DropdownMenuItem<DlnaDevice>>((DlnaDevice device) {
                        return DropdownMenuItem<DlnaDevice>(
                          value: device,
                          child: Text(device.friendlyName ?? device.udn.value),
                        );
                      }).toList(),
                    ),
                    SizedBox(height: 8),
                    ElevatedButton(
                      onPressed: _selectedRenderer == null ? null : _castSampleVideo,
                      child: Text('Cast Sample Video'),
                    ),
                    SizedBox(height: 8),
                    Text('Current State: ${_currentState.toString().split('.').last}'),
                    Text('Position: $_currentPosition / $_duration seconds'),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
  
  void _showError(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(message), backgroundColor: Colors.red),
    );
  }
  
  void _showSuccess(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(message), backgroundColor: Colors.green),
    );
  }

  @override
  void dispose() {
    _discoveryEvents?.dispose();
    _api.dispose();
    super.dispose();
  }
}

```

--------------------------------

### Complete DLNA Media Casting Example in Flutter

Source: https://pub.dev/packages/media_cast_dlna/versions/0.1.3

This is a full-featured example demonstrating DLNA device discovery and media casting. It requires Flutter and the media_cast_dlna package. Ensure you have the necessary permissions for network discovery.

```dart
import 'package:flutter/material.dart';
import 'package:media_cast_dlna/media_cast_dlna.dart';

class DlnaMediaCastDemo extends StatefulWidget {
  @override
  _DlnaMediaCastDemoState createState() => _DlnaMediaCastDemoState();
}

class _DlnaMediaCastDemoState extends State<DlnaMediaCastDemo> {
  final _api = MediaCastDlnaApi();
  List<DlnaDevice> _devices = [];
  DlnaDevice? _selectedRenderer;
  bool _isDiscovering = false;
  TransportState _currentState = TransportState.stopped;
  int _currentPosition = 0;
  int _duration = 0;
  
  @override
  void initState() {
    super.initState();
    _initializePlugin();
  }
  
  Future<void> _initializePlugin() async {
    try {
      await _api.initializeUpnpService();
      print('✅ Media Cast DLNA initialized successfully');
    } catch (e) {
      print('❌ Initialization failed: $e');
    }
  }
  
  Future<void> _startDiscovery() async {
    setState(() => _isDiscovering = true);
    
    try {
      await _api.startDiscovery(
        DiscoveryOptions(
          timeout: DiscoveryTimeout(seconds: 15),
          searchTarget: SearchTarget(target: 'upnp:rootdevice'),
        ),
      );
      
      // Poll for devices
      Timer.periodic(Duration(seconds: 2), (timer) async {
        final devices = await _api.getDiscoveredDevices();
        setState(() => _devices = devices);
        
        if (timer.tick >= 10) {
          timer.cancel();
          await _api.stopDiscovery();
          setState(() => _isDiscovering = false);
        }
      });
    } catch (e) {
      setState(() => _isDiscovering = false);
      _showError('Discovery failed: $e');
    }
  }
  
  Future<void> _castSampleVideo() async {
    if (_selectedRenderer == null) {
      _showError('Please select a renderer device first');
      return;
    }
    
    const sampleUrl = 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4';
    
    try {
      final metadata = VideoMetadata(
        title: 'Big Buck Bunny',
        duration: TimeDuration(seconds: 596),
        resolution: '1920x1080',
        genre: 'Animation',
        upnpClass: 'object.item.videoItem.movie',
      );
      
      await _api.setMediaUri(
        _selectedRenderer!.udn,
        Url(value: sampleUrl),
        metadata,
      );
      await _api.play(_selectedRenderer!.udn);
      
      _showSuccess('Video cast successfully!');
      _startStatusPolling();
      
    } catch (e) {
      _showError('Failed to cast video: $e');
    }
  }
  
  void _startStatusPolling() {
    Timer.periodic(Duration(seconds: 1), (timer) async {
      if (_selectedRenderer == null) {
        timer.cancel();
        return;
      }
      
      try {
        final state = await _api.getTransportState(_selectedRenderer!.udn);
        final position = await _api.getCurrentPosition(_selectedRenderer!.udn);
        final playbackInfo = await _api.getPlaybackInfo(_selectedRenderer!.udn);
        
        setState(() {
          _currentState = state;
          _currentPosition = position.seconds;
          _duration = playbackInfo.duration.seconds;
        });
        
        // Stop polling if not playing
        if (state == TransportState.stopped) {
          timer.cancel();
        }
      } catch (e) {
        print('Status update failed: $e');
      }
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Media Cast DLNA Demo'),
        backgroundColor: Colors.deepPurple,
      ),
      body: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // Discovery Section
            Card(
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  children: [
                    Text('Device Discovery', 
                         style: Theme.of(context).textTheme.titleLarge),
                    SizedBox(height: 8),
                    ElevatedButton(
                      onPressed: _isDiscovering ? null : _startDiscovery,
                      child: Text(_isDiscovering ? 'Discovering...' : 'Start Discovery'),
                    ),
                    SizedBox(height: 8),
                    Text('Found ${_devices.length} devices'),
                  ],
                ),
              ),
            ),
            
            // Device List
            Expanded(
              child: Card(
                child: _devices.isEmpty
                    ? Center(child: Text('No devices found'))
                    : ListView.builder(
                        itemCount: _devices.length,
                        itemBuilder: (context, index) {
                          final device = _devices[index];
                          return ListTile(
                            title: Text(device.friendlyName),
                            subtitle: Text(device.modelName),
                            onTap: () {
                              setState(() => _selectedRenderer = device);
                              _showSuccess('Selected ${device.friendlyName}');
                            },
                          );
                        },
                      ),
              ),
            ),
            
            // Casting Controls
            Card( 
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column( 
                  children: [
                    Text('Media Casting', 
                         style: Theme.of(context).textTheme.titleLarge),
                    SizedBox(height: 8),
                    ElevatedButton(
                      onPressed: _selectedRenderer == null ? null : _castSampleVideo,
                      child: Text('Cast Sample Video'),
                    ),
                    SizedBox(height: 16),
                    if (_selectedRenderer != null)
                      Column( 
                        children: [
                          Text('Selected Renderer: ${_selectedRenderer!.friendlyName}'),
                          SizedBox(height: 8),
                          Text('Status: ${_currentState.toString().split('.').last}'),
                          SizedBox(height: 8),
                          LinearProgressIndicator(
                            value: _duration == 0 ? 0 : _currentPosition / _duration,
                          ),
                          SizedBox(height: 8),
                          Text('${_formatDuration(_currentPosition)} / ${_formatDuration(_duration)}'),
                        ]
                      )
                  ]
                )
              )
            )
          ]
        )
      )
    );
  }
  
  void _showError(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(message), backgroundColor: Colors.red),
    );
  }
  
  void _showSuccess(String message) {
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text(message), backgroundColor: Colors.green),
    );
  }
  
  String _formatDuration(int seconds) {
    final minutes = (seconds / 60).floor();
    final remainingSeconds = seconds % 60;
    return '$minutes:${remainingSeconds.toString().padLeft(2, '0')}';
  }
}

```

--------------------------------

### Playback Control Pattern Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Demonstrates how to control media playback, including setting media, playing, pausing, stopping, and seeking.

```APIDOC
## Playback Control Pattern

```dart
// Set media with typed metadata
await _api.setMediaUri(
  deviceUdn,
  Url(value: mediaUrl),
  VideoMetadata(title: 'Movie Title'),
);

// Control playback
await _api.play(deviceUdn);
await _api.pause(deviceUdn);
await _api.stop(deviceUdn);

// Seek to position
await _api.seek(deviceUdn, TimePosition(seconds: 300));
```
```

--------------------------------

### Media Metadata Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Examples of using sealed classes for different media metadata types (video, audio, image).

```APIDOC
## Sealed Classes for Metadata

Media metadata uses sealed classes for type safety:

```dart
// For video content
final videoMetadata = VideoMetadata(
  title: 'My Movie',
  duration: TimeDuration(seconds: 7200),
  resolution: '1920x1080',
  genre: 'Action',
);

// For audio content  
final audioMetadata = AudioMetadata(
  title: 'My Song',
  artist: 'Artist Name',
  album: 'Album Name',
  duration: TimeDuration(seconds: 240),
);

// For images
final imageMetadata = ImageMetadata(
  title: 'My Photo',
  resolution: '4032x3024',
  date: '2025-07-03',
);
```
```

--------------------------------

### Example pubspec.yaml Dependency

Source: https://pub.dev/packages/media_cast_dlna/install

This is an example of how the media_cast_dlna dependency will appear in your pubspec.yaml file after running `flutter pub add`.

```yaml
dependencies:
  media_cast_dlna: ^0.3.1
```

--------------------------------

### Network Concepts Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Illustrates the use of value objects for network-related concepts like device identification and URLs.

```APIDOC
## Value Objects for Network Concepts

Network-related values use descriptive classes:

```dart
// Device identification
final deviceUdn = DeviceUdn(value: 'uuid:12345678-1234-1234-1234-123456789012');

// Network locations
final mediaUrl = Url(value: 'https://example.com/video.mp4');
final deviceIp = IpAddress(value: '192.168.1.100');
final devicePort = NetworkPort(value: 8080);
```
```

--------------------------------

### Discovery Pattern for DLNA Devices

Source: https://pub.dev/packages/media_cast_dlna/versions/0.1.3

Demonstrates the common pattern for starting and stopping device discovery, including specifying discovery options and retrieving discovered devices.

```dart
// Start discovery with typed options
await _api.startDiscovery(
  DiscoveryOptions(
    timeout: DiscoveryTimeout(seconds: 15),
    searchTarget: SearchTarget(target: 'upnp:rootdevice'),
  ),
);

// Get discovered devices
final devices = await _api.getDiscoveredDevices();

// Stop discovery
await _api.stopDiscovery();

```

--------------------------------

### Complete DLNA Media Cast Demo in Flutter

Source: https://pub.dev/packages/media_cast_dlna/versions/0.2.0

This example initializes the DLNA service, discovers devices, casts a sample video, and polls for playback status. Ensure you have the necessary dependencies and permissions set up.

```dart
import 'package:flutter/material.dart';
import 'package:media_cast_dlna/media_cast_dlna.dart';

class DlnaMediaCastDemo extends StatefulWidget {
  @override
  _DlnaMediaCastDemoState createState() => _DlnaMediaCastDemoState();
}

class _DlnaMediaCastDemoState extends State<DlnaMediaCastDemo> {
  final _api = MediaCastDlnaApi();
  List<DlnaDevice> _devices = [];
  DlnaDevice? _selectedRenderer;
  bool _isDiscovering = false;
  TransportState _currentState = TransportState.stopped;
  int _currentPosition = 0;
  int _duration = 0;
  
  @override
  void initState() {
    super.initState();
    _initializePlugin();
  }
  
  Future<void> _initializePlugin() async {
    try {
      await _api.initializeUpnpService();
      print('✅ Media Cast DLNA initialized successfully');
    } catch (e) {
      print('❌ Initialization failed: $e');
    }
  }
  
  Future<void> _startDiscovery() async {
    setState(() => _isDiscovering = true);
    
    try {
      await _api.startDiscovery(
        DiscoveryOptions(
          timeout: DiscoveryTimeout(seconds: 15),
          searchTarget: SearchTarget(target: 'upnp:rootdevice'),
        ),
      );
      
      // Poll for devices
      Timer.periodic(Duration(seconds: 2), (timer) async {
        final devices = await _api.getDiscoveredDevices();
        setState(() => _devices = devices);
        
        if (timer.tick >= 10) {
          timer.cancel();
          await _api.stopDiscovery();
          setState(() => _isDiscovering = false);
        }
      });
    } catch (e) {
      setState(() => _isDiscovering = false);
      _showError('Discovery failed: $e');
    }
  }
  
  Future<void> _castSampleVideo() async {
    if (_selectedRenderer == null) {
      _showError('Please select a renderer device first');
      return;
    }
    
    const sampleUrl = 'https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4';
    
    try {
      final metadata = VideoMetadata(
        title: 'Big Buck Bunny',
        duration: TimeDuration(seconds: 596),
        resolution: '1920x1080',
        genre: 'Animation',
        upnpClass: 'object.item.videoItem.movie',
      );
      
      await _api.setMediaUri(
        _selectedRenderer!.udn,
        Url(value: sampleUrl),
        metadata,
      );
      await _api.play(_selectedRenderer!.udn);
      
      _showSuccess('Video cast successfully!');
      _startStatusPolling();
      
    } catch (e) {
      _showError('Failed to cast video: $e');
    }
  }
  
  void _startStatusPolling() {
    Timer.periodic(Duration(seconds: 1), (timer) async {
      if (_selectedRenderer == null) {
        timer.cancel();
        return;
      }
      
      try {
        final state = await _api.getTransportState(_selectedRenderer!.udn);
        final position = await _api.getCurrentPosition(_selectedRenderer!.udn);
        final playbackInfo = await _api.getPlaybackInfo(_selectedRenderer!.udn);
        
        setState(() {
          _currentState = state;
          _currentPosition = position.seconds;
          _duration = playbackInfo.duration.seconds;
        });
        
        // Stop polling if not playing
        if (state == TransportState.stopped) {
          timer.cancel();
        }
      } catch (e) {
        print('Status update failed: $e');
      }
    });
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Media Cast DLNA Demo'),
        backgroundColor: Colors.deepPurple,
      ),
      body: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            // Discovery Section
            Card(
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  children: [
                    Text('Device Discovery', 
                         style: Theme.of(context).textTheme.titleLarge),
                    SizedBox(height: 8),
                    ElevatedButton(
                      onPressed: _isDiscovering ? null : _startDiscovery,
                      child: Text(_isDiscovering ? 'Discovering...' : 'Start Discovery'),
                    ),
                    SizedBox(height: 8),
                    Text('Found ${_devices.length} devices'),
                  ],
                ),
              ),
            ),
            
            // Device List
            Expanded(
              child: Card(
                child: _devices.isEmpty
                    ? Center(child: Text('No devices found'))
                    : ListView.builder(
                        itemCount: _devices.length,
                        itemBuilder: (context, index) {
                          final device = _devices[index];

```

--------------------------------

### Discover DLNA Devices

Source: https://pub.dev/packages/media_cast_dlna/versions/0.1.3

Starts device discovery with a timeout and periodically checks for discovered devices. Filters devices to get media renderers or servers.

```dart
Future<void> _startDeviceDiscovery() async {
  try {
    // Start discovery with timeout using the new wrapper classes
    await _api.startDiscovery(
      DiscoveryOptions(
        timeout: DiscoveryTimeout(seconds: 10),
        searchTarget: SearchTarget(target: 'upnp:rootdevice'),
      ),
    );
    
    // Periodically check for discovered devices
    Timer.periodic(Duration(seconds: 2), (timer) async {
      final devices = await _api.getDiscoveredDevices();
      setState(() {
        _discoveredDevices = devices;
      });
      
      // Stop timer after 30 seconds
      if (timer.tick >= 15) {
        timer.cancel();
        await _api.stopDiscovery();
      }
    });
    
  } catch (e) {
    print('Discovery failed: $e');
  }
}

// Get only media renderers (devices that can play content)
List<DlnaDevice> getMediaRenderers() {
  return _discoveredDevices
      .where((device) => device.deviceType.contains('MediaRenderer'))
      .toList();
}

// Get only media servers (devices that provide content)
List<DlnaDevice> getMediaServers() {
  return _discoveredDevices
      .where((device) => device.deviceType.contains('MediaServer'))
      .toList();
}
```

--------------------------------

### Get Media Servers

Source: https://pub.dev/packages/media_cast_dlna

Filters the list of discovered devices to return only those that are media servers, meaning they provide content.

```APIDOC
## getMediaServers()

### Description
Returns a list of discovered DLNA devices that are identified as media servers.

### Method
```dart
List<DlnaDevice> getMediaServers()
```

### Parameters
None

### Response
- **List<DlnaDevice>**: A list of `DlnaDevice` objects representing media servers.
```

--------------------------------

### Start DLNA Device Discovery

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Starts discovering DLNA devices on the network. It listens for device discovery events and updates the list of found devices. Discovery has a timeout and searches for 'upnp:rootdevice'.

```dart
Future<void> _startDiscovery() async {
    _discoveryEvents?.dispose();

    _discoveryEvents = MediaCastDlnaDiscoveryEvents();
    setState(() => _isDiscovering = true);

    _discoveryEvents!.onDeviceFound.listen((device) {
      if (!mounted) return;

      setState(() {
        final index = _devices.indexWhere((d) => d.udn.value == device.udn.value);
        if (index >= 0) {
          _devices[index] = device;
        } else {
          _devices.add(device);
        }
      });
    });

    _discoveryEvents!.onDeviceLost.listen((deviceUdn) {
      if (!mounted) return;

      setState(() {
        _devices.removeWhere((d) => d.udn.value == deviceUdn.value);
      });
    });
    
    try {
      await _api.startDiscovery(
        DiscoveryOptions(
          timeout: DiscoveryTimeout(seconds: 15),
          searchTarget: SearchTarget(target: 'upnp:rootdevice'),
        ),
      );

      // Discovery now runs through callbacks; no polling timer required.
      if (mounted) {
        setState(() => _isDiscovering = false);
      }
    } catch (e) {
      setState(() => _isDiscovering = false);
      _showError('Discovery failed: $e');
    }
  }
```

--------------------------------

### Troubleshoot DLNA Device Discovery

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Guides through troubleshooting steps for device discovery, including network permissions and device status. It uses event-driven callbacks for device discovery and includes error handling.

```dart
Future<void> _troubleshootDiscovery() async {
  // Check network permissions
  print('1. Ensure WIFI permissions are granted');
  print('2. Check if device is on same network as DLNA devices');
  print('3. Verify DLNA devices are powered on and discoverable');

  // Use event-driven discovery callbacks instead of polling snapshots.
  final discoveryEvents = MediaCastDlnaDiscoveryEvents();

  discoveryEvents.onDeviceFound.listen((device) {
    print('Found device: ${device.friendlyName}');
  });

  discoveryEvents.onDeviceLost.listen((deviceUdn) {
    print('Lost device: ${deviceUdn.value}');
  });

  try {
    await _api.startDiscovery(
      DiscoveryOptions(
        timeout: DiscoveryTimeout(seconds: 10),
        searchTarget: SearchTarget(target: 'upnp:rootdevice'),
      ),
    );
  } catch (e) {
    print('Failed to start discovery: $e');
  } finally {
    await discoveryEvents.dispose();
  }
}
```

--------------------------------

### Discovery Pattern

Source: https://pub.dev/packages/media_cast_dlna/versions/0.1.3

Demonstrates how to use the discovery pattern to find DLNA devices on the network, including starting discovery with specific options, retrieving the list of found devices, and stopping the discovery process.

```APIDOC
## Discovery Pattern

```dart
// Start discovery with typed options
await _api.startDiscovery(
  DiscoveryOptions(
    timeout: DiscoveryTimeout(seconds: 15),
    searchTarget: SearchTarget(target: 'upnp:rootdevice'),
  ),
);

// Get discovered devices
final devices = await _api.getDiscoveredDevices();

// Stop discovery
await _api.stopDiscovery();
```
```

--------------------------------

### Typed Wrapper Usage Example

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Demonstrates the use of typed wrapper classes for API calls, contrasting with the older primitive type approach.

```APIDOC
## Typed Wrapper Classes

Instead of using primitive types, we use descriptive wrapper classes:

```dart
// ❌ Old approach with primitives
await api.setVolume(deviceId, 75);
await api.seek(deviceId, 120);
await api.startDiscovery(10);

// ✅ New approach with typed wrappers
await api.setVolume(deviceUdn, VolumeLevel(percentage: 75));
await api.seek(deviceUdn, TimePosition(seconds: 120));
await api.startDiscovery(DiscoveryOptions(
  timeout: DiscoveryTimeout(seconds: 10),
));
```
```

--------------------------------

### Discovery Pattern with Event Listeners

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Implements the discovery pattern using `MediaCastDlnaDiscoveryEvents` to listen for device discovery and loss events, and starts discovery with typed options.

```dart
final discoveryEvents = MediaCastDlnaDiscoveryEvents();

discoveryEvents.onDeviceFound.listen((device) {
  // Add or update device in your state
});

discoveryEvents.onDeviceLost.listen((deviceUdn) {
  // Remove device from your state
});

// Start discovery with typed options
await _api.startDiscovery(
  DiscoveryOptions(
    timeout: DiscoveryTimeout(seconds: 15),
    searchTarget: SearchTarget(target: 'upnp:rootdevice'),
  ),
);

// Stop discovery
await _api.stopDiscovery();

await discoveryEvents.dispose();

```

--------------------------------

### Cast Media with Subtitles

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Demonstrates how to cast media to a DLNA renderer, including specifying multiple subtitle tracks. It also shows how to manage subtitle tracks after casting, such as getting available tracks, the current track, and setting a specific track or disabling subtitles.

```APIDOC
## Cast Media with Subtitles

### Description
Casts media to a DLNA renderer with support for multiple subtitle tracks. Includes functionality to manage subtitle tracks post-casting.

### Method
`_castWithSubtitles(DlnaDevice renderer, String mediaUrl)`

### Parameters
- `renderer` (DlnaDevice) - The DLNA media renderer to cast to.
- `mediaUrl` (String) - The URL of the media to cast.

### Request Example
```dart
// Example usage within a Dart context
final subtitleTracks = [
  SubtitleTrack(
    id: 'sub1',
    language: 'en',
    title: 'English',
    uri: Url(value: 'https://example.com/subtitles/english.srt'),
    mimeType: 'text/srt',
    isDefault: true,
  ),
  SubtitleTrack(
    id: 'sub2',
    language: 'es',
    title: 'Español',
    uri: Url(value: 'https://example.com/subtitles/spanish.srt'),
    mimeType: 'text/srt',
  ),
];

final metadata = VideoMetadata(
  title: 'Movie with Subtitles',
  duration: TimeDuration(seconds: 6300),
  resolution: '1920x1080',
  upnpClass: 'object.item.videoItem.movie',
);

await _api.setMediaUriWithSubtitles(
  renderer.udn,
  Url(value: mediaUrl),
  metadata,
  subtitleTracks,
);
```

## Manage Subtitles

### Description
Provides methods to check for subtitle control support, retrieve available subtitle tracks, get the current subtitle track, set a specific subtitle track, and disable subtitles on a DLNA device.

### Method
`_manageSubtitles(DeviceUdn deviceUdn)`

### Parameters
- `deviceUdn` (DeviceUdn) - The Unique Device Name of the DLNA device.

### API Calls
- `supportsSubtitleControl(DeviceUdn deviceUdn)`: Checks if the device supports subtitle control.
- `getAvailableSubtitleTracks(DeviceUdn deviceUdn)`: Retrieves a list of available subtitle tracks.
- `getCurrentSubtitleTrack(DeviceUdn deviceUdn)`: Gets the currently active subtitle track.
- `setSubtitleTrack(DeviceUdn deviceUdn, String? trackId)`: Sets a specific subtitle track by its ID, or `null` to disable subtitles.
```

--------------------------------

### Migrate Device Properties in Dart

Source: https://pub.dev/packages/media_cast_dlna/changelog

Demonstrates the migration from older device property accessors to the new structure in v0.2.0. Use these examples to update your code when migrating from v0.1.3.

```dart
// Before (v0.1.3)
Text('${device.manufacturerName} - ${device.modelName}')
Text('IP: ${device.ipAddress}:${device.port}')
```

```dart
// After (v0.2.0)
Text('${device.manufacturerDetails.manufacturer} - ${device.modelDetails.modelName}')
Text('IP: ${device.ipAddress.value}:${device.port.value}')
```

--------------------------------

### Discover DLNA Devices

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Starts the discovery process for DLNA devices on the network. It listens for device found and lost events, updating the UI accordingly. Discovery has a 10-second timeout.

```dart
Future<void> _startDeviceDiscovery() async {
  try {
    final discoveryEvents = MediaCastDlnaDiscoveryEvents();

    discoveryEvents.onDeviceFound.listen((device) {
      setState(() {
        final existingIndex = _discoveredDevices.indexWhere(
          (d) => d.udn.value == device.udn.value,
        );

        if (existingIndex >= 0) {
          _discoveredDevices[existingIndex] = device;
        } else {
          _discoveredDevices.add(device);
        }
      });
    });

    discoveryEvents.onDeviceLost.listen((deviceUdn) {
      setState(() {
        _discoveredDevices.removeWhere((d) => d.udn.value == deviceUdn.value);
      });
    });

    // Native renderer connectivity event (no polling timer needed)
    discoveryEvents.onRendererOffline.listen((rendererUdn) {
      if (_selectedRenderer?.udn.value == rendererUdn.value) {
        setState(() {
          _isSelectedRendererOnline = false;
        });
      }
    });

    // Start discovery with timeout using the new wrapper classes
    await _api.startDiscovery(
      DiscoveryOptions(
        timeout: DiscoveryTimeout(seconds: 10),
        searchTarget: SearchTarget(target: 'upnp:rootdevice'),
      ),
    );
  } catch (e) {
    print('Discovery failed: $e');
  }
}

// Get only media renderers (devices that can play content)
List<DlnaDevice> getMediaRenderers() {
  return _discoveredDevices
      .where((device) => device.deviceType.contains('MediaRenderer'))
      .toList();
}

// Get only media servers (devices that provide content)
List<DlnaDevice> getMediaServers() {
  return _discoveredDevices
      .where((device) => device.deviceType.contains('MediaServer'))
      .toList();
}

```

--------------------------------

### Start DLNA Device Discovery

Source: https://pub.dev/packages/media_cast_dlna/versions/0.2.0

Initiates a discovery process for DLNA devices with a specified timeout and search target. It then periodically checks for discovered devices and stops the discovery after a set duration.

```dart
Future<void> _startDeviceDiscovery() async {
  try {
    // Start discovery with timeout using the new wrapper classes
    await _api.startDiscovery(
      DiscoveryOptions(
        timeout: DiscoveryTimeout(seconds: 10),
        searchTarget: SearchTarget(target: 'upnp:rootdevice'),
      ),
    );
    
    // Periodically check for discovered devices
    Timer.periodic(Duration(seconds: 2), (timer) async {
      final devices = await _api.getDiscoveredDevices();
      setState(() {
        _discoveredDevices = devices;
      });
      
      // Stop timer after 30 seconds
      if (timer.tick >= 15) {
        timer.cancel();
        await _api.stopDiscovery();
      }
    });
    
  } catch (e) {
    print('Discovery failed: $e');
  }
}
```

--------------------------------

### Discover DLNA Devices

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Starts the discovery of DLNA devices on the network and listens for device discovery events (found, lost, offline). It also filters discovered devices into media renderers and media servers.

```APIDOC
## _startDeviceDiscovery()

### Description
Initiates the discovery of DLNA devices on the network. It sets up listeners for device discovery events such as devices being found, lost, or renderers going offline. The discovered devices are managed internally and can be filtered into media renderers or media servers.

### Method
```dart
Future<void> _startDeviceDiscovery()
```

### Parameters
None

### Usage
Call this method to begin scanning for DLNA devices. The results are managed internally and can be accessed via `getMediaRenderers()` and `getMediaServers()`.

## getMediaRenderers()

### Description
Returns a list of discovered DLNA devices that are identified as media renderers.

### Method
```dart
List<DlnaDevice> getMediaRenderers()
```

### Parameters
None

### Returns
A list of `DlnaDevice` objects representing media renderers.

## getMediaServers()

### Description
Returns a list of discovered DLNA devices that are identified as media servers.

### Method
```dart
List<DlnaDevice> getMediaServers()
```

### Parameters
None

### Returns
A list of `DlnaDevice` objects representing media servers.
```

--------------------------------

### Start Playback Status Polling

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Starts a timer to periodically poll the DLNA renderer for playback status, including transport state, current position, and duration. Stops polling when the media is stopped.

```dart
void _startStatusPolling() {
    Timer.periodic(Duration(seconds: 1), (timer) async {
      if (_selectedRenderer == null) {
        timer.cancel();
        return;
      }
      
      try {
        final state = await _api.getTransportState(_selectedRenderer!.udn);
        final position = await _api.getCurrentPosition(_selectedRenderer!.udn);
        final playbackInfo = await _api.getPlaybackInfo(_selectedRenderer!.udn);
        
        setState(() {
          _currentState = state;
          _currentPosition = position.seconds;
          _duration = playbackInfo.duration.seconds;
        });
        
        // Stop polling if not playing
        if (state == TransportState.stopped) {
          timer.cancel();
        }
      } catch (e) {
        print('Status update failed: $e');
      }
    });
  }
```

--------------------------------

### Playback Control Pattern

Source: https://pub.dev/packages/media_cast_dlna/versions/0.2.0

Illustrates how to control media playback, including setting media, playing, pausing, stopping, and seeking.

```APIDOC
## Playback Control Pattern

### Set Media URI

```dart
// Set media with typed metadata
await _api.setMediaUri(
  deviceUdn,
  Url(value: mediaUrl),
  VideoMetadata(title: 'Movie Title'),
);
```

### Playback Controls

```dart
// Control playback
await _api.play(deviceUdn);
await _api.pause(deviceUdn);
await _api.stop(deviceUdn);
```

### Seek to Position

```dart
// Seek to position
await _api.seek(deviceUdn, TimePosition(seconds: 300));
```
```

--------------------------------

### Volume Control Pattern

Source: https://pub.dev/packages/media_cast_dlna/versions/0.2.0

Shows how to manage volume levels, including setting volume, retrieving volume information, and toggling mute.

```APIDOC
## Volume Control Pattern

### Set Volume Level

```dart
// Set volume level
await _api.setVolume(deviceUdn, VolumeLevel(percentage: 75));
```

### Get Volume Info

```dart
// Get current volume info
final volumeInfo = await _api.getVolumeInfo(deviceUdn);
print('Current volume: ${volumeInfo.level.percentage}%');
print('Is muted: ${volumeInfo.muteState.isMuted}');
```

### Toggle Mute

```dart
// Toggle mute
await _api.setMute(deviceUdn, MuteOperation(shouldMute: true));
```
```

--------------------------------

### Get Media Renderers

Source: https://pub.dev/packages/media_cast_dlna

Filters the list of discovered devices to return only those that are media renderers, meaning they can play content.

```APIDOC
## getMediaRenderers()

### Description
Returns a list of discovered DLNA devices that are identified as media renderers.

### Method
```dart
List<DlnaDevice> getMediaRenderers()
```

### Parameters
None

### Response
- **List<DlnaDevice>**: A list of `DlnaDevice` objects representing media renderers.
```

--------------------------------

### Device Discovery Pattern

Source: https://pub.dev/packages/media_cast_dlna/versions/0.2.0

Demonstrates how to initiate and manage device discovery using the MediaCast DLNA API.

```APIDOC
## Discovery Pattern

### Start Discovery

```dart
// Start discovery with typed options
await _api.startDiscovery(
  DiscoveryOptions(
    timeout: DiscoveryTimeout(seconds: 15),
    searchTarget: SearchTarget(target: 'upnp:rootdevice'),
  ),
);
```

### Get Discovered Devices

```dart
// Get discovered devices
final devices = await _api.getDiscoveredDevices();
```

### Stop Discovery

```dart
// Stop discovery
await _api.stopDiscovery();
```
```

--------------------------------

### Import media_cast_dlna in Dart

Source: https://pub.dev/packages/media_cast_dlna/install

Import the media_cast_dlna package into your Dart files to start using its functionalities for DLNA/UPnP media casting.

```dart
import 'package:media_cast_dlna/media_cast_dlna.dart';
```

--------------------------------

### Core API Methods

Source: https://pub.dev/packages/media_cast_dlna/versions/0.1.3

This section details the core methods available in the `MediaCastDlna` class for managing DLNA operations, including service initialization, device discovery, and retrieval of discovered devices.

```APIDOC
## Core API Methods

### `MediaCastDlna` Class

Main plugin class for DLNA operations.

**Methods:**

*   `initializeUpnpService()` - Initialize the UPnP service
*   `isUpnpServiceInitialized()` - Check if service is ready
*   `startDiscovery(options)` - Start device discovery
*   `stopDiscovery()` - Stop device discovery
*   `getDiscoveredDevices()` - Get list of discovered devices
```

--------------------------------

### Cast Media to a DLNA Device

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Casts media content to a specified DLNA renderer. It creates video metadata and then sets the media URI and starts playback.

```dart
Future<void> _castMedia(DlnaDevice renderer, String mediaUrl) async {
  try {
    // Create video metadata using the new typed classes
    final metadata = VideoMetadata(
      title: 'My Awesome Video',
      duration: TimeDuration(seconds: 7200), // 2 hours
      resolution: '1920x1080',
      genre: 'Entertainment',
      upnpClass: 'object.item.videoItem.movie',
    );
    
    // Set the media URI on the renderer
    await _api.setMediaUri(
      renderer.udn,
      Url(value: mediaUrl),
      metadata,
    );
    
    // Start playback
    await _api.play(renderer.udn);
    
    print('✅ Media cast successfully!');
    
  } catch (e) {
    print('❌ Failed to cast media: $e');
  }
}

```

--------------------------------

### Build Main Application UI

Source: https://pub.dev/packages/media_cast_dlna/example

Constructs the main UI of the application, including the app bar with device connection controls and the main content area with device selection, playback controls, and test media widgets. The content is displayed using a CustomScrollView with slivers.

```dart
@override
Widget build(BuildContext context) {
  return Scaffold(
    appBar: AppBar(
      title: const Text(AppConstants.appTitle),
      backgroundColor: Theme.of(context).colorScheme.primary,
      foregroundColor: Colors.white,
      actions: [
        IconButton(
          icon: Icon(
            _selectedDevice != null ? Icons.cast_connected : Icons.cast,
          ),
          onPressed: () {
            if (_selectedDevice != null) {
              // Stop monitoring timers and reset selected renderer
              _mediaService.stopMonitoring();
              setState(() {
                _selectedDevice = null;
                _supportedSpeedOptions = _defaultSpeedOptions;
              });
            } else {
              _showCastDevicesModal();
            }
          },
          tooltip: _selectedDevice != null
              ? 'Disconnect from device'
              : 'Cast to device',
        ),
      ],
    ),
    body: CustomScrollView(
      slivers: [
        SliverToBoxAdapter(
          child: DeviceSelectionWidget(
            selectedDevice: _selectedDevice,
            isOnline: _connectivityState.isOnline,
            lastConnectivityCheck: _connectivityState.lastConnectivityCheck,
            onCastPressed: _showCastDevicesModal,
          ),
        ),
        if (_selectedDevice?.udn != null) ...[
          const SliverToBoxAdapter(child: Divider()),
          SliverToBoxAdapter(
            child: PlaybackControlWidget(
              playbackState: _playbackState,
              isDeviceOnline: _connectivityState.isOnline,
              onPlaybackControl: _onPlaybackControl,
              onVolumeChange: _onVolumeChange,
              onSeek: _onSeek,
              onToggleMute: _onToggleMute,
              onSliderDragChanged: _onSliderDragChanged,
              onSpeedChange: _onSpeedChange,
              speedOptions: _supportedSpeedOptions,
            ),
          ),
          SliverToBoxAdapter(
            child: TestMediaWidget(
              isDeviceOnline: _connectivityState.isOnline,
              onPlayMedia: _onPlayTestMedia,
              onPlayCustomUrl: _onPlayCustomUrl,
              customUrlController: _customUrlController,
            ),
          ),
        ],
      ],
    ),
  );
}
```

--------------------------------

### Initialize Media Cast DLNA Plugin

Source: https://pub.dev/packages/media_cast_dlna/versions/0.3.1

Initializes the UPnP service for the Media Cast DLNA plugin. Call this early in your application's lifecycle.

```dart
Future<void> _initializePlugin() async {
    try {
      await _api.initializeUpnpService();
      print('✅ Media Cast DLNA initialized successfully');
    } catch (e) {
      print('❌ Initialization failed: $e');
    }
  }
```
Tokens:
Raw