### PreviewMediaWidget Examples (Dart)

Source: https://context7.com/enough-software/enough_media/llms.txt

Demonstrates various use cases of the PreviewMediaWidget, including basic previews, interactive navigation with hero animations, context menus, and custom builders. This widget is part of the 'enough_media' Flutter package and requires 'flutter/material.dart'.

```dart
import 'package:enough_media/enough_media.dart';
import 'package:flutter/material.dart';
import 'dart:typed_data';

class MediaPreviewExample extends StatelessWidget {
  final Uint8List imageData;

  const MediaPreviewExample({required this.imageData});

  @override
  Widget build(BuildContext context) {
    // Basic preview with fixed dimensions
    final basicProvider = MemoryMediaProvider('image.png', 'image/png', imageData);
    final basicPreview = PreviewMediaWidget(
      mediaProvider: basicProvider,
      width: 150,
      height: 150,
    );

    // Preview with interactive navigation and hero animation
    final interactiveProvider = MemoryMediaProvider('photo.jpg', 'image/jpeg', imageData);
    final interactivePreview = PreviewMediaWidget(
      mediaProvider: interactiveProvider,
      width: 200,
      height: 200,
      showInteractiveDelegate: (interactiveWidget) {
        return Navigator.of(context).push(
          MaterialPageRoute(
            builder: (_) => Scaffold(
              appBar: AppBar(title: Text('Full View')),
              body: interactiveWidget,
            ),
          ),
        );
      },
      useHeroAnimation: true,
    );

    // Preview with context menu
    final contextMenuProvider = MemoryMediaProvider('doc.pdf', 'application/pdf', imageData);
    final contextMenuPreview = PreviewMediaWidget(
      mediaProvider: contextMenuProvider,
      contextMenuEntries: [
        PopupMenuItem(value: 'share', child: Text('Share')),
        PopupMenuItem(value: 'download', child: Text('Download')),
        PopupMenuItem(value: 'delete', child: Text('Delete')),
      ],
      onContextMenuSelected: (provider, entry) {
        if (entry.value == 'share') {
          print('Sharing ${provider.name}');
        } else if (entry.value == 'download') {
          print('Downloading ${provider.name}');
        }
      },
    );

    // Preview with custom builder
    final customPreview = PreviewMediaWidget(
      mediaProvider: basicProvider,
      builder: (context, provider) {
        if (provider.mediaType == 'application/pdf') {
          return Container(
            width: 100,
            height: 100,
            color: Colors.red,
            child: Icon(Icons.picture_as_pdf),
          );
        }
        return null; // Use default preview
      },
      fallbackBuilder: (context, provider) {
        return Container(
          child: Column(
            children: [
              Icon(Icons.insert_drive_file),
              Text(provider.name),
            ],
          ),
        );
      },
    );

    return Column(children: [
      basicPreview,
      interactivePreview,
      contextMenuPreview,
      customPreview,
    ]);
  }
}

```

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

### Enough Media: Convert Media Providers Between Types (Memory, URL, Asset)

Source: https://context7.com/enough-software/enough_media/llms.txt

This example demonstrates how to create and convert media providers between different types, such as MemoryMediaProvider, UrlMediaProvider, and AssetMediaProvider. This allows for flexible data handling and format transformations, including downloading content from URLs, loading from assets, and converting between binary, text, and memory formats. It requires the 'enough_media' package and 'dart:convert' for text encoding.

