PACKET v1.0.0 - Initial release

App móvil Flutter para capturar contenido multimedia, etiquetarlo con hashes y enviarlo a backends configurables.

Features:
- Captura de fotos, audio, video y archivos
- Sistema de etiquetas con bibliotecas externas (HST)
- Packs de etiquetas predefinidos
- Cola de reintentos (hasta 20 contenedores)
- Soporte GPS
- Hash SHA-256 auto-generado por contenedor
- Persistencia SQLite local
- Múltiples destinos configurables

Stack: Flutter 3.38.5, flutter_bloc, sqflite, dio

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

lib/presentation/bloc/captura/captura_cubit.dart

@@ -0,0 +1,191 @@
+import 'dart:typed_data';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:geolocator/geolocator.dart';
+import 'package:image_picker/image_picker.dart';
+import 'package:file_picker/file_picker.dart';
+import '../../../core/utils/hash_utils.dart';
+import '../../../data/repositories/contenedor_repository.dart';
+import '../../../domain/entities/archivo_adjunto.dart';
+import '../../../domain/entities/contenedor.dart';
+import '../../../domain/entities/destino.dart';
+import '../../../domain/entities/gps_location.dart';
+import 'captura_state.dart';
+
+class CapturaCubit extends Cubit<CapturaState> {
+  final ContenedorRepository _repo = ContenedorRepository();
+  final ImagePicker _picker = ImagePicker();
+
+  CapturaCubit()
+      : super(CapturaState(
+          contenedor: Contenedor(hash: HashUtils.generateHash()),
+        ));
+
+  void regenerateHash() {
+    emit(state.copyWith(
+      contenedor: state.contenedor.copyWith(hash: HashUtils.generateHash()),
+    ));
+  }
+
+  void setTitulo(String titulo) {
+    emit(state.copyWith(
+      contenedor: state.contenedor.copyWith(titulo: titulo.isEmpty ? null : titulo),
+    ));
+  }
+
+  void setDescripcion(String descripcion) {
+    emit(state.copyWith(
+      contenedor: state.contenedor.copyWith(
+        descripcion: descripcion.isEmpty ? null : descripcion,
+      ),
+    ));
+  }
+
+  Future<void> capturePhoto() async {
+    try {
+      final image = await _picker.pickImage(source: ImageSource.camera);
+      if (image == null) return;
+
+      final bytes = await image.readAsBytes();
+      final archivo = ArchivoAdjunto(
+        nombre: image.name,
+        mimeType: 'image/jpeg',
+        bytes: bytes,
+        tipo: ArchivoTipo.image,
+        hash: HashUtils.hashFromBytes(bytes),
+      );
+      emit(state.addArchivo(archivo));
+    } catch (e) {
+      emit(state.copyWith(
+        status: CapturaStatus.error,
+        errorMessage: 'Error al capturar foto: $e',
+      ));
+    }
+  }
+
+  Future<void> captureVideo() async {
+    try {
+      final video = await _picker.pickVideo(source: ImageSource.camera);
+      if (video == null) return;
+
+      final bytes = await video.readAsBytes();
+      final archivo = ArchivoAdjunto(
+        nombre: video.name,
+        mimeType: 'video/mp4',
+        bytes: bytes,
+        tipo: ArchivoTipo.video,
+        hash: HashUtils.hashFromBytes(bytes),
+      );
+      emit(state.addArchivo(archivo));
+    } catch (e) {
+      emit(state.copyWith(
+        status: CapturaStatus.error,
+        errorMessage: 'Error al capturar video: $e',
+      ));
+    }
+  }
+
+  Future<void> pickFile() async {
+    try {
+      final result = await FilePicker.platform.pickFiles(withData: true);
+      if (result == null || result.files.isEmpty) return;
+
+      final file = result.files.first;
+      if (file.bytes == null) return;
+
+      final archivo = ArchivoAdjunto(
+        nombre: file.name,
+        mimeType: _getMimeType(file.extension),
+        bytes: file.bytes!,
+        tipo: ArchivoTipo.document,
+        hash: HashUtils.hashFromBytes(file.bytes!),
+      );
+      emit(state.addArchivo(archivo));
+    } catch (e) {
+      emit(state.copyWith(
+        status: CapturaStatus.error,
+        errorMessage: 'Error al seleccionar archivo: $e',
+      ));
+    }
+  }
+
+  void addAudioFile(Uint8List bytes, String nombre) {
+    final archivo = ArchivoAdjunto(
+      nombre: nombre,
+      mimeType: 'audio/m4a',
+      bytes: bytes,
+      tipo: ArchivoTipo.audio,
+      hash: HashUtils.hashFromBytes(bytes),
+    );
+    emit(state.addArchivo(archivo));
+  }
+
+  void removeArchivo(int index) {
+    emit(state.removeArchivo(index));
+  }
+
+  Future<void> captureGps() async {
+    try {
+      final permission = await Geolocator.checkPermission();
+      if (permission == LocationPermission.denied) {
+        await Geolocator.requestPermission();
+      }
+
+      final position = await Geolocator.getCurrentPosition();
+      final gps = GpsLocation(lat: position.latitude, long: position.longitude);
+      emit(state.setGps(gps));
+    } catch (e) {
+      emit(state.copyWith(
+        status: CapturaStatus.error,
+        errorMessage: 'Error al obtener GPS: $e',
+      ));
+    }
+  }
+
+  void clearGps() {
+    emit(state.setGps(null));
+  }
+
+  void setEtiquetas(List<String> etiquetas) {
+    emit(state.setEtiquetas(etiquetas));
+  }
+
+  Future<void> enviar(Destino destino) async {
+    emit(state.copyWith(status: CapturaStatus.sending));
+    try {
+      await _repo.enviar(state.contenedor, destino);
+      emit(state.copyWith(status: CapturaStatus.success));
+      reset();
+    } catch (e) {
+      emit(state.copyWith(
+        status: CapturaStatus.error,
+        errorMessage: 'Error al enviar: $e',
+      ));
+    }
+  }
+
+  void reset() {
+    emit(CapturaState(
+      contenedor: Contenedor(hash: HashUtils.generateHash()),
+    ));
+  }
+
+  String _getMimeType(String? extension) {
+    switch (extension?.toLowerCase()) {
+      case 'pdf':
+        return 'application/pdf';
+      case 'doc':
+      case 'docx':
+        return 'application/msword';
+      case 'xls':
+      case 'xlsx':
+        return 'application/vnd.ms-excel';
+      case 'png':
+        return 'image/png';
+      case 'jpg':
+      case 'jpeg':
+        return 'image/jpeg';
+      default:
+        return 'application/octet-stream';
+    }
+  }
+}