```dart
import 'package:enough_media/enough_media.dart';
import 'dart:typed_data';
import 'dart:convert';

Future<void> providerConversionExample() async {
  // Create from binary data
  final imageBytes = Uint8List.fromList([0xFF, 0xD8, 0xFF /* ... */]);
  final memoryProvider = MemoryMediaProvider(
    'photo.jpg',
    'image/jpeg',
    imageBytes,
    description: 'Profile photo',
  );

  // Convert URL provider to memory (downloads content)
  final urlProvider = UrlMediaProvider(
    'document.txt',
    'text/plain',
    'https://example.com/doc.txt',
  );

  try {
    final memoryVersion = await urlProvider.toMemoryProvider();
    print('Downloaded ${memoryVersion.size} bytes');

    // Convert to text provider
    final textVersion = await memoryVersion.toTextProvider();
    print('Content: ${textVersion.text}');
  } catch (e) {
    print('Error: $e');
  }

  // Convert asset to memory (loads from bundle)
  final assetProvider = AssetMediaProvider(
    'config.json',
    'application/json',
    'assets/config.json',
  );

  final assetMemory = await assetProvider.toMemoryProvider();
  final jsonText = utf8.decode(assetMemory.data);
  print('JSON: $jsonText');

  // Chain conversions
  final urlToText = await UrlMediaProvider(
    'readme.md',
    'text/markdown',
    'https://raw.githubusercontent.com/example/README.md',
  ).toTextProvider();

  print('Markdown content: ${urlToText.text}');
}
```

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

### Untitled

No description

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

### Build Media Preview Widget with Memory Provider

Source: https://github.com/enough-software/enough_media/blob/main/README.md

This function demonstrates how to build a preview widget for media stored in memory. It utilizes the MemoryMediaProvider and the PreviewMediaWidget from the enough_media package. The input consists of media name, MIME type, and raw data as Uint8List.

```dart
import 'package:enough_media/enough_media.dart';
import 'dart:typed_data';
import 'package:flutter/material.dart';


/// Preview media.
Widget buildPreview(String name, String mimeType, Uint8List data) {
  final mediaProvider = MemoryMediaProvider(name, mimeType, data);
  return PreviewMediaWidget(
    mediaProvider: mediaProvider,
  );
}

/// Preview media and let enough_media move to the interactive experience with a Hero-based animation:
Widget buildPreviewWithShowInteractiveDelegate(
    BuildContext context, String name, String mimeType, Uint8List data) {
  final mediaProvider = MemoryMediaProvider(name, mimeType, data);
  return PreviewMediaWidget(
    mediaProvider: mediaProvider,
    showInteractiveDelegate: (media) => Navigator.of(context)
        .push(MaterialPageRoute(builder: (_) => Scaffold(body: media))),
  );
}
```

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

### Build Interactive Media Widget with Memory Provider

Source: https://github.com/enough-software/enough_media/blob/main/README.md

This function shows how to construct an interactive media widget for near-fullscreen experiences using media data from memory. It leverages the MemoryMediaProvider and InteractiveMediaWidget. The function takes the media's name, MIME type, and raw data (Uint8List) as input.

```dart
import 'package:enough_media/enough_media.dart';
import 'dart:typed_data';
import 'package:flutter/material.dart';


/// Provide interactive media, typically for near-fullscreen experiences:
Widget buildInteractive(String name, String mimeType, Uint8List data) {
  final mediaProvider = MemoryMediaProvider(name, mimeType, data);
  return InteractiveMediaWidget(
    mediaProvider: mediaProvider,
  );
}
```

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

### Dart: Implement Media Gallery with Preview and Fullscreen

Source: https://context7.com/enough-software/enough_media/llms.txt

This Dart code implements a media gallery using Flutter and the enough_media package. It displays a grid of media previews, allows opening them in fullscreen with interactive widgets, and supports context menu actions like displaying info and downloading. Dependencies include flutter, material, and dart:typed_data.

```dart
import 'package:enough_media/enough_media.dart';
import 'package:flutter/material.dart';
import 'dart:typed_data';

class MediaGalleryApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MediaGalleryScreen(),
    );
  }
}

class MediaGalleryScreen extends StatelessWidget {
  final List<MediaProvider> mediaItems = [
    UrlMediaProvider(
      'sunset.jpg',
      'image/jpeg',
      'https://example.com/sunset.jpg',
      description: 'Beautiful sunset',
    ),
    UrlMediaProvider(
      'intro.mp4',
      'video/mp4',
      'https://example.com/intro.mp4',
    ),
    AssetMediaProvider(
      'guide.pdf',
      'application/pdf',
      'assets/guide.pdf',
    ),
    MemoryMediaProvider(
      'notes.txt',
      'text/plain',
      Uint8List.fromList(utf8.encode('Sample notes content')),
    ),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Media Gallery'),
      ),
      body: GridView.builder(
        padding: EdgeInsets.all(8),
        gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
          crossAxisCount: 3,
          crossAxisSpacing: 8,
          mainAxisSpacing: 8,
        ),
        itemCount: mediaItems.length,
        itemBuilder: (context, index) {
          final provider = mediaItems[index];
          return PreviewMediaWidget(
            mediaProvider: provider,
            width: 100,
            height: 100,
            showInteractiveDelegate: (interactiveWidget) {
              return Navigator.of(context).push(
                MaterialPageRoute(
                  builder: (_) => Scaffold(
                    appBar: AppBar(
                      title: Text(provider.name),
                      actions: [
                        IconButton(
                          icon: Icon(Icons.share),
                          onPressed: () {
                            print('Share ${provider.name}');
                          },
                        ),
                      ],
                    ),
                    body: interactiveWidget,
                  ),
                ),
              );
            },
            useHeroAnimation: true,
            contextMenuEntries: [
              PopupMenuItem(
                value: 'info',
                child: ListTile(
                  leading: Icon(Icons.info),
                  title: Text('Info'),
                ),
              ),
              PopupMenuItem(
                value: 'download',
                child: ListTile(
                  leading: Icon(Icons.download),
                  title: Text('Download'),
                ),
              ),
            ],
            onContextMenuSelected: (provider, entry) async {
              if (entry.value == 'info') {
                showDialog(
                  context: context,
                  builder: (_) => AlertDialog(
                    title: Text(provider.name),
                    content: Text(
                      'Type: ${provider.mediaType}\n'
                      'Size: ${provider.size ?? "unknown"} bytes\n'
                      'Description: ${provider.description ?? "none"}',
                    ),
                  ),
                );
              } else if (entry.value == 'download') {
                final memory = await provider.toMemoryProvider();
                print('Downloaded ${memory.data.length} bytes');
              }
            },
            fallbackBuilder: (context, provider) {
              return Container(
                color: Colors.grey[300],
                child: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: [
                    Icon(Icons.insert_drive_file, size: 40),
                    Text(
                      provider.name,
                      textAlign: TextAlign.center,
                      style: TextStyle(fontSize: 10),
                    ),
                  ],
                ),
              );
            },
          );
        },
      ),
    );
  }
}

```

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

### Creating and Using MediaProviders in Flutter

Source: https://context7.com/enough-software/enough_media/llms.txt

Demonstrates how to create and utilize different MediaProvider classes (Memory, URL, Asset, Text) in Flutter. It shows how to initialize providers with data sources, check media types, and perform conversions between provider types. This snippet is essential for handling diverse media sources within the enough_media framework.

```dart
import 'package:enough_media/enough_media.dart';
import 'dart:typed_data';

// Memory-based provider for in-memory data
final imageData = Uint8List.fromList([/* image bytes */]);
final memoryProvider = MemoryMediaProvider('photo.jpg', 'image/jpeg', imageData);
print('Is image: ${memoryProvider.isImage}'); // true
print('Size: ${memoryProvider.size} bytes');

// URL-based provider for remote media
final urlProvider = UrlMediaProvider(
  'video.mp4',
  'video/mp4',
  'https://example.com/media/video.mp4',
  size: 1024000,
  description: 'Sample video',
);

// Asset-based provider for bundled resources
final assetProvider = AssetMediaProvider(
  'document.pdf',
  'application/pdf',
  'assets/documents/sample.pdf',
);

// Text-based provider
final textProvider = TextMediaProvider(
  'readme.txt',
  'text/plain',
  'This is the file content',
);

// Check media types
if (urlProvider.isVideo) {
  print('This is a video file');
}

// Convert between provider types
try {
  final textContent = await urlProvider.toTextProvider();
  print('Text content: ${textContent.text}');

  final memoryVersion = await assetProvider.toMemoryProvider();
  print('Loaded ${memoryVersion.data.length} bytes');
} catch (e) {
  print('Conversion failed: $e');
}
```

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

### Untitled

No description

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

### Untitled

No description

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

### Untitled

No description

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

### Build Media Widget by Type - Dart

Source: https://context7.com/enough-software/enough_media/llms.txt

Dynamically builds a Flutter widget based on the detected media type from a MediaProvider. It handles images, videos, audio, text, PDFs, generic applications, and unsupported types, returning specific UI components for each. Dependencies include 'enough_media' and 'flutter/material'.

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

class MediaTypeHandler {
  static Widget buildMediaWidget(BuildContext context, MediaProvider provider) {
    // Check media type using built-in helpers
    if (provider.isImage) {
      return _buildImageMedia(context, provider);
    } else if (provider.isVideo) {
      return _buildVideoMedia(context, provider);
    } else if (provider.isAudio) {
      return _buildAudioMedia(context, provider);
    } else if (provider.isText) {
      return _buildTextMedia(context, provider);
    } else if (provider.mediaType == 'application/pdf') {
      return _buildPdfMedia(context, provider);
    } else if (provider.isApplication) {
      return _buildGenericApplicationMedia(context, provider);
    } else {
      return _buildUnsupportedMedia(context, provider);
    }
  }

  static Widget _buildImageMedia(BuildContext context, MediaProvider provider) {
    return InteractiveMediaWidget(
      mediaProvider: provider,
      heroTag: provider,
    );
  }

  static Widget _buildVideoMedia(BuildContext context, MediaProvider provider) {
    return Container(
      color: Colors.black,
      child: InteractiveMediaWidget(mediaProvider: provider),
    );
  }

  static Widget _buildAudioMedia(BuildContext context, MediaProvider provider) {
    return Scaffold(
      appBar: AppBar(title: Text(provider.name)),
      body: Center(
        child: InteractiveMediaWidget(mediaProvider: provider),
      ),
    );
  }

  static Widget _buildTextMedia(BuildContext context, MediaProvider provider) {
    return Scaffold(
      appBar: AppBar(title: Text(provider.name)),
      body: SingleChildScrollView(
        padding: EdgeInsets.all(16),
        child: InteractiveMediaWidget(mediaProvider: provider),
      ),
    );
  }

  static Widget _buildPdfMedia(BuildContext context, MediaProvider provider) {
    return InteractiveMediaWidget(mediaProvider: provider);
  }

  static Widget _buildGenericApplicationMedia(
      BuildContext context, MediaProvider provider) {
    return Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Icon(Icons.insert_drive_file, size: 64),
          SizedBox(height: 16),
          Text(provider.name, style: Theme.of(context).textTheme.titleLarge),
          Text(provider.mediaType),
          if (provider.description != null) ...[
            SizedBox(height: 8),
            Text(provider.description!),
          ],
        ],
      ),
    );
  }

  static Widget _buildUnsupportedMedia(
      BuildContext context, MediaProvider provider) {
    return Center(
      child: Text(
        'Unsupported media type: ${provider.mediaType}',
        style: TextStyle(color: Colors.red),
      ),
    );
  }

  // Preview with fallback
  static Widget buildPreviewWithFallback(
      BuildContext context, MediaProvider provider) {
    return PreviewMediaWidget(
      mediaProvider: provider,
      width: 120,
      height: 120,
      fallbackBuilder: (context, provider) {
        IconData icon;
        if (provider.isVideo) {
          icon = Icons.video_library;
        } else if (provider.isAudio) {
          icon = Icons.audio_file;
        } else if (provider.mediaType == 'application/pdf') {
          icon = Icons.picture_as_pdf;
        } else {
          icon = Icons.insert_drive_file;
        }

        return Container(
          width: 120,
          height: 120,
          decoration: BoxDecoration(
            color: Colors.grey[200],
            borderRadius: BorderRadius.circular(8),
          ),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Icon(icon, size: 48, color: Colors.grey[600]),
              SizedBox(height: 8),
              Text(
                provider.name,
                style: TextStyle(fontSize: 10),
                textAlign: TextAlign.center,
                maxLines: 2,
                overflow: TextOverflow.ellipsis,
              ),
            ],
          ),
        );
      },
    );
  }
}
```

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

### Untitled

No description

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

### Untitled

No description

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

### InteractiveMediaWidget: Display Various Media Types in Flutter

Source: https://context7.com/enough-software/enough_media/llms.txt

The InteractiveMediaWidget displays images, videos, audio, PDFs, and text, with built-in support for zooming, playback controls, and custom rendering. It automatically selects the appropriate viewer based on the media type. Dependencies include 'enough_media', 'flutter/material', and specific viewer packages like 'photo_view' and 'chewie'. It accepts a 'mediaProvider' as input and optionally a 'heroTag', 'builder', and 'fallbackBuilder' for customization.

```dart
import 'package:enough_media/enough_media.dart';
import 'package:flutter/material.dart';
import 'dart:typed_data';

class InteractiveMediaExample extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // Image with zoom and pan (uses PhotoView)
    final imageData = Uint8List.fromList([/* image bytes */]);
    final imageProvider = MemoryMediaProvider('photo.jpg', 'image/jpeg', imageData);
    final imageWidget = InteractiveMediaWidget(
      mediaProvider: imageProvider,
    );

    // Video with playback controls (uses Chewie)
    final videoProvider = UrlMediaProvider(
      'video.mp4',
      'video/mp4',
      'https://example.com/sample.mp4',
    );
    final videoWidget = InteractiveMediaWidget(
      mediaProvider: videoProvider,
    );

    // Audio player (uses ChewieAudio)
    final audioProvider = UrlMediaProvider(
      'song.mp3',
      'audio/mpeg',
      'https://example.com/audio.mp3',
    );
    final audioWidget = InteractiveMediaWidget(
      mediaProvider: audioProvider,
    );

    // PDF viewer (uses pdfrx)
    final pdfProvider = AssetMediaProvider(
      'manual.pdf',
      'application/pdf',
      'assets/manual.pdf',
    );
    final pdfWidget = InteractiveMediaWidget(
      mediaProvider: pdfProvider,
    );

    // Text display with selection
    final textProvider = TextMediaProvider(
      'notes.txt',
      'text/plain',
      'This is selectable text content that users can copy.',
    );
    final textWidget = InteractiveMediaWidget(
      mediaProvider: textProvider,
    );

    // With hero animation for smooth transitions
    final heroProvider = MemoryMediaProvider('image.png', 'image/png', imageData);
    final heroWidget = InteractiveMediaWidget(
      mediaProvider: heroProvider,
      heroTag: heroProvider, // Use provider as unique tag
    );

    // Custom builder for specific media types
    final customWidget = InteractiveMediaWidget(
      mediaProvider: imageProvider,
      builder: (context, provider) {
        if (provider.mediaType.contains('custom')) {
          return Text('Custom media handler');
        }
        return null; // Use default handler
      },
      fallbackBuilder: (context, provider) {
        return Center(
          child: Text(
            'Unsupported: ${provider.mediaType}\n${provider.name}',
            textAlign: TextAlign.center,
          ),
        );
      },
    );

    // Full example in scaffold
    return Scaffold(
      appBar: AppBar(title: Text('Media Viewer')),
      body: InteractiveMediaWidget(
        mediaProvider: imageProvider,
        heroTag: 'media-hero',
      ),
    );
  }
}
```

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

### Untitled

No description

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.