diff --git a/android/app/src/main/kotlin/com/mossapps/flick/MainActivity.kt b/android/app/src/main/kotlin/com/mossapps/flick/MainActivity.kt index a8b69720..5b2f33f4 100644 --- a/android/app/src/main/kotlin/com/mossapps/flick/MainActivity.kt +++ b/android/app/src/main/kotlin/com/mossapps/flick/MainActivity.kt @@ -4667,6 +4667,23 @@ class MainActivity: FlutterActivity() { ) } + private fun isPhysicalAudioOutput(device: AudioDeviceInfo): Boolean { + return when (device.type) { + AudioDeviceInfo.TYPE_USB_DEVICE, + AudioDeviceInfo.TYPE_USB_HEADSET, + AudioDeviceInfo.TYPE_WIRED_HEADSET, + AudioDeviceInfo.TYPE_WIRED_HEADPHONES, + AudioDeviceInfo.TYPE_LINE_ANALOG, + AudioDeviceInfo.TYPE_LINE_DIGITAL, + AudioDeviceInfo.TYPE_AUX_LINE, + AudioDeviceInfo.TYPE_HDMI, + AudioDeviceInfo.TYPE_HDMI_ARC, + AudioDeviceInfo.TYPE_HDMI_EARC, + AudioDeviceInfo.TYPE_DOCK -> true + else -> false + } + } + private fun getPlaybackDeviceInfo(): Map { val audioManager = getSystemService(Context.AUDIO_SERVICE) as? AudioManager val outputs = if (audioManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { @@ -4678,18 +4695,47 @@ class MainActivity: FlutterActivity() { device.type == AudioDeviceInfo.TYPE_USB_DEVICE || device.type == AudioDeviceInfo.TYPE_USB_HEADSET } + val physicalOutputs = outputs.filter { device -> isPhysicalAudioOutput(device) } + val preferredPhysicalOutput = physicalOutputs.minByOrNull { device -> + outputRoutePriority(device.type) + } + val hasWiredAudioRoute = physicalOutputs.any { device -> + routeTypeForAudioDevice(device.type) == "wired" + } val route = describeCurrentOutputRoute(audioManager) val usbManager = getSystemService(Context.USB_SERVICE) as? UsbManager - val hasAttachedUac2Device = usbManager + val attachedUac2Device = usbManager ?.deviceList ?.values - ?.any { device -> isLikelyUsbAudioDevice(device, route["routeLabel"] as? String) } - ?: false + ?.firstOrNull { device -> isLikelyUsbAudioDevice(device, route["routeLabel"] as? String) } + val hasAttachedUac2Device = attachedUac2Device != null + val physicalOutputType = preferredPhysicalOutput + ?.let { device -> routeTypeForAudioDevice(device.type) } + ?: if (hasAttachedUac2Device) "usb" else null + val physicalOutputId = preferredPhysicalOutput?.id?.toString() + ?: attachedUac2Device?.deviceName + // Android can expose (or remove) its managed audio route after the USB + // broadcast. Keep the physical connection identity independent of that + // route's AudioDeviceInfo.id, including when libusb owns the device. + val physicalOutputConnectionId = attachedUac2Device?.deviceName + ?: preferredPhysicalOutput?.id?.toString() + val physicalOutputLabel = preferredPhysicalOutput?.productName + ?.toString() + ?.takeIf { it.isNotBlank() } + ?: attachedUac2Device?.productName + ?.takeIf { it.isNotBlank() } + ?: (route["routeLabel"] as? String) return mapOf( "hasUsbDac" to (hasUsbAudioRoute || hasAttachedUac2Device), "hasUsbAudioRoute" to hasUsbAudioRoute, "hasAttachedUac2Device" to hasAttachedUac2Device, + "hasWiredAudioRoute" to hasWiredAudioRoute, + "hasPhysicalOutput" to (physicalOutputs.isNotEmpty() || hasAttachedUac2Device), + "physicalOutputType" to physicalOutputType, + "physicalOutputId" to physicalOutputId, + "physicalOutputConnectionId" to physicalOutputConnectionId, + "physicalOutputLabel" to physicalOutputLabel, "manufacturer" to Build.MANUFACTURER, "model" to Build.MODEL, "routeType" to route["routeType"], @@ -5583,10 +5629,12 @@ class MainActivity: FlutterActivity() { // (e.g. re-pin from speaker to the 3.5mm jack when headphones // are plugged in mid-playback). priorityAnchorService.updateRouteDevice() + audioDeviceChannel?.invokeMethod("onPlaybackDevicesChanged", null) } override fun onAudioDevicesRemoved(removedDevices: Array) { priorityAnchorService.updateRouteDevice() + audioDeviceChannel?.invokeMethod("onPlaybackDevicesChanged", null) } } try { diff --git a/docs/SPANISH_REVIEW.md b/docs/SPANISH_REVIEW.md new file mode 100644 index 00000000..47618421 --- /dev/null +++ b/docs/SPANISH_REVIEW.md @@ -0,0 +1,36 @@ +# Spanish translation review + +**Draft, not linguistically verified.** The Latin American Spanish translation +is a community contribution from [discussion #368](https://github.com/moss-apps/Flick/discussions/368). +The contributor reports using ChatGPT to assist with translation. Technical +checks and corrections do not replace native-speaker approval. + +## Try it + +1. Open Settings → Interface → Language and select **Español (Latinoamérica)**. +2. The language option marks the translation as a draft pending native-speaker + review, just as Taglish retains its own draft notice. +3. **English** remains a recognizable escape option in every language. +4. With **System default** selected, Spanish device locales (including `es_MX` + and `es_419`) use this same `es` resource. It is Latin American copy, not a + separate regional translation for each Spanish-speaking country. + +The language choice persists across restarts. Taglish's optional Baybayin labels +do not apply to Spanish. + +## Review before treating it as approved + +- [ ] Native speaker checks natural wording, consistency and Latin American usage. +- [ ] Check onboarding, library navigation, settings, player actions and help on + an Android device, including narrow screens and enlarged text. +- [ ] Check count-dependent messages with zero, one and multiple items, especially + identification, playlist sync and duplicate cleanup. +- [ ] Review audio terminology and warnings: bit-perfect bypass, DSP, DSD/DoP, + fixed USB volume and 432/440 tuning must retain their technical meaning. +- [ ] Confirm library-removal and file-deletion warnings remain unambiguous. +- [ ] Confirm switching back to English and restoring the saved choice work on + a device. + +Keep the draft notice until native-speaker review is complete. Automated tests +cover resource parity, arguments, selected wording and language-switch behavior; +they do not approve the translation or replace device testing. diff --git a/lib/features/player/widgets/player_layout_sheet.dart b/lib/features/player/widgets/player_layout_sheet.dart index 6ce01a1a..704c4964 100644 --- a/lib/features/player/widgets/player_layout_sheet.dart +++ b/lib/features/player/widgets/player_layout_sheet.dart @@ -85,13 +85,15 @@ class _PlayerLayoutSheetState extends ConsumerState { color: context.adaptiveTextSecondary, ), const SizedBox(width: 10), - Text( - l10n.playerLayout, - style: TextStyle( - fontFamily: 'GoogleSansFlex', - fontSize: 18, - fontWeight: FontWeight.w600, - color: context.adaptiveTextPrimary, + Expanded( + child: Text( + l10n.playerLayout, + style: TextStyle( + fontFamily: 'GoogleSansFlex', + fontSize: 18, + fontWeight: FontWeight.w600, + color: context.adaptiveTextPrimary, + ), ), ), ], @@ -1543,17 +1545,19 @@ class _PlayerActionButtonSelector extends StatelessWidget { : context.adaptiveTextSecondary, ), const SizedBox(width: 4), - Text( - action.labelFor(l10n), - style: TextStyle( - fontFamily: 'GoogleSansFlex', - fontSize: 12, - fontWeight: isSelected - ? FontWeight.bold - : FontWeight.normal, - color: isSelected - ? AppColors.textPrimary - : context.adaptiveTextSecondary, + Flexible( + child: Text( + action.labelFor(l10n), + style: TextStyle( + fontFamily: 'GoogleSansFlex', + fontSize: 12, + fontWeight: isSelected + ? FontWeight.bold + : FontWeight.normal, + color: isSelected + ? AppColors.textPrimary + : context.adaptiveTextSecondary, + ), ), ), ], diff --git a/lib/features/settings/data/settings_search_catalog.dart b/lib/features/settings/data/settings_search_catalog.dart index 1485b437..d6cc7b29 100644 --- a/lib/features/settings/data/settings_search_catalog.dart +++ b/lib/features/settings/data/settings_search_catalog.dart @@ -321,7 +321,8 @@ List buildSettingsSearchCatalog() { 'language', l10n.language, [], - keywords: 'locale english chinese taglish filipino baybayin', + keywords: + 'locale english chinese spanish español espanol latinoamérica latinoamerica taglish filipino baybayin', ), SettingsSearchSection('interfaceLabel', l10n.interfaceLabel, [ SettingsSearchItem('animations', l10n.animations), @@ -583,6 +584,7 @@ List buildSettingsSearchCatalog() { _section('orbitLayoutProfile', l10n.orbitLayoutProfile, [ ('portrait', l10n.portrait), ('landscape', l10n.landscape), + ('orbitHeaderBoundaryTitle', l10n.orbitHeaderBoundaryTitle), ]), _section('geometry', l10n.geometry, [ ('curvature', l10n.curvature), diff --git a/lib/features/settings/screens/orbit_settings_screen.dart b/lib/features/settings/screens/orbit_settings_screen.dart index 25f8d10b..3a397e4c 100644 --- a/lib/features/settings/screens/orbit_settings_screen.dart +++ b/lib/features/settings/screens/orbit_settings_screen.dart @@ -5,6 +5,7 @@ import 'package:lucide_icons_flutter/lucide_icons.dart'; import 'package:flick/core/constants/app_constants.dart'; import 'package:flick/core/utils/adaptive_layout.dart'; import 'package:flick/providers/app_preferences_provider.dart'; +import 'package:flick/features/settings/widgets/orbit_preview.dart'; import 'package:flick/features/settings/widgets/settings_widgets.dart'; import 'package:flick/l10n/settings_l10n.dart'; @@ -64,6 +65,7 @@ class _OrbitSettingsScreenState extends ConsumerState { return SettingsScaffold( title: l10n.englishForFilipino.customizeOrbital, initialSection: widget.initialSection, + pinnedHeader: OrbitPreview(landscape: _landscape), body: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ @@ -95,6 +97,16 @@ class _OrbitSettingsScreenState extends ConsumerState { ], ), const SizedBox(height: AppConstants.spacingLg), + SettingsCard( + children: [ + InfoSetting( + icon: LucideIcons.panelTop, + title: l10n.englishForFilipino.orbitHeaderBoundaryTitle, + subtitle: l10n.englishForFilipino.orbitHeaderBoundaryBody, + ), + ], + ), + const SizedBox(height: AppConstants.spacingLg), SettingsSectionHeader( l10n.englishForFilipino.geometry, sectionId: 'geometry', diff --git a/lib/features/settings/widgets/language_settings_card.dart b/lib/features/settings/widgets/language_settings_card.dart index bf8a1ccc..789f0f6f 100644 --- a/lib/features/settings/widgets/language_settings_card.dart +++ b/lib/features/settings/widgets/language_settings_card.dart @@ -40,6 +40,14 @@ class LanguageSettingsCard extends StatelessWidget { onTap: () => LocaleController.instance.select(const Locale('en')), ), const SettingsDivider(), + SelectionSetting( + icon: LucideIcons.languages, + title: 'Español (Latinoamérica)', + subtitle: l10n.spanishDraftDescription, + selected: selectedLocale?.languageCode == 'es', + onTap: () => LocaleController.instance.select(const Locale('es')), + ), + const SettingsDivider(), SelectionSetting( icon: LucideIcons.languages, title: 'Taglish', diff --git a/lib/features/settings/widgets/orbit_preview.dart b/lib/features/settings/widgets/orbit_preview.dart new file mode 100644 index 00000000..2bcf40e4 --- /dev/null +++ b/lib/features/settings/widgets/orbit_preview.dart @@ -0,0 +1,717 @@ +import 'dart:math' as math; + +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:lucide_icons_flutter/lucide_icons.dart'; + +import 'package:flick/core/constants/app_constants.dart'; +import 'package:flick/core/theme/adaptive_color_provider.dart'; +import 'package:flick/core/theme/app_colors.dart'; +import 'package:flick/features/settings/widgets/settings_widgets.dart'; +import 'package:flick/features/songs/widgets/orbit_scroll.dart'; +import 'package:flick/l10n/settings_l10n.dart'; +import 'package:flick/models/song.dart'; +import 'package:flick/providers/app_preferences_provider.dart'; +import 'package:flick/providers/songs_provider.dart'; +import 'package:flick/services/app_preferences_service.dart'; + +/// Live, browse-only preview of the orbit settings. +/// +/// The preview paints the library header above the orbit so the top boundary +/// is visible while the controls below change. Tapping cards only moves the +/// preview's focus; it never starts playback or changes the queue. +class OrbitPreview extends ConsumerStatefulWidget { + const OrbitPreview({super.key, required this.landscape}); + + final bool landscape; + + @override + ConsumerState createState() => _OrbitPreviewState(); +} + +class _OrbitPreviewState extends ConsumerState { + bool? _expanded; + int _selectedIndex = -1; + + @override + void didChangeDependencies() { + super.didChangeDependencies(); + _expanded ??= MediaQuery.sizeOf(context).height >= 620; + } + + @override + Widget build(BuildContext context) { + final expanded = _expanded ?? false; + final prefs = ref.watch(appPreferencesProvider); + final songs = expanded ? _songs(ref) : const []; + + return Padding( + padding: const EdgeInsets.fromLTRB( + AppConstants.spacingMd, + 0, + AppConstants.spacingMd, + AppConstants.spacingMd, + ), + child: SettingsCard( + children: [ + _PreviewHeader( + landscape: widget.landscape, + expanded: expanded, + onToggle: () { + setState(() => _expanded = !expanded); + }, + onFullscreen: expanded + ? () => _openFullscreen( + context, + prefs: prefs, + songs: songs, + selectedIndex: _effectiveIndex(songs.length), + ) + : null, + ), + AnimatedSize( + duration: AppConstants.animationNormal, + curve: Curves.easeOutCubic, + alignment: Alignment.topCenter, + child: expanded + ? _ExpandedPreview( + landscape: widget.landscape, + prefs: prefs, + songs: songs, + selectedIndex: _effectiveIndex(songs.length), + onSelectedIndexChanged: (index) { + setState(() => _selectedIndex = index); + }, + ) + : const SizedBox(width: double.infinity), + ), + ], + ), + ); + } + + List _songs(WidgetRef ref) { + final librarySongs = ref.watch(songsProvider).value?.sortedSongs; + if (librarySongs != null && librarySongs.length >= 5) { + return librarySongs.take(40).toList(growable: false); + } + return _demoSongs(); + } + + int _effectiveIndex(int songCount) { + if (songCount == 0) return 0; + if (_selectedIndex < 0) return songCount ~/ 2; + return _selectedIndex.clamp(0, songCount - 1); + } + + List _demoSongs() { + return List.generate(9, (index) { + final number = index + 1; + return Song( + id: 'orbit-preview-$number', + title: '${l10n.preview} $number', + artist: l10n.flickPreview, + album: l10n.flickPreview, + albumArtist: l10n.flickPreview, + duration: const Duration(minutes: 3, seconds: 30), + fileType: 'FLAC', + trackNumber: number, + year: 2026, + ); + }); + } + + void _openFullscreen( + BuildContext context, { + required AppPreferences prefs, + required List songs, + required int selectedIndex, + }) { + Navigator.of(context).push( + PageRouteBuilder( + transitionDuration: AppConstants.animationNormal, + reverseTransitionDuration: AppConstants.animationNormal, + pageBuilder: (context, animation, secondaryAnimation) { + return _FullScreenOrbitPreview( + landscape: widget.landscape, + prefs: prefs, + songs: songs, + selectedIndex: selectedIndex, + onSelectedIndexChanged: (index) { + if (mounted) { + setState(() => _selectedIndex = index); + } + }, + ); + }, + transitionsBuilder: (context, animation, secondaryAnimation, child) { + return FadeTransition(opacity: animation, child: child); + }, + ), + ); + } +} + +class _PreviewHeader extends StatelessWidget { + const _PreviewHeader({ + required this.landscape, + required this.expanded, + required this.onToggle, + this.onFullscreen, + }); + + final bool landscape; + final bool expanded; + final VoidCallback onToggle; + final VoidCallback? onFullscreen; + + @override + Widget build(BuildContext context) { + return Padding( + padding: const EdgeInsets.fromLTRB( + AppConstants.spacingMd, + AppConstants.spacingXs, + AppConstants.spacingXs, + AppConstants.spacingXs, + ), + child: Row( + children: [ + const Icon(LucideIcons.orbit, size: 18, color: AppColors.accent), + const SizedBox(width: AppConstants.spacingSm), + Expanded( + child: Text( + l10n.livePreview, + style: Theme.of(context).textTheme.titleMedium?.copyWith( + color: context.adaptiveTextPrimary, + fontWeight: FontWeight.w600, + ), + ), + ), + Tooltip( + message: landscape ? l10n.landscape : l10n.portrait, + child: Icon( + landscape + ? LucideIcons.rectangleHorizontal + : LucideIcons.rectangleVertical, + size: 16, + color: context.adaptiveTextTertiary, + ), + ), + const SizedBox(width: AppConstants.spacingXxs), + if (onFullscreen != null) + IconButton( + key: const Key('orbit_preview_fullscreen_button'), + tooltip: l10n.fullscreen, + onPressed: onFullscreen, + visualDensity: VisualDensity.compact, + constraints: const BoxConstraints.tightFor(width: 36, height: 36), + padding: EdgeInsets.zero, + icon: Icon( + LucideIcons.maximize2, + size: 18, + color: context.adaptiveTextSecondary, + ), + ), + IconButton( + key: const Key('orbit_preview_toggle'), + tooltip: expanded ? l10n.orbitPreviewHide : l10n.orbitPreviewShow, + onPressed: onToggle, + visualDensity: VisualDensity.compact, + constraints: const BoxConstraints.tightFor(width: 36, height: 36), + padding: EdgeInsets.zero, + icon: Icon( + expanded ? LucideIcons.chevronUp : LucideIcons.chevronDown, + size: 20, + color: context.adaptiveTextSecondary, + ), + ), + ], + ), + ); + } +} + +class _ExpandedPreview extends StatelessWidget { + const _ExpandedPreview({ + required this.landscape, + required this.prefs, + required this.songs, + required this.selectedIndex, + required this.onSelectedIndexChanged, + }); + + final bool landscape; + final AppPreferences prefs; + final List songs; + final int selectedIndex; + final ValueChanged onSelectedIndexChanged; + + @override + Widget build(BuildContext context) { + return Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Padding( + padding: const EdgeInsets.symmetric( + horizontal: AppConstants.spacingSm, + ), + child: SizedBox( + key: const Key('orbit_preview'), + height: _previewHeight(context), + child: Center( + child: FittedBox( + fit: BoxFit.contain, + child: _VirtualLibraryPreview( + landscape: landscape, + prefs: prefs, + songs: songs, + selectedIndex: selectedIndex, + onSelectedIndexChanged: onSelectedIndexChanged, + ), + ), + ), + ), + ), + Padding( + padding: const EdgeInsets.fromLTRB( + AppConstants.spacingLg, + AppConstants.spacingSm, + AppConstants.spacingLg, + AppConstants.spacingMd, + ), + child: Row( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Icon( + LucideIcons.hand, + size: 14, + color: context.adaptiveTextTertiary, + ), + const SizedBox(width: AppConstants.spacingXs), + Expanded( + child: Text( + l10n.orbitPreviewHint, + style: Theme.of(context).textTheme.bodySmall?.copyWith( + color: context.adaptiveTextTertiary, + ), + ), + ), + ], + ), + ), + ], + ); + } + + double _previewHeight(BuildContext context) { + final screenHeight = MediaQuery.sizeOf(context).height; + final minHeight = landscape ? 120.0 : 180.0; + final maxHeight = math.min(340.0, math.max(minHeight, screenHeight - 360)); + final target = screenHeight * (landscape ? 0.42 : 0.36); + return target.clamp(minHeight, maxHeight); + } +} + +class _VirtualLibraryPreview extends StatelessWidget { + const _VirtualLibraryPreview({ + required this.landscape, + required this.prefs, + required this.songs, + required this.selectedIndex, + required this.onSelectedIndexChanged, + }); + + final bool landscape; + final AppPreferences prefs; + final List songs; + final int selectedIndex; + final ValueChanged onSelectedIndexChanged; + + @override + Widget build(BuildContext context) { + final size = landscape ? const Size(844, 360) : const Size(411, 560); + return SizedBox( + width: size.width, + height: size.height, + child: ClipRRect( + borderRadius: BorderRadius.circular(AppConstants.radiusMd), + child: DecoratedBox( + decoration: BoxDecoration( + color: AppColors.background, + border: Border.all(color: AppColors.glassBorderStrong, width: 2), + ), + child: MediaQuery( + data: MediaQuery.of(context).copyWith( + size: size, + padding: EdgeInsets.zero, + viewPadding: EdgeInsets.zero, + viewInsets: EdgeInsets.zero, + devicePixelRatio: 1, + // The preview is already scaled down by the surrounding + // FittedBox. Keep the miniature library at its base text metrics + // so its narrow cards do not overflow; the real settings chrome + // around it still honors the user's text scale. + textScaler: TextScaler.noScaling, + ), + child: Column( + children: [ + _PreviewLibraryHeader( + songCount: songs.length, + compact: landscape, + ), + Expanded( + child: _PreviewOrbit( + landscape: landscape, + prefs: prefs, + songs: songs, + selectedIndex: selectedIndex, + onSelectedIndexChanged: onSelectedIndexChanged, + ), + ), + ], + ), + ), + ), + ), + ); + } +} + +class _PreviewOrbit extends StatelessWidget { + const _PreviewOrbit({ + required this.landscape, + required this.prefs, + required this.songs, + required this.selectedIndex, + required this.onSelectedIndexChanged, + }); + + final bool landscape; + final AppPreferences prefs; + final List songs; + final int selectedIndex; + final ValueChanged onSelectedIndexChanged; + + @override + Widget build(BuildContext context) { + return OrbitScroll( + songs: songs, + selectedIndex: selectedIndex, + scrollDirection: landscape ? Axis.horizontal : Axis.vertical, + radiusRatio: landscape + ? prefs.orbitLandscapeRadiusRatio + : prefs.orbitRadiusRatio, + centerOffsetRatio: prefs.orbitCenterOffsetRatio, + centerYRatio: landscape + ? prefs.orbitLandscapeCenterYRatio + : prefs.orbitCenterYRatio, + itemSpacing: landscape + ? prefs.orbitLandscapeItemSpacing + : prefs.orbitItemSpacing, + selectedScale: landscape + ? prefs.orbitLandscapeSelectedScale + : prefs.orbitSelectedScale, + depth: landscape ? prefs.orbitLandscapeDepth : prefs.orbitDepth, + visibleItems: landscape + ? prefs.orbitLandscapeVisibleItems + : prefs.orbitVisibleItems, + cardArtSize: prefs.orbitCardArtSize, + cardWidthRatio: landscape + ? prefs.orbitLandscapeCardWidthRatio + : prefs.orbitCardWidthRatio, + artResolutionMultiplier: prefs.orbitArtResolutionMultiplier, + showPath: prefs.orbitShowPath, + showGlow: prefs.orbitShowGlow, + swipeActionsEnabled: false, + isSelectionMode: false, + onSelectedIndexChanged: onSelectedIndexChanged, + onSongSelected: onSelectedIndexChanged, + ); + } +} + +class _FullScreenOrbitPreview extends StatefulWidget { + const _FullScreenOrbitPreview({ + required this.landscape, + required this.prefs, + required this.songs, + required this.selectedIndex, + required this.onSelectedIndexChanged, + }); + + final bool landscape; + final AppPreferences prefs; + final List songs; + final int selectedIndex; + final ValueChanged onSelectedIndexChanged; + + @override + State<_FullScreenOrbitPreview> createState() => + _FullScreenOrbitPreviewState(); +} + +class _FullScreenOrbitPreviewState extends State<_FullScreenOrbitPreview> { + late int _selectedIndex = widget.selectedIndex; + + void _select(int index) { + setState(() => _selectedIndex = index); + widget.onSelectedIndexChanged(index); + } + + @override + Widget build(BuildContext context) { + return Scaffold( + backgroundColor: AppColors.background, + body: DecoratedBox( + decoration: const BoxDecoration(gradient: AppColors.backgroundGradient), + child: SafeArea( + bottom: false, + child: Column( + children: [ + _FullScreenPreviewHeader(landscape: widget.landscape), + _PreviewLibraryHeader( + songCount: widget.songs.length, + compact: MediaQuery.sizeOf(context).height < 500, + ), + Expanded( + child: SizedBox.expand( + key: const Key('orbit_preview_fullscreen'), + child: _PreviewOrbit( + landscape: widget.landscape, + prefs: widget.prefs, + songs: widget.songs, + selectedIndex: _selectedIndex, + onSelectedIndexChanged: _select, + ), + ), + ), + ], + ), + ), + ), + ); + } +} + +class _FullScreenPreviewHeader extends StatelessWidget { + const _FullScreenPreviewHeader({required this.landscape}); + + final bool landscape; + + @override + Widget build(BuildContext context) { + return Padding( + padding: const EdgeInsets.fromLTRB( + AppConstants.spacingLg, + AppConstants.spacingXs, + AppConstants.spacingXs, + AppConstants.spacingXxs, + ), + child: Row( + children: [ + const Icon(LucideIcons.orbit, size: 18, color: AppColors.accent), + const SizedBox(width: AppConstants.spacingSm), + Expanded( + child: Text( + l10n.livePreview, + style: Theme.of(context).textTheme.titleMedium?.copyWith( + color: context.adaptiveTextPrimary, + fontWeight: FontWeight.w600, + ), + ), + ), + Tooltip( + message: landscape ? l10n.landscape : l10n.portrait, + child: Container( + padding: const EdgeInsets.symmetric( + horizontal: AppConstants.spacingXs, + vertical: AppConstants.spacingXxs, + ), + decoration: BoxDecoration( + color: AppColors.surface.withValues(alpha: 0.72), + borderRadius: BorderRadius.circular(AppConstants.radiusSm), + border: Border.all(color: AppColors.glassBorder), + ), + child: Row( + mainAxisSize: MainAxisSize.min, + children: [ + Icon( + landscape + ? LucideIcons.rectangleHorizontal + : LucideIcons.rectangleVertical, + size: 14, + color: context.adaptiveTextTertiary, + ), + const SizedBox(width: AppConstants.spacingXxs), + Text( + landscape ? l10n.landscape : l10n.portrait, + style: Theme.of(context).textTheme.labelSmall?.copyWith( + color: context.adaptiveTextSecondary, + ), + ), + ], + ), + ), + ), + const SizedBox(width: AppConstants.spacingXs), + IconButton( + key: const Key('orbit_preview_close'), + tooltip: l10n.closePreview, + onPressed: () => Navigator.of(context).pop(), + visualDensity: VisualDensity.compact, + constraints: const BoxConstraints.tightFor(width: 40, height: 40), + padding: EdgeInsets.zero, + icon: Icon( + LucideIcons.x, + size: 20, + color: context.adaptiveTextSecondary, + ), + ), + ], + ), + ); + } +} + +class _PreviewLibraryHeader extends StatelessWidget { + const _PreviewLibraryHeader({required this.songCount, required this.compact}); + + final int songCount; + final bool compact; + + @override + Widget build(BuildContext context) { + final horizontalPadding = compact ? 16.0 : 20.0; + final buttonSize = compact ? 28.0 : 34.0; + final iconSize = compact ? 15.0 : 17.0; + + return IgnorePointer( + child: ExcludeSemantics( + child: Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Padding( + padding: EdgeInsets.fromLTRB( + horizontalPadding, + compact ? 10 : 14, + horizontalPadding, + compact ? 6 : 10, + ), + child: Row( + children: [ + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + l10n.yourLibrary, + maxLines: 1, + overflow: TextOverflow.ellipsis, + style: Theme.of(context).textTheme.headlineSmall + ?.copyWith( + fontWeight: FontWeight.w600, + color: context.adaptiveTextPrimary, + ), + ), + const SizedBox(height: 2), + Text( + l10n.songs2(songCount), + maxLines: 1, + overflow: TextOverflow.ellipsis, + style: Theme.of(context).textTheme.bodySmall + ?.copyWith(color: context.adaptiveTextSecondary), + ), + ], + ), + ), + _PreviewHeaderButton( + icon: LucideIcons.checkCheck, + size: buttonSize, + iconSize: iconSize, + ), + SizedBox(width: compact ? 6 : 8), + _PreviewHeaderButton( + icon: LucideIcons.shuffle, + size: buttonSize, + iconSize: iconSize, + ), + SizedBox(width: compact ? 6 : 8), + _PreviewHeaderButton( + icon: Icons.sort_rounded, + size: buttonSize, + iconSize: iconSize, + ), + ], + ), + ), + Padding( + padding: EdgeInsets.fromLTRB( + horizontalPadding, + 0, + horizontalPadding, + compact ? 8 : 12, + ), + child: Container( + height: compact ? 38 : 44, + padding: const EdgeInsets.symmetric( + horizontal: AppConstants.spacingSm, + ), + decoration: BoxDecoration( + color: AppColors.surface.withValues(alpha: 0.72), + borderRadius: BorderRadius.circular(AppConstants.radiusMd), + border: Border.all(color: AppColors.glassBorder), + ), + child: Row( + children: [ + const Icon( + LucideIcons.search, + size: 16, + color: AppColors.textTertiary, + ), + const SizedBox(width: AppConstants.spacingXs), + Expanded( + child: Text( + l10n.searchSongsArtists, + maxLines: 1, + overflow: TextOverflow.ellipsis, + style: Theme.of(context).textTheme.bodySmall?.copyWith( + color: context.adaptiveTextTertiary, + ), + ), + ), + ], + ), + ), + ), + ], + ), + ), + ); + } +} + +class _PreviewHeaderButton extends StatelessWidget { + const _PreviewHeaderButton({ + required this.icon, + required this.size, + required this.iconSize, + }); + + final IconData icon; + final double size; + final double iconSize; + + @override + Widget build(BuildContext context) { + return Container( + width: size, + height: size, + decoration: BoxDecoration( + color: AppColors.surfaceLight.withValues(alpha: 0.75), + borderRadius: BorderRadius.circular(AppConstants.radiusSm), + border: Border.all(color: AppColors.glassBorder), + ), + child: Icon(icon, size: iconSize, color: AppColors.textSecondary), + ); + } +} diff --git a/lib/features/settings/widgets/settings_widgets.dart b/lib/features/settings/widgets/settings_widgets.dart index eef6fcf2..93b4a51e 100644 --- a/lib/features/settings/widgets/settings_widgets.dart +++ b/lib/features/settings/widgets/settings_widgets.dart @@ -661,12 +661,16 @@ class SettingsScaffold extends ConsumerWidget { required this.title, required this.body, this.initialSection, + this.pinnedHeader, }); final String title; final Widget body; final String? initialSection; + /// Optional content that stays visible above the scrollable body. + final Widget? pinnedHeader; + @override Widget build(BuildContext context, WidgetRef ref) { final currentSong = ref.watch(currentSongProvider); @@ -690,6 +694,7 @@ class SettingsScaffold extends ConsumerWidget { children: [ _SettingsBackHeader(title: title), const SizedBox(height: AppConstants.spacingMd), + ?pinnedHeader, Expanded( child: SettingsScrollTarget( initialSection: initialSection, diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index a14c45c4..2445409f 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -7203,6 +7203,14 @@ "@orbital": { "description": "lib/models/song_view_mode.dart:17" }, + "orbitHeaderBoundaryBody": "Orbital cards and the orbit path stay below the Your Library heading and search bar. Raising the orbit clips it at this boundary.", + "@orbitHeaderBoundaryBody": { + "description": "Explains that orbit cards and the path stay below the library header and search bar." + }, + "orbitHeaderBoundaryTitle": "Orbit stops at the library header", + "@orbitHeaderBoundaryTitle": { + "description": "Title of the notice about the orbit's top boundary." + }, "orbitLandscapeHint": "Used when the app window is wider than it is tall.", "@orbitLandscapeHint": { "description": "Explains when the landscape orbit profile is applied." @@ -7215,6 +7223,18 @@ "@orbitPortraitHint": { "description": "Explains when the portrait orbit profile is applied." }, + "orbitPreviewHide": "Hide preview", + "@orbitPreviewHide": { + "description": "Tooltip for collapsing the orbit preview." + }, + "orbitPreviewHint": "Swipe to browse. Nothing plays, queues, or changes your favorites.", + "@orbitPreviewHint": { + "description": "Explains that the orbit preview is browse-only." + }, + "orbitPreviewShow": "Show preview", + "@orbitPreviewShow": { + "description": "Tooltip for expanding the orbit preview." + }, "orbitSharedVisuals": "Shared Visuals", "@orbitSharedVisuals": { "description": "Header for orbit visuals shared by both orientation profiles." @@ -9946,6 +9966,10 @@ "@spaceOdyssey": { "description": "lib/models/song.dart:326" }, + "spanishDraftDescription": "Latin American Spanish. Draft translation pending native-speaker review.", + "@spanishDraftDescription": { + "description": "Language selector notice that the Latin American Spanish translation is a draft awaiting native-speaker review." + }, "spatialTime": "Spatial & Time", "@spatialTime": { "description": "lib/features/settings/screens/equalizer_screen.dart:3548" diff --git a/lib/l10n/app_es.arb b/lib/l10n/app_es.arb new file mode 100755 index 00000000..f085eb00 --- /dev/null +++ b/lib/l10n/app_es.arb @@ -0,0 +1,11919 @@ +{ + "tourCore": "Buscar y reproducir música", + "tourLibrary": "Herramientas de biblioteca", + "tourPlayer": "Reproductor y cola", + "tourAppearance": "Personaliza Flick", + "tourAudio": "Audio y salida", + "tourGuides": "Explorar guías", + "tourPickerBody": "Elige una guía breve. Prueba los controles reales o continúa a tu ritmo.", + "tourWelcomeTitle": "Tu música, a un paso", + "tourWelcomeBody": "Busca una canción, reprodúcela y conoce tu reproductor. Puedes usar los controles reales, continuar sin probarlos o salir en cualquier momento.", + "tourAddBody": "¿Aún no tienes música? Abre los ajustes de biblioteca y elige Agregar carpeta de música. El escaneo puede tardar. Puedes cancelar, denegar el permiso o continuar sin agregar nada; podrás volver más tarde.", + "tourSearchBody": "Escribe una canción o un artista en el campo de búsqueda resaltado. La búsqueda tiene su propia pestaña cuando la agregas a la navegación. Continúa si prefieres explorar.", + "tourPlayTitle": "Elige qué escuchar", + "tourPlayBody": "Toca una canción que quieras escuchar. La guía avanza cuando comienza la reproducción. Nada se reproduce automáticamente; si no hay música disponible o falla la reproducción, puedes continuar de todos modos.", + "tourMiniBody": "El minirreproductor sigue tu música. Tócalo para abrir el reproductor completo o usa Abrir reproductor más abajo. Primero debe haber una canción cargada; puedes continuar sin ella.", + "tourFullBody": "Usa el reproductor para pausar, cambiar de canción y desplazarte por la pista. La cola, las letras y las demás acciones dependen del diseño que elegiste. La guía no cambiará el volumen, la cola ni los ajustes de audio.", + "tourFinishTitle": "Ahora sigue a tu ritmo", + "tourFinishBody": "Listo cierra esta guía. Explora otra cuando quieras o vuelve a encontrarlas en Ajustes → Información de la app → Tutorial interactivo.", + "tourSortBody": "Abre el control de orden resaltado para explorar las opciones de orden y los filtros. Basta con abrirlo para esta guía; no necesitas cambiar la vista de tu biblioteca.", + "tourActionsBody": "Mantén presionada una canción para ver sus acciones, como Reproducir a continuación, agregar a la cola y ver la información de la canción. Abrir el menú no cambia la cola. Continúa si aún no hay canciones.", + "tourPlaylistsBody": "Encuentra Listas de reproducción en el menú de biblioteca o en tu navegación personalizada. Usa las acciones de una canción para agregarla a una lista. Lee la guía de listas de reproducción para conocer el proceso completo.", + "tourQueueBody": "Abre Cola desde el reproductor completo para ver las próximas canciones. Su botón depende del diseño. Puedes mirar sin reordenar ni quitar nada.", + "tourLyricsBody": "Abre Letras en el reproductor completo si tu diseño incluye esta opción. No todas las canciones tienen letras disponibles. Continúa o lee el manual si no encuentras el control o las letras.", + "tourNavBody": "Mantén presionada la barra de navegación para personalizarla o abre los ajustes de navegación más abajo. Elige tus pestañas y su orden; esta guía nunca los cambia por ti.", + "tourPlayerLayoutTitle": "Un reproductor a tu medida", + "tourLayoutBody": "Explora Diseño del reproductor para elegir su apariencia y las acciones que muestra. Los cambios son opcionales y tú decides cuáles hacer.", + "tourOutputTitle": "Conoce tu salida de audio", + "tourOutputBody": "Los ajustes de audio muestran las rutas de salida disponibles. La compatibilidad con DAC USB y audio de alta resolución del dispositivo depende del hardware conectado. Esta guía no activa ningún modo ni garantiza una salida bit-perfect; revisa el indicador de salida del reproductor.", + "tourDspTitle": "Ajusta el sonido con intención", + "tourDspBody": "El ecualizador y las demás herramientas DSP son opcionales. El procesamiento modifica la señal y puede impedir una salida bit-perfect. Explora los controles sin activar nada y consulta el manual antes de cambiar la ruta de audio.", + "tourNotNow": "Ahora no", + "tourEnd": "Terminar recorrido", + "tourStart": "Iniciar recorrido", + "tourContinue": "Continuar", + "tourUseCurrent": "Usar la canción actual", + "tourReadMore": "Leer esto en el manual", + "tourOpenNavigation": "Abrir ajustes de navegación", + "tourOpenLayout": "Abrir Diseño del reproductor", + "tourOpenAudio": "Abrir ajustes de audio", + "tourActionConfirmed": "Listo. Vamos al siguiente paso.", + "tourUnavailable": "¿No ves el control? Puedes continuar o consultar el manual más abajo.", + "filipinoDonationNote": "Gracias por apoyar a Flick.", + "@filipinoDonationNote": { + "description": "Personal note shown only in the Taglish locale, above the donation cards." + }, + "playingLabel": "Reproduciendo", + "@playingLabel": { + "description": "Compact player status heading; the Filipino Baybayin label says Tumutugtog." + }, + "aDraggableOverlayShowsWhileUsing": "Una ventana flotante que puedes mover aparece mientras usas otras apps.", + "@aDraggableOverlayShowsWhileUsing": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:85" + }, + "aLittleRecordOfWhatStayed": "Un pequeño registro de lo que no dejaste de escuchar.", + "@aLittleRecordOfWhatStayed": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:476" + }, + "aNewerFlickBuildIsOn": "Hay una versión más reciente de Flick en Play Store.", + "@aNewerFlickBuildIsOn": { + "description": "lib/features/menu/screens/menu_screen.dart:1234" + }, + "aPlaylistWithThisNameAlready": "Ya existe una lista de reproducción con ese nombre", + "@aPlaylistWithThisNameAlready": { + "description": "lib/features/playlists/screens/playlists_screen.dart:444" + }, + "aPremiumMusicPlayerWithCustom": "Reproductor de música prémium con UAC 2.0 personalizado, desarrollado con Rust para ofrecer la mejor experiencia de audio.", + "@aPremiumMusicPlayerWithCustom": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:470" + }, + "aSmoothContinuousWaveAcrossFrequencies": "Una onda continua y fluida a través de las frecuencias", + "@aSmoothContinuousWaveAcrossFrequencies": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:87" + }, + "aSongWithALongTitle": "Una canción con un título largo para la vista previa", + "@aSongWithALongTitle": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:369" + }, + "aSwipeGestureWhenConfigured": "Un gesto de deslizamiento (si está configurado) activa un visualizador integrado en el minirreproductor.", + "@aSwipeGestureWhenConfigured": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "aTighterMixOfFavoritesAnd": "Una mezcla más equilibrada de tus favoritos y de las canciones a las que siempre vuelves.", + "@aTighterMixOfFavoritesAnd": { + "description": "lib/features/menu/screens/menu_screen.dart:1768" + }, + "aWeekAndCountingYourDedication": "Una semana y seguimos: se nota tu dedicación.", + "@aWeekAndCountingYourDedication": { + "description": "lib/features/milestone/widgets/streak_popup.dart:95" + }, + "aaudio": "AAudio", + "@aaudio": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:680" + }, + "aaudioAndroid81": "AAudio (Android 8.1+)", + "@aaudioAndroid81": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:638" + }, + "aaudioWithOpenslEsFallbackDefault": "AAudio con alternativa OpenSL ES (predeterminada)", + "@aaudioWithOpenslEsFallbackDefault": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:637" + }, + "about": "Acerca de", + "@about": { + "description": "lib/features/artists/screens/artist_detail_screen.dart:654" + }, + "aboutFlickPlayer": "Acerca de Flick Player", + "@aboutFlickPlayer": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:419" + }, + "aboutThisAlbum": "Acerca de este álbum", + "@aboutThisAlbum": { + "description": "lib/features/albums/screens/album_detail_screen.dart:519" + }, + "aboutThem": "Acerca del artista", + "@aboutThem": { + "description": "Artist detail biography section and its expanded sheet." + }, + "absoluteVolumeSync": "Sincronización del volumen absoluto", + "@absoluteVolumeSync": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:398" + }, + "accentColor": "Color de acento", + "@accentColor": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:263" + }, + "accuraterip": "AccurateRip", + "@accuraterip": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1102" + }, + "achieved": "Logrado: {arg1}", + "@achieved": { + "description": "lib/features/milestone/widgets/milestone_card.dart:211", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "achievementUnlocked": "LOGRO DESBLOQUEADO", + "@achievementUnlocked": { + "description": "lib/features/milestone/widgets/milestone_card.dart:174" + }, + "activateFallback": "Activar alternativa", + "@activateFallback": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:179" + }, + "active": "Activo", + "@active": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:670" + }, + "activeBands": "{activeCount} bandas activas", + "@activeBands": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2166", + "placeholders": { + "activeCount": { + "type": "Object" + } + } + }, + "activeDays": "Días con actividad", + "@activeDays": { + "description": "lib/features/recap/widgets/replay_card_options.dart:23" + }, + "activeQueue": "Cola actual", + "@activeQueue": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:276" + }, + "adaptive": "Adaptativo", + "@adaptive": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:211" + }, + "add": "Agregar", + "@add": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3016" + }, + "addAMusicFolderInSettings": "Agrega una carpeta de música en Ajustes", + "@addAMusicFolderInSettings": { + "description": "lib/features/songs/screens/songs_screen.dart:1847" + }, + "addANextTrackButton": "Agrega un botón de siguiente pista", + "@addANextTrackButton": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:185" + }, + "addAPreviousTrackButton": "Agrega un botón de pista anterior", + "@addAPreviousTrackButton": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:177" + }, + "addAtLeastOneLyricLine": "Primero, agrega al menos una línea de letra.", + "@addAtLeastOneLyricLine": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:475" + }, + "addDescription": "Agregar descripción", + "@addDescription": { + "description": "lib/features/albums/screens/album_detail_screen.dart:313" + }, + "addDescription2": "Agregar descripción", + "@addDescription2": { + "description": "lib/features/albums/screens/album_detail_screen.dart:338" + }, + "addMusicFolder": "Agregar carpeta de música", + "@addMusicFolder": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2117" + }, + "addMusicFoldersInSettings": "Agrega carpetas de música en Ajustes", + "@addMusicFoldersInSettings": { + "description": "lib/features/folders/screens/folders_screen.dart:376" + }, + "addMusicWithAlbumTagsTo": "Agrega música con etiquetas de álbum para ver los álbumes aquí", + "@addMusicWithAlbumTagsTo": { + "description": "lib/features/albums/screens/albums_screen.dart:450" + }, + "addMusicWithArtistTagsTo": "Agrega música con etiquetas de artista para verlos aquí", + "@addMusicWithArtistTagsTo": { + "description": "lib/features/artists/screens/artists_screen.dart:485" + }, + "addServer": "Agregar servidor", + "@addServer": { + "description": "lib/features/settings/screens/network_sources_screen.dart:154" + }, + "addSongsFromThePlayerMenu": "Agrega canciones desde el menú del reproductor", + "@addSongsFromThePlayerMenu": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:530" + }, + "addSongsFromThePlayerOr": "Agrega canciones desde el menú del reproductor o desde el menú de acciones de una canción.", + "@addSongsFromThePlayerOr": { + "description": "lib/features/queue/screens/queue_screen.dart:467" + }, + "addSongsToPlaylist": "Agregar {arg1} canciones a la lista de reproducción", + "@addSongsToPlaylist": { + "description": "lib/features/songs/screens/songs_screen.dart:1407", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addSongsToPlaylist2": "Agregar {arg1} canciones a la lista de reproducción", + "@addSongsToPlaylist2": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:52", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addTheSearchTabVia": "Agrega la pestaña Buscar desde Ajustes de la barra inferior: mantén presionada la barra de navegación.", + "@addTheSearchTabVia": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "addToFavorites": "Agregar a favoritos", + "@addToFavorites": { + "description": "lib/features/songs/screens/songs_screen.dart:2008" + }, + "addToFavorites2": "Agregar a favoritos", + "@addToFavorites2": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:88" + }, + "addToPlaylist": "Agregar a la lista de reproducción", + "@addToPlaylist": { + "description": "lib/features/albums/screens/album_detail_screen.dart:344" + }, + "addToPlaylist2": "Agregar a la lista de reproducción", + "@addToPlaylist2": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:211" + }, + "addToQueue": "Agregar a la cola", + "@addToQueue": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:202" + }, + "addToQueue2": "Agregar a la cola", + "@addToQueue2": { + "description": "lib/features/songs/screens/songs_screen.dart:2000" + }, + "addedSongsTo": "Se agregaron {arg1} canciones a «{arg2}»", + "@addedSongsTo": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:158", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "addedSongsTo2": "Se agregaron {arg1} canciones a {playlistName}", + "@addedSongsTo2": { + "description": "lib/features/songs/screens/songs_screen.dart:1489", + "placeholders": { + "arg1": { + "type": "Object" + }, + "playlistName": { + "type": "Object" + } + } + }, + "addedSongsToFavorites": "Se agregaron {arg1} canciones a favoritos", + "@addedSongsToFavorites": { + "description": "lib/features/albums/screens/album_detail_screen.dart:300", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addedSongsToFavorites3": "Se agregaron {arg1} canciones a favoritos", + "@addedSongsToFavorites3": { + "description": "lib/features/songs/screens/songs_screen.dart:1363", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addedTo": "Se agregó a {arg1}", + "@addedTo": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:493", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addedTo2": "Se agregó a «{arg1}»", + "@addedTo2": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:157", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addedToFavorites": "Se agregó a favoritos", + "@addedToFavorites": { + "description": "lib/features/player/widgets/player_action_button_row.dart:487" + }, + "addedToFavorites2": "Se agregó «{arg1}» a favoritos", + "@addedToFavorites2": { + "description": "lib/features/songs/screens/songs_screen.dart:1297", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "addingFavorites": "Agregando a favoritos", + "@addingFavorites": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "addingTheWidget": "Agregando el widget", + "@addingTheWidget": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "addsPreDriveAndCatchesPeaks": "Añade ganancia previa y controla los picos para respetar un límite máximo de salida.", + "@addsPreDriveAndCatchesPeaks": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3393" + }, + "adjustAudioFrequencies": "Ajustar las frecuencias de audio", + "@adjustAudioFrequencies": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:63" + }, + "adjustMetadataTextSizeInArtwork": "Ajusta el tamaño del texto de los metadatos en el modo de tarjeta con ilustración", + "@adjustMetadataTextSizeInArtwork": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:256" + }, + "adjustMetadataTextSizeInImmersive": "Ajusta el tamaño del texto de los metadatos en el modo inmersivo", + "@adjustMetadataTextSizeInImmersive": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:133" + }, + "adjustPlaybackSpeed05x": "Ajusta la velocidad de reproducción (0.5x–2x) desde el control de velocidad. Se conserva el tono.", + "@adjustPlaybackSpeed05x": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "adjustSpacingBetweenButtons": "Ajustar el espacio entre los botones", + "@adjustSpacingBetweenButtons": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:275" + }, + "adjustTheMiniPlayerSurface": "Ajustar la superficie del minirreproductor", + "@adjustTheMiniPlayerSurface": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:198" + }, + "adjustTheSizeOfTheBottom": "Ajustar el tamaño de la barra inferior", + "@adjustTheSizeOfTheBottom": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:259" + }, + "adjustTheSizeOfTheIcons": "Ajustar el tamaño de los íconos", + "@adjustTheSizeOfTheIcons": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:291" + }, + "adjustTheWidthOfTheBottom": "Ajusta el ancho de la barra hacia adentro desde los márgenes laterales habituales", + "@adjustTheWidthOfTheBottom": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:226" + }, + "advanceToARandomCategory": "Avanzar a una categoría aleatoria", + "@advanceToARandomCategory": { + "description": "lib/models/advance_list_order.dart:15" + }, + "advanceToTheNextCategoryAlphabetically": "Avanzar a la siguiente categoría en orden alfabético", + "@advanceToTheNextCategoryAlphabetically": { + "description": "lib/models/advance_list_order.dart:13" + }, + "advanceToTheNextMostRecently": "Avanzar a la categoría agregada más recientemente", + "@advanceToTheNextMostRecently": { + "description": "lib/models/advance_list_order.dart:14" + }, + "advanced": "Avanzado", + "@advanced": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:905" + }, + "advancedMode": "Modo avanzado", + "@advancedMode": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:686" + }, + "afterHours": "A altas horas", + "@afterHours": { + "description": "lib/features/menu/screens/menu_screen.dart:1782" + }, + "afterScanningMatchFilesWithMissing": "Después de escanear, busca en Apple Music coincidencias para los archivos sin etiquetas. Solo las coincidencias seguras se aplican automáticamente.", + "@afterScanningMatchFilesWithMissing": { + "description": "lib/features/settings/widgets/apple_music_settings_tile.dart:40" + }, + "air": "Aire", + "@air": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1891" + }, + "alacAudio": "Audio ALAC", + "@alacAudio": { + "description": "lib/widgets/alac_conversion_indicator.dart:128" + }, + "alacBit": "ALAC de {arg1} bits", + "@alacBit": { + "description": "lib/widgets/alac_conversion_indicator.dart:79", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "album": "Álbum", + "@album": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:263" + }, + "albumArt": "Portada del álbum", + "@albumArt": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:200" + }, + "albumArt2": "Portada del álbum", + "@albumArt2": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:598" + }, + "albumArtImport": "Importar portada del álbum", + "@albumArtImport": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:64" + }, + "albumArtist": "Artista del álbum", + "@albumArtist": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:68" + }, + "albumArtists": "Artistas del álbum", + "@albumArtists": { + "description": "lib/features/search/models/search_category.dart:24" + }, + "albumArtwork": "Portada del álbum", + "@albumArtwork": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2190" + }, + "albumColors": "Colores del álbum", + "@albumColors": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:395" + }, + "albumComplete": "Álbum completo (según las etiquetas)", + "@albumComplete": { + "description": "Verification badge tooltip when every expected track and disc is present." + }, + "albumCompleteExplanation": "Según las etiquetas integradas, tu biblioteca incluye todas las pistas y discos esperados.", + "@albumCompleteExplanation": { + "description": "Explains the tag-only evidence for the verified-complete album badge." + }, + "albumCompleteShort": "Completo", + "@albumCompleteShort": { + "description": "Compact label for complete-album indicators in the metadata line and album grid." + }, + "albumCompleteTitle": "Álbum completo", + "@albumCompleteTitle": { + "description": "Title of the top sheet explaining tag-based album completeness." + }, + "albumCompleteVerificationNote": "Verificado con las etiquetas de los archivos, no con una lista de canciones en línea.", + "@albumCompleteVerificationNote": { + "description": "Clarifies that album completeness is not verified against an online catalog." + }, + "albumCompletenessUnknown": "No se puede verificar si el álbum está completo con las etiquetas de las pistas.", + "@albumCompletenessUnknown": { + "description": "Album detail status when track or disc totals are missing or conflicting." + }, + "albumCount": "Cantidad de álbumes", + "@albumCount": { + "description": "lib/features/artists/screens/artists_screen.dart:878" + }, + "albumDetail": "Detalles del álbum", + "@albumDetail": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "albumIncompleteShort": "Incompleto", + "@albumIncompleteShort": { + "description": "Compact album-grid badge label for an incomplete album." + }, + "albumLimit": "LÍMITE DE ÁLBUMES", + "@albumLimit": { + "description": "lib/features/songs/screens/songs_screen.dart:2958" + }, + "albumMissingDiscNumbers": "Números de disco faltantes: {numbers}", + "@albumMissingDiscNumbers": { + "description": "Lists the disc numbers absent from an incomplete multi-disc album.", + "placeholders": { + "numbers": { + "type": "String" + } + } + }, + "albumMissingDiscs": "{count, plural, =1{Falta 1 disco} other{Faltan {count} discos}}", + "@albumMissingDiscs": { + "description": "Number of whole discs absent from an incomplete album.", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "albumMissingPositions": "Posiciones faltantes (disco:pista): {positions}", + "@albumMissingPositions": { + "description": "Lists missing disc:track positions for a multi-disc album.", + "placeholders": { + "positions": { + "type": "String" + } + } + }, + "albumMissingTrackNumbers": "Números de pista faltantes: {numbers}", + "@albumMissingTrackNumbers": { + "description": "Lists the track numbers absent from a single-disc album.", + "placeholders": { + "numbers": { + "type": "String" + } + } + }, + "albumMissingTracks": "{count, plural, =1{Falta 1 pista} other{Faltan {count} pistas}}", + "@albumMissingTracks": { + "description": "Number of tracks absent from an incomplete album.", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "albumName": "Nombre del álbum", + "@albumName": { + "description": "lib/features/albums/screens/albums_screen.dart:916" + }, + "albumOptions": "Opciones del álbum", + "@albumOptions": { + "description": "lib/features/songs/screens/songs_screen.dart" + }, + "albums": "Álbumes", + "@albums": { + "description": "lib/features/albums/screens/albums_screen.dart:252" + }, + "albums2": "{arg1} álbumes", + "@albums2": { + "description": "lib/features/albums/screens/albums_screen.dart:260", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "albums3": "{_totalAlbums} álbumes", + "@albums3": { + "description": "lib/features/artists/screens/artists_screen.dart:401", + "placeholders": { + "_totalAlbums": { + "type": "Object" + } + } + }, + "albumsAppearAsAGrid": "Los álbumes aparecen en una cuadrícula con sus portadas. Toca cualquiera para abrir sus detalles y ver la lista completa de canciones.", + "@albumsAppearAsAGrid": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "albumsShownPerPage": "Álbumes por página", + "@albumsShownPerPage": { + "description": "lib/features/songs/screens/songs_screen.dart:2968" + }, + "albumsSongs": "{arg1} álbumes • {arg2} canciones", + "@albumsSongs": { + "description": "lib/features/artists/screens/artist_detail_screen.dart:620", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "alignLyricTextToTheCenter": "Centrar el texto de las letras", + "@alignLyricTextToTheCenter": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:69" + }, + "alignLyricTextToTheLeft": "Alinear el texto de las letras a la izquierda", + "@alignLyricTextToTheLeft": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:57" + }, + "alignLyricTextToTheRight": "Alinear el texto de las letras a la derecha", + "@alignLyricTextToTheRight": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:81" + }, + "all": "Todo", + "@all": { + "description": "lib/features/search/widgets/search_filter_chips.dart:60" + }, + "allArtists": "Todos los artistas", + "@allArtists": { + "description": "lib/features/artists/screens/artists_screen.dart:511" + }, + "allClearNoDuplicates": "Todo en orden: no se encontraron duplicados.", + "@allClearNoDuplicates": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:264" + }, + "allDataIsStoredLocallyOn": "Todos los datos se guardan únicamente en tu dispositivo: metadatos de la biblioteca de música, historial de reproducción, listas, preajustes del ecualizador y preferencias de la app. Las credenciales de Last.fm se guardan de forma segura en el dispositivo. Estos datos nunca salen de tu dispositivo, salvo que uses una integración de forma explícita.", + "@allDataIsStoredLocallyOn": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:41" + }, + "allFavoritedTracksInOne": "Todas tus canciones favoritas en un solo lugar. Reprodúcelas, mézclalas o adminístralas desde aquí.", + "@allFavoritedTracksInOne": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "allFolders": "Todas las carpetas", + "@allFolders": { + "description": "lib/features/settings/screens/library_settings_screen.dart:682" + }, + "allFormats": "Todos los formatos", + "@allFormats": { + "description": "lib/providers/songs_provider.dart:116" + }, + "allFrequenciesEqually": "Todas las frecuencias por igual", + "@allFrequenciesEqually": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:125" + }, + "allPass": "Pasa todo", + "@allPass": { + "description": "lib/providers/equalizer_provider.dart:41" + }, + "allResultsAreHiddenByActive": "Los filtros activos ocultan todos los resultados.", + "@allResultsAreHiddenByActive": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:701" + }, + "allSongs": "Todas las canciones", + "@allSongs": { + "description": "lib/models/playback_context.dart:15" + }, + "allWordsStamped": "Todas las palabras sincronizadas", + "@allWordsStamped": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1392" + }, + "allowFlickToRunWithoutAggressive": "Permite que Flick se ejecute sin restricciones agresivas en segundo plano para que sigan funcionando los nuevos escaneos y las funciones en segundo plano", + "@allowFlickToRunWithoutAggressive": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1982" + }, + "allowed": "Permitido", + "@allowed": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:683" + }, + "alphabetical": "Alfabético", + "@alphabetical": { + "description": "lib/models/advance_list_order.dart:7" + }, + "alphabeticalIndexRailOnTheSongs": "Índice alfabético en la pantalla de canciones", + "@alphabeticalIndexRailOnTheSongs": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:193" + }, + "alsoRespectsYourSystemTextSize": "También respeta el tamaño de texto del sistema", + "@alsoRespectsYourSystemTextSize": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:234" + }, + "alt": "Alt {arg1}", + "@alt": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1003", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "amber": "Ámbar", + "@amber": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:275" + }, + "analyzeLoudnessAndWriteReplaygainTags": "Analizar el volumen y escribir etiquetas ReplayGain en todas las canciones", + "@analyzeLoudnessAndWriteReplaygainTags": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2141" + }, + "analyzingAudio": "Analizando el audio", + "@analyzingAudio": { + "description": "lib/features/settings/screens/library_settings_screen.dart:798" + }, + "analyzingLoudness": "Analizando el volumen", + "@analyzingLoudness": { + "description": "lib/features/settings/screens/library_settings_screen.dart:825" + }, + "andArtwork": " y la portada", + "@andArtwork": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:58" + }, + "andMoreInRotation": "{arg1} y más en rotación", + "@andMoreInRotation": { + "description": "lib/features/menu/screens/menu_screen.dart:1439", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "android": "Android", + "@android": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:121" + }, + "androidAudioApi": "API de audio de Android", + "@androidAudioApi": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:346" + }, + "androidBlockedWritingToThisFile": "Android bloqueó la escritura en este archivo. Quita la carpeta desde Ajustes y vuelve a agregarla para conceder acceso de edición; luego inténtalo de nuevo.", + "@androidBlockedWritingToThisFile": { + "description": "lib/services/metadata_editor_service.dart:184" + }, + "androidDeveloperOptionsTheReliableWay": "Opciones para desarrolladores de Android: la forma confiable de cambiar el códec (forzarlo desde la app usa una API del sistema oculta que Android estándar bloquea)", + "@androidDeveloperOptionsTheReliableWay": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:352" + }, + "androidDidNotReturnGalleryPath": "Android no devolvió la ruta de la galería para la imagen guardada.", + "@androidDidNotReturnGalleryPath": { + "description": "l10n pass: user-visible service error" + }, + "androidDockRoute": "Ruta de audio de la base de Android", + "@androidDockRoute": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:931" + }, + "androidManagedRustPlaybackPathUsing": "Ruta de reproducción administrada por Android con el motor Rust nativo Oboe.", + "@androidManagedRustPlaybackPathUsing": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:797" + }, + "androidUsbRoute": "Ruta de audio USB de Android", + "@androidUsbRoute": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:925" + }, + "animatedAlbumArt": "Portada animada del álbum", + "@animatedAlbumArt": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:166" + }, + "animationStyle": "Estilo de animación", + "@animationStyle": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:65" + }, + "animationStyleAndFrequencyFocus": "Estilo de animación y enfoque de frecuencias", + "@animationStyleAndFrequencyFocus": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:194" + }, + "animations": "Animaciones", + "@animations": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:87" + }, + "animationsAndHapticFeedback": "Animaciones y respuesta háptica", + "@animationsAndHapticFeedback": { + "description": "lib/features/settings/screens/settings_screen.dart:187" + }, + "animationsAndHapticFeedbackToggles": "Activar o desactivar las animaciones y la respuesta háptica.", + "@animationsAndHapticFeedbackToggles": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "apiKey": "Clave de API", + "@apiKey": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:447" + }, + "appInfo": "Información de la app", + "@appInfo": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:598" + }, + "appTitle": "Flick Player", + "@appTitle": { + "description": "Application name. Used by MaterialApp.onGenerateTitle and shown in the Android task switcher." + }, + "appearance": "Apariencia", + "@appearance": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:253" + }, + "appearsInTheOverflowMenu": "Aparece en el menú Más opciones", + "@appearsInTheOverflowMenu": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:394" + }, + "appleMusicDataUnavailable": "Datos de Apple Music no disponibles", + "@appleMusicDataUnavailable": { + "description": "lib/features/albums/screens/album_detail_screen.dart:417" + }, + "appleMusicDataUpdated": "Datos de Apple Music actualizados", + "@appleMusicDataUpdated": { + "description": "lib/features/albums/screens/album_detail_screen.dart:416" + }, + "appleMusicLookupFailedCheckYour": "No se pudo buscar en Apple Music. Comprueba tu conexión.", + "@appleMusicLookupFailedCheckYour": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:141" + }, + "appleMusicMotionArtOnAlbums": "Portadas animadas de Apple Music en los álbumes, además de desplazamiento y zoom, brillo ambiental y transiciones suaves en las imágenes destacadas", + "@appleMusicMotionArtOnAlbums": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:168" + }, + "appliedAutoeqFor": "Se aplicó AutoEQ para {arg1}", + "@appliedAutoeqFor": { + "description": "lib/features/settings/screens/equalizer_screen.dart:497", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "apply": "Aplicar", + "@apply": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1073" + }, + "apply2": "Aplicar {arg1}", + "@apply2": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:433", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "applySelected": "Aplicar selección", + "@applySelected": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:351" + }, + "applyTo": "Aplicar a {count, plural, =1{{count} canción} other{{count} canciones}}", + "@applyTo": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:581", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "applyingNewAudioEngine": "Aplicando el nuevo motor de audio…", + "@applyingNewAudioEngine": { + "description": "lib/features/menu/screens/restarting_screen.dart:11" + }, + "apr": "abr", + "@apr": { + "description": "lib/features/milestone/screens/milestones_screen.dart:505" + }, + "aptxAdaptive": "aptX Adaptive", + "@aptxAdaptive": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:596" + }, + "aptxHd": "aptX HD", + "@aptxHd": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:595" + }, + "areYouSureYouWantTo": "¿Seguro que quieres eliminar esta lista de reproducción?", + "@areYouSureYouWantTo": { + "description": "lib/features/playlists/screens/playlists_screen.dart:329" + }, + "areYouSureYouWantTo2": "¿Seguro que quieres borrar todo el historial de escucha? Esta acción no se puede deshacer.", + "@areYouSureYouWantTo2": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:198" + }, + "areYouSureYouWantTo3": "¿Seguro que quieres restablecer todas las preferencias de UAC2? Esta acción no se puede deshacer.", + "@areYouSureYouWantTo3": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1440" + }, + "artResolution": "Resolución de la portada", + "@artResolution": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:137" + }, + "artist": "Artista", + "@artist": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:254" + }, + "artistDetail": "Detalles del artista", + "@artistDetail": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "artistIsNotAvailableForThis": "Este artista no está disponible para esta canción", + "@artistIsNotAvailableForThis": { + "description": "lib/features/player/widgets/player_navigation.dart:45" + }, + "artistList": "Lista de artistas", + "@artistList": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "artistName": "Nombre del artista", + "@artistName": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:215" + }, + "artistUnit": "{count, plural, =1{artista} other{artistas}}", + "@artistUnit": { + "description": "lib/services/milestone_service.dart:226", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "artists": "Artistas", + "@artists": { + "description": "lib/features/artists/screens/artists_screen.dart:253" + }, + "artists2": "{arg1} artistas", + "@artists2": { + "description": "lib/features/artists/screens/artists_screen.dart:261", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "artistsInRotation": "Artistas en rotación", + "@artistsInRotation": { + "description": "lib/features/menu/screens/menu_screen.dart:887" + }, + "artwork": "Ilustración", + "@artwork": { + "description": "lib/features/recap/widgets/replay_card_options.dart:12" + }, + "artworkCacheCleared": "Se vació la caché de portadas", + "@artworkCacheCleared": { + "description": "lib/features/settings/screens/library_settings_screen.dart:286" + }, + "artworkCard": "Tarjeta con portada", + "@artworkCard": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:203" + }, + "artworkLookupFailed": "No se pudo obtener la portada (HTTP {status}).", + "@artworkLookupFailed": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "status": { + "type": "int" + } + } + }, + "artworkLookupInvalidData": "La búsqueda de portada devolvió datos no válidos.", + "@artworkLookupInvalidData": { + "description": "l10n pass: user-visible service error" + }, + "artworkLookupTemporarilyUnavailable": "La búsqueda de portada no está disponible temporalmente.", + "@artworkLookupTemporarilyUnavailable": { + "description": "l10n pass: user-visible service error" + }, + "artworkPlacement": "Ubicación de la portada", + "@artworkPlacement": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:239" + }, + "artworkPlacement2": "Ubicación de la portada", + "@artworkPlacement2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:288" + }, + "artworkSize": "Tamaño de la portada", + "@artworkSize": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:208" + }, + "artworkSize2": "Tamaño de la portada", + "@artworkSize2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:239" + }, + "asmrDreams": "ASMR Dreams", + "@asmrDreams": { + "description": "lib/models/song.dart:367" + }, + "atKhzBit": " a {arg1} kHz/{arg2} bits", + "@atKhzBit": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:88", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "atLeastOneVersionMustStay": "Debe quedar al menos una versión.", + "@atLeastOneVersionMustStay": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1322" + }, + "attack": "Ataque", + "@attack": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3345" + }, + "audio": "Audio", + "@audio": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:40" + }, + "audioFocus": "Enfoque de audio", + "@audioFocus": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:714" + }, + "audioFormat": "Formato de audio", + "@audioFormat": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:215" + }, + "audioFormatIsDisabled": "El formato de audio está desactivado", + "@audioFormatIsDisabled": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:237" + }, + "audioSignalPath": "Ruta de señal de audio", + "@audioSignalPath": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:480" + }, + "audioTestingEquipment": "Equipo de pruebas de audio", + "@audioTestingEquipment": { + "description": "lib/features/settings/screens/support_flick_screen.dart:173" + }, + "aug": "ago", + "@aug": { + "description": "lib/features/milestone/screens/milestones_screen.dart:509" + }, + "auroraSounds": "Aurora Sounds", + "@auroraSounds": { + "description": "lib/models/song.dart:319" + }, + "authenticationResponseMissingToken": "Falta el token en la respuesta de autenticación", + "@authenticationResponseMissingToken": { + "description": "l10n pass: user-visible service error" + }, + "auto": "Automático", + "@auto": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1224" + }, + "autoAdvance": "Avance automático", + "@autoAdvance": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1427" + }, + "autoBeMsbDefaultOnlyChange": "Automático: BE-MSB predeterminado; cámbialo solo si el DSD nativo produce un siseo", + "@autoBeMsbDefaultOnlyChange": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1716" + }, + "autoBitPerfectForUsbDacs": "Bit perfecto automático para DAC USB", + "@autoBitPerfectForUsbDacs": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:491" + }, + "autoCollapse": "Contraer automáticamente", + "@autoCollapse": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:77" + }, + "autoFill": "Completar automáticamente", + "@autoFill": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1689" + }, + "autoFocusSearch": "Enfocar automáticamente la búsqueda", + "@autoFocusSearch": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:137" + }, + "autoFullView": "Vista completa automática", + "@autoFullView": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:216" + }, + "autoHideTimeout": "Tiempo antes de ocultarse automáticamente", + "@autoHideTimeout": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:205" + }, + "autoIdentifyUntaggedAlbums": "Identificar automáticamente álbumes sin etiquetas", + "@autoIdentifyUntaggedAlbums": { + "description": "lib/features/settings/widgets/apple_music_settings_tile.dart:38" + }, + "autoNativeDsdOnDapsDop": "Automático: DSD nativo en reproductores de audio digital (DAP), DoP para DAC USB y PCM en los demás casos", + "@autoNativeDsdOnDapsDop": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1637" + }, + "autoReconnect": "Reconexión automática", + "@autoReconnect": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:183" + }, + "autoShowFullViewAfterInactivity": "Mostrar automáticamente la vista completa tras un periodo de inactividad", + "@autoShowFullViewAfterInactivity": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:217" + }, + "autoShowTheSpotifyStyleImmersive": "Mostrar automáticamente la vista completa inmersiva estilo Spotify tras un periodo de inactividad", + "@autoShowTheSpotifyStyleImmersive": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:170" + }, + "autoU8ByteInterleavedRecommended": "Automático: U8 intercalado por bytes (recomendado)", + "@autoU8ByteInterleavedRecommended": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1731" + }, + "autoeqHeadphones": "Audífonos AutoEQ", + "@autoeqHeadphones": { + "description": "lib/features/settings/screens/equalizer_screen.dart:758" + }, + "autoeqHeadphones2": "Audífonos AutoEQ", + "@autoeqHeadphones2": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:188" + }, + "automatic": "Automático", + "@automatic": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:311" + }, + "automaticUpdateChecks": "Buscar actualizaciones automáticamente", + "@automaticUpdateChecks": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:173" + }, + "automaticallyOpenKeyboardWhenSwitchingTo": "Abrir automáticamente el teclado al cambiar a la búsqueda", + "@automaticallyOpenKeyboardWhenSwitchingTo": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:138" + }, + "autoplayOnQueueEnd": "Reproducción automática al final de la cola", + "@autoplayOnQueueEnd": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:73" + }, + "availableDevices": "Dispositivos disponibles", + "@availableDevices": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:70" + }, + "b": "B{arg1}", + "@b": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2405", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "back": "Atrás", + "@back": { + "description": "lib/features/onboarding/widgets/tutorial_overlay.dart:338" + }, + "backOnline": "De nuevo en línea", + "@backOnline": { + "description": "lib/widgets/common/offline_notice.dart:137" + }, + "backToLocker": "Volver a Locker", + "@backToLocker": { + "description": "lib/features/player/screens/full_player_screen.dart:731" + }, + "backToReplay": "Volver a Replay", + "@backToReplay": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:298" + }, + "backend": "Motor", + "@backend": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:632" + }, + "background": "Fondo", + "@background": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:155" + }, + "blurGradient": "Degradado difuminado", + "colorGradient": "Degradado de color", + "backgroundOpacity": "Opacidad del fondo", + "@backgroundOpacity": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:197" + }, + "backgroundPlaybackAnchor": "Anclaje de reproducción en segundo plano", + "@backgroundPlaybackAnchor": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:49" + }, + "balance": "Balance", + "@balance": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3563" + }, + "balance2": "Balance {arg1}", + "@balance2": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3515", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "balanceTempoDampFilterDelaysSize": "Controles de balance, tempo, amortiguación, filtro, retardo, tamaño, mezcla y expansión adicional.", + "@balanceTempoDampFilterDelaysSize": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3550" + }, + "balancedQualityAndStability": "Equilibrio entre calidad y estabilidad", + "@balancedQualityAndStability": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:505" + }, + "band": "Banda", + "@band": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:211" + }, + "bandControls": "Controles de banda", + "@bandControls": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1822" + }, + "bandEditors": "Editores de banda", + "@bandEditors": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2240" + }, + "bandPass": "Filtro pasa banda", + "@bandPass": { + "description": "lib/providers/equalizer_provider.dart:37" + }, + "bandU2022": "Banda {arg1} • {arg2}", + "@bandU2022": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2578", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "bands": "{arg1}/31 bandas", + "@bands": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2178", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "bandsActive": "{activeCount}/{arg1} bandas activas", + "@bandsActive": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:294", + "placeholders": { + "activeCount": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "bandsAdjusted": "{adjustedBands} bandas ajustadas", + "@bandsAdjusted": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1749", + "placeholders": { + "adjustedBands": { + "type": "Object" + } + } + }, + "bandsAdjusted2": "{adjustedCount}/{arg1} bandas ajustadas", + "@bandsAdjusted2": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:291", + "placeholders": { + "adjustedCount": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "bandsPreampDb": "{arg1} bandas · preamplificación {arg2} dB · {arg3}", + "@bandsPreampDb": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:366", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + }, + "arg3": { + "type": "Object" + } + } + }, + "barHeight": "Altura de la barra", + "@barHeight": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:258" + }, + "bars": "Barras", + "@bars": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:70" + }, + "baseAlbumArtSizeForEach": "Tamaño base de la portada para cada tarjeta de canción", + "@baseAlbumArtSizeForEach": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:80" + }, + "bass": "Graves", + "@bass": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1665" + }, + "bassMidTreble": "Graves, medios y agudos", + "@bassMidTreble": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1639" + }, + "bassTreble": "Graves + agudos", + "@bassTreble": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:156" + }, + "battery": "{battery}% de batería", + "@battery": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:117", + "placeholders": { + "battery": { + "type": "Object" + } + } + }, + "baybayinHeadings": "Etiquetas en baybayin", + "@baybayinHeadings": { + "description": "Optional visual script preference, shown only when the UI is Taglish." + }, + "baybayinHeadingsDescription": "Experimental: encabezados seleccionados, accesos directos para explorar y etiquetas de navegación. Las etiquetas de accesibilidad se mantienen en alfabeto latino.", + "@baybayinHeadingsDescription": { + "description": "Explains the limited, opt-in scope of Baybayin headings." + }, + "baybayinPilotDescription": "Mezcla de tagalo e inglés. Texto preliminar para revisión.", + "@baybayinPilotDescription": { + "description": "Language selector notice that the Taglish copy is a draft for review." + }, + "beLsbBigEndianSubslotLsb": "BE-LSB: subranura en orden big-endian, primero el bit menos significativo", + "@beLsbBigEndianSubslotLsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1722" + }, + "beMsbBigEndianSubslotMsb": "BE-MSB: subranura en orden big-endian, primero el bit más significativo (predeterminado)", + "@beMsbBigEndianSubslotMsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1718" + }, + "beMsbPackingTheDefaultWire": "Empaquetado BE-MSB: convención predeterminada de transmisión", + "@beMsbPackingTheDefaultWire": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1827" + }, + "besideTheSong": "Junto a la canción", + "@besideTheSong": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:499" + }, + "bigEndian32BitSubslotMsb": "Subranura de 32 bits en orden big-endian, primero el bit más significativo", + "@bigEndian32BitSubslotMsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1832" + }, + "bigEndianSubslotLsbFirstBit": "Subranura en orden big-endian, primero el bit menos significativo (bits invertidos)", + "@bigEndianSubslotLsbFirstBit": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1842" + }, + "bit": "{depth} bits", + "@bit": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1361", + "placeholders": { + "depth": { + "type": "Object" + } + } + }, + "bitDepth": "Profundidad de bits", + "@bitDepth": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:612" + }, + "bitDepth2": "Profundidad de bits", + "@bitDepth2": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1350" + }, + "bitDepths": "Profundidades de bits", + "@bitDepths": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:569" + }, + "bitPerfect": "BIT PERFECTO", + "@bitPerfect": { + "description": "lib/features/player/widgets/bit_perfect_capsule.dart:144" + }, + "bitPerfect2": "Bit perfecto", + "@bitPerfect2": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:420" + }, + "bitPerfectCapsule": "Cápsula de bit perfecto", + "@bitPerfectCapsule": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:366" + }, + "bitPerfectDapInternal": "Bit perfecto (interno del DAP)", + "@bitPerfectDapInternal": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:459" + }, + "bitPerfectDapInternalDisabledSoftware": "Bit perfecto (interno del DAP) desactivado: hay efectos de software activos.", + "@bitPerfectDapInternalDisabledSoftware": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:474" + }, + "bitPerfectDapInternalEnabledAll": "Bit perfecto (interno del DAP) activado: se omitieron todos los procesos DSP.", + "@bitPerfectDapInternalEnabledAll": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:473" + }, + "bitPerfectEnabledParametricEqIs": "Bit perfecto activado: el ecualizador paramétrico se omite en la conexión USB directa. Reinicia la app para aplicar los cambios de reproducción.", + "@bitPerfectEnabledParametricEqIs": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:437" + }, + "bitPerfectUsbDac": "Bit perfecto (DAC USB)", + "@bitPerfectUsbDac": { + "description": "lib/features/menu/screens/menu_screen.dart:512" + }, + "bitPerfectUsbDacCouldNot": "No se pudo activar el modo bit perfecto (DAC USB). Consulta los diagnósticos USB para conocer el motivo.", + "@bitPerfectUsbDacCouldNot": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:426" + }, + "bitPerfectUsbDacCouldNot2": "No se pudo activar el modo bit perfecto (DAC USB) para {arg1}. Consulta los diagnósticos USB.", + "@bitPerfectUsbDacCouldNot2": { + "description": "lib/widgets/uac2/usb_bit_perfect_prompt.dart:274", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "bitPerfectUsbDacEnabledFor": "Se activó el modo bit perfecto (DAC USB) para {arg1}.", + "@bitPerfectUsbDacEnabledFor": { + "description": "lib/widgets/uac2/usb_bit_perfect_prompt.dart:273", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "bitPerfectVerified": "Bit perfecto verificado", + "@bitPerfectVerified": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:490" + }, + "bitSubslotsLlRrPer": "Subranuras de 16 bits: LL|RR por trama", + "@bitSubslotsLlRrPer": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1768" + }, + "bitSubslotsLlllRrrrPer": "Subranuras de 32 bits: LLLL|RRRR por trama (heredado)", + "@bitSubslotsLlllRrrrPer": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1763" + }, + "bitrateAdjustsToSignalQuality": "La tasa de bits se ajusta a la calidad de la señal", + "@bitrateAdjustsToSignalQuality": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:503" + }, + "blocked": "Bloqueado", + "@blocked": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:683" + }, + "blue": "Azul", + "@blue": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:283" + }, + "bluetooth": "Bluetooth", + "@bluetooth": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:225" + }, + "bluetoothCodecInfo": "Información del códec Bluetooth", + "@bluetoothCodecInfo": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:558" + }, + "bluetoothOutput": "Salida Bluetooth", + "@bluetoothOutput": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:929" + }, + "boldSaturatedColorsFromAlbumArt": "Colores intensos y saturados de la portada del álbum.", + "@boldSaturatedColorsFromAlbumArt": { + "description": "lib/models/album_color_mode.dart:39" + }, + "boostBeyond100UpTo200": "Aumentar por encima del 100 % (hasta el 200 %)", + "@boostBeyond100UpTo200": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:121" + }, + "border": "Borde", + "@border": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:208" + }, + "bothBitPerfectOptionsAreOff": "Las dos opciones de bit perfecto están desactivadas en este DAP, así que el motor estándar no está disponible. Aún puedes usar Rust con Oboe o USB isócrono.", + "@bothBitPerfectOptionsAreOff": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:873" + }, + "bottom": "Abajo", + "@bottom": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:628" + }, + "bottomBar": "Barra inferior", + "@bottomBar": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:27" + }, + "bottomBarAlwaysVisible": "Barra inferior siempre visible", + "@bottomBarAlwaysVisible": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:142" + }, + "bottomBarWidth": "Ancho de la barra inferior", + "@bottomBarWidth": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:225" + }, + "bouncy": "Elástico", + "@bouncy": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:169" + }, + "browseAllArtistsInYour": "Explora todos los artistas de tu biblioteca. Toca un artista para ver sus álbumes y canciones.", + "@browseAllArtistsInYour": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "browseByArtworkOpenAnyAlbum": "Explora las portadas, abre cualquier álbum y ve directamente a la lista de canciones.", + "@browseByArtworkOpenAnyAlbum": { + "description": "lib/features/albums/screens/albums_screen.dart:348" + }, + "browseByFolder": "Explorar por carpeta", + "@browseByFolder": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "browseMore": "Explorar más", + "@browseMore": { + "description": "lib/features/menu/screens/menu_screen.dart:1033" + }, + "browseTheFullControlsGuide": "Consulta la guía completa de controles", + "@browseTheFullControlsGuide": { + "description": "lib/features/settings/screens/settings_screen.dart:238" + }, + "browseYourArtistLibrary": "Explora la biblioteca de artistas", + "@browseYourArtistLibrary": { + "description": "lib/features/menu/screens/menu_screen.dart:1438" + }, + "browseYourArtistsExploreTheirDiscographies": "Explora tus artistas, descubre su discografía y reproduce sus canciones.", + "@browseYourArtistsExploreTheirDiscographies": { + "description": "lib/features/artists/screens/artists_screen.dart:378" + }, + "browsingYourLibrary": "Explorando tu biblioteca", + "@browsingYourLibrary": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "buffer": "Búfer", + "@buffer": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1024" + }, + "build": "{kAppVersion} (compilación {kAppBuild})", + "@build": { + "description": "lib/core/constants/app_constants.dart:6", + "placeholders": { + "kAppVersion": { + "type": "Object" + }, + "kAppBuild": { + "type": "Object" + } + } + }, + "buildFlavor": "Variante de compilación", + "@buildFlavor": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:655" + }, + "buildFlavorFull": "full: versión para descarga directa", + "@buildFlavorFull": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:83" + }, + "buildFlavorPlay": "play: versión de Google Play", + "@buildFlavorPlay": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:84" + }, + "buildingYourMusicHome": "Preparando tu espacio musical", + "@buildingYourMusicHome": { + "description": "lib/features/menu/screens/menu_screen.dart:2252" + }, + "builtIn": "Integrado", + "@builtIn": { + "description": "lib/features/settings/screens/equalizer_screen.dart:766" + }, + "buttonSpacing": "Espacio entre botones", + "@buttonSpacing": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:274" + }, + "buttons": "Botones", + "@buttons": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:110" + }, + "buyMeACoffee": "Cómprame un café", + "@buyMeACoffee": { + "description": "Buy Me a Coffee donation option label on the Support Flick screen." + }, + "by": "«{arg1}» de {arg2}", + "@by": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:726", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "bypassAllDspEqDynamicsCrossfade": "Omitir todo el procesamiento DSP (ecualizador, dinámica, fundido cruzado y velocidad) en la ruta interna de alta resolución del DAP nativo. Desactívalo para usar efectos de software. Esto también se desactiva al apagar Bit perfecto (DAC USB).", + "@bypassAllDspEqDynamicsCrossfade": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:461" + }, + "byteInterleavedLrlrStream": "Intercalado por bytes: flujo LRLR", + "@byteInterleavedLrlrStream": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1773" + }, + "cacheWaveformsAndLoudnessForAll": "Guardar en caché las formas de onda y el volumen de todas las canciones", + "@cacheWaveformsAndLoudnessForAll": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2133" + }, + "cachedAlbumArtWillBeRemoved": "Se eliminarán las portadas en caché ({arg1}). Se volverán a cargar automáticamente mientras exploras.", + "@cachedAlbumArtWillBeRemoved": { + "description": "lib/features/settings/screens/library_settings_screen.dart:272", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "cachedWavConversionsWillBeRemoved": "Se eliminarán las conversiones WAV en caché ({size}). Los archivos volverán a convertirse la próxima vez que se reproduzcan.", + "@cachedWavConversionsWillBeRemoved": { + "description": "lib/features/settings/screens/library_settings_screen.dart:402", + "placeholders": { + "size": { + "type": "Object" + } + } + }, + "calculatingSize": "Calculando el tamaño…", + "@calculatingSize": { + "description": "lib/features/settings/screens/library_settings_screen.dart:250" + }, + "calmFrequencies": "Frecuencias suaves", + "@calmFrequencies": { + "description": "lib/models/song.dart:313" + }, + "camera": "Cámara", + "@camera": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:404" + }, + "cameraAccessIsNeededYouCan": "Se necesita acceso a la cámara. Puedes activarlo en los ajustes de Android.", + "@cameraAccessIsNeededYouCan": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:146" + }, + "cameraAndPhotoLibraryAccessIs": "El acceso a la cámara y a la biblioteca de fotos se usa únicamente para la función Flick Replay, que permite crear fondos personalizados para los pósteres del resumen de escucha. Las fotos solo se usan cuando lo solicitas y permanecen en tu dispositivo. No se suben ni se transmiten imágenes.", + "@cameraAndPhotoLibraryAccessIs": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:46" + }, + "cameraAndPhotos": "Cámara y fotos", + "@cameraAndPhotos": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:44" + }, + "cancel": "Cancelar", + "@cancel": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:1150" + }, + "capAt60hzBalancedSmoothnessAnd": "Limitar a 60 Hz: equilibrio entre fluidez y batería", + "@capAt60hzBalancedSmoothnessAnd": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:224" + }, + "capMs": "límite {arg1} ms", + "@capMs": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1027", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "capabilities": "Capacidades", + "@capabilities": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:82" + }, + "capabilitiesNotAvailable": "Capacidades no disponibles", + "@capabilitiesNotAvailable": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:529" + }, + "capabilityState": "Estado de las capacidades", + "@capabilityState": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:625" + }, + "cardSize": "Tamaño de tarjeta", + "@cardSize": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:79" + }, + "cardWidth": "Ancho de tarjeta", + "@cardWidth": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:91" + }, + "cast": "Transmitir", + "@cast": { + "description": "lib/features/player/widgets/player_action_button_row.dart:843" + }, + "casting": "Transmitiendo", + "@casting": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:66" + }, + "castingTapToManage": "Transmitiendo: toca para administrar", + "@castingTapToManage": { + "description": "lib/features/player/widgets/player_action_button_row.dart:843" + }, + "castingTo": "Transmitiendo a {deviceName}", + "@castingTo": { + "description": "Snack bar shown after starting a cast session.", + "placeholders": { + "deviceName": { + "type": "Object" + } + } + }, + "castingTo2": "Transmitiendo a {arg1}", + "@castingTo2": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:54", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "categories": "Categorías", + "@categories": { + "description": "lib/models/shuffle_mode.dart:14" + }, + "ceiling": "Límite máximo", + "@ceiling": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3420" + }, + "center": "Centro", + "@center": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:68" + }, + "centerTheTitleAndInfoIn": "Centrar el título y la información en el encabezado de detalles", + "@centerTheTitleAndInfoIn": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:193" + }, + "centeredHeaderTitle": "Título centrado en el encabezado", + "@centeredHeaderTitle": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:192" + }, + "centeredWidensToFitYourControls": "Centrado; se amplía para dar cabida a los controles", + "@centeredWidensToFitYourControls": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:91" + }, + "centralTransportControlsPreviousRestarts": "Controles de reproducción centrales. El botón Anterior reinicia la pista si ya pasaron más de 3 segundos.", + "@centralTransportControlsPreviousRestarts": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "ch": "{channels} canales", + "@ch": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:621", + "placeholders": { + "channels": { + "type": "Object" + } + } + }, + "ch2": "{ch} canales", + "@ch2": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:932", + "placeholders": { + "ch": { + "type": "Object" + } + } + }, + "ch3": "{arg1} / {arg2} canales", + "@ch3": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:273", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "changeCover": "Cambiar portada", + "@changeCover": { + "description": "lib/features/playlists/screens/playlists_screen.dart:610" + }, + "changingSampleRateBitDepthOr": "Cambiar la frecuencia de muestreo, la profundidad de bits o el manejo de canales puede remuestrear las canciones y afectar la calidad de reproducción, el tono, la velocidad o la estabilidad en algunos dispositivos.", + "@changingSampleRateBitDepthOr": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1234" + }, + "channels": "Canales", + "@channels": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:620" + }, + "channels2": "{arg1} canales", + "@channels2": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:660", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "channels3": "{ch} canales", + "@channels3": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:185", + "placeholders": { + "ch": { + "type": "Object" + } + } + }, + "checkAgain": "Volver a comprobar", + "@checkAgain": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:609" + }, + "checkTheVersionsYouWantTo": "Marca las versiones que quieres conservar; las que no marques se eliminarán de tu biblioteca. Debe quedar al menos una.", + "@checkTheVersionsYouWantTo": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1265" + }, + "checkVersionsToKeepUncheckedWill": "Marca las versiones que quieres conservar; las demás se eliminarán", + "@checkVersionsToKeepUncheckedWill": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:321" + }, + "checking": "Comprobando…", + "@checking": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1118" + }, + "checkingForUpdates": "Buscando actualizaciones", + "@checkingForUpdates": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:133" + }, + "checkingForUpdates2": "Buscando actualizaciones…", + "@checkingForUpdates2": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:608" + }, + "childrenSPrivacy": "Privacidad de los menores", + "@childrenSPrivacy": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:79" + }, + "chooseAction": "Elegir acción", + "@chooseAction": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:968" + }, + "chooseAudioEngine": "Elegir motor de audio", + "@chooseAudioEngine": { + "description": "lib/features/menu/screens/menu_screen.dart:464" + }, + "chooseFromBuiltInPresets": "Elige entre los preajustes integrados (Normal, refuerzo de graves, refuerzo de agudos, voz, etc.) o guarda uno propio.", + "@chooseFromBuiltInPresets": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "chooseLocationU2026": "Elegir ubicación…", + "@chooseLocationU2026": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:494" + }, + "chooseWhichToKeep": "Elegir cuáles conservar", + "@chooseWhichToKeep": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1178" + }, + "chromecast": "Chromecast", + "@chromecast": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:46" + }, + "circularDotsRadiusFollowsAmplitude": "Puntos circulares: el radio sigue la amplitud", + "@circularDotsRadiusFollowsAmplitude": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:112" + }, + "cityBeats": "City Beats", + "@cityBeats": { + "description": "lib/models/song.dart:331" + }, + "claimedByFlick": "Reclamado por Flick", + "@claimedByFlick": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:703" + }, + "cleanStraightLineWithPrecisionScrubbing": "Línea recta y limpia con desplazamiento preciso.", + "@cleanStraightLineWithPrecisionScrubbing": { + "description": "lib/models/progress_bar_style.dart:27" + }, + "clear": "Borrar", + "@clear": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1214" + }, + "clearAll": "Borrar todo", + "@clearAll": { + "description": "lib/features/queue/screens/queue_screen.dart:434" + }, + "clearAllUac2Settings": "Borrar todos los ajustes de UAC2", + "@clearAllUac2Settings": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:558" + }, + "clearArtworkCache": "¿Borrar la caché de portadas?", + "@clearArtworkCache": { + "description": "lib/features/settings/screens/library_settings_screen.dart:270" + }, + "clearArtworkCache2": "Borrar la caché de portadas", + "@clearArtworkCache2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2162" + }, + "clearConvertedAudio": "Borrar el audio convertido", + "@clearConvertedAudio": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2176" + }, + "clearConvertedAudioCache": "¿Borrar la caché de audio convertido?", + "@clearConvertedAudioCache": { + "description": "lib/features/settings/screens/library_settings_screen.dart:400" + }, + "clearFilters": "Borrar filtros", + "@clearFilters": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:807" + }, + "clearHistory": "Borrar historial", + "@clearHistory": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:196" + }, + "clearLogs": "¿Borrar los registros?", + "@clearLogs": { + "description": "lib/features/settings/screens/logs_screen.dart:230" + }, + "clearTheCounterAndAnyUnlocked": "Borrar el contador y los hitos de racha que ya se desbloquearon", + "@clearTheCounterAndAnyUnlocked": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:174" + }, + "clearWord": "Borrar palabra", + "@clearWord": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1594" + }, + "clearWords": "Borrar palabras", + "@clearWords": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1418" + }, + "clearing": "Borrando…", + "@clearing": { + "description": "lib/features/settings/screens/library_settings_screen.dart:249" + }, + "close": "Cerrar", + "@close": { + "description": "lib/features/milestone/screens/milestones_screen.dart:224" + }, + "closePreview": "Cerrar vista previa", + "@closePreview": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:473" + }, + "codecApplied": "Códec aplicado: {arg1}", + "@codecApplied": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:144", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "codecControl": "Control del códec", + "@codecControl": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:341" + }, + "codecForcingUnavailableOnThisDevice": "No se puede forzar el códec en este dispositivo. Cámbialo en Opciones para desarrolladores → Códec de audio Bluetooth.", + "@codecForcingUnavailableOnThisDevice": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:152" + }, + "codecInfo": "Información del códec", + "@codecInfo": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:444" + }, + "codecU0026Audio": "Códec y audio", + "@codecU0026Audio": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:336" + }, + "collapseAfter": "Contraer después de", + "@collapseAfter": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:91" + }, + "collapsed": "Contraído", + "@collapsed": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:334" + }, + "collection": "Colección", + "@collection": { + "description": "lib/features/albums/screens/albums_screen.dart:490" + }, + "color": "Color", + "@color": { + "description": "lib/features/player/widgets/share/share_template.dart:9" + }, + "comingSoon": "Muy pronto", + "@comingSoon": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1664" + }, + "compatibility": "Compatibilidad", + "@compatibility": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1213" + }, + "compatibleWithPowerampEq": "Compatible con Poweramp EQ", + "@compatibleWithPowerampEq": { + "description": "lib/features/settings/screens/equalizer_screen.dart:668" + }, + "completelyHiddenFromTheBottomBar": "Completamente oculta en la barra inferior", + "@completelyHiddenFromTheBottomBar": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:393" + }, + "compressor": "Compresor", + "@compressor": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3303" + }, + "compressorOff": "Compresor desactivado", + "@compressorOff": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3263" + }, + "compressorOn": "Compresor activado", + "@compressorOn": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3263" + }, + "configureDefaultStyleAndSensitivity": "Configura el estilo predeterminado y la sensibilidad en Ajustes → Visualizador.", + "@configureDefaultStyleAndSensitivity": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "configureLyricsSavingAndFetching": "Configura cómo se guardan y buscan las letras.", + "@configureLyricsSavingAndFetching": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "configureSwipeBehaviorInSettings": "Configura el gesto de deslizamiento en Ajustes → Diseño del reproductor → Deslizamiento del minirreproductor.", + "@configureSwipeBehaviorInSettings": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "configureUsbDacAmpDevices": "Configurar dispositivos DAC/amplificadores USB", + "@configureUsbDacAmpDevices": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:50" + }, + "configureWidgetAppearanceAndShown": "Configura la apariencia del widget y los controles visibles en Ajustes → Widgets.", + "@configureWidgetAppearanceAndShown": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "configureYourMusicExperience": "Configura tu experiencia musical", + "@configureYourMusicExperience": { + "description": "lib/features/settings/screens/settings_screen.dart:312" + }, + "connect": "Conectar", + "@connect": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:785" + }, + "connectAMusicServer": "Conectar un servidor de música", + "@connectAMusicServer": { + "description": "lib/features/settings/screens/network_sources_screen.dart:155" + }, + "connectASubsonicJellyfinWebdavUpnp": "Conecta un servidor Subsonic, Jellyfin, WebDAV, UPnP o Tidal para transmitir desde tu biblioteca remota.", + "@connectASubsonicJellyfinWebdavUpnp": { + "description": "lib/features/settings/screens/network_sources_screen.dart:199" + }, + "connectAUsbDacOrAudio": "Conectar un DAC USB o una interfaz de audio", + "@connectAUsbDacOrAudio": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:296" + }, + "connectListenbrainz": "Conectar a ListenBrainz", + "@connectListenbrainz": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:651" + }, + "connectToScrobbleYourListeningHistory": "Conéctate para registrar tu historial de escucha", + "@connectToScrobbleYourListeningHistory": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:979" + }, + "connectToScrobbleYourMusic": "Conéctate para registrar lo que escuchas", + "@connectToScrobbleYourMusic": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:356" + }, + "connectToSubmitYourListeningHistory": "Conéctate para enviar tu historial de escucha", + "@connectToSubmitYourListeningHistory": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:481" + }, + "connectToTheInternetToCheck": "Conéctate a internet para buscar actualizaciones.", + "@connectToTheInternetToCheck": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:80" + }, + "connected": "Conectado", + "@connected": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:110" + }, + "connectedAccount": "Cuenta conectada", + "@connectedAccount": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:888" + }, + "connectedAs": "Conectado como {username}", + "@connectedAs": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:770", + "placeholders": { + "username": { + "type": "Object" + } + } + }, + "connecting": "Conectando", + "@connecting": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:901" + }, + "connection": "Conexión", + "@connection": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:428" + }, + "connectionBehavior": "Comportamiento de la conexión", + "@connectionBehavior": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:244" + }, + "connectionFailedRetry": "Falló la conexión: volver a intentar", + "@connectionFailedRetry": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:355" + }, + "connectionManagement": "Administración de conexiones", + "@connectionManagement": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:140" + }, + "connectionNotices": "Avisos de conexión", + "@connectionNotices": { + "description": "Connection notice visibility setting in Interface settings" + }, + "connectionNoticesDescription": "Mostrar avisos cuando no hay conexión y cuando vuelve", + "@connectionNoticesDescription": { + "description": "Description of the connection notice visibility setting" + }, + "connectionOk": "Conexión correcta", + "@connectionOk": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:353" + }, + "connectionStatus": "Estado de la conexión", + "@connectionStatus": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:607" + }, + "containsValuesOutsideTheSupportedRanges": "El preajuste «{presetName}» contiene valores fuera de los límites permitidos; se ajustaron así:\n", + "@containsValuesOutsideTheSupportedRanges": { + "description": "lib/features/settings/screens/equalizer_screen.dart:585", + "placeholders": { + "presetName": { + "type": "Object" + } + } + }, + "content": "Contenido", + "@content": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:195" + }, + "contentControls": "Contenido y controles", + "@contentControls": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:148" + }, + "contentPlacement": "Ubicación del contenido", + "@contentPlacement": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:228" + }, + "contentPlacement2": "Ubicación del contenido", + "@contentPlacement2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:271" + }, + "continueLabel": "Continuar", + "@continueLabel": { + "description": "lib/features/milestone/widgets/streak_popup.dart:265" + }, + "continueThroughTheSearchResults": "Seguir recorriendo los resultados de búsqueda", + "@continueThroughTheSearchResults": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:253" + }, + "continueThroughYourEntireLibrary": "Seguir recorriendo toda tu biblioteca", + "@continueThroughYourEntireLibrary": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:265" + }, + "controls": "Controles", + "@controls": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "conversionFailed": "Error al convertir: {error}", + "@conversionFailed": { + "description": "lib/widgets/alac_conversion_indicator.dart:249", + "placeholders": { + "error": { + "type": "Object" + } + } + }, + "convertedAudioCacheCleared": "Se vació la caché de audio convertido", + "@convertedAudioCacheCleared": { + "description": "lib/features/settings/screens/library_settings_screen.dart:416" + }, + "convertedSuccessfully": "{fileName} se convirtió correctamente", + "@convertedSuccessfully": { + "description": "lib/widgets/alac_conversion_indicator.dart:233", + "placeholders": { + "fileName": { + "type": "Object" + } + } + }, + "convertingAudio": "Convirtiendo audio…", + "@convertingAudio": { + "description": "lib/widgets/alac_conversion_indicator.dart:39" + }, + "convertingToWav": "Convirtiendo {fileName} a WAV…", + "@convertingToWav": { + "description": "lib/widgets/alac_conversion_indicator.dart:218", + "placeholders": { + "fileName": { + "type": "Object" + } + } + }, + "convolverImpulseResponse": "Convolución / respuesta al impulso", + "@convolverImpulseResponse": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3747" + }, + "copies": "{arg1} • {arg2} copias", + "@copies": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1077", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "copy": "Copiar", + "@copy": { + "description": "lib/features/settings/screens/logs_screen.dart:180" + }, + "copyLink": "Copiar enlace", + "@copyLink": { + "description": "lib/features/settings/screens/logs_screen.dart:299" + }, + "copyYourUserTokenFromListenbrainz": "Copia tu token de usuario desde los ajustes de ListenBrainz y pégalo abajo.", + "@copyYourUserTokenFromListenbrainz": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:662" + }, + "copyright": "Derechos de autor", + "@copyright": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:698" + }, + "cornerRadius": "Radio de las esquinas", + "@cornerRadius": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:136" + }, + "cosmicOrchestra": "Cosmic Orchestra", + "@cosmicOrchestra": { + "description": "lib/models/song.dart:322" + }, + "couldNotCheckForUpdates": "No se pudieron buscar actualizaciones", + "@couldNotCheckForUpdates": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:151" + }, + "couldNotConnectToLastFm": "No se pudo conectar con Last.fm. Comprueba las credenciales de la API e inténtalo de nuevo.", + "@couldNotConnectToLastFm": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:81" + }, + "couldNotConnectToListenbrainzCheck": "No se pudo conectar con ListenBrainz. Comprueba el token e inténtalo de nuevo.", + "@couldNotConnectToListenbrainzCheck": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:609" + }, + "couldNotLoadAlbumSongs": "No se pudieron cargar las canciones del álbum", + "@couldNotLoadAlbumSongs": { + "description": "lib/features/player/widgets/player_navigation.dart:85" + }, + "couldNotCreateThePosterImage": "No se pudo crear la imagen del póster.", + "@couldNotCreateThePosterImage": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:228" + }, + "couldNotLoadArtistSongs": "No se pudieron cargar las canciones del artista", + "@couldNotLoadArtistSongs": { + "description": "lib/features/player/widgets/player_navigation.dart:56" + }, + "couldNotLoadIr": "No se pudo cargar la respuesta al impulso: {e}", + "@couldNotLoadIr": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3723", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "couldNotLoadSession": "No se pudo cargar la sesión", + "@couldNotLoadSession": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:755" + }, + "couldNotOpenBrowser": "No se pudo abrir el navegador.", + "@couldNotOpenBrowser": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:683" + }, + "couldNotOpenKoFiPlease": "No se pudo abrir Ko-fi. Inténtalo de nuevo.", + "@couldNotOpenKoFiPlease": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:796" + }, + "couldNotOpenLink": "No se pudo abrir el enlace", + "@couldNotOpenLink": { + "description": "lib/features/settings/screens/support_flick_screen.dart:110" + }, + "couldNotOpenLink2": "No se pudo abrir el enlace: {e}", + "@couldNotOpenLink2": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:692", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "couldNotOpenThatPhotoTry": "No se pudo abrir esa foto. Prueba con otra imagen.", + "@couldNotOpenThatPhotoTry": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:170" + }, + "couldNotOpenTheLink": "No se pudo abrir el enlace", + "@couldNotOpenTheLink": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:584" + }, + "couldNotOpenTheLink2": "No se pudo abrir el enlace: {e}", + "@couldNotOpenTheLink2": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:588", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "couldNotOpenThePlayStore": "No se pudo abrir Play Store.", + "@couldNotOpenThePlayStore": { + "description": "lib/features/menu/screens/menu_screen.dart:229" + }, + "couldNotOpenThePlayStore2": "No se pudo abrir Play Store: {error}", + "@couldNotOpenThePlayStore2": { + "description": "lib/features/menu/screens/menu_screen.dart:237", + "placeholders": { + "error": { + "type": "Object" + } + } + }, + "couldNotOpenThePlayStore3": "No se pudo abrir Play Store", + "@couldNotOpenThePlayStore3": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:117" + }, + "couldNotPrepareTheEditedFile": "No se pudo preparar el archivo editado: {error}", + "@couldNotPrepareTheEditedFile": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String" + } + } + }, + "couldNotReachTheServer": "No se pudo acceder al servidor. Comprueba la URL y las credenciales e inténtalo de nuevo.", + "@couldNotReachTheServer": { + "description": "l10n pass: user-visible service error" + }, + "couldNotReadTheCoverColors": "No se pudieron leer los colores de la portada. La señal sigue disponible.", + "@couldNotReadTheCoverColors": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:103" + }, + "couldNotReadTheSelectedImage": "No se pudo leer la imagen seleccionada.", + "@couldNotReadTheSelectedImage": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:142" + }, + "couldNotReadTheSelectedLyrics": "No se pudo leer el archivo de letras seleccionado.", + "@couldNotReadTheSelectedLyrics": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:129" + }, + "couldNotResolveTheAlbum": "No se pudo identificar el álbum de esta canción.", + "@couldNotResolveTheAlbum": { + "description": "l10n pass: user-visible service error" + }, + "couldNotRenamePlaylist": "No se pudo cambiar el nombre de la lista de reproducción.", + "@couldNotRenamePlaylist": { + "description": "lib/features/playlists/playlist_rename_action.dart:31" + }, + "couldNotSaveTheLyricsFile": "No se pudo guardar el archivo de letras.", + "@couldNotSaveTheLyricsFile": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:565" + }, + "couldNotSaveYourRecapPlease": "No se pudo guardar el resumen. Inténtalo de nuevo.", + "@couldNotSaveYourRecapPlease": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:259" + }, + "couldNotUpdatePlaylistCover": "No se pudo actualizar la portada de la lista. Prueba con otra imagen.", + "@couldNotUpdatePlaylistCover": { + "description": "lib/features/playlists/playlist_cover_actions.dart:57" + }, + "couldNotUseTheSelectedLyrics": "No se pudo usar el archivo de letras seleccionado.", + "@couldNotUseTheSelectedLyrics": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:142" + }, + "couldnTOpenTheBrowserAutomatically": "No se pudo abrir el navegador automáticamente. Autoriza el acceso desde cualquier dispositivo con este enlace; completaremos el inicio de sesión cuando lo hagas:\n", + "@couldnTOpenTheBrowserAutomatically": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:589" + }, + "countingFiles": "Contando archivos…", + "@countingFiles": { + "description": "lib/features/settings/screens/library_settings_screen.dart:985" + }, + "covers": "{done} / {total} portadas", + "@covers": { + "description": "lib/features/settings/screens/library_settings_screen.dart:979", + "placeholders": { + "done": { + "type": "Object" + }, + "total": { + "type": "Object" + } + } + }, + "creatingPlaylists": "Creando listas de reproducción", + "@creatingPlaylists": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "cropCoverHint": "Pellizca para acercar y arrastra para reubicar", + "@cropCoverHint": { + "description": "lib/features/playlists/screens/playlist_cover_editor_screen.dart" + }, + "customActionButtons": "Botones de acciones personalizados", + "@customActionButtons": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "customizeTheHomeScreenWidget": "Personaliza la apariencia del widget de la pantalla de inicio.", + "@customizeTheHomeScreenWidget": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "customizing": "Personalizando", + "@customizing": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dedicatedSearchTab": "Pestaña de búsqueda exclusiva", + "@dedicatedSearchTab": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "drag": "Arrastrar", + "@drag": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dragAnywhereOnTheWaveform": "Arrastra en cualquier punto de la forma de onda para recorrer la pista. La forma de onda representa el volumen del audio a lo largo del tiempo.", + "@dragAnywhereOnTheWaveform": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dragEachFrequencyBandSlider": "Arrastra el control de cada banda de frecuencia para ajustar el sonido. El ecualizador se aplica a todo el audio de Flick.", + "@dragEachFrequencyBandSlider": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dragScrollHandle": "Arrastrar el control de desplazamiento", + "@dragScrollHandle": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dragTheScrollHandleOn": "Arrastra el control del borde derecho para avanzar por el alfabeto. Un globo muestra la letra actual.", + "@dragTheScrollHandleOn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "dragTracksByTheirHandle": "Arrastra las pistas desde el control para cambiar su orden. Los cambios se aplican de inmediato.", + "@dragTracksByTheirHandle": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "eachBrowseTabHasIts": "Cada pestaña de exploración tiene arriba su propia barra de búsqueda, que filtra el contenido de esa pestaña mientras escribes.", + "@eachBrowseTabHasIts": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "editCover": "Editar portada", + "crop": "Recortar", + "adjust": "Ajustar", + "editing": "Editando", + "@editing": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "enableDisable": "Activar / desactivar", + "@enableDisable": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "fastScroll": "Desplazamiento rápido", + "@fastScroll": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "fastScrollThroughLongLists": "Desplázate rápidamente por listas largas (pestaña Canciones).", + "@fastScrollThroughLongLists": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "favoritesTab": "Pestaña Favoritos", + "@favoritesTab": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "fetchingLyrics": "Buscando letras", + "@fetchingLyrics": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "filters": "Filtros", + "brightness": "Brillo", + "contrast": "Contraste", + "flickFetchesLyricsAutomaticallyWhen": "Flick busca letras automáticamente cuando están disponibles. También puedes pegarlas o editarlas manualmente.", + "@flickFetchesLyricsAutomaticallyWhen": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "folderPlayback": "Reproducción por carpeta", + "@folderPlayback": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "fromAnySongsLong": "En el menú que aparece al mantener presionada cualquier canción, elige Reproducir a continuación para insertarla justo después de la pista actual.", + "@fromAnySongsLong": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "gaplessPlaybackCrossfadeViewModes": "Reproducción sin pausas, fundido cruzado, modos de vista y apariencia del tema.", + "@gaplessPlaybackCrossfadeViewModes": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "generateAShareCardWith": "Crea una tarjeta para compartir con la portada y la información de la pista, o comparte el archivo directamente.", + "@generateAShareCardWith": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "gestures": "Gestos", + "@gestures": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "gridView": "Vista de cuadrícula", + "@gridView": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "homeScreenWidget": "Widget de pantalla de inicio", + "@homeScreenWidget": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "ifSearchIsInYour": "Si agregas Buscar a la barra de navegación, puedes buscar canciones, álbumes y artistas a la vez, con resultados agrupados.", + "@ifSearchIsInYour": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "immersiveView": "Vista inmersiva", + "@immersiveView": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "inAppInfoU2192Interactive": "En Información de la app → Tutorial interactivo, vuelve a reproducir el recorrido guiado. Ver bienvenida vuelve a mostrar las pantallas de bienvenida.", + "@inAppInfoU2192Interactive": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "inTabSearch": "Búsqueda dentro de la pestaña", + "@inTabSearch": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "inTheFullPlayerTap": "En el reproductor completo, toca el ícono del visualizador para activarlo o desactivarlo.", + "@inTheFullPlayerTap": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "interface": "Interfaz", + "@interface": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "lastFmAndListenBrainzScrobbling": "Configuración del registro de reproducciones en Last.fm y ListenBrainz.", + "@lastFmAndListenBrainzScrobbling": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "layoutModeSizingMiniPlayer": "Modo de diseño, tamaño, gesto del minirreproductor y botones de acciones rápidas personalizados.", + "@layoutModeSizingMiniPlayer": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "library": "Biblioteca", + "@library": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "longPressASong": "Mantén presionada una canción", + "@longPressASong": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "longPressOrTapAgain": "Mantén presionado o vuelve a tocar para cambiar de estilo de visualizador (barras, onda, radial, etc.).", + "@longPressOrTapAgain": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "longPressTheNavBar": "Mantén presionada la barra de navegación o ve a Ajustes → Barra inferior para elegir qué pestañas aparecen y en qué orden.", + "@longPressTheNavBar": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "longPressYourHomeScreen": "Mantén presionada la pantalla de inicio → Agregar widget → Flick. Elige un tamaño y colócalo en la pantalla de inicio.", + "@longPressYourHomeScreen": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manageScanFoldersTriggerRescans": "Administra las carpetas de análisis, vuelve a analizarlas y usa la herramienta para quitar duplicados.", + "@manageScanFoldersTriggerRescans": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualBands": "Bandas manuales", + "@manualBands": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualBitPerfectCapsule": "Cápsula de bit perfecto", + "@manualBitPerfectCapsule": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualBottomBar": "Barra inferior", + "@manualBottomBar": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualLongPress": "Mantener presionado", + "@manualLongPress": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualLyricsSyncStudio": "Estudio de letras y sincronización", + "@manualLyricsSyncStudio": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualPlayNext": "Reproducir a continuación", + "@manualPlayNext": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualPlaybackSpeed": "Velocidad de reproducción", + "@manualPlaybackSpeed": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualQueue2": "Cola", + "@manualQueue2": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualRemoving": "Quitar", + "@manualRemoving": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualSongs": "Canciones", + "@manualSongs": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualSwipeLeftRightOnThe": "Desliza a la izquierda o a la derecha en el área principal para cambiar entre las pestañas de la barra de navegación.", + "@manualSwipeLeftRightOnThe": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "manualTap": "Tocar", + "@manualTap": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "nextPreviousTrackOrToggle": "Pista siguiente/anterior (o activar o desactivar el visualizador, según los ajustes).", + "@nextPreviousTrackOrToggle": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openAPlaylistToReorder": "Abre una lista para reordenar las canciones (arrastra el control), quitarlas (desliza o mantén presionado) o cambiar el nombre o eliminar la lista desde su menú.", + "@openAPlaylistToReorder": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openFromTheLyricsEdit": "Ábrelo desde el ícono de edición de letras. Toca Marcar cuando suene cada línea para sincronizarla con la música. Guarda para conservar la sincronización.", + "@openFromTheLyricsEdit": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openTheActionsSheetFor": "Abre la hoja de acciones de una canción o personaliza la barra de navegación.", + "@openTheActionsSheetFor": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openTheFullPlayer": "Abrir el reproductor completo", + "@openTheFullPlayer": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openTheQueueFromThe": "Abre la cola desde el reproductor completo. La pista que se está reproduciendo aparece resaltada y las siguientes se muestran debajo.", + "@openTheQueueFromThe": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "openingTheFullPlayer": "Abriendo el reproductor completo", + "@openingTheFullPlayer": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "opensTheActionsSheetPlay": "Abre la hoja de acciones: Reproducir a continuación, Agregar a la cola, Agregar a la lista, Ir al álbum, Ir al artista, Compartir, Ver información o Eliminar.", + "@opensTheActionsSheetPlay": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "playASongOpenAn": "Reproduce una canción, abre un álbum o activa un control.", + "@playASongOpenAn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "playPauseNextPrevious": "Reproducir / Pausar / Siguiente / Anterior", + "@playPauseNextPrevious": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "playTheWholeAlbumShuffle": "Reproduce el álbum completo, mézclalo o elige canciones individuales. Arriba se muestran la portada, el año y el artista.", + "@playTheWholeAlbumShuffle": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "playing": "Reproduciendo", + "@playing": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "playingASong": "Reproduciendo una canción", + "@playingASong": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "reSyncALineBy": "Vuelve a sincronizar una línea tocándola de nuevo en el momento correcto.", + "@reSyncALineBy": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "removeItFromTheQueue": "Quitar de la cola.", + "@removeItFromTheQueue": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "reordering": "Cambiando el orden", + "@reordering": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "replayTutorial": "Volver a reproducir el tutorial", + "@replayTutorial": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "saturation": "Saturación", + "scrubTheWaveformSeekbarReorder": "Deslizar la barra de reproducción por la forma de onda; reordenar elementos de la cola y canciones de la lista.", + "@scrubTheWaveformSeekbarReorder": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "seeYourMusicOrganizedBy": "Consulta tu música organizada según la estructura de carpetas del disco. Útil si organizas los archivos manualmente.", + "@seeYourMusicOrganizedBy": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "selectionMode": "Modo de selección", + "@selectionMode": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "setACountdownAfterWhich": "Configura una cuenta regresiva para detener la reproducción. Opciones: 5, 10, 15, 30, 45 o 60 minutos, o al terminar la pista.", + "@setACountdownAfterWhich": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "showOrHideHomeScreen": "Mostrar u ocultar secciones y pestañas de la pantalla de inicio.", + "@showOrHideHomeScreen": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "showsTheArtistsAlbums": "Muestra los álbumes del artista y la lista completa de canciones. Reproduce todo, mézclalo o elige desde qué canción empezar.", + "@showsTheArtistsAlbums": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "shuffleFromTheHeaderPlays": "El botón Aleatorio del encabezado reproduce toda la biblioteca en orden aleatorio.", + "@shuffleFromTheHeaderPlays": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "shuffleRepeat": "Aleatorio y repetir", + "@shuffleRepeat": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "sort": "Ordenar", + "@sort": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "sortAlbumsByTitleArtist": "Ordena los álbumes por título, artista, año o fecha en que se agregaron desde el ícono de orden.", + "@sortAlbumsByTitleArtist": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "sortPersistsAcrossSessions": "El orden se conserva entre sesiones.", + "@sortPersistsAcrossSessions": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "starRateTheCurrentTrack": "Asigna una calificación por estrellas a la pista actual. Las calificaciones se guardan y puedes usarlas para ordenar.", + "@starRateTheCurrentTrack": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "styles": "Estilos", + "@styles": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeATrackLeftOr": "Desliza una pista a la izquierda o a la derecha para quitarla de la cola.", + "@swipeATrackLeftOr": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeBetweenTabs": "Deslizar para cambiar de pestaña", + "@swipeBetweenTabs": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeHorizontallyOnMiniPlayer": "Deslizar horizontalmente sobre el minirreproductor", + "@swipeHorizontallyOnMiniPlayer": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeLeftRightOnThe": "Desliza el minirreproductor a la izquierda o a la derecha para ir a la pista siguiente o anterior (si está habilitado en Ajustes).", + "@swipeLeftRightOnThe": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeOnAQueueItem": "Deslizar un elemento de la cola", + "@swipeOnAQueueItem": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "swipeToSwitch": "Deslizar para cambiar", + "@swipeToSwitch": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "syncStudio": "Estudio de sincronización", + "@syncStudio": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapAFolderToPlay": "Toca una carpeta para reproducir todas las canciones que contiene, incluidas las subcarpetas.", + "@tapAFolderToPlay": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapAPlaylistToPlay": "Toca una lista para reproducirla en orden o usa el botón Aleatorio para mezclar las canciones.", + "@tapAPlaylistToPlay": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapAnySongToPlay": "Toca cualquier canción para reproducirla de inmediato. La cola se reconstruye a partir de esa canción.", + "@tapAnySongToPlay": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapAnywhereOnTheMini": "Toca cualquier parte del minirreproductor para ampliarlo y abrir el reproductor completo.", + "@tapAnywhereOnTheMini": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapShuffleToToggleRandom": "Toca Aleatorio para activar el orden aleatorio. Toca Repetir para alternar entre desactivado → todo → una canción. Mantén presionado cualquiera de los dos para ver más opciones.", + "@tapShuffleToToggleRandom": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheAlbumArtTo": "Toca la portada para alternar entre la vista de portada y la de un disco de vinilo giratorio.", + "@tapTheAlbumArtTo": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheButtonToCreate": "Toca el botón + para crear una lista de reproducción. Ponle un nombre y agrega canciones manteniendo presionada cualquier canción y eligiendo Agregar a la lista.", + "@tapTheButtonToCreate": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheCheckIconIn": "Toca la marca de verificación del encabezado para entrar en el modo de selección. Elige varias canciones para agregarlas a la cola o a una lista, o para eliminarlas en lote.", + "@tapTheCheckIconIn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheEQIconTo": "Toca el ícono del ecualizador para abrirlo y ver los preajustes y los controles manuales de bandas.", + "@tapTheEQIconTo": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheEditIconIn": "Toca el ícono de edición de las letras para abrir el Estudio de letras y sincronización.", + "@tapTheEditIconIn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheHeartOnA": "Toca el corazón de una canción (en el reproductor completo o en el menú que aparece al mantenerla presionada) para marcarla como favorita.", + "@tapTheHeartOnA": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheLyricsIconIn": "Toca el ícono de letras en el reproductor completo. Las letras sincronizadas se desplazan y resaltan automáticamente; las que no están sincronizadas aparecen como texto normal.", + "@tapTheLyricsIconIn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheLyricsIconTo": "Toca el ícono de letras para abrir su vista. Si hay letras sincronizadas, se resaltarán al ritmo de la música.", + "@tapTheLyricsIconTo": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheMiniPlayerThe": "Toca el minirreproductor para ampliarlo. Se abrirá el reproductor completo con la portada del álbum, la barra de reproducción con forma de onda y todos los controles.", + "@tapTheMiniPlayerThe": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheQueueIconTo": "Toca el ícono de la cola para ver y reordenar las próximas pistas. Arrástralas para cambiar el orden o desliza para quitarlas.", + "@tapTheQueueIconTo": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapTheSortIconTop": "Toca el ícono de orden (arriba a la derecha del encabezado) para abrir el panel Ordenar y filtrar. Ordena por título, artista, álbum, fecha en que se agregó o última reproducción. Filtra por tipo de archivo (FLAC, MP3, etc.).", + "@tapTheSortIconTop": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "tapToHideControlsFor": "Toca para ocultar los controles y dejar solo la portada del álbum. Toca otra vez para mostrarlos.", + "@tapToHideControlsFor": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "theLeftAndRightAction": "Puedes personalizar los botones de acción izquierdo y derecho, sobre la fila de reproducción, en Ajustes → Diseño del reproductor → Acciones rápidas.", + "@theLeftAndRightAction": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "theMiniPlayerSitsAbove": "El minirreproductor aparece sobre la barra de navegación y muestra la portada, el título y el artista de la pista actual, junto con su progreso.", + "@theMiniPlayerSitsAbove": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "theSongsTabListsEvery": "La pestaña Canciones muestra todas las pistas que Flick ha analizado. Desplázate para explorar o usa la barra de búsqueda para filtrar por título o artista.", + "@theSongsTabListsEvery": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "theWidgetShowsCurrentTrack": "El widget muestra la portada y el título de la pista actual, con controles para reproducir, pausar y avanzar. Toca la portada para abrir la app.", + "@theWidgetShowsCurrentTrack": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "thisScreenReopenAnytimeFrom": "Esta pantalla. Puedes volver a abrirla en cualquier momento desde Ajustes → Ayuda y manual.", + "@thisScreenReopenAnytimeFrom": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "toggleTheAudioVisualizerOn": "Activa o desactiva el visualizador de audio y cambia su estilo desde el ícono del visualizador.", + "@toggleTheAudioVisualizerOn": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "toggleTheMasterSwitchAt": "Activa o desactiva el interruptor principal de arriba para omitir el ecualizador sin perder tus ajustes.", + "@toggleTheMasterSwitchAt": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "toggling": "Activando o desactivando", + "@toggling": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "uac2USBDACPreferencesAnd": "Preferencias del DAC USB UAC2 y ajustes del ecualizador.", + "@uac2USBDACPreferencesAnd": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "useTheWaveformScrubberTo": "Usa la barra de reproducción con forma de onda para ir a una línea que te perdiste.", + "@useTheWaveformScrubberTo": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "viewingLyrics": "Viendo las letras", + "@viewingLyrics": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "viewingTheQueue": "Viendo la cola", + "@viewingTheQueue": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "vinylMorph": "Efecto de transformación en vinilo", + "@vinylMorph": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "visualizerToggle": "Activar o desactivar el visualizador", + "@visualizerToggle": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "warmth": "Calidez", + "vignette": "Viñeta", + "rotateLeft": "Girar a la izquierda", + "rotateRight": "Girar a la derecha", + "flipHorizontal": "Voltear horizontalmente", + "flipVertical": "Voltear verticalmente", + "filterOriginal": "Original", + "filterMono": "Mono", + "filterWarm": "Cálido", + "filterCool": "Frío", + "filterFade": "Desvanecido", + "filterPunch": "Intenso", + "filterNoir": "Noir", + "create": "Crear", + "@create": { + "description": "lib/features/playlists/screens/playlists_screen.dart:403" + }, + "createACollection": "Crear una colección", + "@createACollection": { + "description": "lib/features/menu/screens/menu_screen.dart:1448" + }, + "createACustomPreset": "Crear un preajuste personalizado", + "@createACustomPreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:738" + }, + "createAPlaylistImportAnM3u": "Crea una lista de reproducción, importa una lista M3U o deja que las mezclas de arriba acompañen la sesión.", + "@createAPlaylistImportAnM3u": { + "description": "lib/features/menu/screens/menu_screen.dart:991" + }, + "createLyrics": "Crear letras", + "@createLyrics": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:208" + }, + "createNewPlaylist": "Crear una lista de reproducción", + "@createNewPlaylist": { + "description": "lib/features/songs/screens/songs_screen.dart:1442" + }, + "createNewPlaylist2": "Crear una lista de reproducción", + "@createNewPlaylist2": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:464" + }, + "createOrRefreshPlaylistsFoundInside": "Crear o actualizar las listas de reproducción encontradas en las carpetas analizadas", + "@createOrRefreshPlaylistsFoundInside": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1856" + }, + "createPlaylist": "Crear lista de reproducción", + "@createPlaylist": { + "description": "lib/features/playlists/screens/playlists_screen.dart:124" + }, + "createPlaylistFromSelected": "Crear una lista con la selección", + "@createPlaylistFromSelected": { + "description": "lib/features/songs/screens/songs_screen.dart:1586" + }, + "createYourFirstPlaylistOrJump": "Crea tu primera lista de reproducción o abre una de tus colecciones guardadas.", + "@createYourFirstPlaylistOrJump": { + "description": "lib/features/menu/screens/menu_screen.dart:974" + }, + "createYourFirstPlaylistToOrganize": "Crea tu primera lista de reproducción para organizar\ntus canciones favoritas", + "@createYourFirstPlaylistToOrganize": { + "description": "lib/features/playlists/screens/playlists_screen.dart:242" + }, + "created": "Creada: {arg1}", + "@created": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:435", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "createdAndAddedSong": "Se creó {arg1} y se agregó la canción", + "@createdAndAddedSong": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:546", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "createdAndAddedSongs": "Se creó {name} y se agregaron {arg1} canciones", + "@createdAndAddedSongs": { + "description": "lib/features/songs/screens/songs_screen.dart:1523", + "placeholders": { + "name": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "creativeFx": "Efectos creativos", + "@creativeFx": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3505" + }, + "credentialsRejectedByReEnterThe": "{arg1} rechazó las credenciales. Vuelve a ingresar la contraseña.", + "@credentialsRejectedByReEnterThe": { + "description": "lib/features/settings/screens/network_sources_screen.dart:110", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "credentialsSavedSuccessfully": "Las credenciales se guardaron correctamente.", + "@credentialsSavedSuccessfully": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:622" + }, + "crispestHeavierDuringFastScrolling": "Más nítido: mayor carga durante el desplazamiento rápido", + "@crispestHeavierDuringFastScrolling": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:167" + }, + "crossfade": "Fundido cruzado", + "@crossfade": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:318" + }, + "crossfadeIsMostReliableOnThe": "El fundido cruzado funciona mejor con el motor Estándar. Puede ser inestable con el motor de alta calidad (Rust); cambia a Estándar para obtener transiciones uniformes.", + "@crossfadeIsMostReliableOnThe": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:372" + }, + "crossfeed": "Mezcla entre canales", + "@crossfeed": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:395" + }, + "crossfeedBs2b": "Mezcla entre canales (BS2B)", + "@crossfeedBs2b": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:428" + }, + "crossfeedEasy": "Mezcla entre canales sencilla", + "@crossfeedEasy": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:396" + }, + "crossfeedRunsOnTheHighQuality": "La mezcla entre canales solo funciona con el motor de alta calidad (Rust). El motor Estándar reproduce el audio sin este efecto.", + "@crossfeedRunsOnTheHighQuality": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:453" + }, + "crystalCaverns": "Crystal Caverns", + "@crystalCaverns": { + "description": "lib/models/song.dart:348" + }, + "cueSheetTracksCannotBeEdited": "No se pueden editar las pistas de una hoja CUE.", + "@cueSheetTracksCannotBeEdited": { + "description": "lib/services/metadata_editor_service.dart:67" + }, + "cueSheetTracksCannotBeEdited2": "No se pueden editar las pistas de una hoja CUE", + "@cueSheetTracksCannotBeEdited2": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:319" + }, + "currentArtwork": "Portada actual", + "@currentArtwork": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:327" + }, + "currentCustomArt": "Imagen personalizada actual", + "@currentCustomArt": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:326" + }, + "currentPlaybackMode": "Modo de reproducción actual", + "@currentPlaybackMode": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1080" + }, + "currentRoute": "Ruta actual: {arg1}.", + "@currentRoute": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:528", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "currentSongPreviewOnly": "Canción actual · solo vista previa", + "@currentSongPreviewOnly": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:389" + }, + "currentStreak": "Racha actual", + "@currentStreak": { + "description": "lib/features/milestone/screens/milestones_screen.dart:756" + }, + "curvature": "Curvatura", + "@curvature": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:26" + }, + "curvatureSizingDepthAndVisuals": "Curvatura, tamaño, profundidad y efectos visuales", + "@curvatureSizingDepthAndVisuals": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:129" + }, + "curve": "Curva", + "@curve": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:571" + }, + "curveOfTheOrbitArcHigher": "Curva del arco orbital: cuanto mayor sea, más suave", + "@curveOfTheOrbitArcHigher": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:27" + }, + "curvePreview": "Vista previa de la curva", + "@curvePreview": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1778" + }, + "curvedWave": "Onda curva", + "@curvedWave": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:94" + }, + "custom": "Personalizado", + "@custom": { + "description": "lib/features/settings/screens/equalizer_screen.dart:782" + }, + "customFormat": "Formato personalizado", + "@customFormat": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:266" + }, + "customFormatForcesPlaybackToThe": "El formato personalizado obliga a reproducir en el formato de salida seleccionado. Si la frecuencia de muestreo, la profundidad de bits o los canales elegidos no son adecuados para la canción o el dispositivo, el sonido, el tono, la velocidad o la estabilidad podrían verse afectados.", + "@customFormatForcesPlaybackToThe": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1315" + }, + "customFormatIsDisabledInBit": "El formato personalizado está desactivado en el modo Bit perfecto (DAC USB), que requiere una coincidencia exacta de la frecuencia de muestreo. Desactiva Bit perfecto (DAC USB) para usar formatos personalizados.", + "@customFormatIsDisabledInBit": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:281" + }, + "customFormatIsUnavailableBecauseAudio": "El formato personalizado no está disponible porque el formato de audio está desactivado en Ajustes.", + "@customFormatIsUnavailableBecauseAudio": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:286" + }, + "customWidth": "Ancho personalizado", + "@customWidth": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:90" + }, + "customizeBottomBar": "Personalizar la barra inferior", + "@customizeBottomBar": { + "description": "lib/widgets/navigation/flick_nav_bar.dart:463" + }, + "customizeHomeScreenWidgets": "Personalizar los widgets de la pantalla de inicio", + "@customizeHomeScreenWidgets": { + "description": "lib/features/settings/screens/settings_screen.dart:223" + }, + "customizeOrbital": "Personalizar Orbital", + "@customizeOrbital": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:17" + }, + "customizeWhichTabsAppearAndTheir": "Personaliza qué pestañas aparecen y su tamaño", + "@customizeWhichTabsAppearAndTheir": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:181" + }, + "dAgo": "hace {arg1} d", + "@dAgo": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:494", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dAgo2": "hace {arg1} d", + "@dAgo2": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:494", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dacClaim": "Asignación del DAC", + "@dacClaim": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:700" + }, + "dacWillBeOfferedAgain": "{count, plural, =1{Se volverá a ofrecer {count} DAC} other{Se volverán a ofrecer {count} DAC}}.", + "@dacWillBeOfferedAgain": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:514", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "daily": "Diario", + "@daily": { + "description": "lib/data/repositories/recently_played_repository.dart:14" + }, + "damp": "Amortiguación", + "@damp": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3589" + }, + "dapNativeBitOrder": "Orden de bits nativo del DAP", + "@dapNativeBitOrder": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1521" + }, + "dapNativeByteGrouping": "Agrupación de bytes nativa del DAP", + "@dapNativeByteGrouping": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1532" + }, + "dark": "Oscuro", + "@dark": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:180" + }, + "dataCollection": "Recopilación de datos", + "@dataCollection": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:34" + }, + "date": "Fecha", + "@date": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:697" + }, + "dateAdded": "Fecha en que se agregó", + "@dateAdded": { + "description": "lib/features/folders/screens/folders_screen.dart:2596" + }, + "dateAddedNewest": "Fecha en que se agregó (más reciente)", + "@dateAddedNewest": { + "description": "lib/features/playlists/widgets/playlist_sort_bottom_sheet.dart:23" + }, + "dateAddedOldest": "Fecha en que se agregó (más antigua)", + "@dateAddedOldest": { + "description": "lib/features/playlists/widgets/playlist_sort_bottom_sheet.dart:25" + }, + "dayStreak": "días seguidos", + "@dayStreak": { + "description": "lib/features/milestone/widgets/streak_popup.dart:193" + }, + "dayStreak2": "Racha diaria", + "@dayStreak2": { + "description": "lib/app/app.dart:423" + }, + "dayStreak3": "Racha diaria", + "@dayStreak3": { + "description": "lib/features/milestone/screens/milestones_screen.dart:378" + }, + "dayStreaks": "Rachas diarias", + "@dayStreaks": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:161" + }, + "dayUnit": "{count, plural, =1{día} other{días}}", + "@dayUnit": { + "description": "lib/features/milestone/screens/milestones_screen.dart:782", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "db10": "{arg1} dB", + "@db10": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3320", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "db13": "{arg1} dB", + "@db13": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3421", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "db15": "{arg1}% {arg2} dB", + "@db15": { + "description": "lib/widgets/uac2/iso_volume_popup.dart:275", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "db2": "{value} dB", + "@db2": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1549", + "placeholders": { + "value": { + "type": "Object" + } + } + }, + "db9": "{arg1} dB", + "@db9": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2645", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dbCut": "atenuación de {arg1} dB", + "@dbCut": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2377", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dbMax": "máx. {arg1} dB", + "@dbMax": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1787", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "deactivateFallback": "Desactivar alternativa", + "@deactivateFallback": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:178" + }, + "dec": "dic", + "@dec": { + "description": "lib/features/milestone/screens/milestones_screen.dart:513" + }, + "decode": "Decodificar", + "@decode": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:917" + }, + "decodeSongsAfterScanningToCache": "Decodificar las canciones después del análisis para guardar en caché los picos de forma de onda y las métricas de volumen", + "@decodeSongsAfterScanningToCache": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1899" + }, + "deepEarth": "Deep Earth", + "@deepEarth": { + "description": "lib/models/song.dart:353" + }, + "deepScan": "Análisis profundo", + "@deepScan": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1868" + }, + "deepScanOff": "Análisis profundo desactivado", + "@deepScanOff": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1694" + }, + "deepScanOn": "Análisis profundo activado", + "@deepScanOn": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1694" + }, + "defaultAndroidPlaybackEngineUsedBy": "Motor de reproducción predeterminado de Android que Flick usa actualmente.", + "@defaultAndroidPlaybackEngineUsedBy": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:761" + }, + "defaultAndroidPlayerPlaysEverything": "Reproductor predeterminado de Android: reproduce todo de forma confiable. La opción más segura para la mayoría de las personas.", + "@defaultAndroidPlayerPlaysEverything": { + "description": "lib/features/menu/screens/menu_screen.dart:484" + }, + "defaultLabel": "Predeterminado", + "@defaultLabel": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:859" + }, + "del": "Supr", + "@del": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1019" + }, + "delays": "Retardos", + "@delays": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3615" + }, + "delete": "Eliminar", + "@delete": { + "description": "lib/features/playlists/screens/playlists_screen.dart:649" + }, + "deleteAndAllSongsAndPlaylists": "¿Eliminar «{arg1}» y todas las canciones y listas sincronizadas desde ahí? Se conservarán las descargas en caché.", + "@deleteAndAllSongsAndPlaylists": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:329", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "deleteFile": "Eliminar archivo", + "@deleteFile": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:753" + }, + "deleteFiles": "Eliminar archivos", + "@deleteFiles": { + "description": "lib/features/songs/screens/songs_screen.dart:1644" + }, + "deletePlaylist": "Eliminar lista de reproducción", + "@deletePlaylist": { + "description": "lib/features/playlists/screens/playlists_screen.dart:328" + }, + "deletePreset": "¿Eliminar el preajuste?", + "@deletePreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:704" + }, + "deleteSelected": "Eliminar selección", + "@deleteSelected": { + "description": "lib/features/songs/screens/songs_screen.dart:1594" + }, + "deleteSong": "Eliminar canción", + "@deleteSong": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:197" + }, + "deleteSong2": "¿Eliminar la canción?", + "@deleteSong2": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:718" + }, + "deleteSong3": "Eliminar canción", + "@deleteSong3": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:716" + }, + "deleteSongs": "¿Eliminar {arg1} canciones?", + "@deleteSongs": { + "description": "lib/features/songs/screens/songs_screen.dart:1624", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "deleteSongs2": "Eliminar canciones", + "@deleteSongs2": { + "description": "lib/features/songs/screens/songs_screen.dart:1622" + }, + "deleteThisCannotBeUndone": "¿Eliminar «{arg1}»? Esta acción no se puede deshacer.", + "@deleteThisCannotBeUndone": { + "description": "lib/features/settings/screens/equalizer_screen.dart:705", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "deleted": "Se eliminó «{arg1}»", + "@deleted": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:829", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "deletedSongs": "Se eliminaron {arg1} canciones", + "@deletedSongs": { + "description": "lib/features/songs/screens/songs_screen.dart:1714", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "depth": "Profundidad", + "@depth": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:125" + }, + "deselectAll": "Anular selección de todo", + "@deselectAll": { + "description": "lib/features/songs/screens/songs_screen.dart:1574" + }, + "designed": "Diseñado", + "@designed": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:593" + }, + "detailScreens": "Pantallas de detalles", + "@detailScreens": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:137" + }, + "details": "Detalles", + "@details": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:522" + }, + "developerMode": "Modo de desarrollador", + "@developerMode": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:359" + }, + "developerOptionsIsDisabledEnableIt": "Las Opciones para desarrolladores están desactivadas. Actívalas en Ajustes → Acerca del teléfono (toca 7 veces Número de compilación) y vuelve a intentarlo.", + "@developerOptionsIsDisabledEnableIt": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:173" + }, + "device": "Dispositivo", + "@device": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:641" + }, + "deviceCapabilities": "Capacidades del dispositivo", + "@deviceCapabilities": { + "description": "lib/widgets/uac2/uac2_device_capabilities.dart:38" + }, + "deviceConnected": "Dispositivo conectado", + "@deviceConnected": { + "description": "lib/widgets/uac2/uac2_hotplug_monitor.dart:48" + }, + "deviceDac": "DAC del dispositivo", + "@deviceDac": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:923" + }, + "deviceDacVolume": "Volumen del DAC del dispositivo", + "@deviceDacVolume": { + "description": "lib/widgets/uac2/uac2_volume_control.dart:163" + }, + "deviceDisconnected": "Dispositivo desconectado", + "@deviceDisconnected": { + "description": "lib/widgets/uac2/uac2_hotplug_monitor.dart:49" + }, + "deviceInformation": "Información del dispositivo", + "@deviceInformation": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:79" + }, + "deviceType": "Tipo de dispositivo", + "@deviceType": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:553" + }, + "devices": "Dispositivos", + "@devices": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:306" + }, + "direct": "Directo", + "@direct": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:657" + }, + "directAlsaOutputIsActiveAnd": "La salida ALSA directa está activa y omite el servidor de audio de Android.", + "@directAlsaOutputIsActiveAnd": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1047" + }, + "directLibusbIsochronousUsbEngineBest": "Motor USB isócrono directo con libusb. Se recomienda combinarlo con Bit perfecto (DAC USB) para verificar la reproducción en un DAC externo.", + "@directLibusbIsochronousUsbEngineBest": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:830" + }, + "directUsb": "USB directo", + "@directUsb": { + "description": "lib/widgets/uac2/uac2_player_status.dart:224" + }, + "directUsbDeviceManaged": "USB directo administrado por el dispositivo", + "@directUsbDeviceManaged": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:691" + }, + "directUsbExperimental": "USB directo experimental", + "@directUsbExperimental": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:500" + }, + "disableBatteryOptimization": "Desactivar la optimización de batería", + "@disableBatteryOptimization": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1972" + }, + "disableBatteryOptimizationRecommended": "Desactivar la optimización de batería (recomendado)", + "@disableBatteryOptimizationRecommended": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1971" + }, + "disabled": "Desactivado", + "@disabled": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:185" + }, + "disabledInBitPerfectMode": "Desactivado en modo bit perfecto", + "@disabledInBitPerfectMode": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:274" + }, + "disabledInBitPerfectUsbDac": "Desactivado en modo Bit perfecto (DAC USB) (requiere una frecuencia exacta)", + "@disabledInBitPerfectUsbDac": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:235" + }, + "disabledWhileBothBitPerfectOptions": "Desactivado porque las dos opciones de bit perfecto están apagadas en este DAP.", + "@disabledWhileBothBitPerfectOptions": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:760" + }, + "disc": "Disco", + "@disc": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:80" + }, + "disc2": "Disco n.º", + "@disc2": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:288" + }, + "discard": "Descartar", + "@discard": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:594" + }, + "discardChanges": "¿Descartar los cambios?", + "@discardChanges": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:588" + }, + "discardChanges2": "¿Descartar los cambios?", + "@discardChanges2": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:562" + }, + "disconnect": "Desconectar", + "@disconnect": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:253" + }, + "disconnectBehaviorAndCodecInfo": "Comportamiento al desconectarse e información del códec", + "@disconnectBehaviorAndCodecInfo": { + "description": "lib/features/settings/screens/settings_screen.dart:148" + }, + "disconnectFrom": "Desconectar de {arg1}", + "@disconnectFrom": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:113", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "disconnectLastFm": "¿Desconectar Last.fm?", + "@disconnectLastFm": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:156" + }, + "disconnectListenbrainz": "¿Desconectar ListenBrainz?", + "@disconnectListenbrainz": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:95" + }, + "discord": "Discord", + "@discord": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:501" + }, + "discoversDlnaUpnpAndChromecastReceivers": "Busca receptores DLNA, UPnP y Chromecast en tu red", + "@discoversDlnaUpnpAndChromecastReceivers": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:76" + }, + "dismiss": "Descartar", + "@dismiss": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2000" + }, + "display": "Pantalla", + "@display": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:38" + }, + "displayFileFormatAndBitrateIn": "Mostrar el formato de archivo y la tasa de bits en el modo inmersivo", + "@displayFileFormatAndBitrateIn": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:205" + }, + "displayFileFormatAndBitrateIn2": "Mostrar el formato de archivo y la tasa de bits en el modo de tarjeta con portada", + "@displayFileFormatAndBitrateIn2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:343" + }, + "displayTextLabelsBelowIcons": "Mostrar etiquetas de texto debajo de los íconos", + "@displayTextLabelsBelowIcons": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:307" + }, + "displayTheAlbumNameInArtwork": "Mostrar el nombre del álbum en el modo de tarjeta con portada", + "@displayTheAlbumNameInArtwork": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:330" + }, + "displayTheArtistNameInArtwork": "Mostrar el nombre del artista en el modo de tarjeta con portada", + "@displayTheArtistNameInArtwork": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:318" + }, + "displayTheArtistNameInImmersive": "Mostrar el nombre del artista en el modo inmersivo", + "@displayTheArtistNameInImmersive": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:193" + }, + "displayTheTrackTitleInArtwork": "Mostrar el título de la pista en el modo de tarjeta con portada", + "@displayTheTrackTitleInArtwork": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:306" + }, + "displayTheTrackTitleInImmersive": "Mostrar el título de la pista en el modo inmersivo", + "@displayTheTrackTitleInImmersive": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:181" + }, + "distanceBetweenSongsAlongTheArc": "Distancia entre canciones a lo largo del arco", + "@distanceBetweenSongsAlongTheArc": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:63" + }, + "dlnaAndUpnpReceiversAreControlled": "Los receptores DLNA y UPnP se controlan directamente con Dart puro, sin dependencias adicionales. La compatibilidad con Chromecast usa el SDK nativo de Cast. Se pueden transmitir fuentes de red (Subsonic, WebDAV, Jellyfin y UPnP), archivos locales y canciones en caché; los archivos locales se sirven directamente desde este teléfono. Mientras transmites, las teclas de volumen y el panel de volumen del sistema controlan el dispositivo conectado.", + "@dlnaAndUpnpReceiversAreControlled": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:300" + }, + "dlnaUpnp": "DLNA / UPnP", + "@dlnaUpnp": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:45" + }, + "dlnaUpnpAndChromecastReceivers": "Receptores DLNA, UPnP y Chromecast", + "@dlnaUpnpAndChromecastReceivers": { + "description": "lib/features/settings/screens/settings_screen.dart:160" + }, + "donTShowAgainToday": "No volver a mostrar hoy", + "@donTShowAgainToday": { + "description": "lib/features/milestone/widgets/streak_popup.dart:287" + }, + "donate": "Donar", + "@donate": { + "description": "lib/features/settings/screens/support_flick_screen.dart:198" + }, + "donateFundFeaturesAndKeepThe": "Contribuye, apoya nuevas funciones y ayuda a mantener viva la app", + "@donateFundFeaturesAndKeepThe": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:718" + }, + "done": "Listo", + "@done": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:634" + }, + "dop": "DoP", + "@dop": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:712" + }, + "dots": "Puntos", + "@dots": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:111" + }, + "doubleTapABandToReset": "Toca dos veces una banda para restablecerla", + "@doubleTapABandToReset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1753" + }, + "doubleTapToReset": "Toca dos veces para restablecer", + "@doubleTapToReset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:383" + }, + "doubleTapToResetThisBand": "Toca dos veces para restablecer esta banda", + "@doubleTapToResetThisBand": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1904" + }, + "down": "{arg1} abajo", + "@down": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:566", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "downloadTheLatestApkFromFlick": "Descarga el APK más reciente desde flick-player.site", + "@downloadTheLatestApkFromFlick": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:145" + }, + "downloadUpdate": "Descargar actualización", + "@downloadUpdate": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:638" + }, + "dp": "{arg1} dp", + "@dp": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:107", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dp2": "{arg1} dp", + "@dp2": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:131", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dp3": "{arg1} dp", + "@dp3": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:142", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dragABoundaryToStretchOr": "Arrastra un límite para alargar o acortar la palabra anterior. El último límite desplaza la línea siguiente.", + "@dragABoundaryToStretchOr": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1705" + }, + "dragBandsUpOrDown": "Arrastra las bandas hacia arriba o abajo", + "@dragBandsUpOrDown": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:129" + }, + "dragToChangeFrequencyGain": "Arrastra para cambiar la frecuencia y la ganancia", + "@dragToChangeFrequencyGain": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:161" + }, + "dragToMovePinchToWiden": "Arrastra para mover • Pellizca para ampliar o reducir", + "@dragToMovePinchToWiden": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:130" + }, + "dragVerticallyToChangeGain": "Arrastra verticalmente para cambiar la ganancia", + "@dragVerticallyToChangeGain": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:160" + }, + "drawTheCurvedArcBehindThe": "Dibujar el arco curvo detrás de las canciones", + "@drawTheCurvedArcBehindThe": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:180" + }, + "driftMs": "Desfase de {arg1} ms", + "@driftMs": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1040", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "dsdDsfPlayback": "Reproducción DSD / DSF", + "@dsdDsfPlayback": { + "description": "lib/features/settings/screens/support_flick_screen.dart:180" + }, + "dsdMode": "Modo DSD", + "@dsdMode": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:713" + }, + "dsdOutputMode": "Modo de salida DSD", + "@dsdOutputMode": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1508" + }, + "dsdStream": "Flujo DSD", + "@dsdStream": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:918" + }, + "duckOnNotifications": "Atenuar el audio con las notificaciones", + "@duckOnNotifications": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:243" + }, + "duplicateCleaner": "Limpiador de duplicados", + "@duplicateCleaner": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:429" + }, + "duplicatesRemovedUsingRecommendedPicks": "Se quitaron los duplicados con las selecciones recomendadas.", + "@duplicatesRemovedUsingRecommendedPicks": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:947" + }, + "duration": "Duración", + "@duration": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:330" + }, + "durationMatch": "Coincidencia de duración", + "@durationMatch": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:874" + }, + "dynamics": "Dinámica", + "@dynamics": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3255" + }, + "earlier": "Anterior", + "@earlier": { + "description": "lib/data/repositories/recently_played_repository.dart:296" + }, + "earlierStandoutsPulledBackIntoView": "Canciones destacadas de antes que vuelven a aparecer gracias a tu historial de escucha.", + "@earlierStandoutsPulledBackIntoView": { + "description": "lib/features/menu/screens/menu_screen.dart:1759" + }, + "editCredentials": "Editar credenciales", + "@editCredentials": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:921" + }, + "editDescription": "Editar descripción", + "@editDescription": { + "description": "lib/features/albums/screens/album_detail_screen.dart:313" + }, + "editDescription2": "Editar descripción", + "@editDescription2": { + "description": "lib/features/albums/screens/album_detail_screen.dart:339" + }, + "editMetadata": "Editar metadatos", + "@editMetadata": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:268" + }, + "editServer": "Editar servidor", + "@editServer": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:368" + }, + "editSync": "Editar y sincronizar", + "@editSync": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:208" + }, + "editText": "Editar texto", + "@editText": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:770" + }, + "editToken": "Editar token", + "@editToken": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:348" + }, + "electricSunset": "Atardecer eléctrico", + "@electricSunset": { + "description": "lib/models/song.dart:327" + }, + "empty": "Vacío", + "@empty": { + "description": "lib/features/folders/screens/folders_screen.dart:2039" + }, + "emptyLine": "(Línea vacía)", + "@emptyLine": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1143" + }, + "emptyTheLibraryFilesOnDisk": "Vaciar la biblioteca; se conservarán los archivos del disco", + "@emptyTheLibraryFilesOnDisk": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2184" + }, + "enable": "Activar", + "@enable": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1589" + }, + "enable432HzTuning": "¿Activar la afinación a 432 Hz?", + "@enable432HzTuning": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1584" + }, + "enableAnimatedTransitionsAndEffects": "Activar transiciones y efectos animados", + "@enableAnimatedTransitionsAndEffects": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:88" + }, + "enableEqToEdit": "Activar el ecualizador para editarlo", + "@enableEqToEdit": { + "description": "lib/features/settings/screens/equalizer_screen.dart:384" + }, + "enableFullLibraryAccess": "Activar acceso completo a la biblioteca", + "@enableFullLibraryAccess": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2049" + }, + "enableVibrationOnInteractions": "Activar la vibración al interactuar", + "@enableVibrationOnInteractions": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:101" + }, + "enabled": "Activado", + "@enabled": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1200" + }, + "endpoint": "Punto de conexión", + "@endpoint": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:998" + }, + "engine": "Motor", + "@engine": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:628" + }, + "engineSelector": "Selector de motor", + "@engineSelector": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:101" + }, + "english": "Inglés", + "@english": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:68" + }, + "enterAValidNumber": "Ingresa un número válido para {label}", + "@enterAValidNumber": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:126", + "placeholders": { + "label": { + "type": "Object" + } + } + }, + "enterAValueFromTo": "Ingresa un valor entre {arg1}% y {arg2}%", + "@enterAValueFromTo": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:743", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "enterAYear19999": "Ingresa un año (1–9999)", + "@enterAYear19999": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:115" + }, + "enterYourApiKey": "Ingresa tu clave de API", + "@enterYourApiKey": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:458" + }, + "enterYourSharedSecret": "Ingresa tu secreto compartido", + "@enterYourSharedSecret": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:512" + }, + "ep": "EP {arg1}", + "@ep": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1000", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "eqDynamics": "Ecualizador y dinámica", + "@eqDynamics": { + "description": "lib/features/settings/screens/equalizer_screen.dart:88" + }, + "equalPower": "Potencia constante", + "@equalPower": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:245" + }, + "equalizer": "Ecualizador", + "@equalizer": { + "description": "lib/features/player/widgets/player_action_button_row.dart:756" + }, + "error": "Error: {error}", + "@error": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:226", + "placeholders": { + "error": { + "type": "Object" + } + } + }, + "error2": "Error: {arg1}", + "@error2": { + "description": "lib/widgets/uac2/uac2_device_selector.dart:90", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "error3": "Error", + "@error3": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:909" + }, + "errorLoadingCapabilities": "Error al cargar las capacidades: {error}", + "@errorLoadingCapabilities": { + "description": "lib/widgets/uac2/uac2_device_capabilities.dart:89", + "placeholders": { + "error": { + "type": "Object" + } + } + }, + "errorLoadingPlaylists": "Error al cargar las listas de reproducción", + "@errorLoadingPlaylists": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:70" + }, + "errorLoadingPlaylists2": "Error al cargar las listas de reproducción: {error}", + "@errorLoadingPlaylists2": { + "description": "lib/features/songs/screens/songs_screen.dart:1435", + "placeholders": { + "error": { + "type": "Object" + } + } + }, + "errorLoadingPreference": "Error al cargar la preferencia", + "@errorLoadingPreference": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1198" + }, + "errorLoadingSongs": "Error al cargar las canciones", + "@errorLoadingSongs": { + "description": "lib/features/songs/screens/songs_screen.dart:1834" + }, + "etherealTones": "Tonos etéreos", + "@etherealTones": { + "description": "lib/models/song.dart:349" + }, + "everyAlbumHasArtistAndAlbum": "Todos los álbumes tienen etiquetas de artista y de álbum.", + "@everyAlbumHasArtistAndAlbum": { + "description": "lib/features/settings/screens/missing_metadata_screen.dart:78" + }, + "everySongIsRemovedFromYour": "Se quitarán de tu biblioteca todas las canciones. Se conservarán los archivos del disco; vuelve a analizar las carpetas para agregarlas otra vez.", + "@everySongIsRemovedFromYour": { + "description": "lib/features/settings/screens/library_settings_screen.dart:430" + }, + "exactMatch": "Coincidencia exacta", + "@exactMatch": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:363" + }, + "excludeTinyClipsPreviewsAndAccidental": "Excluir clips muy cortos, vistas previas y fragmentos accidentales", + "@excludeTinyClipsPreviewsAndAccidental": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1830" + }, + "exclusiveDirectPcmIsActiveAnd": "La salida PCM directa exclusiva está activa y omite el mezclador de Android usando la frecuencia nativa de la pista.", + "@exclusiveDirectPcmIsActiveAnd": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1049" + }, + "exclusiveUsbBitPerfectReEngaged": "Se reactivó el modo bit perfecto USB exclusivo.", + "@exclusiveUsbBitPerfectReEngaged": { + "description": "lib/widgets/uac2/usb_bit_perfect_prompt.dart:254" + }, + "exclusiveUsbDroppedToTheAndroid": "La conexión USB exclusiva pasó al mezclador de Android. El modo bit perfecto está en pausa.", + "@exclusiveUsbDroppedToTheAndroid": { + "description": "lib/widgets/uac2/usb_bit_perfect_prompt.dart:291" + }, + "exclusiveUsbIsActiveAndBypassing": "La conexión USB exclusiva está activa y omite el mezclador de Android.", + "@exclusiveUsbIsActiveAndBypassing": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1045" + }, + "exclusiveUsbIsStillUnavailableCheck": "USB exclusivo sigue sin estar disponible. Consulta los diagnósticos USB.", + "@exclusiveUsbIsStillUnavailableCheck": { + "description": "lib/widgets/uac2/usb_bit_perfect_prompt.dart:255" + }, + "expanded": "Expandido", + "@expanded": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:329" + }, + "expandedHeaderArt": "Portada del encabezado expandido", + "@expandedHeaderArt": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:179" + }, + "expectedAJsonObject": "Se esperaba un objeto JSON.", + "@expectedAJsonObject": { + "description": "lib/services/eq_preset_file_service.dart:90" + }, + "experimental": "Experimental", + "@experimental": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:96" + }, + "experimentalDownTunePlaybackBy432": "Experimental: multiplica la velocidad de reproducción por 432/440 para bajar la afinación de 440 a 432 Hz. Esto desactiva el paso directo bit-perfect y usa la ruta DSP.", + "@experimentalDownTunePlaybackBy432": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1559" + }, + "exportAsM3u": "Exportar como .m3u", + "@exportAsM3u": { + "description": "lib/features/playlists/screens/playlists_screen.dart:628" + }, + "exportAsM3u8": "Exportar como .m3u8", + "@exportAsM3u8": { + "description": "lib/features/playlists/screens/playlists_screen.dart:638" + }, + "exportCsv": "Exportar CSV", + "@exportCsv": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:771" + }, + "exportCurrentPreset": "Exportar el preajuste actual", + "@exportCurrentPreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:751" + }, + "exportEqualizerPreset": "Exportar preajuste del ecualizador", + "@exportEqualizerPreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:626" + }, + "exportFailed": "Error al exportar: {e}", + "@exportFailed": { + "description": "lib/features/playlists/screens/playlists_screen.dart:533", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "exportFormat": "Formato de exportación", + "@exportFormat": { + "description": "lib/features/settings/screens/equalizer_screen.dart:652" + }, + "exportTxt": "Exportar TXT", + "@exportTxt": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:772" + }, + "exportedPresetTo": "Se exportó el preajuste a {savePath}", + "@exportedPresetTo": { + "description": "lib/features/settings/screens/equalizer_screen.dart:639", + "placeholders": { + "savePath": { + "type": "Object" + } + } + }, + "exportedPresetTo2": "Se exportó el preajuste a {fallbackPath}", + "@exportedPresetTo2": { + "description": "lib/features/settings/screens/equalizer_screen.dart:645", + "placeholders": { + "fallbackPath": { + "type": "Object" + } + } + }, + "exportedSongsTo": "Se exportaron {arg1} canciones a «{arg2}».", + "@exportedSongsTo": { + "description": "lib/features/playlists/screens/playlists_screen.dart:525", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "extendedVolume": "Volumen ampliado", + "@extendedVolume": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:120" + }, + "externalLabel": "Externo", + "@externalLabel": { + "description": "lib/features/folders/screens/folders_screen.dart:782" + }, + "externalSongsCannotBeEdited": "No se pueden editar canciones externas.", + "@externalSongsCannotBeEdited": { + "description": "lib/services/metadata_editor_service.dart:73" + }, + "externalSongsCannotBeEdited2": "No se pueden editar canciones externas", + "@externalSongsCannotBeEdited2": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:318" + }, + "extraCovers": "Portadas adicionales", + "@extraCovers": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:684" + }, + "failedToActivateFallback": "No se pudo activar la alternativa", + "@failedToActivateFallback": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:61" + }, + "failedToAddFolder": "No se pudo agregar la carpeta: {e}", + "@failedToAddFolder": { + "description": "lib/features/settings/screens/library_settings_screen.dart:488", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToAddToFavorites": "No se pudo agregar «{arg1}» a favoritos", + "@failedToAddToFavorites": { + "description": "lib/features/songs/screens/songs_screen.dart:1289", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "failedToClearCache": "No se pudo borrar la caché: {e}", + "@failedToClearCache": { + "description": "lib/features/settings/screens/library_settings_screen.dart:288", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToDeactivateFallback": "No se pudo desactivar la alternativa", + "@failedToDeactivateFallback": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:81" + }, + "failedToDownloadAlbumArt": "No se pudo descargar la portada del álbum (HTTP {status}).", + "@failedToDownloadAlbumArt": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "status": { + "type": "int" + } + } + }, + "failedToGetPersistedUris": "No se pudieron obtener los URI persistentes: {error}", + "@failedToGetPersistedUris": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToImportPresetFile": "No se pudo importar el archivo de preajuste.", + "@failedToImportPresetFile": { + "description": "lib/features/settings/screens/equalizer_screen.dart:566" + }, + "failedToOpenAllFilesAccess": "No se pudo abrir la configuración de acceso a todos los archivos: {e}", + "@failedToOpenAllFilesAccess": { + "description": "lib/features/settings/screens/library_settings_screen.dart:224", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToOpenBatteryOptimizationSettings": "No se pudo abrir la configuración de optimización de batería: {e}", + "@failedToOpenBatteryOptimizationSettings": { + "description": "lib/features/settings/screens/library_settings_screen.dart:203", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToOpenFolderPicker": "No se pudo abrir el selector de carpetas: {error}", + "@failedToOpenFolderPicker": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToPersistFolderAccess": "No se pudo conservar el acceso a la carpeta", + "@failedToPersistFolderAccess": { + "description": "l10n pass: user-visible service error" + }, + "failedToPersistPermission": "No se pudo conservar el permiso: {error}", + "@failedToPersistPermission": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToReadBatteryOptimizationStatus": "No se pudo leer el estado de optimización de batería: {error}", + "@failedToReadBatteryOptimizationStatus": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToReleasePermission": "No se pudo liberar el permiso: {error}", + "@failedToReleasePermission": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToRemoveFolder": "No se pudo quitar la carpeta: {e}", + "@failedToRemoveFolder": { + "description": "lib/features/settings/screens/library_settings_screen.dart:501", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToRemoveSongs": "No se pudieron quitar las canciones: {e}", + "@failedToRemoveSongs": { + "description": "lib/features/settings/screens/library_settings_screen.dart:445", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToRequestBatteryOptimizationBypass": "No se pudo solicitar la excepción a la optimización de batería: {error}", + "@failedToRequestBatteryOptimizationBypass": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "error": { + "type": "String?" + } + } + }, + "failedToSave": "No se pudo guardar", + "@failedToSave": { + "description": "lib/features/player/widgets/share/share_bottom_sheet.dart:171" + }, + "failedToSaveMetadata": "No se pudieron guardar los metadatos: {e}", + "@failedToSaveMetadata": { + "description": "lib/services/metadata_editor_service.dart:100", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "failedToSaveMetadata2": "No se pudieron guardar los metadatos.", + "@failedToSaveMetadata2": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:204" + }, + "failedToSaveTheRecapImage": "No se pudo guardar la imagen del resumen en la galería.", + "@failedToSaveTheRecapImage": { + "description": "l10n pass: user-visible service error" + }, + "failedToSearchAlbumArtOnline": "No se pudo buscar la portada del álbum en línea.", + "@failedToSearchAlbumArtOnline": { + "description": "l10n pass: user-visible service error" + }, + "failedToStartStreaming": "No se pudo iniciar la transmisión", + "@failedToStartStreaming": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:270" + }, + "failedToStopStreaming": "No se pudo detener la transmisión", + "@failedToStopStreaming": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:283" + }, + "failedToWritePlaylistFile": "No se pudo escribir el archivo de la lista de reproducción", + "@failedToWritePlaylistFile": { + "description": "lib/services/playlist_service.dart:655" + }, + "failedToWriteTagsToTheFile": "No se pudieron escribir las etiquetas en el archivo.", + "@failedToWriteTagsToTheFile": { + "description": "l10n pass: user-visible service error" + }, + "faintHueShiftFromAlbumArt": "Ligero cambio de tono a partir de la portada del álbum.", + "@faintHueShiftFromAlbumArt": { + "description": "lib/models/album_color_mode.dart:35" + }, + "fallback": "Alternativa", + "@fallback": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:706" + }, + "fallbackAudio": "Audio alternativo", + "@fallbackAudio": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:136" + }, + "fallbackAudioActivated": "Se activó el audio alternativo", + "@fallbackAudioActivated": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:60" + }, + "fallbackAudioDeactivated": "Se desactivó el audio alternativo", + "@fallbackAudioDeactivated": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:80" + }, + "fallbackAudioWillBeUsedIf": "Se usará el audio alternativo si falla el dispositivo UAC2", + "@fallbackAudioWillBeUsedIf": { + "description": "lib/widgets/uac2/uac2_fallback_manager.dart:197" + }, + "fastDirectTrackingImmediateResponse": "Seguimiento directo rápido: respuesta inmediata", + "@fastDirectTrackingImmediateResponse": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:186" + }, + "fastIndexScrolling": "Desplazamiento rápido por el índice", + "@fastIndexScrolling": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:192" + }, + "favoriteAll": "Agregar todo a favoritos", + "@favoriteAll": { + "description": "lib/widgets/common/detail_header.dart:257" + }, + "favoriteRemoval": "Quitar de favoritos", + "@favoriteRemoval": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:289" + }, + "favoriteSongs": "Canciones favoritas", + "@favoriteSongs": { + "description": "lib/features/menu/screens/menu_screen.dart:1408" + }, + "favorites": "Favoritos", + "@favorites": { + "description": "lib/features/favorites/screens/favorites_screen.dart:301" + }, + "favoritesYouHaveNotRevisitedLately": "Favoritos que hace tiempo no vuelves a escuchar", + "@favoritesYouHaveNotRevisitedLately": { + "description": "lib/features/menu/screens/menu_screen.dart:1757" + }, + "feb": "feb", + "@feb": { + "description": "lib/features/milestone/screens/milestones_screen.dart:503" + }, + "feedback": "Comentarios", + "@feedback": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3654" + }, + "file": "Archivo", + "@file": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:909" + }, + "fileInformation": "Información del archivo", + "@fileInformation": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:444" + }, + "fileIsNoLongerAvailable": "Este archivo ya no está disponible. Es posible que se haya movido o eliminado. Vuelve a analizar la biblioteca e inténtalo de nuevo.", + "@fileIsNoLongerAvailable": { + "description": "lib/services/metadata_editor_service.dart: user-visible service error" + }, + "filePath": "Ruta del archivo", + "@filePath": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:82" + }, + "files": "{done} / {total} archivos", + "@files": { + "description": "lib/features/settings/screens/library_settings_screen.dart:982", + "placeholders": { + "done": { + "type": "Object" + }, + "total": { + "type": "Object" + } + } + }, + "files2": "{count, plural, =1{{count} archivo} other{{count} archivos}}", + "@files2": { + "description": "lib/features/settings/screens/missing_metadata_screen.dart:128", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "filesChecked": "Se revisaron {arg1} archivos…", + "@filesChecked": { + "description": "lib/features/settings/screens/library_settings_screen.dart:984", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "filter": "Filtrar", + "@filter": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3602" + }, + "filterByFormat": "FILTRAR POR FORMATO", + "@filterByFormat": { + "description": "lib/features/songs/screens/songs_screen.dart:2894" + }, + "filterFilesSizeLimitsAndPlaylist": "Filtrar archivos, establecer límites de tamaño y configurar la importación de listas de reproducción", + "@filterFilesSizeLimitsAndPlaylist": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1781" + }, + "filterLogs": "Filtrar registros…", + "@filterLogs": { + "description": "lib/features/settings/screens/logs_screen.dart:355" + }, + "filterNonMusicFilesFolders": "Filtrar archivos y carpetas que no sean de música", + "@filterNonMusicFilesFolders": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1815" + }, + "findAndCleanUpDuplicateSongs": "Buscar y limpiar canciones duplicadas", + "@findAndCleanUpDuplicateSongs": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:395" + }, + "findAndRemoveDuplicateSongs": "Buscar y quitar canciones duplicadas", + "@findAndRemoveDuplicateSongs": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2148" + }, + "findSongsArtistsAlbumsFolders": "Buscar canciones, artistas, álbumes y carpetas…", + "@findSongsArtistsAlbumsFolders": { + "description": "lib/features/search/screens/search_screen.dart:249" + }, + "fineTuneTheOverallGain": "Ajustar con precisión la ganancia general", + "@fineTuneTheOverallGain": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:214" + }, + "finishingMetadataEnrichment": "Finalizando el enriquecimiento de metadatos…", + "@finishingMetadataEnrichment": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1170" + }, + "finishingMetadataForSongs": "{count, plural, =1{Finalizando los metadatos de {count} canción…} other{Finalizando los metadatos de {count} canciones…}}", + "@finishingMetadataForSongs": { + "description": "lib/app/app.dart:504", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "finishingUp": "Terminando…", + "@finishingUp": { + "description": "lib/features/menu/screens/restarting_screen.dart:13" + }, + "fix": "Corregir", + "@fix": { + "description": "lib/features/settings/screens/network_sources_screen.dart:116" + }, + "fixMissingMetadata": "Corregir metadatos faltantes", + "@fixMissingMetadata": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2213" + }, + "fixedBands": "31 bandas fijas", + "@fixedBands": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1741" + }, + "fixedCenterFrequenciesWithADb": "Frecuencias centrales fijas con un rango de {arg1} dB. Toca para interactuar.", + "@fixedCenterFrequenciesWithADb": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1780", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "flac24Bit96Khz": "FLAC · 24 bits / 96 kHz", + "@flac24Bit96Khz": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:1200" + }, + "flat": "Plano", + "@flat": { + "description": "lib/services/eq_preset_service.dart:280" + }, + "flatResponse": "Respuesta plana", + "@flatResponse": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1748" + }, + "flick": "Flick", + "@flick": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:547" + }, + "flickCanAttemptToPreferA": "Flick puede intentar dar prioridad al códec seleccionado arriba, pero el resultado depende del dispositivo, los audífonos y la versión de Android. Para forzar el códec se usa una API oculta del sistema y puede que no funcione en dispositivos sin root.", + "@flickCanAttemptToPreferA": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:604" + }, + "flickCanReceivePlaybackHandoffsFrom": "Flick puede recibir transferencias de reproducción de Locker (otra app de Moss). Las solicitudes de reproducción solo contienen las rutas y los metadatos de los archivos de canciones. No se intercambian datos personales. La integración funciona completamente de forma local.", + "@flickCanReceivePlaybackHandoffsFrom": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:71" + }, + "flickChecksFlickPlayerSiteFor": "Flick busca actualizaciones en flick-player.site cuando tienes conexión a internet", + "@flickChecksFlickPlayerSiteFor": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:176" + }, + "flickIsBuiltAndMaintainedBy": "Flick lo desarrolla y mantiene una sola persona, sin presupuesto. No hay equipo, financiación ni anuncios.", + "@flickIsBuiltAndMaintainedBy": { + "description": "lib/features/settings/screens/support_flick_screen.dart:138" + }, + "flickLogs": "Registros de Flick", + "@flickLogs": { + "description": "lib/features/settings/screens/logs_screen.dart:110" + }, + "flickNoLongerHasPermissionToEditThisFile": "Flick ya no tiene permiso para editar este archivo. Vuelve a agregar su carpeta en Ajustes para conceder acceso de edición e inténtalo de nuevo.", + "@flickNoLongerHasPermissionToEditThisFile": { + "description": "lib/services/metadata_editor_service.dart: user-visible service error" + }, + "flickPlayer": "Flick Player", + "@flickPlayer": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:444" + }, + "flickPlayerDoesNotCollectStore": "Flick Player no recopila, almacena ni transmite datos personales. No reúne información personal, estadísticas de uso, informes de fallos ni identificadores publicitarios. No comparte datos con terceros.", + "@flickPlayerDoesNotCollectStore": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:36" + }, + "flickPreview": "Vista previa de Flick", + "@flickPreview": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:930" + }, + "flickReplay": "Flick Replay", + "@flickReplay": { + "description": "lib/features/menu/screens/menu_screen.dart:1089" + }, + "flickScansForPlayStoreUpdates": "Flick busca actualizaciones en Play Store cuando tienes conexión a internet", + "@flickScansForPlayStoreUpdates": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:175" + }, + "flickWillAlwaysBeFreeDonations": "Flick siempre será gratis. Las donaciones mantienen vivo el proyecto sin muros de pago ni suscripciones.", + "@flickWillAlwaysBeFreeDonations": { + "description": "lib/features/settings/screens/support_flick_screen.dart:145" + }, + "flickWillForceYourChosenCodec": "Flick forzará el códec que elegiste al conectarse", + "@flickWillForceYourChosenCodec": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:343" + }, + "flickplayer": "FlickPlayer", + "@flickplayer": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:230" + }, + "floatingIsland": "Isla flotante", + "@floatingIsland": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:154" + }, + "floatingMiniPlayer": "Minirreproductor flotante", + "@floatingMiniPlayer": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:83" + }, + "folder": "Carpeta", + "@folder": { + "description": "lib/models/playback_context.dart:13" + }, + "folderLimit": "LÍMITE DE CARPETAS", + "@folderLimit": { + "description": "lib/features/folders/screens/folders_screen.dart:2258" + }, + "folderName": "Nombre de la carpeta", + "@folderName": { + "description": "lib/features/folders/screens/folders_screen.dart:2588" + }, + "folderOf": "Carpeta {current} de {total}", + "@folderOf": { + "description": "lib/features/settings/screens/library_settings_screen.dart:996", + "placeholders": { + "current": { + "type": "Object" + }, + "total": { + "type": "Object" + } + } + }, + "folderOf2": "Carpeta {current} de {total}", + "@folderOf2": { + "description": "lib/widgets/common/floating_scan_progress.dart:403", + "placeholders": { + "current": { + "type": "Object" + }, + "total": { + "type": "Object" + } + } + }, + "folderSongCount": "Cantidad de canciones en la carpeta", + "@folderSongCount": { + "description": "lib/features/folders/screens/folders_screen.dart:2590" + }, + "folders": "Carpetas", + "@folders": { + "description": "lib/features/folders/screens/folders_screen.dart:320" + }, + "folders2": "{arg1} carpetas", + "@folders2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1474", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "foldersScanningAndDuplicates": "Carpetas, análisis y duplicados", + "@foldersScanningAndDuplicates": { + "description": "lib/features/settings/screens/settings_screen.dart:84" + }, + "foldersShownPerPage": "Carpetas por página", + "@foldersShownPerPage": { + "description": "lib/features/folders/screens/folders_screen.dart:2267" + }, + "fontScale": "Escala de fuente", + "@fontScale": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:235" + }, + "footerLine": "Línea de pie", + "@footerLine": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:689" + }, + "forceDop": "Forzar DoP", + "@forceDop": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1681" + }, + "forceDopAlwaysUseDsdOver": "Forzar DoP: usar siempre DSD sobre PCM (DAC USB)", + "@forceDopAlwaysUseDsdOver": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1641" + }, + "forcePcm": "Forzar PCM", + "@forcePcm": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1672" + }, + "forcePcmAlwaysConvertDsdTo": "Forzar PCM: convertir siempre DSD a PCM", + "@forcePcmAlwaysConvertDsdTo": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1639" + }, + "format": "Formato", + "@format": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:551" + }, + "formatControlsAreDisabledTheEngine": "Los controles de formato están desactivados. El motor usa el formato predeterminado.", + "@formatControlsAreDisabledTheEngine": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:218" + }, + "formatStrategy": "Estrategia de formato", + "@formatStrategy": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:233" + }, + "formatStrategyAndCustomFormatControls": "La estrategia de formato y los controles de formato personalizado están activos.", + "@formatStrategyAndCustomFormatControls": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:217" + }, + "formatStrategyIsDisabledInBit": "La estrategia de formato está desactivada en el modo Bit perfecto (DAC USB), que requiere una coincidencia exacta de la frecuencia de muestreo. Desactiva Bit perfecto (DAC USB) para cambiar las preferencias de formato.", + "@formatStrategyIsDisabledInBit": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:244" + }, + "formatStrategyIsUnavailableBecauseAudio": "La estrategia de formato no está disponible porque el formato de audio está desactivado en Ajustes.", + "@formatStrategyIsUnavailableBecauseAudio": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:249" + }, + "foundOnline": "Se encontró «{arg1}» en línea.", + "@foundOnline": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:121", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "frPkt": "{arg1} tramas/paquete", + "@frPkt": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:988", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "freeOpenSource": "Gratis y de código abierto", + "@freeOpenSource": { + "description": "lib/features/settings/screens/support_flick_screen.dart:143" + }, + "freq": "Frec.", + "@freq": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2623" + }, + "frequency": "Frecuencia", + "@frequency": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2611" + }, + "frequencyFocus": "Enfoque de frecuencias", + "@frequencyFocus": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:119" + }, + "freshAdditions": "Novedades recientes", + "@freshAdditions": { + "description": "lib/features/menu/screens/menu_screen.dart:1774" + }, + "from": "De {sourceLabel}", + "@from": { + "description": "lib/widgets/common/fetched_description.dart:41", + "placeholders": { + "sourceLabel": { + "type": "Object" + } + } + }, + "fromSquareCornersToARounded": "De esquinas cuadradas a una barra redondeada", + "@fromSquareCornersToARounded": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:137" + }, + "fullBleedAlbumArtWithThe": "Portada del álbum a sangre, con la estética cinematográfica actual.", + "@fullBleedAlbumArtWithThe": { + "description": "lib/models/player_screen_mode.dart:26" + }, + "fullLibrary": "Biblioteca completa", + "@fullLibrary": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:264" + }, + "fullLibraryAccess": "Acceso completo a la biblioteca", + "@fullLibraryAccess": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1884" + }, + "fullPlayer": "Reproductor completo", + "@fullPlayer": { + "description": "lib/providers/tutorial_provider.dart:48" + }, + "fullScan": "Análisis completo", + "@fullScan": { + "description": "lib/features/settings/screens/library_settings_screen.dart:708" + }, + "fullSpectrum": "Espectro completo", + "@fullSpectrum": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:124" + }, + "fullViewCardSize": "Tamaño de tarjeta en vista completa", + "@fullViewCardSize": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:304" + }, + "fullViewCardSize2": "Tamaño de tarjeta en vista completa", + "@fullViewCardSize2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:164" + }, + "fullscreen": "Pantalla completa", + "@fullscreen": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:152" + }, + "fundingNativeDsdDsfPlaybackDevelopment": "Financia el desarrollo de la reproducción DSD/DSF nativa, una función muy solicitada por los audiófilos.", + "@fundingNativeDsdDsfPlaybackDevelopment": { + "description": "lib/features/settings/screens/support_flick_screen.dart:182" + }, + "fxOff": "Efectos desactivados", + "@fxOff": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3511" + }, + "fxOn": "Efectos activados", + "@fxOn": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3511" + }, + "gain": "Ganancia", + "@gain": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2666" + }, + "gallery": "Galería", + "@gallery": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:610" + }, + "gapAboveNavigation": "Espacio sobre la navegación", + "@gapAboveNavigation": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:101" + }, + "gaplessPlayback": "Reproducción sin pausas", + "@gaplessPlayback": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:272" + }, + "gaplessViewModeAndAppearance": "Reproducción sin pausas, modo de vista y apariencia", + "@gaplessViewModeAndAppearance": { + "description": "lib/features/settings/screens/settings_screen.dart:104" + }, + "gb": "{arg1} GB", + "@gb": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:26", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "generatedFromYourListeningHabitsFavorites": "Se generan a partir de tus hábitos de escucha, tus favoritos y lo que agregaste recientemente.", + "@generatedFromYourListeningHabitsFavorites": { + "description": "lib/features/menu/screens/menu_screen.dart:846" + }, + "genre": "Género", + "@genre": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:70" + }, + "geometry": "Geometría", + "@geometry": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:21" + }, + "getStarted": "Comenzar", + "@getStarted": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:269" + }, + "getTheLatestApkFromFlick": "Descarga el APK más reciente desde flick-player.site", + "@getTheLatestApkFromFlick": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:639" + }, + "getYourApiCredentials": "Obtener credenciales de API", + "@getYourApiCredentials": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:404" + }, + "github": "GitHub", + "@github": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:489" + }, + "goToAlbum": "Ir al álbum", + "@goToAlbum": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:324" + }, + "goToArtist": "Ir al artista", + "@goToArtist": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:315" + }, + "goodAfternoon": "Buenas tardes", + "@goodAfternoon": { + "description": "lib/features/menu/screens/menu_screen.dart:275" + }, + "goodEvening": "Buenas noches", + "@goodEvening": { + "description": "lib/features/menu/screens/menu_screen.dart:276" + }, + "goodMorning": "Buenos días", + "@goodMorning": { + "description": "lib/features/menu/screens/menu_screen.dart:274" + }, + "gotIt": "Entendido", + "@gotIt": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:721" + }, + "grantBluetoothAccess": "Conceder acceso a Bluetooth", + "@grantBluetoothAccess": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:235" + }, + "grantedScansReadEveryVolumeDirectly": "Concedido: el análisis lee directamente todos los volúmenes, incluidos DSD, DSF y WavPack", + "@grantedScansReadEveryVolumeDirectly": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1886" + }, + "graphic": "Gráfico", + "@graphic": { + "description": "lib/features/settings/screens/equalizer_screen.dart:4162" + }, + "graphicEq": "Ecualizador gráfico", + "@graphicEq": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1735" + }, + "green": "Verde", + "@green": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:291" + }, + "groupingByTitleArtistThisIs": "Agrupar por título y artista suele ser rápido.", + "@groupingByTitleArtistThisIs": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:152" + }, + "groups": "Grupos", + "@groups": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:626" + }, + "groupsToRemove": "{arg1} grupos • {arg2} por quitar", + "@groupsToRemove": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:394", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "groupsToRemove2": "{arg1} grupos • {toRemove} por quitar", + "@groupsToRemove2": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:556", + "placeholders": { + "arg1": { + "type": "Object" + }, + "toRemove": { + "type": "Object" + } + } + }, + "growsFurtherIfLargerSystemText": "Se amplía si el texto grande del sistema necesita más espacio", + "@growsFurtherIfLargerSystemText": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:126" + }, + "hAgo": "hace {arg1} h", + "@hAgo": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:493", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "hapticFeedback": "Respuesta háptica", + "@hapticFeedback": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:100" + }, + "hardwareUsbDac": "Hardware (DAC USB)", + "@hardwareUsbDac": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1153" + }, + "hardwareVolumeIsDetectedButWrites": "Se detecta el volumen del hardware, pero no se permiten cambios mientras está activa la reproducción USB directa.", + "@hardwareVolumeIsDetectedButWrites": { + "description": "lib/widgets/uac2/uac2_volume_control.dart:246" + }, + "hasArtwork": "Tiene portada", + "@hasArtwork": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1579" + }, + "havingMoreThan4ButtonsMay": "Más de 4 botones pueden comprimir sus etiquetas de texto. Prueba a reducir el espacio entre los botones más abajo.", + "@havingMoreThan4ButtonsMay": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:241" + }, + "heavyRotation": "En rotación frecuente", + "@heavyRotation": { + "description": "lib/features/menu/screens/menu_screen.dart:1765" + }, + "held": "En espera", + "@held": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:715" + }, + "help": "Ayuda", + "@help": { + "description": "lib/features/settings/screens/settings_screen.dart:230" + }, + "helpManual": "Ayuda y manual", + "@helpManual": { + "description": "lib/features/settings/screens/settings_screen.dart:237" + }, + "hiResDirect": "Directo de alta resolución", + "@hiResDirect": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:417" + }, + "hidden": "Oculto", + "@hidden": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:202" + }, + "hideLyrics": "Ocultar letras", + "@hideLyrics": { + "description": "lib/features/player/widgets/player_action_button_row.dart:440" + }, + "hideNavigationButtonsAfterBeingIdle": "Ocultar los botones de navegación tras un periodo de inactividad", + "@hideNavigationButtonsAfterBeingIdle": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:79" + }, + "hidePassword": "Ocultar contraseña", + "@hidePassword": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:765" + }, + "hideShortStingersRingtonesAndVoice": "Ocultar fragmentos cortos, tonos de llamada y fragmentos de voz", + "@hideShortStingersRingtonesAndVoice": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1843" + }, + "hideTheFloatingMiniPlayerPill": "Ocultar la pastilla flotante del minirreproductor", + "@hideTheFloatingMiniPlayerPill": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:157" + }, + "hideTheIndexRailAfterInactivity": "Ocultar el índice tras un periodo de inactividad", + "@hideTheIndexRailAfterInactivity": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:206" + }, + "hideVisualizer": "Ocultar visualizador", + "@hideVisualizer": { + "description": "lib/features/player/widgets/player_action_button_row.dart:551" + }, + "hideVisualizer2": "Ocultar visualizador", + "@hideVisualizer2": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:305" + }, + "high": "Alto", + "@high": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:158" + }, + "high120hz": "Alto (120 Hz)", + "@high120hz": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:235" + }, + "highFrequenciesOnly": "Solo frecuencias altas", + "@highFrequenciesOnly": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:149" + }, + "highPass": "Filtro pasa altos", + "@highPass": { + "description": "lib/providers/equalizer_provider.dart:35" + }, + "highQuality": "Alta calidad", + "@highQuality": { + "description": "lib/features/menu/screens/menu_screen.dart:497" + }, + "highQualityEngine": "Motor de alta calidad", + "@highQualityEngine": { + "description": "lib/features/menu/screens/menu_screen.dart:390" + }, + "highQualityWidelySupported": "Alta calidad y amplia compatibilidad", + "@highQualityWidelySupported": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:487" + }, + "highResolutionAptx": "aptX de alta resolución", + "@highResolutionAptx": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:489" + }, + "highShelf": "Filtro shelving de agudos", + "@highShelf": { + "description": "lib/providers/equalizer_provider.dart:31" + }, + "highestBitrateUpTo990Kbps": "La tasa de bits más alta (hasta 990 kbps)", + "@highestBitrateUpTo990Kbps": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:491" + }, + "highestQuality": "Máxima calidad", + "@highestQuality": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1211" + }, + "historyCleared": "Se borró el historial", + "@historyCleared": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:208" + }, + "holdASongToUnfavorite": "Mantén presionada una canción para quitarla de favoritos", + "@holdASongToUnfavorite": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:307" + }, + "homeScreenSections": "Secciones de la pantalla de inicio", + "@homeScreenSections": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:24" + }, + "horizontalReach": "Alcance horizontal", + "@horizontalReach": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:50" + }, + "hourUnit": "{count, plural, =1{hora} other{horas}}", + "@hourUnit": { + "description": "lib/services/milestone_service.dart:226", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "howFarTheArcOpensFrom": "Qué tanto se abre el arco desde el borde izquierdo", + "@howFarTheArcOpensFrom": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:51" + }, + "howMuchSideCardsShrinkAway": "Cuánto se reducen las tarjetas laterales al alejarse del centro", + "@howMuchSideCardsShrinkAway": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:126" + }, + "howWeHandleYourData": "Cómo tratamos tus datos", + "@howWeHandleYourData": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:667" + }, + "howWideEachCardSpansAcross": "Qué ancho ocupa cada tarjeta en la pantalla", + "@howWideEachCardSpansAcross": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:92" + }, + "httpBasicNeedsItRecoverableStored": "HTTP Basic necesita poder recuperar la contraseña; se guarda codificada", + "@httpBasicNeedsItRecoverableStored": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:77" + }, + "hz": "{rate} Hz", + "@hz": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1145", + "placeholders": { + "rate": { + "type": "Object" + } + } + }, + "hz3": "{hz} Hz", + "@hz3": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:657", + "placeholders": { + "hz": { + "type": "Object" + } + } + }, + "hz5": "Hz", + "@hz5": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2629" + }, + "hz6": "{arg1} Hz", + "@hz6": { + "description": "lib/widgets/alac_conversion_indicator.dart:137", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "hzTuning": "Afinación a 432 Hz", + "@hzTuning": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1557" + }, + "iconSize": "Tamaño de ícono", + "@iconSize": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:290" + }, + "identified": "{count, plural, =1{Se identificó {count} canción} other{Se identificaron {count} canciones}}{note}.", + "@identified": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:64", + "placeholders": { + "count": { + "type": "int" + }, + "note": { + "type": "Object" + } + } + }, + "identifyAlbum": "Identificar álbum", + "@identifyAlbum": { + "description": "lib/features/albums/screens/album_detail_screen.dart:349" + }, + "identifyAlbum2": "Identificar álbum", + "@identifyAlbum2": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:215" + }, + "identifyAlbumsWithUnknownArtistOr": "Identificar álbumes con etiquetas de artista o título desconocidas", + "@identifyAlbumsWithUnknownArtistOr": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2214" + }, + "idle": "Inactivo", + "@idle": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:899" + }, + "ifYouConnectYourLastFm": "Si conectas tu cuenta de Last.fm, las credenciales se guardan de forma segura en el dispositivo. Los datos de reproducción solo se envían a Last.fm. No recibimos ni procesamos esos datos.", + "@ifYouConnectYourLastFm": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:61" + }, + "ignoreTracksUnder500Kb": "Ignorar pistas de menos de 500 KB", + "@ignoreTracksUnder500Kb": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1828" + }, + "ignoreTracksUnder60Seconds": "Ignorar pistas de menos de 60 segundos", + "@ignoreTracksUnder60Seconds": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1841" + }, + "immersive": "Inmersivo", + "@immersive": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:278" + }, + "immersiveFullViewTimer": "Temporizador de vista completa inmersiva", + "@immersiveFullViewTimer": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:168" + }, + "importFailed": "Error al importar: {e}", + "@importFailed": { + "description": "lib/features/playlists/screens/playlists_screen.dart:506", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "importM3uM3u8": "Importar M3U/M3U8", + "@importM3uM3u8": { + "description": "lib/features/playlists/screens/playlists_screen.dart:134" + }, + "importM3uM3u8Playlists": "Importar listas M3U/M3U8", + "@importM3uM3u8Playlists": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1854" + }, + "importPresetFile": "Importar archivo de preajuste", + "@importPresetFile": { + "description": "lib/features/settings/screens/equalizer_screen.dart:744" + }, + "imported": "Se importó «{arg1}»", + "@imported": { + "description": "lib/features/settings/screens/equalizer_screen.dart:561", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "importedArtIsSavedInsideThe": "La portada importada se guarda en la app y se sincroniza con todas las canciones de este álbum.", + "@importedArtIsSavedInsideThe": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:669" + }, + "importedArtIsSavedInsideThe2": "La portada importada se guarda en la app solo para esta canción.", + "@importedArtIsSavedInsideThe2": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:670" + }, + "importedPreset": "Preajuste importado", + "@importedPreset": { + "description": "lib/services/eq_preset_file_service.dart:191" + }, + "importedWithSongs": "Se importó «{arg1}» con {arg2} canciones.{unmatchedText}", + "@importedWithSongs": { + "description": "lib/features/playlists/screens/playlists_screen.dart:498", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + }, + "unmatchedText": { + "type": "Object" + } + } + }, + "impulseResponse": "Respuesta al impulso", + "@impulseResponse": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3762" + }, + "inAppUpdates": "Actualizaciones desde la app", + "@inAppUpdates": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:74" + }, + "inLabel": "en {folder}", + "@inLabel": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1555", + "placeholders": { + "folder": { + "type": "Object" + } + } + }, + "inYourLibrary": "{count, plural, =1{{count} canción} other{{count} canciones}} en tu biblioteca", + "@inYourLibrary": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:249", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "inactive": "Inactivo", + "@inactive": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:670" + }, + "incredibleOverAMonthOfDaily": "Increíble: más de un mes escuchando música todos los días.", + "@incredibleOverAMonthOfDaily": { + "description": "lib/features/milestone/widgets/streak_popup.dart:96" + }, + "info2": "Información", + "@info2": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:126" + }, + "initializing": "Inicializando…", + "@initializing": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1171" + }, + "inkCardWithTheReplaySignature": "Tarjeta de tinta con los acentos característicos de Replay", + "@inkCardWithTheReplaySignature": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:683" + }, + "inputGain": "Ganancia de entrada", + "@inputGain": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3406" + }, + "insertIntoTheCurrentQueueFallBackToResults": "Insertar en la cola actual; si no, volver a los resultados", + "@insertIntoTheCurrentQueueFallBackToResults": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:278" + }, + "inst": "Inst.", + "@inst": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:885" + }, + "instructions": "Instrucciones", + "@instructions": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:775" + }, + "instrumental": "Instrumental", + "@instrumental": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:594" + }, + "integrations": "Integraciones", + "@integrations": { + "description": "lib/features/settings/screens/integrations_settings_screen.dart:14" + }, + "interactiveEq": "Ecualizador interactivo", + "@interactiveEq": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:121" + }, + "interactiveTutorial": "Tutorial interactivo", + "@interactiveTutorial": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:693" + }, + "interfaceClaimed": "Interfaz asignada", + "@interfaceClaimed": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:693" + }, + "interfaceLabel": "Interfaz", + "@interfaceLabel": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:36" + }, + "invalidToken": "Token no válido", + "@invalidToken": { + "description": "l10n pass: user-visible service error" + }, + "isOfflineRetainedSongsStillListed": "{folder} está sin conexión; las canciones guardadas siguen en la lista", + "@isOfflineRetainedSongsStillListed": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1254", + "placeholders": { + "folder": { + "type": "Object" + } + } + }, + "isochronousUsb": "USB isócrono", + "@isochronousUsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:828" + }, + "itemSpacing": "Espacio entre elementos", + "@itemSpacing": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:62" + }, + "items": "{count} elementos", + "@items": { + "description": "lib/features/folders/screens/folders_screen.dart:1185", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "jan": "ene", + "@jan": { + "description": "lib/features/milestone/screens/milestones_screen.dart:502" + }, + "jellyfin": "Jellyfin", + "@jellyfin": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:65" + }, + "jellyfinEmby": "Jellyfin · Emby", + "@jellyfinEmby": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:66" + }, + "jul": "jul", + "@jul": { + "description": "lib/features/milestone/screens/milestones_screen.dart:508" + }, + "jumpBackIn": "Retomar", + "@jumpBackIn": { + "description": "lib/features/menu/screens/menu_screen.dart:1310" + }, + "jumpToTheFlickListingAnd": "Ve a la ficha de Flick y actualiza desde allí", + "@jumpToTheFlickListingAnd": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:632" + }, + "jun": "jun", + "@jun": { + "description": "lib/features/milestone/screens/milestones_screen.dart:507" + }, + "justAudioExoplayer": "just_audio / ExoPlayer", + "@justAudioExoplayer": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:758" + }, + "justAudioExoplayerDefault": "just_audio / ExoPlayer (predeterminado)", + "@justAudioExoplayerDefault": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:629" + }, + "justNow": "Ahora mismo", + "@justNow": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:491" + }, + "karaokeEffect": "Efecto de karaoke", + "@karaokeEffect": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:43" + }, + "karaokePreview": "Vista previa de karaoke", + "@karaokePreview": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1623" + }, + "kb": "{arg1} KB", + "@kb": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:22", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "keepAll": "Conservar todo", + "@keepAll": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1251" + }, + "keepEditing": "Seguir editando", + "@keepEditing": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:598" + }, + "keepItGoingOpenTomorrowTo": "Sigue así. Abre la app mañana para sumar otro día.", + "@keepItGoingOpenTomorrowTo": { + "description": "lib/features/milestone/widgets/streak_popup.dart:94" + }, + "keepListeningWithFlick": "Sigue escuchando con Flick", + "@keepListeningWithFlick": { + "description": "lib/features/recap/widgets/replay_poster.dart:195" + }, + "keepMiniPlayerAndNavVisible": "Mantener visible el minirreproductor y la navegación", + "@keepMiniPlayerAndNavVisible": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:143" + }, + "keepPlaybackPausedWhenADevice": "Mantener la reproducción en pausa cuando se reconecte un dispositivo", + "@keepPlaybackPausedWhenADevice": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:274" + }, + "keepPlayingOnQuit": "Seguir reproduciendo al salir", + "@keepPlayingOnQuit": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:35" + }, + "keepRelativeLevelsInsideEachAlbum": "Conservar los niveles relativos dentro de cada álbum", + "@keepRelativeLevelsInsideEachAlbum": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:206" + }, + "keepTheSessionMovingOrHead": "Sigue con la sesión o vuelve directamente al reproductor.", + "@keepTheSessionMovingOrHead": { + "description": "lib/features/menu/screens/menu_screen.dart:1313" + }, + "keepYourReplay": "Conserva tu Replay.", + "@keepYourReplay": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:465" + }, + "keeping": "Conservando • {type} • {br}", + "@keeping": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1016", + "placeholders": { + "type": { + "type": "Object" + }, + "br": { + "type": "Object" + } + } + }, + "keepingOfToRemove": "Se conservan {keptCount} de {arg1} • se quitarán {removeCount}", + "@keepingOfToRemove": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1019", + "placeholders": { + "keptCount": { + "type": "Object" + }, + "arg1": { + "type": "Object" + }, + "removeCount": { + "type": "Object" + } + } + }, + "keepingThisVersion": "Conservar esta versión", + "@keepingThisVersion": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1531" + }, + "keepsBitPerfectAudioAliveIn": "Mantiene el audio bit perfecto activo en segundo plano", + "@keepsBitPerfectAudioAliveIn": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:51" + }, + "keepsSoftwareVolumeAndDspActive": "Mantiene activos el volumen por software y el DSP en la ruta compartida del DAP.", + "@keepsSoftwareVolumeAndDspActive": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:796" + }, + "keptInSecureStorageToRe": "Se conserva en el almacenamiento seguro para volver a iniciar sesión cuando venza el token", + "@keptInSecureStorageToRe": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:69" + }, + "keptWillBeRemoved": "{keptCount} se conservan • se quitarán {removeCount}", + "@keptWillBeRemoved": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1277", + "placeholders": { + "keptCount": { + "type": "Object" + }, + "removeCount": { + "type": "Object" + } + } + }, + "khz": "{arg1} kHz", + "@khz": { + "description": "lib/widgets/uac2/uac2_player_status.dart:186", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "khz2": "{arg1} kHz", + "@khz2": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1143", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "khzBit": "{arg1} kHz/{arg2} bits", + "@khzBit": { + "description": "lib/widgets/uac2/uac2_player_status.dart:77", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "khzBit2": "{arg1} kHz/{arg2} bits", + "@khzBit2": { + "description": "lib/widgets/uac2/uac2_status_indicator.dart:51", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "khzBitCh": "{arg1} kHz / {arg2} bits / {arg3} canales", + "@khzBitCh": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:274", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + }, + "arg3": { + "type": "Object" + } + } + }, + "koFi": "Ko-fi", + "@koFi": { + "description": "Ko-fi donation option label on the Support Flick screen." + }, + "label": "Etiqueta", + "@label": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:434" + }, + "labelOrganization": "Sello discográfico / organización", + "@labelOrganization": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:699" + }, + "landscape": "Horizontal", + "@landscape": { + "description": "Orbit settings profile for windows that are wider than they are tall." + }, + "landscapeLayoutReset": "Se restableció el diseño horizontal", + "@landscapeLayoutReset": { + "description": "Confirmation shown after resetting the landscape orbit layout." + }, + "language": "Idioma", + "@language": { + "description": "Settings entry label and the title of the language picker." + }, + "languageSectionDescription": "Elige el idioma que se usará en toda la app.", + "@languageSectionDescription": { + "description": "Helper text under the language setting." + }, + "languageSystemDefault": "Predeterminado del sistema", + "@languageSystemDefault": { + "description": "Language option that follows the device locale." + }, + "lastFm": "Last.fm", + "@lastFm": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:730" + }, + "lastFmConfiguration": "Configuración de Last.fm", + "@lastFmConfiguration": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:347" + }, + "lastFmConnected": "Last.fm conectado", + "@lastFmConnected": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:829" + }, + "lastFmConnected2": "Se conectó Last.fm.", + "@lastFmConnected2": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:97" + }, + "lastFmListenbrainzScrobbling": "Registro de reproducciones en Last.fm y ListenBrainz", + "@lastFmListenbrainzScrobbling": { + "description": "lib/features/settings/screens/settings_screen.dart:211" + }, + "lastFmScrobbling": "Registro de reproducciones en Last.fm", + "@lastFmScrobbling": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:59" + }, + "lastPick": "Última selección", + "@lastPick": { + "description": "lib/features/menu/screens/menu_screen.dart:1361" + }, + "lastUpdated": "Última actualización", + "@lastUpdated": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:98" + }, + "lastWeek": "La semana pasada", + "@lastWeek": { + "description": "lib/data/repositories/recently_played_repository.dart:291" + }, + "lateNightSessions": "Sesiones nocturnas", + "@lateNightSessions": { + "description": "lib/models/song.dart:344" + }, + "latestArrivalsFromYourLibrary": "Lo último que llegó a tu biblioteca", + "@latestArrivalsFromYourLibrary": { + "description": "lib/features/menu/screens/menu_screen.dart:1775" + }, + "latestUpdate": "Última actualización", + "@latestUpdate": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:250" + }, + "layered": "En capas", + "@layered": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:580" + }, + "layoutMode": "Modo de diseño", + "@layoutMode": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:98" + }, + "layoutModeSizingAndQuickActions": "Modo de diseño, tamaño y acciones rápidas", + "@layoutModeSizingAndQuickActions": { + "description": "lib/features/settings/screens/settings_screen.dart:126" + }, + "ldac330Kbps": "LDAC 330 kbps", + "@ldac330Kbps": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:497" + }, + "ldac660Kbps": "LDAC 660 kbps", + "@ldac660Kbps": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:498" + }, + "ldac990Kbps": "LDAC 990 kbps", + "@ldac990Kbps": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:499" + }, + "ldacAdaptive": "LDAC adaptable", + "@ldacAdaptive": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:496" + }, + "ldacBitsPerSample": "Bits por muestra de LDAC", + "@ldacBitsPerSample": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:380" + }, + "leLsbLittleEndianSubslotLsb": "LE-LSB: subranura en orden little-endian, primero el bit menos significativo", + "@leLsbLittleEndianSubslotLsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1724" + }, + "leMsbLittleEndianSubslotMsb": "LE-MSB: subranura en orden little-endian, primero el bit más significativo", + "@leMsbLittleEndianSubslotMsb": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1720" + }, + "leaveEmptyToKeepTheCurrent": "Déjalo vacío para conservar las credenciales actuales", + "@leaveEmptyToKeepTheCurrent": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:460" + }, + "left": "Izquierda", + "@left": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:56" + }, + "leftBottom": "Izquierda (abajo)", + "@leftBottom": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:349" + }, + "leftBottomButton": "Botón izquierdo (abajo)", + "@leftBottomButton": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:410" + }, + "leftTop": "Izquierda (arriba)", + "@leftTop": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:337" + }, + "leftTopButton": "Botón izquierdo (arriba)", + "@leftTopButton": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:385" + }, + "length": "Duración:", + "@length": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1838" + }, + "lengthOfTheOverlap": "Duración del solapamiento", + "@lengthOfTheOverlap": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:331" + }, + "lengthS": "Duración: {arg1} s", + "@lengthS": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1799", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "letAndroidChooseTheBestCodec": "Permitir que Android elija el mejor códec", + "@letAndroidChooseTheBestCodec": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:485" + }, + "letAndroidChooseTheOutputDevice": "Permitir que Android elija el dispositivo de salida", + "@letAndroidChooseTheOutputDevice": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:312" + }, + "letAndroidNegotiateTheCodecAutomatically": "Permitir que Android negocie el códec automáticamente", + "@letAndroidNegotiateTheCodecAutomatically": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:344" + }, + "letOboePickTheBestApi": "Permitir que Oboe elija la mejor API. Primero AAudio y luego OpenSL ES como alternativa.", + "@letOboePickTheBestApi": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:662" + }, + "letTheSystemDecideBestBattery": "Dejar que el sistema decida: máximo ahorro de batería", + "@letTheSystemDecideBestBattery": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:212" + }, + "letsFlickScanYourEntireLibrary": "Permite que Flick analice directamente toda tu biblioteca, incluidos los archivos DSD, DSF y WavPack que algunos dispositivos ocultan del índice multimedia del sistema", + "@letsFlickScanYourEntireLibrary": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2057" + }, + "level": "Nivel", + "@level": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:511" + }, + "libraryEmptied": "Se vació la biblioteca", + "@libraryEmptied": { + "description": "lib/features/settings/screens/library_settings_screen.dart:443" + }, + "libraryGlanceCard": "Tarjeta de resumen de la biblioteca", + "@libraryGlanceCard": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:149" + }, + "libraryLabel": "Biblioteca", + "@libraryLabel": { + "description": "lib/features/menu/screens/menu_screen.dart:1051" + }, + "licenses": "Licencias", + "@licenses": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:659" + }, + "light": "Claro", + "@light": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:166" + }, + "likedSongs": "{arg1} canciones que te gustan", + "@likedSongs": { + "description": "lib/features/favorites/screens/favorites_screen.dart:308", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "likedSongsLiveHere": "Aquí están tus canciones favoritas", + "@likedSongsLiveHere": { + "description": "lib/features/menu/screens/menu_screen.dart:1410" + }, + "likesAndReplaysBlendedTogether": "Me gusta y repeticiones combinados", + "@likesAndReplaysBlendedTogether": { + "description": "lib/features/menu/screens/menu_screen.dart:1766" + }, + "limit": "Límite", + "@limit": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3016" + }, + "limitPositiveGainSoTheLevel": "Limitar la ganancia positiva para que el nivel nunca supere el máximo", + "@limitPositiveGainSoTheLevel": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:230" + }, + "limiter": "Limitador", + "@limiter": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3391" + }, + "limiterOff": "Limitador desactivado", + "@limiterOff": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3269" + }, + "limiterOn": "Limitador activado", + "@limiterOn": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3269" + }, + "line": "Línea", + "@line": { + "description": "lib/models/progress_bar_style.dart:18" + }, + "lineOf": "Línea {arg1} de {arg2}", + "@lineOf": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1290", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "lineOfWords": "Línea {arg1} de {arg2} · {captured}/{segmentCount} palabras", + "@lineOfWords": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1366", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + }, + "captured": { + "type": "Object" + }, + "segmentCount": { + "type": "Object" + } + } + }, + "lineThickness": "Grosor de línea", + "@lineThickness": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart" + }, + "lineThicknessDescription": "Ajusta el grosor de la línea de progreso.", + "@lineThicknessDescription": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart" + }, + "linear": "Lineal", + "@linear": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:919" + }, + "lines": "Líneas", + "@lines": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:865" + }, + "lines2": "{arg1} líneas", + "@lines2": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:952", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "linkReady": "Enlace listo", + "@linkReady": { + "description": "lib/features/settings/screens/logs_screen.dart:170" + }, + "linkedToThisSong": "Se vinculó «{arg1}» con esta canción.", + "@linkedToThisSong": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:140", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "list": "Lista", + "@list": { + "description": "lib/models/song_view_mode.dart:19" + }, + "listAvailableLocalAudioOutputDevices": "Mostrar los dispositivos locales de salida de audio disponibles", + "@listAvailableLocalAudioOutputDevices": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:258" + }, + "listenbrainz": "ListenBrainz", + "@listenbrainz": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:426" + }, + "listenbrainzConnected": "ListenBrainz conectado", + "@listenbrainzConnected": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:259" + }, + "listenbrainzConnected2": "Se conectó ListenBrainz.", + "@listenbrainzConnected2": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:599" + }, + "listeningHours": "Horas de escucha", + "@listeningHours": { + "description": "lib/features/milestone/screens/milestones_screen.dart:377" + }, + "listeningToByOnFlick": "Escuchando {arg1} de {arg2} en Flick", + "@listeningToByOnFlick": { + "description": "lib/features/player/widgets/share/share_bottom_sheet.dart:134", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "littleEndianSubslotLsbFirstBits": "Subranura en orden little-endian, primero los bits menos significativos", + "@littleEndianSubslotLsbFirstBits": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1847" + }, + "littleEndianSubslotMsbFirstBits": "Subranura en orden little-endian, primero los bits más significativos", + "@littleEndianSubslotMsbFirstBits": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1837" + }, + "livePreview": "Vista previa en tiempo real", + "@livePreview": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:669" + }, + "livingOrnament": "Adorno animado", + "@livingOrnament": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:669" + }, + "loadAJsonOrTxtPreset": "Cargar un preajuste JSON o TXT", + "@loadAJsonOrTxtPreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:745" + }, + "loadAnImpulseResponseForRoom": "Cargar una respuesta al impulso para reverberación de sala, mezcla entre canales, gabinete o corrección.", + "@loadAnImpulseResponseForRoom": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3749" + }, + "loadIr": "Cargar respuesta al impulso", + "@loadIr": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3787" + }, + "loadedIr": "Respuesta al impulso cargada: {displayName}", + "@loadedIr": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3717", + "placeholders": { + "displayName": { + "type": "Object" + } + } + }, + "loadingArtwork": "Cargando portada", + "@loadingArtwork": { + "description": "lib/features/settings/screens/library_settings_screen.dart:629" + }, + "loadingArtwork2": "Cargando portada…", + "@loadingArtwork2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:961" + }, + "loadingFavoritesRecentSessionsGenerated": "Cargando favoritos, sesiones recientes, mezclas generadas y listas de reproducción.", + "@loadingFavoritesRecentSessionsGenerated": { + "description": "lib/features/menu/screens/menu_screen.dart:2260" + }, + "loadingPatchNotes": "Cargando notas de la versión…", + "@loadingPatchNotes": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:276" + }, + "loadingReplay": "Cargando Replay", + "@loadingReplay": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:235" + }, + "loadingSession": "Cargando sesión…", + "@loadingSession": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:737" + }, + "localData": "Datos locales", + "@localData": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:39" + }, + "@@locale": "es", + "locked": "Bloqueado", + "@locked": { + "description": "lib/features/milestone/screens/milestones_screen.dart:588" + }, + "logFrequencyControl": "Control de frecuencia logarítmica", + "@logFrequencyControl": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2170" + }, + "logs": "Registros", + "@logs": { + "description": "lib/features/settings/screens/logs_screen.dart:277" + }, + "logsCopied": "Registros copiados", + "@logsCopied": { + "description": "lib/features/settings/screens/logs_screen.dart:91" + }, + "longPress": "Mantener presionado", + "@longPress": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:306" + }, + "longSongTitles": "Títulos de canciones largos", + "@longSongTitles": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:244" + }, + "look": "Apariencia", + "@look": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:520" + }, + "lookingForCoverArtFromMusicbrainz": "Buscando portadas en MusicBrainz y Cover Art Archive.", + "@lookingForCoverArtFromMusicbrainz": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:471" + }, + "lookingForTheLatestFlickRelease": "Buscando la versión más reciente de Flick", + "@lookingForTheLatestFlickRelease": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:136" + }, + "lookingForTheLatestPlayStore": "Buscando la actualización más reciente de Play Store", + "@lookingForTheLatestPlayStore": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:135" + }, + "lossless": " Sin pérdida", + "@lossless": { + "description": "lib/widgets/common/detail_header.dart:157" + }, + "losslessQualityPreservedDuringConversion": "Se conserva la calidad sin pérdida durante la conversión", + "@losslessQualityPreservedDuringConversion": { + "description": "lib/widgets/alac_conversion_indicator.dart:158" + }, + "low": "Bajo", + "@low": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:142" + }, + "lowAndHighFrequenciesScoopedMids": "Graves y agudos realzados, medios atenuados", + "@lowAndHighFrequenciesScoopedMids": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:157" + }, + "lowFrequenciesOnly": "Solo frecuencias bajas", + "@lowFrequenciesOnly": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:133" + }, + "lowLatencyGoodQuality": "Baja latencia, buena calidad", + "@lowLatencyGoodQuality": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:488" + }, + "lowLatencyMode": "Modo de baja latencia", + "@lowLatencyMode": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:432" + }, + "lowPass": "Filtro pasa bajos", + "@lowPass": { + "description": "lib/providers/equalizer_provider.dart:33" + }, + "lowShelf": "Filtro shelving de graves", + "@lowShelf": { + "description": "lib/providers/equalizer_provider.dart:29" + }, + "lrclib": "LRCLib", + "@lrclib": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:381" + }, + "lyric": "Letra", + "@lyric": { + "description": "lib/features/player/widgets/share/share_template.dart:5" + }, + "lyrics": "Letras", + "@lyrics": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:295" + }, + "lyricsPreview": "Vista previa de letras", + "@lyricsPreview": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:1012" + }, + "lyricsSavedFromLrclib": "Letras guardadas desde LRCLib.", + "@lyricsSavedFromLrclib": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:162" + }, + "lyricsSavingBehavior": "Comportamiento al guardar letras", + "@lyricsSavingBehavior": { + "description": "lib/features/settings/screens/settings_screen.dart:172" + }, + "lyricsSyncHelp": "Ayuda para sincronizar letras", + "@lyricsSyncHelp": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:647" + }, + "lyricsSyncStudio": "Estudio de letras y sincronización", + "@lyricsSyncStudio": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:747" + }, + "lyricsText": "Texto de las letras", + "@lyricsText": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:615" + }, + "m": "{arg1} min", + "@m": { + "description": "lib/features/player/widgets/sleep_timer_bottom_sheet.dart:133", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "m2": "{arg1} min", + "@m2": { + "description": "lib/features/player/widgets/sleep_timer_bottom_sheet.dart:162", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "mAgo": "hace {arg1} min", + "@mAgo": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:492", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "madeForYou": "Hecho para ti", + "@madeForYou": { + "description": "lib/features/menu/screens/menu_screen.dart:844" + }, + "makeup": "Compensación", + "@makeup": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3372" + }, + "manual": "Manual", + "@manual": { + "description": "lib/features/manual/screens/manual_screen.dart:133" + }, + "manualOrder": "Orden manual", + "@manualOrder": { + "description": "lib/features/playlists/widgets/playlist_sort_bottom_sheet.dart:21" + }, + "manualQueue": "Cola manual", + "@manualQueue": { + "description": "lib/features/queue/screens/queue_screen.dart:221" + }, + "manufacturer": "Fabricante", + "@manufacturer": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:468" + }, + "mar": "mar", + "@mar": { + "description": "lib/features/milestone/screens/milestones_screen.dart:504" + }, + "masterBypassed": "Ecualizador principal omitido", + "@masterBypassed": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3273" + }, + "matchAudioFilename": "Coincidir con el nombre del archivo de audio", + "@matchAudioFilename": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:25" + }, + "matchByArtistAlbumAndTrack": "Identificar {count, plural, =1{{count} archivo} other{{count} archivos}} por artista, álbum y duración de la pista", + "@matchByArtistAlbumAndTrack": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:225", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "matchEqToYourHeadphoneModel": "Ajustar el ecualizador a tu modelo de audífonos", + "@matchEqToYourHeadphoneModel": { + "description": "lib/features/settings/screens/equalizer_screen.dart:759" + }, + "matchNavigation": "Igualar navegación", + "@matchNavigation": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:82" + }, + "matches": "Coincidencias", + "@matches": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:354" + }, + "maxB": "Máx. {arg1} B", + "@maxB": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1012", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "maximumAudioQuality": "Máxima calidad de audio", + "@maximumAudioQuality": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:506" + }, + "maximumSmoothnessUsesMoreBattery": "Máxima fluidez: consume más batería", + "@maximumSmoothnessUsesMoreBattery": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:236" + }, + "may": "may", + "@may": { + "description": "lib/features/milestone/screens/milestones_screen.dart:506" + }, + "may42026": "4 de mayo de 2026", + "@may42026": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:108" + }, + "mayStopInTheBackgroundOn": "Puede que en algunos dispositivos deje de funcionar en segundo plano", + "@mayStopInTheBackgroundOn": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:52" + }, + "mb": "{arg1} MB", + "@mb": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:24", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "media": "Multimedia", + "@media": { + "description": "lib/features/settings/screens/settings_screen.dart:76" + }, + "medium": "Medio", + "@medium": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:150" + }, + "menu": "Menú", + "@menu": { + "description": "lib/models/nav_bar_config.dart:5" + }, + "metadata": "Metadatos", + "@metadata": { + "description": "lib/features/settings/screens/integrations_settings_screen.dart:23" + }, + "metropolitan": "Metropolitano", + "@metropolitan": { + "description": "lib/models/song.dart:335" + }, + "mhz": "{arg1} MHz", + "@mhz": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1141", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "mid": "Medios", + "@mid": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1680" + }, + "midFrequenciesOnly": "Solo frecuencias medias", + "@midFrequenciesOnly": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:141" + }, + "midnightCityDreams": "Sueños de ciudad a medianoche", + "@midnightCityDreams": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:866" + }, + "midnightDreams": "Sueños de medianoche", + "@midnightDreams": { + "description": "lib/models/song.dart:318" + }, + "midnightSignal": "Señal de medianoche", + "@midnightSignal": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:914" + }, + "milestone": "Hito", + "@milestone": { + "description": "lib/app/app.dart:402" + }, + "milestones": "Hitos", + "@milestones": { + "description": "lib/features/milestone/screens/milestones_screen.dart:122" + }, + "min": "{arg1} min", + "@min": { + "description": "lib/features/player/widgets/sleep_timer_bottom_sheet.dart:174", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "miniPlayer": "Minirreproductor", + "@miniPlayer": { + "description": "lib/providers/tutorial_provider.dart:38" + }, + "miniPlayerAppearance": "Apariencia del minirreproductor", + "@miniPlayerAppearance": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:193" + }, + "miniPlayerDefaultsRestored": "Se restablecieron los valores predeterminados del minirreproductor", + "@miniPlayerDefaultsRestored": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:292" + }, + "miniPlayerHeight": "Altura del minirreproductor", + "@miniPlayerHeight": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:125" + }, + "miniPlayerLayout": "Diseño del minirreproductor", + "@miniPlayerLayout": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:64" + }, + "minimal": "Mínimo", + "@minimal": { + "description": "lib/features/player/widgets/share/share_template.dart:13" + }, + "minimize": "Minimizar", + "@minimize": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1058" + }, + "minimserverServiioKodi": "MinimServer · Serviio · Kodi", + "@minimserverServiioKodi": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:82" + }, + "mirrorTest": "Prueba de espejo", + "@mirrorTest": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:1187" + }, + "mirrored": "En espejo", + "@mirrored": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:103" + }, + "mitLicenseCopyrightC2026Flick": "Licencia MIT\n\nCopyright (c) 2026 Colaboradores de Flick Player\n\nPor la presente se concede permiso, sin cargo, a toda persona que obtenga una copia de este software y de los archivos de documentación asociados (el «Software») para tratar el Software sin restricciones, incluidos, entre otros, los derechos de usar, copiar, modificar, combinar, publicar, distribuir, sublicenciar o vender copias del Software, y permitir que las personas a quienes se proporcione el Software lo hagan, sujeto a las siguientes condiciones:\n\nEl aviso de derechos de autor anterior y este aviso de permiso deben incluirse en todas las copias o partes sustanciales del Software.\n\nEL SOFTWARE SE PROPORCIONA «TAL CUAL», SIN GARANTÍAS DE NINGÚN TIPO, EXPRESAS O IMPLÍCITAS, INCLUIDAS, ENTRE OTRAS, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN FIN DETERMINADO Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE LOS DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGUNA RECLAMACIÓN, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, EXTRACONTRACTUAL O DE OTRO TIPO, QUE SURJA DE, SE DERIVE DE O ESTÉ RELACIONADA CON EL SOFTWARE O SU USO U OTRAS OPERACIONES CON EL SOFTWARE.\n", + "@mitLicenseCopyrightC2026Flick": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:516" + }, + "mix": "Mezcla", + "@mix": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3641" + }, + "mix2": "Mezcla {arg1}", + "@mix2": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3523", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "mixer": "Mezclador", + "@mixer": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:659" + }, + "mixerManagement": "Administración del mezclador", + "@mixerManagement": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:688" + }, + "moAgo": "hace {arg1} meses", + "@moAgo": { + "description": "lib/features/menu/screens/menu_screen.dart:3203", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "mod": "Mod", + "@mod": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1014" + }, + "moderate": "Moderado", + "@moderate": { + "description": "lib/models/album_color_mode.dart:24" + }, + "mono": "Mono", + "@mono": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:621" + }, + "monthly": "Mensual", + "@monthly": { + "description": "lib/data/repositories/recently_played_repository.dart:16" + }, + "more": "Más", + "@more": { + "description": "lib/features/settings/screens/logs_screen.dart:322" + }, + "more2": "{arg1} + {arg2} más", + "@more2": { + "description": "lib/features/menu/screens/menu_screen.dart:1842", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "moreActions": "Más acciones", + "@moreActions": { + "description": "lib/features/songs/screens/songs_screen.dart:1556" + }, + "moreArtists": "Más artistas", + "@moreArtists": { + "description": "lib/features/artists/screens/artists_screen.dart:762" + }, + "moreArtists2": "Más artistas", + "@moreArtists2": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:154" + }, + "moreExportOptions": "Más opciones de exportación", + "@moreExportOptions": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:762" + }, + "moreFrom": "Más de {arg1}", + "@moreFrom": { + "description": "lib/features/albums/screens/album_detail_screen.dart:549", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "moreFromArtist": "Más de este artista", + "@moreFromArtist": { + "description": "lib/features/artists/screens/artists_screen.dart:752" + }, + "moreFromArtist2": "Más de este artista", + "@moreFromArtist2": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:142" + }, + "moreTo": "{arg1} más para {arg2}", + "@moreTo": { + "description": "lib/features/milestone/screens/milestones_screen.dart:794", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "moreToUnlock": "{remaining} {unit} más para desbloquear.", + "@moreToUnlock": { + "description": "lib/features/milestone/screens/milestones_screen.dart:618", + "placeholders": { + "remaining": { + "type": "Object" + }, + "unit": { + "type": "Object" + } + } + }, + "mossEcosystem": "Ecosistema Moss", + "@mossEcosystem": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:69" + }, + "mostDlnaServersNeedNoPassword": "La mayoría de los servidores DLNA no requieren contraseña", + "@mostDlnaServersNeedNoPassword": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:85" + }, + "mostPlayed": "Más reproducidas", + "@mostPlayed": { + "description": "lib/features/artists/screens/artist_detail_screen.dart:701" + }, + "mostReplayed": "Más repetida · {arg1}", + "@mostReplayed": { + "description": "lib/features/recap/widgets/replay_sections.dart:91", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "motionArtInBitPerfect": "Motion Art en modo bit perfecto", + "@motionArtInBitPerfect": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:64" + }, + "motionArtIsReplacedWhileBit": "La animación de portada se reemplaza mientras está activa la salida bit perfecta", + "@motionArtIsReplacedWhileBit": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:67" + }, + "motionArtPlaysDuringBitPerfect": "La animación de portada se reproduce con audio bit perfecto (puede interrumpir la reproducción en algunos DAP)", + "@motionArtPlaysDuringBitPerfect": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:66" + }, + "motionArtRefreshed": "Se actualizó la animación de portada", + "@motionArtRefreshed": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:255" + }, + "moveEveryStampedLyricForwardOr": "Desplazar todas las líneas de letras sincronizadas hacia adelante o hacia atrás a la vez.", + "@moveEveryStampedLyricForwardOr": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1987" + }, + "movement": "Movimiento", + "@movement": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:164" + }, + "ms": "{arg1} ms", + "@ms": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1025", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "ms2": "{arg1} ms", + "@ms2": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3346", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "ms3": "{arg1} ms", + "@ms3": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3360", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "ms4": "{arg1} ms", + "@ms4": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3434", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "ms5": "{arg1} ms", + "@ms5": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3616", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "multiFilterBands": "Bandas con varios filtros", + "@multiFilterBands": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2174" + }, + "musicFolders": "{arg1} carpetas de música", + "@musicFolders": { + "description": "lib/features/folders/screens/folders_screen.dart:327", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "mute": "Silenciar", + "@mute": { + "description": "lib/widgets/uac2/iso_volume_popup.dart:260" + }, + "my": "Mi {arg1}", + "@my": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:435", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "nDb": "{arg1}%\n{arg2} dB", + "@nDb": { + "description": "lib/widgets/uac2/iso_volume_popup.dart:292", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "nameAZ": "Nombre (A-Z)", + "@nameAZ": { + "description": "lib/features/folders/screens/folders_screen.dart:2421" + }, + "narrow": "{amount}% más estrecho", + "@narrow": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3493", + "placeholders": { + "amount": { + "type": "Object" + } + } + }, + "nativeDsd": "DSD nativo", + "@nativeDsd": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:712" + }, + "nativeDsdExperimental": "DSD nativo (experimental)", + "@nativeDsdExperimental": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1690" + }, + "nativeDsdExperimentalMayBeBuggy": "DSD nativo: experimental (puede tener errores)", + "@nativeDsdExperimentalMayBeBuggy": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1643" + }, + "nativeFlickPresetFormat": "Formato nativo de preajustes de Flick", + "@nativeFlickPresetFormat": { + "description": "lib/features/settings/screens/equalizer_screen.dart:661" + }, + "naturalEqualizerFeelResponsiveYetSmooth": "Ecualizador natural: respuesta rápida y a la vez fluida", + "@naturalEqualizerFeelResponsiveYetSmooth": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:178" + }, + "natureAmbient": "Ambiente natural", + "@natureAmbient": { + "description": "lib/models/song.dart:317" + }, + "navidromeAirsonicGonic": "Navidrome · Airsonic · Gonic", + "@navidromeAirsonicGonic": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:58" + }, + "navigationAppearance": "Apariencia de navegación", + "@navigationAppearance": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:216" + }, + "navigationBar": "Barra de navegación", + "@navigationBar": { + "description": "lib/providers/tutorial_provider.dart:11" + }, + "navigationDefaultsRestored": "Se restablecieron los valores predeterminados de navegación", + "@navigationDefaultsRestored": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:298" + }, + "needsMetadata": "Faltan metadatos", + "@needsMetadata": { + "description": "lib/features/settings/screens/missing_metadata_screen.dart:87" + }, + "negotiated": "Negociado: {arg1}", + "@negotiated": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:519", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "neonLimeWithSignalOrangeReplay": "Verde neón con acentos naranja señal de Replay", + "@neonLimeWithSignalOrangeReplay": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:674" + }, + "neonNights": "Noches de neón", + "@neonNights": { + "description": "lib/models/song.dart:357" + }, + "neonPulse": "Pulso de neón", + "@neonPulse": { + "description": "lib/models/song.dart:328" + }, + "neonSkyline": "Horizonte de neón", + "@neonSkyline": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:878" + }, + "network": "Red", + "@network": { + "description": "lib/models/playback_context.dart:16" + }, + "networkSources": "Fuentes de red", + "@networkSources": { + "description": "lib/features/settings/screens/network_sources_screen.dart:136" + }, + "neutral": "{amount}% neutral", + "@neutral": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3492", + "placeholders": { + "amount": { + "type": "Object" + } + } + }, + "neverSynced": "Nunca sincronizado", + "@neverSynced": { + "description": "lib/features/settings/screens/network_sources_screen.dart:318" + }, + "newLabel": "Nuevo", + "@newLabel": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1009" + }, + "next": "Siguiente", + "@next": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:269" + }, + "nextSong": "Canción siguiente", + "@nextSong": { + "description": "lib/widgets/common/mini_player_bar.dart:266" + }, + "nextSong2": "Canción siguiente", + "@nextSong2": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:184" + }, + "nextToGo": "Siguiente: {arg1} — faltan {remaining} {unit}", + "@nextToGo": { + "description": "lib/features/milestone/widgets/milestone_card.dart:217", + "placeholders": { + "arg1": { + "type": "Object" + }, + "remaining": { + "type": "Object" + }, + "unit": { + "type": "Object" + } + } + }, + "nextcloudOwncloudSabredav": "Nextcloud · ownCloud · SabreDAV", + "@nextcloudOwncloudSabredav": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:74" + }, + "night": "Noche", + "@night": { + "description": "lib/features/recap/widgets/replay_card_options.dart:11" + }, + "no": "No", + "@no": { + "description": "lib/features/settings/screens/logs_screen.dart:220" + }, + "noAchievementsYetKeepListening": "Aún no hay logros: sigue escuchando", + "@noAchievementsYetKeepListening": { + "description": "lib/features/settings/screens/settings_screen.dart:254" + }, + "noAlbumDataYet": "Aún no hay datos del álbum", + "@noAlbumDataYet": { + "description": "lib/features/recap/widgets/replay_poster.dart:228" + }, + "noAlbumsFound": "No se encontraron álbumes", + "@noAlbumsFound": { + "description": "lib/features/albums/screens/albums_screen.dart:442" + }, + "noAppleMusicReleaseFoundTry": "No se encontró el lanzamiento en Apple Music. Prueba a editar el nombre del artista o del álbum y vuelve a buscar.", + "@noAppleMusicReleaseFoundTry": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:339" + }, + "noArtistsFound": "No se encontraron artistas", + "@noArtistsFound": { + "description": "lib/features/artists/screens/artists_screen.dart:477" + }, + "noArtistsMatch": "Ningún artista coincide con «{_searchQuery}»", + "@noArtistsMatch": { + "description": "lib/features/artists/screens/artists_screen.dart:533", + "placeholders": { + "_searchQuery": { + "type": "Object" + } + } + }, + "noAudioWasFoundIfThis": "No se encontró audio. Si esta carpeta contiene música, es posible que un archivo .nomedia la esté ocultando o que Android aún no la haya indexado. Prueba a activar el análisis profundo o quita cualquier archivo .nomedia y vuelve a analizarla.", + "@noAudioWasFoundIfThis": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1427" + }, + "noCastingDevicesFoundMakeSure": "No se encontraron dispositivos para transmitir. Asegúrate de que el teléfono y el receptor estén conectados a la misma red.", + "@noCastingDevicesFoundMakeSure": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:204" + }, + "noCategoriesSelected": "No hay categorías seleccionadas", + "@noCategoriesSelected": { + "description": "lib/features/search/screens/search_screen.dart:315" + }, + "noChangelogNotesForThisVersion": "Aún no hay notas de cambios para esta versión.", + "@noChangelogNotesForThisVersion": { + "description": "lib/features/whats_new/widgets/whats_new_bottom_sheet.dart:56" + }, + "noCustomAlbumArtIsSet": "Todavía no hay una portada personalizada para el álbum.", + "@noCustomAlbumArtIsSet": { + "description": "l10n pass: user-visible service error" + }, + "noCustomPresetsYet": "Aún no hay preajustes personalizados.", + "@noCustomPresetsYet": { + "description": "lib/features/settings/screens/equalizer_screen.dart:788" + }, + "noDuplicatesFound": "No se encontraron duplicados", + "@noDuplicatesFound": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:393" + }, + "noFavoritesYet": "Aún no tienes favoritos", + "@noFavoritesYet": { + "description": "lib/features/favorites/screens/favorites_screen.dart:353" + }, + "noFeaturedTrackYet": "Aún no hay una pista destacada", + "@noFeaturedTrackYet": { + "description": "lib/features/menu/screens/menu_screen.dart:2329" + }, + "noFiltersFoundInPresetFile": "No se encontraron filtros en el archivo de preajuste.", + "@noFiltersFoundInPresetFile": { + "description": "lib/services/eq_preset_file_service.dart:185" + }, + "noFoldersAdded": "No se agregaron carpetas", + "@noFoldersAdded": { + "description": "lib/features/folders/screens/folders_screen.dart:368" + }, + "noHistoryYet": "Aún no hay historial", + "@noHistoryYet": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:346" + }, + "noInternetConnectionPleaseCheckYour": "No hay conexión a internet. Comprueba la red e inténtalo de nuevo.", + "@noInternetConnectionPleaseCheckYour": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:80" + }, + "noLibraryFilesForThisAlbum": "No se encontraron archivos de la biblioteca para este álbum.", + "@noLibraryFilesForThisAlbum": { + "description": "l10n pass: user-visible service error" + }, + "noLogsYet": "Aún no hay registros.", + "@noLogsYet": { + "description": "lib/features/settings/screens/logs_screen.dart:441" + }, + "noLyricsFoundOnlineForThis": "No se encontraron letras en línea para esta canción.", + "@noLyricsFoundOnlineForThis": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:166" + }, + "noLyricsYet": "Aún no hay letras", + "@noLyricsYet": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:413" + }, + "noMatchFound": "No se encontró ninguna coincidencia", + "@noMatchFound": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:524" + }, + "noMatches": "No hay coincidencias.", + "@noMatches": { + "description": "lib/features/settings/screens/logs_screen.dart:441" + }, + "noMatchesFor": "No hay coincidencias para «{_query}»", + "@noMatchesFor": { + "description": "lib/features/manual/screens/manual_screen.dart:224", + "placeholders": { + "_query": { + "type": "Object" + } + } + }, + "noMatchesFound": "No se encontraron coincidencias", + "@noMatchesFound": { + "description": "lib/features/songs/screens/songs_screen.dart:1854" + }, + "noMatchesTryFewerWordsOr": "No hay coincidencias. Prueba con menos palabras o busca en línea.", + "@noMatchesTryFewerWordsOr": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:317" + }, + "noMusicYet": "Aún no hay música", + "@noMusicYet": { + "description": "lib/features/songs/screens/songs_screen.dart:1846" + }, + "noNewAdditionsYet": "Todavía no hay canciones nuevas", + "@noNewAdditionsYet": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:318" + }, + "noNewUpdateFound": "No se encontraron actualizaciones nuevas.", + "@noNewUpdateFound": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:95" + }, + "noOnlineArtworkFound": "No se encontraron portadas en línea", + "@noOnlineArtworkFound": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:489" + }, + "noOutputDevicesAvailable": "No hay dispositivos de salida disponibles.", + "@noOutputDevicesAvailable": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:264" + }, + "noPatchNotesAvailableYet": "Aún no hay notas de la versión.", + "@noPatchNotesAvailableYet": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:251" + }, + "noPlaybackYet": "Aún no hay reproducciones", + "@noPlaybackYet": { + "description": "lib/features/menu/screens/menu_screen.dart:1362" + }, + "noPlaylistsYet": "Aún no hay listas de reproducción", + "@noPlaylistsYet": { + "description": "lib/features/menu/screens/menu_screen.dart:989" + }, + "noPlaylistsYet2": "Aún no hay listas de reproducción", + "@noPlaylistsYet2": { + "description": "lib/features/playlists/screens/playlists_screen.dart:234" + }, + "noPlaylistsYetNcreateOneIn": "Aún no hay listas de reproducción.\nCrea una en la pestaña Listas.", + "@noPlaylistsYetNcreateOneIn": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:79" + }, + "noRankingDataYet": "Aún no hay datos de clasificación", + "@noRankingDataYet": { + "description": "lib/features/recap/widgets/replay_poster.dart:323" + }, + "noResultsFor": "No hay resultados para «{query}»", + "@noResultsFor": { + "description": "lib/features/search/screens/search_screen.dart:282", + "placeholders": { + "query": { + "type": "Object" + } + } + }, + "noResultsFoundFor": "No se encontraron resultados para «{query}».", + "@noResultsFoundFor": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:196", + "placeholders": { + "query": { + "type": "Object" + } + } + }, + "noRipData": "No hay datos de extracción", + "@noRipData": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1063" + }, + "noScanResultsYet": "Aún no hay resultados del análisis", + "@noScanResultsYet": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:229" + }, + "noServerPlaylistsFound": "No se encontraron listas de reproducción en el servidor", + "@noServerPlaylistsFound": { + "description": "lib/features/playlists/screens/playlists_screen.dart:472" + }, + "noServersConnected": "No hay servidores conectados", + "@noServersConnected": { + "description": "lib/features/settings/screens/network_sources_screen.dart:190" + }, + "noSongPlaying": "No se está reproduciendo ninguna canción", + "@noSongPlaying": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:701" + }, + "noSongsFound": "No se encontraron canciones", + "@noSongsFound": { + "description": "lib/features/folders/screens/folders_screen.dart:1362" + }, + "noSongsInThisPlaylist": "Esta lista de reproducción no tiene canciones", + "@noSongsInThisPlaylist": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:522" + }, + "noUpcomingQueueItemsYet": "Aún no hay canciones siguientes en la cola.", + "@noUpcomingQueueItemsYet": { + "description": "lib/features/queue/screens/queue_screen.dart:507" + }, + "noUpdateAvailable": "No hay actualizaciones disponibles", + "@noUpdateAvailable": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:165" + }, + "noUrbData": "No hay datos URB", + "@noUrbData": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:965" + }, + "noUsbAudioDevicesFound": "No se encontraron dispositivos de audio USB", + "@noUsbAudioDevicesFound": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:289" + }, + "noWordTimingYetAutoFill": "Aún no hay tiempos para las palabras. El autorrelleno las distribuye uniformemente como punto de partida; también puedes marcarlas en el modo Sincronizar palabras.", + "@noWordTimingYetAutoFill": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1698" + }, + "nocturnal": "Nocturno", + "@nocturnal": { + "description": "lib/models/song.dart:323" + }, + "none": "Ninguno", + "@none": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3769" + }, + "normalizeEachTrackToMatchLoudness": "Normalizar cada pista para igualar el volumen", + "@normalizeEachTrackToMatchLoudness": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:198" + }, + "notAnAlacFile": "No es un archivo ALAC", + "@notAnAlacFile": { + "description": "lib/widgets/alac_conversion_indicator.dart:112" + }, + "notAvailableInBitPerfectMode": "No disponible en modo bit perfecto", + "@notAvailableInBitPerfectMode": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:308" + }, + "notFoundOnlineTryADifferent": "No se encontró en línea. Prueba con otra forma de escribirlo.", + "@notFoundOnlineTryADifferent": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:123" + }, + "notGrantedEnableSoScansCover": "Permiso no concedido: actívalo para que el análisis incluya archivos DSD, DSF y WavPack que el índice del sistema podría omitir", + "@notGrantedEnableSoScansCover": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1888" + }, + "notHeld": "No retenido", + "@notHeld": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:715" + }, + "notRecommendedForNormalUsageDsd": "No se recomienda para el uso normal. La reproducción DSD es inestable y puede causar cortes de audio.", + "@notRecommendedForNormalUsageDsd": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1620" + }, + "notRegistered": "No registrado", + "@notRegistered": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:705" + }, + "notSet": "No establecido", + "@notSet": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:275" + }, + "notStampedYet": "Aún no sincronizado", + "@notStampedYet": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1156" + }, + "notVerified": "No verificado", + "@notVerified": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1103" + }, + "notch": "Muesca", + "@notch": { + "description": "lib/providers/equalizer_provider.dart:39" + }, + "notchDepth": "Profundidad de muesca", + "@notchDepth": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2642" + }, + "noticeableTintingFromAlbumArt": "Tinte perceptible a partir de la portada del álbum.", + "@noticeableTintingFromAlbumArt": { + "description": "lib/models/album_color_mode.dart:37" + }, + "nov": "nov", + "@nov": { + "description": "lib/features/milestone/screens/milestones_screen.dart:512" + }, + "now": "Ahora", + "@now": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1032" + }, + "nowPlaying": "En reproducción", + "@nowPlaying": { + "description": "lib/features/player/screens/full_player_screen.dart:604" + }, + "nowPlaying2": "En reproducción", + "@nowPlaying2": { + "description": "lib/features/queue/screens/queue_screen.dart:550" + }, + "numberOnArt": "Número en la portada", + "@numberOnArt": { + "description": "lib/models/song_tile_thumbnail_mode.dart:22" + }, + "oauthSignInNoPasswordStored": "Inicio de sesión con OAuth; aquí no se guarda ninguna contraseña", + "@oauthSignInNoPasswordStored": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:101" + }, + "oceanWaves": "Olas del océano", + "@oceanWaves": { + "description": "lib/models/song.dart:312" + }, + "oct": "oct", + "@oct": { + "description": "lib/features/milestone/screens/milestones_screen.dart:511" + }, + "off": "Desactivado", + "@off": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:189" + }, + "offCropsToFillTheSquare": "Desactivado: recorta la imagen para llenar el cuadrado; activado: estira la portada de borde a borde", + "@offCropsToFillTheSquare": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2197" + }, + "offline": "Sin conexión", + "@offline": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:158" + }, + "onAndroidTheStandardJustAudio": "En Android, la ruta de reproducción estándar de just_audio ahora aplica equivalentes nativos del ecualizador, la dinámica, el balance y los efectos espaciales en los dispositivos compatibles. El motor Rust sigue ofreciendo la versión más precisa de estos controles, por lo que algunos resultados en Android son aproximados.", + "@onAndroidTheStandardJustAudio": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3911" + }, + "onRepeat": "En repetición", + "@onRepeat": { + "description": "lib/features/menu/screens/menu_screen.dart:1748" + }, + "onboardingBrowseBody": "Desliza entre pestañas para explorar\nCanciones, Artistas, Álbumes y\nListas. Ordena y busca en\ntoda tu colección.", + "@onboardingBrowseBody": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:44" + }, + "onboardingBrowseTitle": "Explora\ntu música", + "@onboardingBrowseTitle": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:43" + }, + "onboardingLibraryBody": "Ve a Ajustes y toca\nCarpetas de música para analizar\ntu dispositivo. Compatible con MP3, FLAC,\nAAC, WAV y más.", + "@onboardingLibraryBody": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:38" + }, + "onboardingLibraryTitle": "Crea tu\nbiblioteca", + "@onboardingLibraryTitle": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:37" + }, + "onboardingPlaybackBody": "Toca cualquier canción para abrir el reproductor\ncompleto con barra de reproducción de forma de onda,\necualizador, letras y visuales\nde portada ambiental.", + "@onboardingPlaybackBody": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:50" + }, + "onboardingPlaybackTitle": "Reproducción\ncompleta", + "@onboardingPlaybackTitle": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:49" + }, + "onboardingReadyBody": "Empieza a explorar tu música.\nRelájate y disfruta\ndel sonido de Flick Player.", + "@onboardingReadyBody": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:56" + }, + "onboardingReadyTitle": "Ya\nestá todo listo", + "@onboardingReadyTitle": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:55" + }, + "onboardingWelcomeBody": "Un reproductor de música atractivo y rápido\npara tu biblioteca local.\nSin anuncios. Sin rastreo. Solo música.", + "@onboardingWelcomeBody": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:31" + }, + "onboardingWelcomeTitle": "Te damos la bienvenida a\nFlick Player", + "@onboardingWelcomeTitle": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:30" + }, + "onlineArtistAlbumInformation": "Información de artistas y álbumes en línea", + "@onlineArtistAlbumInformation": { + "description": "lib/features/settings/widgets/apple_music_settings_tile.dart" + }, + "onlineResults": "Resultados en línea", + "@onlineResults": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:365" + }, + "onlyLibraryEntriesAreRemovedYour": "Solo se quitan las entradas de la biblioteca; los archivos de audio permanecen en el disco.", + "@onlyLibraryEntriesAreRemovedYour": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:557" + }, + "onlyReReadFilesThatAre": "Volver a leer solo los archivos nuevos o modificados.", + "@onlyReReadFilesThatAre": { + "description": "lib/features/settings/screens/library_settings_screen.dart:702" + }, + "open": "Abrir", + "@open": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:156" + }, + "openAndroidSettings": "Abrir ajustes de Android", + "@openAndroidSettings": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:407" + }, + "openBluetoothCodecSettings": "Abrir ajustes del códec Bluetooth", + "@openBluetoothCodecSettings": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:351" + }, + "openFullNotes": "Abrir notas completas", + "@openFullNotes": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:401" + }, + "openInAppleMusic": "Abrir en Apple Music", + "@openInAppleMusic": { + "description": "lib/features/albums/screens/album_detail_screen.dart:360" + }, + "openInBrowser": "Abrir en el navegador", + "@openInBrowser": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:623" + }, + "openInPlayStore": "Abrir en Play Store", + "@openInPlayStore": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:631" + }, + "openLibrary": "Abrir biblioteca", + "@openLibrary": { + "description": "lib/features/menu/screens/menu_screen.dart:1322" + }, + "openListenbrainzOrgSettings": "Abrir listenbrainz.org/settings", + "@openListenbrainzOrgSettings": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:717" + }, + "openManual": "Abrir manual", + "@openManual": { + "description": "lib/features/onboarding/widgets/tutorial_overlay.dart:345" + }, + "openPlayer": "Abrir reproductor", + "@openPlayer": { + "description": "lib/features/menu/screens/menu_screen.dart:1319" + }, + "openReleaseNotes": "Abrir notas de la versión", + "@openReleaseNotes": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:312" + }, + "openSourceLicenses": "Abrir licencias de código abierto", + "@openSourceLicenses": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:660" + }, + "openThePlayStoreToInstall": "Abre Play Store para instalar la versión más reciente de Flick", + "@openThePlayStoreToInstall": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:144" + }, + "openedFromLocker": "Abierto desde Locker", + "@openedFromLocker": { + "description": "lib/features/player/screens/full_player_screen.dart:616" + }, + "openslEs": "OpenSL ES", + "@openslEs": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:700" + }, + "openslEsLegacy": "OpenSL ES (heredado)", + "@openslEsLegacy": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:639" + }, + "orRemoveAllUsingRecommendedPicks": "O quitar todos con las selecciones recomendadas", + "@orRemoveAllUsingRecommendedPicks": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:851" + }, + "orbital": "Orbital", + "@orbital": { + "description": "lib/models/song_view_mode.dart:17" + }, + "orbitHeaderBoundaryBody": "Las tarjetas orbitales y la trayectoria de la órbita permanecen debajo del encabezado Tu biblioteca y de la barra de búsqueda. Si elevas la órbita, se recorta en este límite.", + "@orbitHeaderBoundaryBody": { + "description": "Explains that orbit cards and the path stay below the library header and search bar." + }, + "orbitHeaderBoundaryTitle": "La órbita se detiene en la cabecera de la biblioteca", + "@orbitHeaderBoundaryTitle": { + "description": "Title of the notice about the orbit's top boundary." + }, + "orbitLandscapeHint": "Se usa cuando la ventana de la app es más ancha que alta.", + "@orbitLandscapeHint": { + "description": "Explains when the landscape orbit profile is applied." + }, + "orbitLayoutProfile": "Perfil de diseño", + "@orbitLayoutProfile": { + "description": "Header for choosing the portrait or landscape orbit profile." + }, + "orbitPortraitHint": "Se usa cuando la ventana de la app es más alta que ancha.", + "@orbitPortraitHint": { + "description": "Explains when the portrait orbit profile is applied." + }, + "orbitPreviewHide": "Ocultar vista previa", + "@orbitPreviewHide": { + "description": "Tooltip for collapsing the orbit preview." + }, + "orbitPreviewHint": "Desliza para explorar. No se reproduce, no se añade a la cola ni se cambian los favoritos.", + "@orbitPreviewHint": { + "description": "Explains that the orbit preview is browse-only." + }, + "orbitPreviewShow": "Mostrar vista previa", + "@orbitPreviewShow": { + "description": "Tooltip for expanding the orbit preview." + }, + "orbitSharedVisuals": "Elementos visuales compartidos", + "@orbitSharedVisuals": { + "description": "Header for orbit visuals shared by both orientation profiles." + }, + "otherPlaylists": "Otras listas de reproducción", + "@otherPlaylists": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:604" + }, + "ourRustPoweredEngineCleanerSound": "Nuestro motor con tecnología Rust ofrece un sonido más limpio y una reproducción más fluida. Recomendado para escuchar a diario.", + "@ourRustPoweredEngineCleanerSound": { + "description": "lib/features/menu/screens/menu_screen.dart:499" + }, + "outlineTheMiniPlayer": "Delinear el minirreproductor", + "@outlineTheMiniPlayer": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:209" + }, + "output": "Salida", + "@output": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:281" + }, + "outputDevice": "Dispositivo de salida", + "@outputDevice": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:120" + }, + "outputMode": "Modo de salida", + "@outputMode": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:408" + }, + "outputRate": "Frecuencia de salida", + "@outputRate": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:601" + }, + "overlapTheEndOfATrack": "Superponer el final de una pista con la siguiente", + "@overlapTheEndOfATrack": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:321" + }, + "overlayPermissionIsRequiredToShow": "Se requiere permiso de superposición para mostrar el reproductor flotante", + "@overlayPermissionIsRequiredToShow": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:299" + }, + "overviewMetricsChooseUpTo3": "Métricas generales · elige hasta 3", + "@overviewMetricsChooseUpTo3": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:643" + }, + "paired": "Emparejado", + "@paired": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:110" + }, + "parametric": "Paramétrico", + "@parametric": { + "description": "lib/features/settings/screens/equalizer_screen.dart:4169" + }, + "parametricBandsWithIndependentFrequency": "{arg1} bandas paramétricas con controles independientes de frecuencia, ganancia y Q. Toca para interactuar.", + "@parametricBandsWithIndependentFrequency": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2205", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "parametricEq": "Ecualizador paramétrico", + "@parametricEq": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2160" + }, + "passthrough": "Paso directo", + "@passthrough": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:682" + }, + "password": "Contraseña", + "@password": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:456" + }, + "pasteOrTypeTheSongLyrics": "Pega o escribe aquí la letra de la canción, una línea por renglón", + "@pasteOrTypeTheSongLyrics": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:623" + }, + "pasteYourListenbrainzToken": "Pega tu token de ListenBrainz", + "@pasteYourListenbrainzToken": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:741" + }, + "patchNotes": "Notas de la versión", + "@patchNotes": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:259" + }, + "pause": "Pausar", + "@pause": { + "description": "lib/widgets/common/mini_player_bar.dart:262" + }, + "pauseOnBluetoothConnect": "Pausar al conectarse por Bluetooth", + "@pauseOnBluetoothConnect": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:260" + }, + "pauseOnDisconnect": "Pausar al desconectarse", + "@pauseOnDisconnect": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:249" + }, + "pauseOnUsbDacAttach": "Pausar al conectar un DAC USB", + "@pauseOnUsbDacAttach": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:282" + }, + "pauseOnUsbDacDetach": "Pausar al desconectar un DAC USB", + "@pauseOnUsbDacDetach": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:293" + }, + "pcmFrames": "Tramas PCM", + "@pcmFrames": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:987" + }, + "peakHour": "Hora de mayor actividad", + "@peakHour": { + "description": "lib/features/recap/widgets/replay_card_options.dart:24" + }, + "peaking": "Pico", + "@peaking": { + "description": "lib/providers/equalizer_provider.dart:27" + }, + "permission": "Permiso", + "@permission": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:230" + }, + "personalPlaylist": "Lista de reproducción personal", + "@personalPlaylist": { + "description": "lib/features/menu/screens/menu_screen.dart:1837" + }, + "phoneAndHeadsetVolumeAreIndependent": "El volumen del teléfono y el de los audífonos son independientes", + "@phoneAndHeadsetVolumeAreIndependent": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:401" + }, + "phoneAndHeadsetVolumeAreLinked": "El volumen del teléfono y el de los audífonos están vinculados", + "@phoneAndHeadsetVolumeAreLinked": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:400" + }, + "photoFraming": "Encuadre de la foto", + "@photoFraming": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:619" + }, + "pickALineWithLyrics": "Elige una línea con letra", + "@pickALineWithLyrics": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1390" + }, + "pickALyricLineIn": "1. En Líneas, elige una línea de la letra y luego cambia a Herramientas.\n2. Pulsa reproducir y toca el botón grande «Marcar palabra» al oír cada palabra. El primer toque también marca el tiempo de la línea.\n3. Toca una etiqueta de palabra para ajustarla, cambiarle el tiempo o borrarla.\n4. Las líneas con todas las palabras marcadas se guardan con tiempos de karaoke para cada palabra.", + "@pickALyricLineIn": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:678" + }, + "pickAgain": "Elegir de nuevo", + "@pickAgain": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:610" + }, + "pickImage": "Elegir imagen", + "@pickImage": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:341" + }, + "pickUpExactlyWhereYourLast": "Retoma justo donde terminaste en tus últimas sesiones.", + "@pickUpExactlyWhereYourLast": { + "description": "lib/features/menu/screens/menu_screen.dart:933" + }, + "pinchApartNarrowerHigherQNpinch": "Pellizca hacia afuera para estrechar (Q más alto)\nPellizca hacia adentro para ensanchar (Q más bajo)", + "@pinchApartNarrowerHigherQNpinch": { + "description": "lib/widgets/equalizer/interactive_eq_graph.dart:158" + }, + "pitch": "Tono", + "@pitch": { + "description": "lib/features/player/widgets/pitch_bottom_sheet.dart:37" + }, + "pitchSemitones": "{semitones, plural, =1{{semitones} semitono} other{{semitones} semitonos}}", + "@pitchSemitones": { + "description": "lib/features/player/widgets/pitch_bottom_sheet.dart:95", + "placeholders": { + "semitones": { + "type": "int" + } + } + }, + "pixelatedLightestOnMemory": "Pixelado: consume menos memoria", + "@pixelatedLightestOnMemory": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:143" + }, + "plain": "Normal", + "@plain": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:581" + }, + "plainText": "Texto sin formato", + "@plainText": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:379" + }, + "play": "Reproducir", + "@play": { + "description": "lib/widgets/common/detail_header.dart:273" + }, + "playAFewSongsAndThis": "Reproduce algunas canciones y esta página empezará a mostrar mezclas, artistas y accesos directos.", + "@playAFewSongsAndThis": { + "description": "lib/features/menu/screens/menu_screen.dart:1316" + }, + "playAFewTracksTodayTo": "Reproduce algunas canciones hoy para crear el resumen diario.", + "@playAFewTracksTodayTo": { + "description": "lib/data/repositories/recently_played_repository.dart:33" + }, + "playARandomLibrarySongWhen": "Reproducir una canción aleatoria de la biblioteca cuando termine la cola", + "@playARandomLibrarySongWhen": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:75" + }, + "playAgain": "Reproducir de nuevo", + "@playAgain": { + "description": "lib/features/menu/screens/menu_screen.dart:1321" + }, + "playAtTheRecordedLevel": "Reproducir al nivel grabado", + "@playAtTheRecordedLevel": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:190" + }, + "playBadges": "Insignias de reproducción", + "@playBadges": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:679" + }, + "playCategoriesInRandomOrderTracks": "Reproducir las categorías en orden aleatorio y las pistas en secuencia", + "@playCategoriesInRandomOrderTracks": { + "description": "lib/models/shuffle_mode.dart:22" + }, + "playInOrder": "Reproducir en orden", + "@playInOrder": { + "description": "lib/models/shuffle_mode.dart:19" + }, + "playNext": "Reproducir a continuación", + "@playNext": { + "description": "lib/features/queue/screens/queue_screen.dart:843" + }, + "playStoreUpdatesUseGooglePlay": "Las actualizaciones de Play Store usan la API de actualización dentro de Google Play (sujeta a las políticas de privacidad de Google). Las notas de la versión se obtienen desde la API de GitHub Releases sin enviar datos personales.", + "@playStoreUpdatesUseGooglePlay": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:76" + }, + "playback": "Reproducción", + "@playback": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:28" + }, + "playbackCacheLimit": "Límite de caché de reproducción", + "@playbackCacheLimit": { + "description": "lib/features/settings/screens/library_settings_screen.dart:336" + }, + "playbackCacheLimit2": "Límite de caché de reproducción: {arg1}", + "@playbackCacheLimit2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:328", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "playbackCacheUnlimited": "Caché de reproducción ilimitada", + "@playbackCacheUnlimited": { + "description": "lib/features/settings/screens/library_settings_screen.dart:327" + }, + "playbackContinuesWhenABluetoothDevice": "La reproducción continúa cuando se conecta un dispositivo Bluetooth", + "@playbackContinuesWhenABluetoothDevice": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:263" + }, + "playbackContinuesWhenAUsbDac": "La reproducción continúa cuando se conecta un DAC USB", + "@playbackContinuesWhenAUsbDac": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:285" + }, + "playbackContinuesWhenAUsbDac2": "La reproducción continúa cuando se desconecta un DAC USB", + "@playbackContinuesWhenAUsbDac2": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:296" + }, + "playbackContinuesWhenAudioOutput": "La reproducción continúa cuando se desconecta la salida de audio", + "@playbackContinuesWhenAudioOutput": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:252" + }, + "playbackContinuesWhenTheAppIs": "La reproducción continúa cuando cierras la app al deslizarla fuera de la pantalla", + "@playbackContinuesWhenTheAppIs": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:37" + }, + "playbackDesynced": "Reproducción desincronizada", + "@playbackDesynced": { + "description": "lib/app/app.dart:488" + }, + "playbackDisplay": "Reproducción y pantalla", + "@playbackDisplay": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:24" + }, + "playbackEngine": "Motor de reproducción", + "@playbackEngine": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:324" + }, + "playbackIsUsingAndroidManagedOutput": "La reproducción usa la salida administrada por Android y es posible que se remuestree.", + "@playbackIsUsingAndroidManagedOutput": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1051" + }, + "playbackIsUsingTheStandardAndroid": "La reproducción usa la ruta de salida estándar de Android.", + "@playbackIsUsingTheStandardAndroid": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1053" + }, + "playbackModeWillUpdateAfterThe": "El modo de reproducción se actualizará después de la próxima actualización de la ruta o de la reproducción.", + "@playbackModeWillUpdateAfterThe": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1055" + }, + "playbackPath": "Ruta de reproducción", + "@playbackPath": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:616" + }, + "playbackPausesWhenABluetoothAudio": "La reproducción se pausa cuando se conecta un dispositivo de audio Bluetooth", + "@playbackPausesWhenABluetoothAudio": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:262" + }, + "playbackPausesWhenAUsbDac": "La reproducción se pausa cuando se conecta un DAC USB", + "@playbackPausesWhenAUsbDac": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:284" + }, + "playbackPausesWhenAUsbDac2": "La reproducción se pausa cuando se desconecta físicamente un DAC USB", + "@playbackPausesWhenAUsbDac2": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:295" + }, + "playbackPausesWhenBluetoothOrHeadphones": "La reproducción se pausa cuando se desconectan los audífonos o Bluetooth", + "@playbackPausesWhenBluetoothOrHeadphones": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:251" + }, + "playbackPausesWhileNotificationSoundsPlay": "La reproducción se pausa mientras suenan las notificaciones", + "@playbackPausesWhileNotificationSoundsPlay": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:246" + }, + "playbackResumesWhenADeviceReconnects": "La reproducción se reanuda si un dispositivo vuelve a conectarse en 30 segundos", + "@playbackResumesWhenADeviceReconnects": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:273" + }, + "playbackSpeed": "Velocidad de reproducción", + "@playbackSpeed": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:342" + }, + "playbackStopsWhenTheAppIs": "La reproducción se detiene cuando cierras la app al deslizarla fuera de la pantalla", + "@playbackStopsWhenTheAppIs": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:38" + }, + "played": "{count, plural, =1{Se reprodujo 1 canción} other{Se reprodujeron {count} canciones}}", + "@played": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:268", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "playerLayout": "Diseño del reproductor", + "@playerLayout": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:92" + }, + "playerMenuAddToPlaylist": "Agregar a la lista de reproducción", + "@playerMenuAddToPlaylist": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playerMenuAddToQueue": "Agregar a la cola", + "@playerMenuAddToQueue": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playerMenuEditMetadata": "Editar metadatos", + "@playerMenuEditMetadata": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playerMenuRefreshAlbumArt": "Actualizar portada animada", + "@playerMenuRefreshAlbumArt": { + "description": "Full-player song actions sheet; Taglish calls this album art." + }, + "playerMenuSetAlbumArt": "Establecer portada del álbum", + "@playerMenuSetAlbumArt": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playerMenuShare": "Compartir", + "@playerMenuShare": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playerMenuSleepTimer": "Temporizador de apagado", + "@playerMenuSleepTimer": { + "description": "Full-player song actions sheet; Taglish uses supplied wording." + }, + "playlist": "{count, plural, =1{{count} lista de reproducción} other{{count} listas de reproducción}}", + "@playlist": { + "description": "lib/features/playlists/screens/playlists_screen.dart:92", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "playlist2": "Lista de reproducción", + "@playlist2": { + "description": "lib/models/playback_context.dart:14" + }, + "playlistCoverRemoved": "Se quitó la portada de la lista de reproducción", + "@playlistCoverRemoved": { + "description": "lib/features/playlists/playlist_cover_actions.dart:93" + }, + "playlistCoverUpdated": "Se actualizó la portada de la lista de reproducción", + "@playlistCoverUpdated": { + "description": "lib/features/playlists/playlist_cover_actions.dart:58" + }, + "playlistCreated": "Se creó la lista de reproducción «{arg1}»", + "@playlistCreated": { + "description": "lib/features/playlists/screens/playlists_screen.dart:457", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "playlistExportAndroidOnly": "Por ahora, la exportación de listas de reproducción solo está disponible en Android.", + "@playlistExportAndroidOnly": { + "description": "lib/services/playlist_service.dart:627" + }, + "playlistImportAndroidOnly": "Por ahora, la importación de listas de reproducción solo está disponible en Android.", + "@playlistImportAndroidOnly": { + "description": "lib/services/playlist_service.dart:469" + }, + "playlistName": "Nombre de la lista de reproducción", + "@playlistName": { + "description": "lib/features/playlists/screens/playlists_screen.dart:356" + }, + "playlistNotFound": "No se encontró la lista de reproducción", + "@playlistNotFound": { + "description": "lib/services/playlist_service.dart:634" + }, + "playlistRenamed": "Se cambió el nombre de la lista a «{arg1}»", + "@playlistRenamed": { + "description": "lib/features/playlists/playlist_rename_action.dart:34", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "playlists": "Listas de reproducción", + "@playlists": { + "description": "lib/features/menu/screens/menu_screen.dart:1446" + }, + "plays": "{arg1} reproducciones", + "@plays": { + "description": "lib/features/menu/screens/menu_screen.dart:2699", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "plays2": "{count, plural, =1{1 reproducción} other{{count} reproducciones}}", + "@plays2": { + "description": "lib/features/recap/widgets/replay_style.dart:45", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "playsInRotation": "reproducciones en rotación", + "@playsInRotation": { + "description": "lib/features/recap/widgets/replay_poster.dart:147" + }, + "pleaseEnterAPlaylistName": "Ingresa un nombre para la lista de reproducción", + "@pleaseEnterAPlaylistName": { + "description": "lib/features/playlists/screens/playlists_screen.dart:430" + }, + "pleaseEnterYourListenbrainzUserToken": "Ingresa tu token de usuario de ListenBrainz.", + "@pleaseEnterYourListenbrainzUserToken": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:584" + }, + "portrait": "Vertical", + "@portrait": { + "description": "Orbit settings profile for windows that are taller than they are wide." + }, + "portraitLayoutReset": "Se restableció el diseño vertical", + "@portraitLayoutReset": { + "description": "Confirmation shown after resetting the portrait orbit layout." + }, + "posterPreviewPlays": "Vista previa del póster {arg1}. {arg2} reproducciones.", + "@posterPreviewPlays": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:423", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "preAmp": "Preamplificación", + "@preAmp": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:213" + }, + "preamp": "Preamplificador", + "@preamp": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1262" + }, + "preferences": "Preferencias", + "@preferences": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:147" + }, + "preloadAudioData": "Precargar datos de audio", + "@preloadAudioData": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1897" + }, + "preloadLibraryAudio": "Precargar el audio de la biblioteca", + "@preloadLibraryAudio": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2132" + }, + "preloadingAudio": "Precargando audio", + "@preloadingAudio": { + "description": "lib/features/settings/screens/library_settings_screen.dart:785" + }, + "preloadingAudio2": "Precargando audio {arg1}/{arg2}", + "@preloadingAudio2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1376", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "preloadingAudio3": "Precargando audio", + "@preloadingAudio3": { + "description": "lib/widgets/common/floating_scan_progress.dart:379" + }, + "preparing": "Preparando…", + "@preparing": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:753" + }, + "presence": "Presencia", + "@presence": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1890" + }, + "preset": "Preajuste: {activePresetName}", + "@preset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:90", + "placeholders": { + "activePresetName": { + "type": "Object" + } + } + }, + "presetFileIsEmpty": "El archivo de preajuste está vacío.", + "@presetFileIsEmpty": { + "description": "lib/services/eq_preset_file_service.dart:115" + }, + "presetImportedWithAdjustments": "Preajuste importado con ajustes", + "@presetImportedWithAdjustments": { + "description": "lib/features/settings/screens/equalizer_screen.dart:578" + }, + "presetName": "Nombre del preajuste", + "@presetName": { + "description": "lib/features/settings/screens/equalizer_screen.dart:438" + }, + "presets": "Preajustes", + "@presets": { + "description": "lib/features/settings/screens/equalizer_screen.dart:66" + }, + "pressBackAgainToExit": "Pulsa atrás otra vez para salir", + "@pressBackAgainToExit": { + "description": "lib/app/app.dart:739" + }, + "preventClipping": "Evitar la saturación", + "@preventClipping": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:228" + }, + "preview": "Vista previa", + "@preview": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:686" + }, + "previewUse": "Vista previa y usar", + "@previewUse": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:457" + }, + "previousSong": "Canción anterior", + "@previousSong": { + "description": "lib/widgets/common/mini_player_bar.dart:258" + }, + "previousSong2": "Canción anterior", + "@previousSong2": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:176" + }, + "prewarming": "Calentando", + "@prewarming": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:905" + }, + "prioritiseConnectionStability": "Priorizar la estabilidad de la conexión", + "@prioritiseConnectionStability": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:504" + }, + "privacyPolicy": "Política de privacidad", + "@privacyPolicy": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:666" + }, + "processingLive": "Procesamiento en tiempo real", + "@processingLive": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3273" + }, + "product": "Producto", + "@product": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:475" + }, + "productId": "ID del producto", + "@productId": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:496" + }, + "progress": "Progreso", + "@progress": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:168" + }, + "progressBar": "Barra de progreso", + "@progressBar": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:234" + }, + "protocol": "Protocolo", + "@protocol": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:372" + }, + "pulledFromYourLateSessionPlays": "Basado en las canciones que escuchaste en tus últimas sesiones nocturnas", + "@pulledFromYourLateSessionPlays": { + "description": "lib/features/menu/screens/menu_screen.dart:1783" + }, + "purple": "Morado", + "@purple": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:299" + }, + "queue": "Cola", + "@queue": { + "description": "lib/features/menu/screens/menu_screen.dart:1081" + }, + "queue2": "Cola {count}", + "@queue2": { + "description": "lib/features/player/screens/full_player_screen.dart:777", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "queueIsEmpty": "La cola está vacía", + "@queueIsEmpty": { + "description": "lib/features/queue/screens/queue_screen.dart:459" + }, + "queued": "Se agregó «{arg1}» a la cola", + "@queued": { + "description": "lib/features/player/widgets/player_navigation.dart:25", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "queuedSongs": "Se agregaron {arg1} canciones a la cola", + "@queuedSongs": { + "description": "lib/features/albums/screens/album_detail_screen.dart:263", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "queuedSongs3": "Se agregaron {arg1} canciones a la cola", + "@queuedSongs3": { + "description": "lib/features/songs/screens/songs_screen.dart:1345", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "quickAccess": "Acceso rápido", + "@quickAccess": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:29" + }, + "quickActions": "Acciones rápidas", + "@quickActions": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:333" + }, + "quickOrFullReIndexOf": "Análisis rápido o completo de todas las carpetas", + "@quickOrFullReIndexOf": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2126" + }, + "quickScan": "Análisis rápido", + "@quickScan": { + "description": "lib/features/settings/screens/library_settings_screen.dart:701" + }, + "random": "Aleatorio", + "@random": { + "description": "lib/models/advance_list_order.dart:9" + }, + "rate": "Calificar", + "@rate": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1035" + }, + "rating": "Calificación", + "@rating": { + "description": "lib/features/manual/data/manual_data.dart:236" + }, + "ratio": "Proporción", + "@ratio": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3332" + }, + "rawDsdStreamToDacRequires": "La transmisión DSD sin procesar al DAC requiere compatibilidad de hardware con ENCODING_DSD; de lo contrario, se cambia automáticamente a DoP o PCM.", + "@rawDsdStreamToDacRequires": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1692" + }, + "rawPcm": "→ PCM sin procesar", + "@rawPcm": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:918" + }, + "reReadMetadataForEveryFile": "Volver a leer los metadatos de todos los archivos. Es más lento; úsalo si las etiquetas parecen desactualizadas.", + "@reReadMetadataForEveryFile": { + "description": "lib/features/settings/screens/library_settings_screen.dart:710" + }, + "readMode": "Modo de lectura", + "@readMode": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1086" + }, + "readingTheCoverColors": "Leyendo los colores de la portada…", + "@readingTheCoverColors": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:562" + }, + "readyToRemoveSongKeepingIn": "Todo listo para quitar {count, plural, =1{{count} canción} other{{count} canciones}}. Total a conservar: {kept}.", + "@readyToRemoveSongKeepingIn": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:784", + "placeholders": { + "count": { + "type": "int" + }, + "kept": { + "type": "Object" + } + } + }, + "recapSavedAs": "Resumen guardado como {format}", + "@recapSavedAs": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:245", + "placeholders": { + "format": { + "type": "Object" + } + } + }, + "recentPicksOnHand": "{arg1} selecciones recientes disponibles", + "@recentPicksOnHand": { + "description": "lib/features/menu/screens/menu_screen.dart:1421", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "recentlyAdded": "Agregadas recientemente", + "@recentlyAdded": { + "description": "lib/features/menu/screens/menu_screen.dart:1428" + }, + "recentlyAddedTracksWaitingForMore": "Canciones agregadas recientemente que aún necesitan más reproducciones.", + "@recentlyAddedTracksWaitingForMore": { + "description": "lib/features/menu/screens/menu_screen.dart:1776" + }, + "recentlyPlayed": "Reproducidas recientemente", + "@recentlyPlayed": { + "description": "lib/features/menu/screens/menu_screen.dart:931" + }, + "recommended": "Recomendado", + "@recommended": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1515" + }, + "recommendedOnly": "Solo recomendados", + "@recommendedOnly": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1213" + }, + "reconnectAttempts": "Intentos de reconexión", + "@reconnectAttempts": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:160" + }, + "reconnectNow": "Reconectar ahora", + "@reconnectNow": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:205" + }, + "reconnectToTheInternetToScan": "Vuelve a conectarte a internet para buscar actualizaciones", + "@reconnectToTheInternetToScan": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:614" + }, + "reconnectToWiFiOrMobile": "Vuelve a conectarte a Wi-Fi o a los datos móviles para que Flick pueda buscar de nuevo", + "@reconnectToWiFiOrMobile": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:159" + }, + "reconnectionFailed": "No se pudo reconectar", + "@reconnectionFailed": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:72" + }, + "reconnectionSuccessful": "Reconexión correcta", + "@reconnectionSuccessful": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:72" + }, + "recorded": "Grabado", + "@recorded": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:869" + }, + "refreshAppleMusic": "Actualizar Apple Music", + "@refreshAppleMusic": { + "description": "lib/features/albums/screens/album_detail_screen.dart:365" + }, + "refreshDevices": "Actualizar dispositivos", + "@refreshDevices": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:443" + }, + "refreshDevices2": "Actualizar dispositivos", + "@refreshDevices2": { + "description": "lib/widgets/uac2/uac2_device_selector.dart:179" + }, + "refreshOutputs": "Actualizar salidas", + "@refreshOutputs": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:257" + }, + "refreshRate": "Frecuencia de actualización", + "@refreshRate": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:206" + }, + "refreshingAppleMusicData": "Actualizando los datos de Apple Music", + "@refreshingAppleMusicData": { + "description": "lib/features/albums/screens/album_detail_screen.dart:402" + }, + "registeredNotClaimed": "Registrado, sin asignar", + "@registeredNotClaimed": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:704" + }, + "reinitializingPlayback": "Reiniciando la reproducción…", + "@reinitializingPlayback": { + "description": "lib/features/menu/screens/restarting_screen.dart:12" + }, + "release": "Liberación", + "@release": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3358" + }, + "remove": "Quitar", + "@remove": { + "description": "lib/features/queue/screens/queue_screen.dart:847" + }, + "removeAll": "Quitar todo", + "@removeAll": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:927" + }, + "removeAllSongs": "¿Quitar todas las canciones?", + "@removeAllSongs": { + "description": "lib/features/settings/screens/library_settings_screen.dart:428" + }, + "removeAllSongs2": "Quitar todas las canciones", + "@removeAllSongs2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2183" + }, + "removeAllWithBestPicks": "¿Quitar todo con las mejores selecciones?", + "@removeAllWithBestPicks": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:924" + }, + "removeAndAllOfItsSongs": "¿Quitar «{arg1}» y todas sus canciones de la biblioteca? Los archivos del disco no se eliminarán.", + "@removeAndAllOfItsSongs": { + "description": "lib/features/settings/screens/library_settings_screen.dart:838", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removeCustomArt": "Quitar imagen personalizada", + "@removeCustomArt": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:357" + }, + "removeCover": "Quitar portada", + "@removeCover": { + "description": "lib/features/playlists/screens/playlists_screen.dart:651" + }, + "removeDuplicates": "Quitar duplicados", + "@removeDuplicates": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2147" + }, + "removeDuplicates2": "¿Quitar {toRemove} duplicados?", + "@removeDuplicates2": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:876", + "placeholders": { + "toRemove": { + "type": "Object" + } + } + }, + "removeDuplicates3": "Quitar {toRemove} duplicados", + "@removeDuplicates3": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:813", + "placeholders": { + "toRemove": { + "type": "Object" + } + } + }, + "removeFolder": "¿Quitar la carpeta?", + "@removeFolder": { + "description": "lib/features/settings/screens/library_settings_screen.dart:836" + }, + "removeFromFavorites": "Quitar de favoritos", + "@removeFromFavorites": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:88" + }, + "removeFromFavorites2": "Quitar de favoritos", + "@removeFromFavorites2": { + "description": "lib/widgets/common/detail_header.dart:257" + }, + "removeFromLibrary": "Quitar de la biblioteca", + "@removeFromLibrary": { + "description": "lib/features/songs/screens/songs_screen.dart:1639" + }, + "removeFromPlaylist": "Quitar de la lista de reproducción", + "@removeFromPlaylist": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:78" + }, + "removeSelected": "Quitar selección", + "@removeSelected": { + "description": "lib/features/queue/screens/queue_screen.dart:371" + }, + "removeServer": "¿Quitar el servidor?", + "@removeServer": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:327" + }, + "removeServer2": "Quitar servidor", + "@removeServer2": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:520" + }, + "removeTheDatabaseEntriesOrDelete": "Quitar las entradas de la base de datos o eliminar los archivos del dispositivo. Esta acción no se puede deshacer.", + "@removeTheDatabaseEntriesOrDelete": { + "description": "lib/features/songs/screens/songs_screen.dart:1629" + }, + "removeTheDatabaseEntryOrDelete": "Quitar la entrada de la base de datos o eliminar el archivo del dispositivo. Esta acción no se puede deshacer.", + "@removeTheDatabaseEntryOrDelete": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:736" + }, + "removeTheseSongsFromYourLibrary": "Quita estas canciones de la biblioteca. Los archivos del dispositivo no se verán afectados.", + "@removeTheseSongsFromYourLibrary": { + "description": "lib/features/songs/screens/songs_screen.dart:1630" + }, + "removeThisSongFromYourLibrary": "Quita esta canción de la biblioteca. El archivo del dispositivo no se verá afectado.", + "@removeThisSongFromYourLibrary": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:737" + }, + "removedCustomAlbumArtFor": "Se quitó la portada personalizada de «{arg1}».", + "@removedCustomAlbumArtFor": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:193", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedCustomAlbumArtFor2": "Se quitó la portada personalizada de «{arg1}».", + "@removedCustomAlbumArtFor2": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:194", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedDuplicatesKept": "Se quitaron {arg1} duplicados; se conservaron {arg2}.", + "@removedDuplicatesKept": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:901", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "removedFromFavorites": "Se quitó «{arg1}» de favoritos", + "@removedFromFavorites": { + "description": "lib/features/favorites/screens/favorites_screen.dart:61", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedFromFavorites2": "Se quitó {arg1} de favoritos", + "@removedFromFavorites2": { + "description": "lib/features/favorites/screens/favorites_screen.dart:126", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedFromFavorites3": "Se quitó de favoritos", + "@removedFromFavorites3": { + "description": "lib/features/player/widgets/player_action_button_row.dart:487" + }, + "removedFromLibrary": "Se quitó «{arg1}» de la biblioteca", + "@removedFromLibrary": { + "description": "lib/features/songs/widgets/song_actions_bottom_sheet.dart:830", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedSongsFromFavorites": "Se quitaron {arg1} canciones de favoritos", + "@removedSongsFromFavorites": { + "description": "lib/features/albums/screens/album_detail_screen.dart:299", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removedSongsFromLibrary": "Se quitaron {arg1} canciones de la biblioteca", + "@removedSongsFromLibrary": { + "description": "lib/features/songs/screens/songs_screen.dart:1715", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "removing": "Quitando…", + "@removing": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:813" + }, + "removingDuplicates": "Quitando duplicados…", + "@removingDuplicates": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:783" + }, + "rename": "Cambiar nombre", + "@rename": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1082" + }, + "renamePreset": "Cambiar nombre del preajuste", + "@renamePreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:437" + }, + "repeat": "Repetir: {arg1}", + "@repeat": { + "description": "lib/features/player/widgets/player_controls.dart:218", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "repeatMode": "Modo de repetición", + "@repeatMode": { + "description": "lib/features/player/widgets/loop_mode_sheet.dart:16" + }, + "repeatRewind": "Rebobinar al repetir", + "@repeatRewind": { + "description": "lib/features/menu/screens/menu_screen.dart:1756" + }, + "replaceAlbumNameWithAVerified": "Reemplazar el nombre del álbum con una cápsula bit-perfect verificada durante la transmisión bit-perfect", + "@replaceAlbumNameWithAVerified": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:368" + }, + "replay": "Replay", + "@replay": { + "description": "lib/features/recap/widgets/replay_poster.dart:15" + }, + "replayCouldnTLoad": "No se pudo cargar Replay.", + "@replayCouldnTLoad": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:248" + }, + "replayStudio": "Estudio de Replay", + "@replayStudio": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:304" + }, + "replayTheTutorialAndFeatureGuide": "Volver a reproducir el tutorial y la guía de funciones", + "@replayTheTutorialAndFeatureGuide": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:680" + }, + "replaygain": "ReplayGain", + "@replaygain": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:184" + }, + "replaygainScan": "Análisis de ReplayGain", + "@replaygainScan": { + "description": "lib/features/settings/screens/library_settings_screen.dart:812" + }, + "reportedOutputRate": "Frecuencia de salida informada", + "@reportedOutputRate": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:676" + }, + "requestedOutputRate": "Frecuencia de salida solicitada", + "@requestedOutputRate": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:667" + }, + "requiredToDetectDevicesCodecsAnd": "Se necesita para detectar dispositivos, códecs y niveles de batería", + "@requiredToDetectDevicesCodecsAnd": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:237" + }, + "resampler": "Remuestreador", + "@resampler": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:669" + }, + "rescanLibrary": "Volver a analizar la biblioteca", + "@rescanLibrary": { + "description": "lib/features/settings/screens/library_settings_screen.dart:693" + }, + "reset": "Restablecer", + "@reset": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:339" + }, + "resetArtwork": "Restablecer portada", + "@resetArtwork": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:207" + }, + "resetArtworkDescription": "¿Volver a detectar la portada a partir de los archivos de este álbum? Las portadas detectadas automáticamente se reemplazarán con las que se lean de los archivos; las personalizadas se conservarán.", + "@resetArtworkDescription": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:208" + }, + "resetArtworkFor": "Restablecer la portada de «{arg1}».", + "@resetArtworkFor": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:231", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "resetArtworkFor2": "Restablecer la portada de «{arg1}».", + "@resetArtworkFor2": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:232", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "resetCardDesign": "Restablecer diseño de tarjeta", + "@resetCardDesign": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:314" + }, + "resetDeclinedUsbDacs": "Restablecer los DAC USB rechazados", + "@resetDeclinedUsbDacs": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:512" + }, + "resetDynamics": "Restablecer dinámica", + "@resetDynamics": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3285" + }, + "resetFx": "Restablecer efectos", + "@resetFx": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3534" + }, + "resetMiniPlayerToDefaults": "Restablecer los valores predeterminados del minirreproductor", + "@resetMiniPlayerToDefaults": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:279" + }, + "resetNavigationToDefaults": "Restablecer los valores predeterminados de navegación", + "@resetNavigationToDefaults": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:283" + }, + "resetPreferences": "Restablecer preferencias", + "@resetPreferences": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:557" + }, + "resetStreakData": "¿Restablecer los datos de racha?", + "@resetStreakData": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:20" + }, + "resetStreakData2": "Restablecer datos de racha", + "@resetStreakData2": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:173" + }, + "resetTo0Db": "Restablecer a 0 dB", + "@resetTo0Db": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2746" + }, + "resetToDefaults": "Restablecer valores predeterminados", + "@resetToDefaults": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:199" + }, + "resolution": "Resolución", + "@resolution": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:560" + }, + "resonance": "Resonancia", + "@resonance": { + "description": "lib/providers/equalizer_provider.dart:70" + }, + "restart": "Reiniciar", + "@restart": { + "description": "lib/widgets/common/engine_restart_notice.dart:88" + }, + "restartRequired": "Es necesario reiniciar", + "@restartRequired": { + "description": "lib/widgets/common/engine_restart_notice.dart:46" + }, + "restartTheAppToApplyPlayback": "Reinicia la app para aplicar los cambios de reproducción.", + "@restartTheAppToApplyPlayback": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:989" + }, + "restartYourDeviceToApplyOutput": "Reinicia el dispositivo para aplicar los cambios de formato de salida.", + "@restartYourDeviceToApplyOutput": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1000" + }, + "restartingFlick": "Reiniciando Flick", + "@restartingFlick": { + "description": "lib/features/menu/screens/restarting_screen.dart:126" + }, + "restoreDefaultProgressBarSize": "Restablece el tamaño predeterminado del estilo de barra de progreso seleccionado.", + "@restoreDefaultProgressBarSize": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart" + }, + "restoreThisProfilesOrbitLayout": "Restablecer el diseño orbital original de este perfil", + "@restoreThisProfilesOrbitLayout": { + "description": "Subtitle for resetting only the selected orbit profile." + }, + "results": "Resultados ({arg1})", + "@results": { + "description": "lib/features/artists/screens/artists_screen.dart:510", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "resumeAFamiliarFavoriteOrShuffle": "Retoma un favorito conocido o mezcla una de las listas que se crearon a partir de lo que escuchas.", + "@resumeAFamiliarFavoriteOrShuffle": { + "description": "lib/features/menu/screens/menu_screen.dart:1315" + }, + "resumeOnReconnect": "Reanudar al reconectarse", + "@resumeOnReconnect": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:271" + }, + "retakePhoto": "Volver a tomar la foto", + "@retakePhoto": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:605" + }, + "retroFuture": "Futuro retro", + "@retroFuture": { + "description": "lib/models/song.dart:358" + }, + "retry": "Reintentar", + "@retry": { + "description": "lib/features/songs/screens/songs_screen.dart:1838" + }, + "reviewBeforeYouClean": "Revisar antes de limpiar", + "@reviewBeforeYouClean": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:545" + }, + "right": "Derecha", + "@right": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:80" + }, + "rightBottom": "Derecha (abajo)", + "@rightBottom": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:373" + }, + "rightBottomButton": "Botón derecho (abajo)", + "@rightBottomButton": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:460" + }, + "rightTop": "Derecha (arriba)", + "@rightTop": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:361" + }, + "rightTopButton": "Botón derecho (arriba)", + "@rightTopButton": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:435" + }, + "ripSource": "Fuente de extracción", + "@ripSource": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1078" + }, + "root": "Raíz", + "@root": { + "description": "lib/services/sources/upnp_service.dart:239" + }, + "rotationSeek": "búsqueda rotatoria", + "@rotationSeek": { + "description": "lib/features/player/widgets/album_art_box.dart:704" + }, + "roundedAlbumArtCardWithA": "Tarjeta redondeada con portada y fondo difuminado de la misma imagen.", + "@roundedAlbumArtCardWithA": { + "description": "lib/models/player_screen_mode.dart:28" + }, + "route": "Ruta", + "@route": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:654" + }, + "routesBluetoothThroughTheHiRes": "Enruta el audio Bluetooth por el motor Rust de alta resolución", + "@routesBluetoothThroughTheHiRes": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:419" + }, + "routesBluetoothThroughTheRustEngine": "Enruta el audio Bluetooth por el motor Rust", + "@routesBluetoothThroughTheRustEngine": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:434" + }, + "runAnotherPlayStoreUpdateScan": "Buscar actualizaciones de Play Store ahora mismo", + "@runAnotherPlayStoreUpdateScan": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:612" + }, + "runAnotherUpdateScanRightNow": "Buscar actualizaciones ahora mismo", + "@runAnotherUpdateScanRightNow": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:613" + }, + "rustViaOboe": "Rust mediante Oboe", + "@rustViaOboe": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:794" + }, + "rustViaOboeHighRes": "Rust mediante Oboe (alta resolución)", + "@rustViaOboeHighRes": { + "description": "lib/models/audio_engine_type.dart:39" + }, + "s": "{arg1} s", + "@s": { + "description": "lib/features/player/widgets/lyrics_word_timeline.dart:192", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "s2": "{arg1} s", + "@s2": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:734", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "sAgo": "hace {arg1} s", + "@sAgo": { + "description": "lib/widgets/uac2/uac2_hotplug_monitor.dart:103", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "sCurve": "Curva en S", + "@sCurve": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:248" + }, + "sambaWindowsShareTransportPending": "Samba · recurso compartido de Windows", + "@sambaWindowsShareTransportPending": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:90" + }, + "sampleArtist": "Artista de ejemplo", + "@sampleArtist": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:370" + }, + "samplePreview": "Vista previa de muestra", + "@samplePreview": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:874" + }, + "sampleRate": "Frecuencia de muestreo", + "@sampleRate": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:370" + }, + "sampleRate2": "Frecuencia de muestreo", + "@sampleRate2": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1319" + }, + "sampleRates": "Frecuencias de muestreo", + "@sampleRates": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:560" + }, + "sampleSongPreviewOnly": "Canción de ejemplo · solo vista previa", + "@sampleSongPreviewOnly": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:388" + }, + "samples": "Muestras", + "@samples": { + "description": "lib/widgets/alac_conversion_indicator.dart:144" + }, + "save": "Guardar", + "@save": { + "description": "lib/features/player/widgets/share/share_bottom_sheet.dart:299" + }, + "saveAsText": "Guardar como texto", + "@saveAsText": { + "description": "lib/features/settings/screens/logs_screen.dart:325" + }, + "saveChanges": "Guardar cambios", + "@saveChanges": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:545" + }, + "saveConnect": "Guardar y conectar", + "@saveConnect": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:656" + }, + "saveCreatesAnLrcFileIf": "Al guardar, se crea un archivo `.lrc`. Si algunas líneas aún no tienen tiempo marcado, Flick lo completa automáticamente para que el archivo siga funcionando. Las líneas con todas las palabras marcadas se exportan con tiempos de karaoke para cada palabra.", + "@saveCreatesAnLrcFileIf": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:2040" + }, + "saveCurrentAsPreset": "Guardar como preajuste", + "@saveCurrentAsPreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:737" + }, + "saveCustomizeReplay": "Guardar / personalizar Replay", + "@saveCustomizeReplay": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:221" + }, + "saveInFlick": "Guardar en Flick", + "@saveInFlick": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:503" + }, + "saveLogs": "Guardar registros", + "@saveLogs": { + "description": "lib/features/settings/screens/logs_screen.dart:207" + }, + "saveLrcFile": "Guardar archivo LRC", + "@saveLrcFile": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:490" + }, + "saveLrcFile2": "Guardar archivo LRC", + "@saveLrcFile2": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:525" + }, + "saveLyrics": "Guardar letras", + "@saveLyrics": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:1184" + }, + "savePng": "Guardar PNG", + "@savePng": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:756" + }, + "savePreset": "Guardar preajuste", + "@savePreset": { + "description": "lib/features/settings/screens/equalizer_screen.dart:437" + }, + "saveTheCurrentEqAsJson": "Guardar el ecualizador actual como JSON o TXT", + "@saveTheCurrentEqAsJson": { + "description": "lib/features/settings/screens/equalizer_screen.dart:752" + }, + "saved": "Guardado", + "@saved": { + "description": "lib/features/settings/screens/logs_screen.dart:217" + }, + "savedAgain": "Guardado · otra vez", + "@savedAgain": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:755" + }, + "savedAndVerified": "Guardado y verificado", + "@savedAndVerified": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:187" + }, + "savedCollections": "{playlistCount} colecciones guardadas", + "@savedCollections": { + "description": "lib/features/menu/screens/menu_screen.dart:1449", + "placeholders": { + "playlistCount": { + "type": "Object" + } + } + }, + "savedLyricsAndLinkedThemTo": "Se guardaron las letras y se vincularon con esta canción.", + "@savedLyricsAndLinkedThemTo": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:557" + }, + "savedLyricsBesideTheSongAs": "Se guardaron las letras junto a la canción como archivo `.lrc`.", + "@savedLyricsBesideTheSongAs": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:556" + }, + "savedLyricsToTheChosenLocation": "Se guardaron las letras en la ubicación seleccionada.", + "@savedLyricsToTheChosenLocation": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:554" + }, + "savedPlaylistsAndQuickJumpsInto": "Listas guardadas y accesos rápidos a la organización de tu biblioteca.", + "@savedPlaylistsAndQuickJumpsInto": { + "description": "lib/features/menu/screens/menu_screen.dart:975" + }, + "savedToGallery": "Guardado en la galería", + "@savedToGallery": { + "description": "lib/features/player/widgets/share/share_bottom_sheet.dart:163" + }, + "savedToNNNshareIt": "Guardado en:\n{path}\n\n¿Quieres compartirlo ahora?", + "@savedToNNNshareIt": { + "description": "lib/features/settings/screens/logs_screen.dart:218", + "placeholders": { + "path": { + "type": "Object" + } + } + }, + "savedToYourGallery": "{arg1} se guardó en la galería", + "@savedToYourGallery": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:244", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "savedVerificationPending": "Guardado (verificación pendiente)", + "@savedVerificationPending": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:195" + }, + "saving": "Guardando…", + "@saving": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:791" + }, + "saving2": "Guardando", + "@saving2": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:20" + }, + "savingRecapAndroidOnly": "Por ahora, guardar imágenes del resumen solo está disponible en Android.", + "@savingRecapAndroidOnly": { + "description": "l10n pass: user-visible service error" + }, + "scaleOfTheCenteredFocusedSong": "Tamaño de la tarjeta de canción centrada y enfocada", + "@scaleOfTheCenteredFocusedSong": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:114" + }, + "scaleTheAlbumArtCard": "Ajustar el tamaño de la tarjeta con portada", + "@scaleTheAlbumArtCard": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:240" + }, + "scaleTheFullViewAlbumArt": "Ajustar el tamaño de la tarjeta con portada en vista completa", + "@scaleTheFullViewAlbumArt": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:165" + }, + "scalesWithWidgetSizeAutomatically": "Se ajusta automáticamente al tamaño del widget", + "@scalesWithWidgetSizeAutomatically": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:236" + }, + "scanAgain": "Analizar de nuevo", + "@scanAgain": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:285" + }, + "scanComplete": "Análisis completo", + "@scanComplete": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1299" + }, + "scanFailedPleaseTryAgain": "No se pudo completar el análisis. Inténtalo de nuevo.", + "@scanFailedPleaseTryAgain": { + "description": "lib/features/settings/screens/library_settings_screen.dart:556" + }, + "scanForDevices": "Buscar dispositivos", + "@scanForDevices": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:75" + }, + "scanProgress": "Progreso del análisis", + "@scanProgress": { + "description": "lib/widgets/common/floating_scan_progress.dart:489" + }, + "scanReplaygain": "Analizar ReplayGain", + "@scanReplaygain": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2139" + }, + "scanningForDuplicates": "Buscando duplicados…", + "@scanningForDuplicates": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:142" + }, + "scanningSettings": "Ajustes del análisis", + "@scanningSettings": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1775" + }, + "scanningSongsFound": "Analizando… Se encontraron {count} canciones", + "@scanningSongsFound": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1640", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "scanningYourLibrary": "Analizando tu biblioteca…", + "@scanningYourLibrary": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:390" + }, + "scroll": "Desplazarse", + "@scroll": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:248" + }, + "scrollForMore": "Desplázate para ver más", + "@scrollForMore": { + "description": "lib/features/songs/screens/songs_screen.dart:3163" + }, + "scrollingPausesWhenReducedMotionIs": "El desplazamiento se pausa si está activada la opción para reducir el movimiento", + "@scrollingPausesWhenReducedMotionIs": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:250" + }, + "seamlessTransitionBetweenTracks": "Transición fluida entre pistas", + "@seamlessTransitionBetweenTracks": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:275" + }, + "search": "Buscar", + "@search": { + "description": "lib/providers/tutorial_provider.dart:21" + }, + "searchAgain": "Buscar de nuevo", + "@searchAgain": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:241" + }, + "searchArtistTitle": "Buscar artista + título…", + "@searchArtistTitle": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:618" + }, + "searchArtists": "Buscar artistas…", + "@searchArtists": { + "description": "lib/features/artists/screens/artists_screen.dart:297" + }, + "searchFailed": "Error en la búsqueda", + "@searchFailed": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:479" + }, + "searchFailed2": "Error en la búsqueda: {e}", + "@searchFailed2": { + "description": "lib/features/search/screens/search_screen.dart:220", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "searchHeadphones": "Buscar audífonos…", + "@searchHeadphones": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:233" + }, + "searchModelCount": "Buscar {count, plural, =1{{count} modelo} other{{count} modelos}}…", + "@searchModelCount": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:233", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "searchOnline": "Buscar en línea", + "@searchOnline": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:219" + }, + "searchOnline2": "Buscar en línea", + "@searchOnline2": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:414" + }, + "searchOnlineCreateYourOwnSynced": "Busca letras en línea, crea tus propias letras sincronizadas o importa un archivo existente.", + "@searchOnlineCreateYourOwnSynced": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:424" + }, + "searchOnlineLyrics": "Buscar letras en línea", + "@searchOnlineLyrics": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:277" + }, + "searchPlayback": "Buscar en reproducción", + "@searchPlayback": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:247" + }, + "searchResults": "Resultados de búsqueda", + "@searchResults": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:252" + }, + "searchSongsArtists": "Buscar canciones, artistas…", + "@searchSongsArtists": { + "description": "lib/features/songs/screens/songs_screen.dart:206" + }, + "searchSongsArtistsAlbums": "Buscar canciones, artistas y álbumes…", + "@searchSongsArtistsAlbums": { + "description": "lib/features/search/screens/search_screen.dart:138" + }, + "searchTheManual": "Buscar en el manual…", + "@searchTheManual": { + "description": "lib/features/manual/screens/manual_screen.dart:198" + }, + "searchSettings": "Buscar ajustes…", + "@searchSettings": { + "description": "Search field on the main settings page" + }, + "searchYourLibrary": "Buscar en tu biblioteca", + "@searchYourLibrary": { + "description": "lib/features/search/screens/search_screen.dart:240" + }, + "searching": "Buscando…", + "@searching": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:75" + }, + "searchingOnline": "Buscando en línea", + "@searchingOnline": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:469" + }, + "searchingTheLocalNetwork": "Buscando en la red local…", + "@searchingTheLocalNetwork": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:205" + }, + "secondsOfInactivityBeforeCollapsing": "Segundos de inactividad antes de contraer", + "@secondsOfInactivityBeforeCollapsing": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:93" + }, + "seeAll": "Ver todo", + "@seeAll": { + "description": "lib/features/menu/screens/menu_screen.dart:939" + }, + "seeAll2": "Ver los {count}", + "@seeAll2": { + "description": "lib/features/search/screens/search_screen.dart:371", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "seeWhatIsNewInThis": "Descubre las novedades de esta actualización", + "@seeWhatIsNewInThis": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:624" + }, + "select": "Seleccionar", + "@select": { + "description": "lib/features/favorites/screens/favorites_screen.dart:182" + }, + "selectAFolderToScan": "Selecciona una carpeta para analizar", + "@selectAFolderToScan": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2118" + }, + "selectALineAndEdit": "1. Selecciona una línea y edita directamente su marca de tiempo o usa «Usar hora actual».\n2. En la línea de tiempo de palabras, arrastra un límite para alargar o acortar el segmento anterior; los cambios se ajustan a intervalos de 10 ms.\n3. Toca letras en el inspector para dividir una palabra en sílabas con tiempos separados (ritmo lento y luego rápido) y después arrastra sus límites.\n4. Arrastra el último límite (o usa Duración ±) para cambiar el tiempo de la línea siguiente. Usa Autorrellenar para distribuir las palabras uniformemente.\n5. Usa los controles de desplazamiento para mover a la vez todas las letras marcadas.\n6. Guarda para generar el archivo `.lrc` final.", + "@selectALineAndEdit": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:694" + }, + "selectARelease": "Seleccionar un lanzamiento", + "@selectARelease": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:580" + }, + "selectAll": "Seleccionar todo", + "@selectAll": { + "description": "lib/features/favorites/screens/favorites_screen.dart:263" + }, + "selectAll2": "Seleccionar todo", + "@selectAll2": { + "description": "lib/features/songs/screens/songs_screen.dart:1574" + }, + "selectDevice": "Seleccionar dispositivo", + "@selectDevice": { + "description": "lib/widgets/uac2/uac2_device_selector.dart:58" + }, + "selected": "{count} seleccionados", + "@selected": { + "description": "lib/features/favorites/screens/favorites_screen.dart:252", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "selectedFileIsNotASupported": "El archivo seleccionado no es una imagen compatible.", + "@selectedFileIsNotASupported": { + "description": "l10n pass: user-visible service error" + }, + "selectedOfSong": "Selección: {selected} de {count, plural, =1{{count} canción} other{{count} canciones}}", + "@selectedOfSong": { + "description": "lib/features/queue/screens/queue_screen.dart:349", + "placeholders": { + "selected": { + "type": "Object" + }, + "count": { + "type": "int" + } + } + }, + "selectedPlaylistFileIsEmpty": "El archivo de lista de reproducción seleccionado está vacío", + "@selectedPlaylistFileIsEmpty": { + "description": "l10n pass: user-visible service error" + }, + "selectedSize": "Tamaño seleccionado", + "@selectedSize": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:113" + }, + "sep": "sep", + "@sep": { + "description": "lib/features/milestone/screens/milestones_screen.dart:510" + }, + "separateFromNavBar": "Separar de la barra de navegación", + "@separateFromNavBar": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:60" + }, + "separateTheMiniPlayerToCustomize": "Separa el minirreproductor para personalizar su ancho y el espacio. Tus valores personalizados se conservan al volver a unirlo.", + "@separateTheMiniPlayerToCustomize": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:115" + }, + "serialNumber": "Número de serie", + "@serialNumber": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:482" + }, + "serverPlaylistSyncFailed": "No se pudo sincronizar la lista de reproducción del servidor: {e}", + "@serverPlaylistSyncFailed": { + "description": "lib/features/playlists/screens/playlists_screen.dart:481", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "serverUrl": "URL del servidor", + "@serverUrl": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:442" + }, + "session": "Sesión", + "@session": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:107" + }, + "setAlbumArt": "Establecer portada del álbum", + "@setAlbumArt": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:220" + }, + "setCover": "Establecer portada", + "@setCover": { + "description": "lib/features/playlists/screens/playlists_screen.dart:608" + }, + "setToNow": "Establecer en ahora", + "@setToNow": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1589" + }, + "settings": "Ajustes", + "@settings": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:166" + }, + "shadow": "Sombra", + "@shadow": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:216" + }, + "shadowJazz": "Shadow Jazz", + "@shadowJazz": { + "description": "lib/models/song.dart:340" + }, + "share": "Compartir", + "@share": { + "description": "lib/features/player/widgets/player_action_button_row.dart:676" + }, + "shareFailed": "No se pudo compartir: {e}", + "@shareFailed": { + "description": "lib/features/player/widgets/share/share_bottom_sheet.dart:139", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "sharedSecret": "Secreto compartido", + "@sharedSecret": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:500" + }, + "sharpRecommended": "Nítido (recomendado)", + "@sharpRecommended": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:159" + }, + "shiftMetadataTextUpOrDown": "Mover el texto de metadatos hacia arriba o abajo", + "@shiftMetadataTextUpOrDown": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:149" + }, + "shiftOnlyTheAlbumArtUp": "Mover solo la portada del álbum hacia arriba o abajo", + "@shiftOnlyTheAlbumArtUp": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:289" + }, + "shiftOnlyTheSongDetailsUp": "Mover solo los detalles de la canción hacia arriba o abajo", + "@shiftOnlyTheSongDetailsUp": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:272" + }, + "showASystemOverlayMiniPlayer": "Mostrar un minirreproductor superpuesto sobre otras apps", + "@showASystemOverlayMiniPlayer": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:86" + }, + "showAThinPlaybackProgressLine": "Mostrar una línea delgada con el progreso de reproducción", + "@showAThinPlaybackProgressLine": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:169" + }, + "showAlbum": "Mostrar álbum", + "@showAlbum": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:261" + }, + "showAlbum2": "Mostrar álbum", + "@showAlbum2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:329" + }, + "showAlbumArtwork": "Mostrar la portada del álbum.", + "@showAlbumArtwork": { + "description": "lib/models/song_tile_thumbnail_mode.dart:29" + }, + "showAlbumArtworkOnTheMini": "Mostrar la portada del álbum en el minirreproductor", + "@showAlbumArtworkOnTheMini": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:201" + }, + "showAppleMusicBiographiesRecommendationsAnd": "Mostrar biografías de Apple Music, artistas similares, canciones destacadas, notas de los álbumes y retratos de los artistas.", + "@showAppleMusicBiographiesRecommendationsAnd": { + "description": "lib/features/settings/widgets/apple_music_settings_tile.dart" + }, + "showArtist": "Mostrar artista", + "@showArtist": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:256" + }, + "showArtist2": "Mostrar artista", + "@showArtist2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:192" + }, + "showArtistBelowSongTitle": "Mostrar el artista debajo del título de la canción", + "@showArtistBelowSongTitle": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:216" + }, + "showFileInfo": "Mostrar información del archivo", + "@showFileInfo": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:266" + }, + "showFileInfo2": "Mostrar información del archivo", + "@showFileInfo2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:204" + }, + "showFrame": "Mostrar cuadro", + "@showFrame": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:271" + }, + "showFrame2": "Mostrar cuadro", + "@showFrame2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:354" + }, + "showGlow": "Mostrar brillo", + "@showGlow": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:187" + }, + "showLabels": "Mostrar etiquetas", + "@showLabels": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:306" + }, + "showLess": "Mostrar menos", + "@showLess": { + "description": "lib/features/search/screens/search_screen.dart:671" + }, + "showLyrics": "Mostrar letras", + "@showLyrics": { + "description": "lib/features/player/widgets/player_action_button_row.dart:440" + }, + "showMore": "Mostrar más", + "@showMore": { + "description": "lib/features/songs/screens/songs_screen.dart:3180" + }, + "showMoreArtByFadingOnly": "Mostrar más portada desvaneciendo solo la parte inferior del encabezado y bajando el contenido", + "@showMoreArtByFadingOnly": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:181" + }, + "showOrHideHomeScreenSections": "Mostrar u ocultar secciones de la pantalla de inicio", + "@showOrHideHomeScreenSections": { + "description": "lib/features/settings/screens/settings_screen.dart:199" + }, + "showOrbitPath": "Mostrar la trayectoria orbital", + "@showOrbitPath": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:179" + }, + "showOtherArtistsOnAlbumPages": "Mostrar otros artistas en las páginas de álbumes", + "@showOtherArtistsOnAlbumPages": { + "description": "lib/features/artists/screens/artists_screen.dart:763" + }, + "showPassword": "Mostrar contraseña", + "@showPassword": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:765" + }, + "showPlaylistPreviewsOnTheHome": "Mostrar vistas previas de listas en la pantalla de inicio", + "@showPlaylistPreviewsOnTheHome": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:78" + }, + "showRecentlyPlayedArtistsOnThe": "Mostrar los artistas reproducidos recientemente en la pantalla de inicio", + "@showRecentlyPlayedArtistsOnThe": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:54" + }, + "showRelatedAlbumsOnAlbumPages": "Mostrar álbumes relacionados en las páginas de álbumes", + "@showRelatedAlbumsOnAlbumPages": { + "description": "lib/features/artists/screens/artists_screen.dart:753" + }, + "showSmartMixesGeneratedFromYour": "Mostrar mezclas inteligentes generadas a partir de tus hábitos de escucha", + "@showSmartMixesGeneratedFromYour": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:42" + }, + "showTheArtistBelowTheSong": "Mostrar el artista debajo del título de la canción", + "@showTheArtistBelowTheSong": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:161" + }, + "showTheAtAGlanceSummary": "Mostrar el resumen rápido en Artistas/Álbumes", + "@showTheAtAGlanceSummary": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:150" + }, + "showTheAudioEnginePickerCard": "Mostrar la tarjeta para elegir el motor de audio en la pantalla de inicio", + "@showTheAudioEnginePickerCard": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:102" + }, + "showTheAudioVisualizerOffSaves": "Mostrar el visualizador de audio (desactivarlo ahorra batería)", + "@showTheAudioVisualizerOffSaves": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:29" + }, + "showTheBrowseChipsForLibrary": "Mostrar los accesos rápidos para explorar las secciones de la biblioteca en la pantalla de inicio", + "@showTheBrowseChipsForLibrary": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:90" + }, + "showTheFloatingMiniPlayerPill": "Mostrar la pastilla flotante del minirreproductor en las pantallas", + "@showTheFloatingMiniPlayerPill": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:156" + }, + "showTheGlassFrameAroundAlbum": "Mostrar el marco de vidrio alrededor de la portada del álbum", + "@showTheGlassFrameAroundAlbum": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:355" + }, + "showTheGridOfShortcutCards": "Mostrar la cuadrícula de tarjetas de acceso directo en la pantalla de inicio", + "@showTheGridOfShortcutCards": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:30" + }, + "showTheMiniPlayerAsIts": "Mostrar el minirreproductor como una barra independiente sobre los botones", + "@showTheMiniPlayerAsIts": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:61" + }, + "showTheNumberOverBlurredArt": "Mostrar el número sobre la portada difuminada.", + "@showTheNumberOverBlurredArt": { + "description": "lib/models/song_tile_thumbnail_mode.dart:33" + }, + "showTheTabInTheBottom": "Mostrar la pestaña {arg1} en la barra inferior", + "@showTheTabInTheBottom": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:165", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "showTheTrackNumber": "Mostrar el número de pista.", + "@showTheTrackNumber": { + "description": "lib/models/song_tile_thumbnail_mode.dart:31" + }, + "showTheUsbVolumeBarOn": "Mostrar la barra de volumen USB en la pantalla de inicio", + "@showTheUsbVolumeBarOn": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:114" + }, + "showTheUsbVolumeBarOn2": "Mostrar la barra de volumen USB en la pantalla de ajustes UAC2", + "@showTheUsbVolumeBarOn2": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:126" + }, + "showTitle": "Mostrar título", + "@showTitle": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:251" + }, + "showTitle2": "Mostrar título", + "@showTitle2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:180" + }, + "showVerboseAudioDiagnosticsAndEngine": "Mostrar diagnósticos de audio detallados y registros de seguimiento del motor y la sesión.", + "@showVerboseAudioDiagnosticsAndEngine": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:361" + }, + "showVisualizer": "Mostrar visualizador", + "@showVisualizer": { + "description": "lib/features/player/widgets/player_action_button_row.dart:551" + }, + "showYourRecentListeningHistoryOn": "Mostrar el historial de escucha reciente en la pantalla de inicio", + "@showYourRecentListeningHistoryOn": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:66" + }, + "showingAllAlbums": "Se muestran los {totalCount} álbumes", + "@showingAllAlbums": { + "description": "lib/features/songs/screens/songs_screen.dart:3122", + "placeholders": { + "totalCount": { + "type": "Object" + } + } + }, + "showingOfAlbums": "Se muestran {visibleCount} de {totalCount} álbumes", + "@showingOfAlbums": { + "description": "lib/features/songs/screens/songs_screen.dart:3123", + "placeholders": { + "visibleCount": { + "type": "Object" + }, + "totalCount": { + "type": "Object" + } + } + }, + "showingYourLastLoadedReplay": "Se muestra el último Replay que cargaste.", + "@showingYourLastLoadedReplay": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:386" + }, + "shownWhenThereIsRoomBeside": "Se muestra cuando hay espacio junto a los controles", + "@shownWhenThereIsRoomBeside": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:153" + }, + "shuffle": "Aleatorio", + "@shuffle": { + "description": "lib/widgets/common/detail_header.dart:267" + }, + "shuffle2": "Aleatorio: {arg1}", + "@shuffle2": { + "description": "lib/features/player/widgets/player_controls.dart:113", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "shuffleFavorites": "Mezclar favoritos", + "@shuffleFavorites": { + "description": "lib/features/menu/screens/menu_screen.dart:1325" + }, + "shuffleMode": "Modo aleatorio", + "@shuffleMode": { + "description": "lib/features/player/widgets/shuffle_mode_sheet.dart:18" + }, + "shuffleSongsAndJumpBetweenCategories": "Mezclar canciones y saltar entre categorías", + "@shuffleSongsAndJumpBetweenCategories": { + "description": "lib/models/shuffle_mode.dart:21" + }, + "shuffleSongsInCurrentList": "Mezclar canciones de la lista actual", + "@shuffleSongsInCurrentList": { + "description": "lib/models/shuffle_mode.dart:20" + }, + "signInFailedRetry": "Error al iniciar sesión: volver a intentar", + "@signInFailedRetry": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:355" + }, + "signInWithTidal": "Iniciar sesión con Tidal", + "@signInWithTidal": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:360" + }, + "signInWithYourAccountHifi": "Inicia sesión con tu cuenta · HiFi sin pérdida", + "@signInWithYourAccountHifi": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:98" + }, + "signInWithYourOwnTidal": "Inicia sesión con tu cuenta de Tidal. El audio sin pérdida HiFi (FLAC/ALAC) se reproduce con el motor bit perfecto; Tidal restringe HiRes/MQA y Atmos, que mostrarán un error en lugar de reproducirse.", + "@signInWithYourOwnTidal": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:419" + }, + "signal": "Señal", + "@signal": { + "description": "lib/features/recap/widgets/replay_card_options.dart:10" + }, + "signalAccurateUnverified": "AccurateRip sin verificar", + "@signalAccurateUnverified": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalAccurateVerified": "AccurateRip verificado en el registro", + "@signalAccurateVerified": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalAltSetting": "Ajuste alternativo", + "@signalAltSetting": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalBufferCapacity": "Capacidad del búfer", + "@signalBufferCapacity": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalBufferFill": "Nivel del búfer", + "@signalBufferFill": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalBufferOccupancy": "Ocupación del búfer al abrir", + "@signalBufferOccupancy": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalBufferTarget": "Objetivo del búfer", + "@signalBufferTarget": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalCopyCrc": "CRC de copia", + "@signalCopyCrc": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalCrcCannotCompare": "No se puede comparar", + "@signalCrcCannotCompare": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalCrcComparison": "Comparación de CRC", + "@signalCrcComparison": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalCrcMatch": "Coincide", + "@signalCrcMatch": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalCrcMismatch": "No coincide", + "@signalCrcMismatch": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalDriftFromTarget": "Desfase respecto al objetivo", + "@signalDriftFromTarget": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalDsdBitRate": "Tasa de bits DSD", + "@signalDsdBitRate": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalFileFormat": "Formato del archivo", + "@signalFileFormat": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalFramesPerPacket": "Tramas / paquete", + "@signalFramesPerPacket": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalMaxPacket": "Paquete máximo", + "@signalMaxPacket": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalNoRipDescription": "No se encontró información de extracción ni de verificación para esta pista.", + "@signalNoRipDescription": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalNotReported": "No informado", + "@signalNotReported": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalNotVerified": "No verificado", + "@signalNotVerified": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalOrangeSurfaceFromTheReplay": "Superficie naranja señal de la portada de Replay", + "@signalOrangeSurfaceFromTheReplay": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:692" + }, + "signalRecordingUnavailable": "Historial de extracción no disponible", + "@signalRecordingUnavailable": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalRipDescription": "Información del registro de extracción; no corresponde a una etapa de la ruta de reproducción actual.", + "@signalRipDescription": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalRipProvenance": "Procedencia de la extracción", + "@signalRipProvenance": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalRipper": "Extractor", + "@signalRipper": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalServiceInterval": "Intervalo de servicio", + "@signalServiceInterval": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSnapshot": "Instantánea", + "@signalSnapshot": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSnapshotAtOpen": "Instantánea al abrir", + "@signalSnapshotAtOpen": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSourceDescription": "Propiedades del archivo de origen, no de la salida enviada al dispositivo.", + "@signalSourceDescription": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSourceDetails": "Detalles del formato de origen", + "@signalSourceDetails": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSubslot": "Subranura", + "@signalSubslot": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalSyncType": "Tipo de sincronización", + "@signalSyncType": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalTarget": "objetivo", + "@signalTarget": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalTestCrc": "CRC de prueba", + "@signalTestCrc": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalTransportFormat": "Transporte", + "@signalTransportFormat": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUnderruns": "Subdesbordamientos", + "@signalUnderruns": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUsageType": "Tipo de uso", + "@signalUsageType": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUsbDescription": "Valores de transporte disponibles cuando se abrió este panel. No es un registro en tiempo real de paquetes.", + "@signalUsbDescription": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUsbMissingDescription": "Los detalles URB solo se informan en la ruta USB directa. No se infiere ninguna actividad de transferencia.", + "@signalUsbMissingDescription": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUsbTransport": "Transporte USB", + "@signalUsbTransport": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalUsbUnavailable": "Detalles del transporte USB no disponibles", + "@signalUsbUnavailable": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalVerificationMissing": "Verificación no informada", + "@signalVerificationMissing": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signalVerifiedInLog": "Verificado en el registro", + "@signalVerifiedInLog": { + "description": "lib/features/player/widgets/audio_signal_report.dart" + }, + "signedIn": "Sesión iniciada", + "@signedIn": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:353" + }, + "silkySmoothBZierCurvesFluid": "Curvas de Bézier muy suaves y fluidas, con un movimiento natural", + "@silkySmoothBZierCurvesFluid": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:95" + }, + "similarArtists": "Artistas similares", + "@similarArtists": { + "description": "lib/features/artists/screens/artist_detail_screen.dart:730" + }, + "simple": "Simple", + "@simple": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:901" + }, + "simpleMode": "Modo simple", + "@simpleMode": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:653" + }, + "simplifiedChinese": "Chino simplificado", + "@simplifiedChinese": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:59" + }, + "single": "Sencillo", + "@single": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:575" + }, + "size": "Tamaño", + "@size": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3628" + }, + "sizing": "Ajuste de tamaño", + "@sizing": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:74" + }, + "skip": "Omitir", + "@skip": { + "description": "lib/features/onboarding/screens/onboarding_screen.dart:167" + }, + "skipUnsupportedFilesAndHiddenNomedia": "Omitir archivos no compatibles y directorios .nomedia ocultos", + "@skipUnsupportedFilesAndHiddenNomedia": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1817" + }, + "skippedUnmatchedEntr": " {count, plural, =1{Se omitió {count} entrada sin coincidencia} other{Se omitieron {count} entradas sin coincidencia}}.", + "@skippedUnmatchedEntr": { + "description": "lib/features/playlists/screens/playlists_screen.dart:493", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "sleepTimer": "Temporizador de apagado", + "@sleepTimer": { + "description": "lib/features/albums/screens/album_detail_screen.dart:370" + }, + "sleepTimer2": "Temporizador de apagado", + "@sleepTimer2": { + "description": "lib/features/player/widgets/sleep_timer_bottom_sheet.dart:55" + }, + "sleeves": "Fundas", + "@sleeves": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:567" + }, + "slope": "Pendiente", + "@slope": { + "description": "lib/providers/equalizer_provider.dart:64" + }, + "smbInvalidServerUrl": "Usa smb://servidor/recurso o smb://servidor/recurso/carpeta. Ingresa las credenciales en los campos de usuario y contraseña, no en la URL.", + "smbSigningRequired": "El servidor requiere firma SMB. Usa una cuenta permitida por la política de seguridad del servidor; es posible que no se permita el acceso de invitado.", + "smbCacheWriteFailed": "No se pudo guardar la descarga SMB. Comprueba el espacio libre en el teléfono e inténtalo de nuevo.", + "smbDownloadIncomplete": "La descarga SMB no terminó. Comprueba la conexión e inténtalo de nuevo; no se reproducirá ningún archivo parcial.", + "smbPathNotFound": "No se encontró la carpeta o el archivo SMB. Comprueba la carpeta en la URL del servidor o vuelve a sincronizar la biblioteca.", + "smbDecodeFailed": "Se descargó el archivo SMB, pero no se pudo iniciar la reproducción. Prueba el mismo archivo localmente en Flick y comprueba la salida de audio seleccionada.", + "smbOperationFailed": "Falló la operación SMB. Ejecuta Probar conexión y comprueba la etapa o el código SMB en el registro antes de volver a intentarlo.", + "smbAccessDenied": "Acceso denegado. Comprueba que la cuenta tenga permiso para leer este recurso compartido.", + "@smbAccessDenied": { + "description": "l10n pass: user-visible service error" + }, + "smbAuthFailed": "El servidor rechazó el nombre de usuario o la contraseña. Comprueba la cuenta: Samba podría asignar los usuarios desconocidos como invitados.", + "@smbAuthFailed": { + "description": "l10n pass: user-visible service error" + }, + "smbConnectionRefused": "Se rechazó la conexión. Comprueba que el uso compartido de archivos esté activado y que el puerto 445 esté accesible.", + "@smbConnectionRefused": { + "description": "l10n pass: user-visible service error" + }, + "smbCouldNotReach": "No se pudo acceder al servidor. Comprueba la dirección IP y que el teléfono esté conectado a la misma red.", + "@smbCouldNotReach": { + "description": "l10n pass: user-visible service error" + }, + "smbHostNotResolved": "No se pudo encontrar el nombre del servidor. Prueba con la dirección IP; Android no puede resolver nombres NetBIOS ni .local.", + "@smbHostNotResolved": { + "description": "l10n pass: user-visible service error" + }, + "smbMissingServerAddress": "Falta la dirección del servidor: usa smb://host/recurso (por ejemplo, smb://nas/musica).", + "@smbMissingServerAddress": { + "description": "l10n pass: user-visible service error" + }, + "smbMissingShareName": "Falta el nombre del recurso compartido: usa smb://host/recurso (por ejemplo, smb://nas/musica).", + "@smbMissingShareName": { + "description": "l10n pass: user-visible service error" + }, + "smbServerUnresponsive": "El servidor dejó de responder. Comprueba el servidor e inténtalo de nuevo.", + "@smbServerUnresponsive": { + "description": "l10n pass: user-visible service error" + }, + "smbShareNotFound": "El servidor respondió, pero no se encontró el recurso compartido. Comprueba su nombre en la URL.", + "@smbShareNotFound": { + "description": "l10n pass: user-visible service error" + }, + "smbSharesCanBeAddedNow": "Los recursos SMB2/3 se conectan con el cliente integrado. Ingresa la URL del recurso (smb://host/recurso) e inicia sesión si el servidor lo solicita.", + "@smbSharesCanBeAddedNow": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:405" + }, + "smbTimedOut": "Se agotó el tiempo de espera. Usa la IP del servidor (no un nombre NetBIOS o .local), comprueba el puerto 445 y asegúrate de que el teléfono esté en la misma red.", + "@smbTimedOut": { + "description": "l10n pass: user-visible service error" + }, + "smooth": "Suave", + "@smooth": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:177" + }, + "smoothsPeaksAndRaisesBodyBefore": "Suaviza los picos y realza el cuerpo del sonido antes de que el limitador controle los transitorios.", + "@smoothsPeaksAndRaisesBodyBefore": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3305" + }, + "snappy": "Ágil", + "@snappy": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:185" + }, + "softDetailBalanced": "Detalle suave y equilibrado", + "@softDetailBalanced": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:151" + }, + "softHighlightBehindTheSelectedSong": "Resaltado suave detrás de la canción seleccionada", + "@softHighlightBehindTheSelectedSong": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:188" + }, + "softwareAppControlled": "Software (controlado por la app)", + "@softwareAppControlled": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1155" + }, + "solid": "Sólido", + "@solid": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:187" + }, + "soloDeveloper": "Desarrollador independiente", + "@soloDeveloper": { + "description": "lib/features/settings/screens/support_flick_screen.dart:136" + }, + "someOnlineFeaturesMayNotWork": " · Es posible que algunas funciones en línea no estén disponibles", + "@someOnlineFeaturesMayNotWork": { + "description": "lib/widgets/common/offline_notice.dart:185" + }, + "someWordsAreStillUntimedFinish": "Aún faltan tiempos para algunas palabras. Termina de marcarlas en el modo Sincronizar palabras.", + "@someWordsAreStillUntimedFinish": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1702" + }, + "somethingWentWrong": "Algo salió mal", + "@somethingWentWrong": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:190" + }, + "song2": "{count, plural, =1{{count} canción} other{{count} canciones}}", + "@song2": { + "description": "lib/features/playlists/screens/playlists_screen.dart:592", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "song3": "{count, plural, =1{{count} canción} other{{count} canciones}} · {server}", + "@song3": { + "description": "lib/features/playlists/screens/playlists_screen.dart:593", + "placeholders": { + "count": { + "type": "int" + }, + "server": { + "type": "Object" + } + } + }, + "songActions": "Acciones de la canción", + "@songActions": { + "description": "lib/features/songs/widgets/song_actions_button.dart:29" + }, + "songArtist": "Artista de la canción", + "@songArtist": { + "description": "lib/features/folders/screens/folders_screen.dart:2594" + }, + "songCount": "Cantidad de canciones", + "@songCount": { + "description": "lib/features/artists/screens/artists_screen.dart:876" + }, + "songGestures": "Gestos de canción", + "@songGestures": { + "description": "lib/providers/tutorial_provider.dart:33" + }, + "songHasNoFilePath": "La canción no tiene una ruta de archivo.", + "@songHasNoFilePath": { + "description": "l10n pass: user-visible service error" + }, + "songMetadata": "Metadatos de la canción", + "@songMetadata": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:42" + }, + "songTitle": "Título de la canción", + "@songTitle": { + "description": "lib/features/folders/screens/folders_screen.dart:2592" + }, + "songUnit": "{count, plural, =1{canción} other{canciones}}", + "@songUnit": { + "description": "lib/services/milestone_service.dart:226", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "songViewList": "Vista de canciones: lista", + "@songViewList": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:115" + }, + "songViewOrbital": "Vista de canciones: orbital", + "@songViewOrbital": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:103" + }, + "songs": "{arg1} • {arg2} canciones", + "@songs": { + "description": "lib/features/albums/screens/album_detail_screen.dart:666", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "songs12": "{arg1} canciones", + "@songs12": { + "description": "lib/features/search/screens/search_screen.dart:967", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songs13": "{count} canciones", + "@songs13": { + "description": "lib/features/search/screens/search_screen.dart:1080", + "placeholders": { + "count": { + "type": "Object" + } + } + }, + "songs14": "Canciones", + "@songs14": { + "description": "lib/features/manual/data/manual_data.dart:29" + }, + "songs15": "{arg1} canciones", + "@songs15": { + "description": "lib/features/folders/screens/folders_screen.dart:776", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songs2": "{songCount} canciones", + "@songs2": { + "description": "lib/features/albums/screens/album_detail_screen.dart:889", + "placeholders": { + "songCount": { + "type": "Object" + } + } + }, + "songs3": "{arg1} canciones", + "@songs3": { + "description": "lib/features/artists/screens/artist_detail_screen.dart:1058", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songs4": "{_totalSongs} canciones", + "@songs4": { + "description": "lib/features/artists/screens/artists_screen.dart:396", + "placeholders": { + "_totalSongs": { + "type": "Object" + } + } + }, + "songs5": "{arg1} canciones", + "@songs5": { + "description": "lib/features/folders/screens/folders_screen.dart:1617", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songs9": "{arg1} canciones", + "@songs9": { + "description": "lib/features/player/widgets/add_to_playlist_sheet.dart:124", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songsAlbums": "{arg1} canciones • {uniqueAlbums} álbumes", + "@songsAlbums": { + "description": "lib/features/albums/screens/album_detail_screen.dart:1010", + "placeholders": { + "arg1": { + "type": "Object" + }, + "uniqueAlbums": { + "type": "Object" + } + } + }, + "songsAlbums2": "{arg1} canciones · {albumCount} álbumes", + "@songsAlbums2": { + "description": "lib/features/search/screens/search_screen.dart:850", + "placeholders": { + "arg1": { + "type": "Object" + }, + "albumCount": { + "type": "Object" + } + } + }, + "songsBeforeTheTappedTrackQueue": "Las canciones anteriores a la pista seleccionada se agregan al final de la cola", + "@songsBeforeTheTappedTrackQueue": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:50" + }, + "songsCategories": "Canciones y categorías", + "@songsCategories": { + "description": "lib/models/shuffle_mode.dart:13" + }, + "songsCount": "{count, plural, =1{{count} canción} other{{count} canciones}}", + "@songsCount": { + "description": "lib/features/recap/widgets/replay_poster.dart:280", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "songsFound": "Se encontraron {arg1} canciones", + "@songsFound": { + "description": "lib/features/settings/screens/network_sources_screen.dart:406", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "songsIn": "{songs, plural, =1{{songs} canción} other{{songs} canciones}} en {folders, plural, =1{{folders} carpeta} other{{folders} carpetas}}", + "@songsIn": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1600", + "placeholders": { + "songs": { + "type": "int" + }, + "folders": { + "type": "int" + } + } + }, + "songsInRotation": "{count, plural, =1{{count} canción en tu rotación} other{{count} canciones en tu rotación}}", + "@songsInRotation": { + "description": "lib/features/recap/widgets/replay_sections.dart:466", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "songsU2022Albums": "{arg1} canciones • {uniqueAlbums} álbumes", + "@songsU2022Albums": { + "description": "lib/features/artists/screens/artists_screen.dart:675", + "placeholders": { + "arg1": { + "type": "Object" + }, + "uniqueAlbums": { + "type": "Object" + } + } + }, + "songsYouPlayWillAppearHere": "Las canciones que reproduzcas aparecerán aquí", + "@songsYouPlayWillAppearHere": { + "description": "lib/features/recently_played/screens/recently_played_screen.dart:354" + }, + "songsYouScanIntoYourLibrary": "Las canciones que analices para agregarlas a tu biblioteca aparecerán aquí", + "@songsYouScanIntoYourLibrary": { + "description": "lib/features/recently_added/screens/recently_added_screen.dart:326" + }, + "sortBy": "ORDENAR POR", + "@sortBy": { + "description": "lib/features/songs/screens/songs_screen.dart:2878" + }, + "sortFilter": "Ordenar y filtrar", + "@sortFilter": { + "description": "lib/providers/tutorial_provider.dart:27" + }, + "sortSongs": "Ordenar canciones", + "@sortSongs": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:399" + }, + "source": "Origen", + "@source": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:718" + }, + "sourceRate": "Frecuencia de origen", + "@sourceRate": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:568" + }, + "spaceBetweenTheTwoBars": "Espacio entre las dos barras", + "@spaceBetweenTheTwoBars": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:102" + }, + "spaceOdyssey": "Odisea espacial", + "@spaceOdyssey": { + "description": "lib/models/song.dart:326" + }, + "spanishDraftDescription": "Español latinoamericano. Traducción preliminar pendiente de revisión por hablantes nativos.", + "@spanishDraftDescription": { + "description": "Language selector notice that the Latin American Spanish translation is a draft awaiting native-speaker review." + }, + "spatialTime": "Espacial y tiempo", + "@spatialTime": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3548" + }, + "speedUp": "Acelerar", + "@speedUp": { + "description": "lib/app/app.dart:508" + }, + "springPhysicsEnergeticAndReactive": "Física de resorte: dinámica y reactiva", + "@springPhysicsEnergeticAndReactive": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:170" + }, + "squareRoot": "Raíz cuadrada", + "@squareRoot": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:247" + }, + "stampNext": "Marcar y siguiente", + "@stampNext": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1202" + }, + "stampNow": "Marcar ahora", + "@stampNow": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1202" + }, + "stampThisLineFirstToEdit": "Primero marca el tiempo de esta línea para editar su línea de tiempo de palabras.", + "@stampThisLineFirstToEdit": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1695" + }, + "standard": "Estándar", + "@standard": { + "description": "lib/features/menu/screens/menu_screen.dart:482" + }, + "standard60hz": "Estándar (60 Hz)", + "@standard60hz": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:223" + }, + "standardBluetoothRoutingViaAndroid": "Enrutamiento Bluetooth estándar mediante Android", + "@standardBluetoothRoutingViaAndroid": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:420" + }, + "standardEngine": "Motor estándar", + "@standardEngine": { + "description": "lib/features/menu/screens/menu_screen.dart:386" + }, + "starlightSerenade": "Serenata de luz estelar", + "@starlightSerenade": { + "description": "lib/models/song.dart:321" + }, + "start": "Iniciar", + "@start": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1816" + }, + "startAtNow": "Empezar ahora", + "@startAtNow": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1871" + }, + "startBuildingYourHome": "Empieza a crear tu pantalla de inicio", + "@startBuildingYourHome": { + "description": "lib/features/menu/screens/menu_screen.dart:1311" + }, + "startPlayingToPopulateThisSpace": "Empieza a reproducir música para llenar este espacio", + "@startPlayingToPopulateThisSpace": { + "description": "lib/features/menu/screens/menu_screen.dart:2339" + }, + "startStreaming": "Iniciar transmisión", + "@startStreaming": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:207" + }, + "startedPresetDownload": "Se inició la descarga del preajuste.", + "@startedPresetDownload": { + "description": "lib/features/settings/screens/equalizer_screen.dart:634" + }, + "state": "Estado", + "@state": { + "description": "lib/widgets/uac2/uac2_connection_manager.dart:152" + }, + "status": "Estado", + "@status": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:87" + }, + "stepByStepWalkthroughOfThe": "Recorrido guiado paso a paso por la app", + "@stepByStepWalkthroughOfThe": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:694" + }, + "stereo": "Estéreo", + "@stereo": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:621" + }, + "stop": "Detener", + "@stop": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1399" + }, + "stopAtTheEndOfThe": "Detener al final de la lista actual", + "@stopAtTheEndOfThe": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:51" + }, + "stopCasting": "Detener transmisión", + "@stopCasting": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:112" + }, + "stopStreaming": "Detener transmisión", + "@stopStreaming": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:207" + }, + "stopUsbOnQuit": "Detener USB al salir", + "@stopUsbOnQuit": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:539" + }, + "stopWhenTheQueueEnds": "Detener al terminar la cola", + "@stopWhenTheQueueEnds": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:76" + }, + "stoppingIn": "Se detendrá en {arg1}", + "@stoppingIn": { + "description": "lib/features/player/widgets/sleep_timer_bottom_sheet.dart:113", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "storage": "Almacenamiento", + "@storage": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2157" + }, + "storageAccessIsRequiredToScan": "Se necesita acceso al almacenamiento para analizar y leer archivos de música, extraer metadatos, importar o exportar preajustes del ecualizador y guardar imágenes del resumen. Todo el procesamiento se realiza en el dispositivo.", + "@storageAccessIsRequiredToScan": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:51" + }, + "storagePermissionIsRequiredToAdd": "Se necesita permiso de almacenamiento para agregar carpetas de música", + "@storagePermissionIsRequiredToAdd": { + "description": "lib/features/settings/screens/library_settings_screen.dart:461" + }, + "storagePermissionRequiredForRecap": "Se necesita permiso de almacenamiento para guardar imágenes del resumen en esta versión de Android.", + "@storagePermissionRequiredForRecap": { + "description": "l10n pass: user-visible service error" + }, + "storagePermissions": "Permisos de almacenamiento", + "@storagePermissions": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:49" + }, + "storeOn": "Guardar en", + "@storeOn": { + "description": "lib/features/playlists/screens/playlists_screen.dart:372" + }, + "storedAsASaltedHashNever": "Se guarda como un hash con sal, nunca como texto sin cifrar", + "@storedAsASaltedHashNever": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:61" + }, + "storedEncodedPlaybackUnavailableInThis": "Se guarda codificado en Base64; es necesario para iniciar sesión con NTLM", + "@storedEncodedPlaybackUnavailableInThis": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:93" + }, + "stormChasers": "Cazatormentas", + "@stormChasers": { + "description": "lib/models/song.dart:376" + }, + "strategy": "Estrategia", + "@strategy": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:633" + }, + "stream": "Flujo", + "@stream": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1035" + }, + "streamConfigurationNotAvailable": "Configuración del flujo no disponible", + "@streamConfigurationNotAvailable": { + "description": "lib/widgets/uac2/uac2_stream_config.dart:57" + }, + "streamStable": "Flujo estable", + "@streamStable": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:694" + }, + "streaming": "Transmitiendo", + "@streaming": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:907" + }, + "streamingFromQueue": "Transmitiendo desde la cola", + "@streamingFromQueue": { + "description": "lib/features/menu/screens/menu_screen.dart:1359" + }, + "stretchNonSquareArt": "Estirar portadas no cuadradas", + "@stretchNonSquareArt": { + "description": "lib/features/settings/screens/library_settings_screen.dart:2195" + }, + "strong": "Fuerte", + "@strong": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:221" + }, + "studioGradeOutputForExternalDacs": "Salida de calidad de estudio para DAC externos y amplificadores de audífonos. Omite el procesamiento de audio de Android para ofrecer un sonido puro.", + "@studioGradeOutputForExternalDacs": { + "description": "lib/features/menu/screens/menu_screen.dart:514" + }, + "sub": "Subgraves", + "@sub": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1887" + }, + "subfolderCount": "{count, plural, =1{{count} subcarpeta} other{{count} subcarpetas}}", + "@subfolderCount": { + "description": "lib/features/folders/screens/folders_screen.dart:2033", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "subsonic": "Subsonic", + "@subsonic": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:57" + }, + "subsonicServersSyncAndStreaming": "Servidores Subsonic, sincronización y transmisión", + "@subsonicServersSyncAndStreaming": { + "description": "lib/features/settings/screens/settings_screen.dart:94" + }, + "subtle": "Sutil", + "@subtle": { + "description": "lib/models/album_color_mode.dart:22" + }, + "support": "Ayuda", + "@support": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:703" + }, + "supportDevelopmentOnBuyMeACoffee": "Apoya el desarrollo en Buy Me a Coffee", + "@supportDevelopmentOnBuyMeACoffee": { + "description": "Buy Me a Coffee donation option subtitle on the Support Flick screen." + }, + "supportDevelopmentOnKoFi": "Apoya el desarrollo en Ko-fi", + "@supportDevelopmentOnKoFi": { + "description": "lib/features/settings/screens/support_flick_screen.dart:213" + }, + "supportFlick": "Apoyar Flick", + "@supportFlick": { + "description": "lib/features/menu/screens/menu_screen.dart:367" + }, + "supportFlickOnKoFi": "Apoya Flick en Ko-fi", + "@supportFlickOnKoFi": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:775" + }, + "surfaceShading": "Sombreado de superficie", + "@surfaceShading": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:674" + }, + "sweepAHighlightThroughWordsAs": "Resalta las palabras al ritmo de la voz", + "@sweepAHighlightThroughWordsAs": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:45" + }, + "swipe": "Deslizar", + "@swipe": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:294" + }, + "swipeActions": "Acciones al deslizar", + "@swipeActions": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:125" + }, + "swipeHorizontallyToFineTuneEach": "Desliza horizontalmente para ajustar con precisión cada banda central.", + "@swipeHorizontallyToFineTuneEach": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1823" + }, + "swipeLeftRightToSkipTracks": "Desliza a la izquierda o a la derecha para cambiar de pista", + "@swipeLeftRightToSkipTracks": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:49" + }, + "swipeLeftToUnfavoriteASong": "Desliza a la izquierda para quitar una canción de favoritos", + "@swipeLeftToUnfavoriteASong": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:295" + }, + "swipeSongsLeftToQueueOr": "Desliza canciones a la izquierda para agregarlas a la cola o a la derecha para marcarlas como favoritas", + "@swipeSongsLeftToQueueOr": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:126" + }, + "swipeToShowOrHideThe": "Desliza para mostrar u ocultar el visualizador", + "@swipeToShowOrHideThe": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:37" + }, + "switchSongs": "Cambiar canciones", + "@switchSongs": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:48" + }, + "switchToTheExclusiveUsbPath": "Cambiar automáticamente a la ruta USB exclusiva cuando se conecte un DAC. Se recuerdan los DAC rechazados.", + "@switchToTheExclusiveUsbPath": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:493" + }, + "switchedBackToTheAutomaticLyrics": "Se volvió a la fuente automática de letras.", + "@switchedBackToTheAutomaticLyrics": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:151" + }, + "syllablesTapALetterToSplit": "Sílabas: toca una letra para separar o unir:\n", + "@syllablesTapALetterToSplit": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1908" + }, + "symmetricalBarsMirroredFromTheCenter": "Barras simétricas reflejadas desde el centro", + "@symmetricalBarsMirroredFromTheCenter": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:104" + }, + "sync": "Sincronizar", + "@sync": { + "description": "lib/app/app.dart:491" + }, + "syncFailed": "Error al sincronizar: {e}", + "@syncFailed": { + "description": "lib/features/settings/screens/network_sources_screen.dart:112", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "syncNow": "Sincronizar ahora", + "@syncNow": { + "description": "lib/features/settings/screens/network_sources_screen.dart:285" + }, + "syncServerPlaylists": "Sincronizar listas del servidor", + "@syncServerPlaylists": { + "description": "lib/features/playlists/screens/playlists_screen.dart:144" + }, + "synced": "Sincronizado", + "@synced": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:568" + }, + "synced2": "Sincronizado: {arg1}", + "@synced2": { + "description": "lib/features/settings/screens/network_sources_screen.dart:318", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "syncedLrc": "LRC sincronizado", + "@syncedLrc": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:377" + }, + "syncedPlaylistFromServers": "{count, plural, =1{Se sincronizó {count} lista de reproducción} other{Se sincronizaron {count} listas de reproducción}} desde los servidores", + "@syncedPlaylistFromServers": { + "description": "lib/features/playlists/screens/playlists_screen.dart:473", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "syncing": "Sincronizando…", + "@syncing": { + "description": "lib/features/settings/screens/network_sources_screen.dart:365" + }, + "synthwaveCity": "Ciudad synthwave", + "@synthwaveCity": { + "description": "lib/models/song.dart:308" + }, + "system": "Sistema", + "@system": { + "description": "lib/features/settings/screens/casting_settings_screen.dart:243" + }, + "systemAndroidMixer": "Sistema (mezclador de Android)", + "@systemAndroidMixer": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1151" + }, + "tagsWereWrittenButCouldNot": "Se escribieron las etiquetas, pero no se pudieron confirmar al volver a leer el archivo. Al volver a analizar la biblioteca se corregirán las diferencias.", + "@tagsWereWrittenButCouldNot": { + "description": "lib/services/metadata_editor_service.dart:131" + }, + "tap": "Tocar: «{label}»", + "@tap": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1393", + "placeholders": { + "label": { + "type": "Object" + } + } + }, + "tapABandToExpandDrag": "Toca una banda para ampliarla. Arrastra una perilla para ajustarla. Toca un valor para ingresarlo directamente.", + "@tapABandToExpandDrag": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2242" + }, + "tapAllOrEnableAChip": "Toca Todo o activa un filtro para ver resultados", + "@tapAllOrEnableAChip": { + "description": "lib/features/search/screens/search_screen.dart:324" + }, + "tapChipsToFilterCategories": "Toca los filtros para elegir categorías", + "@tapChipsToFilterCategories": { + "description": "lib/features/search/screens/search_screen.dart:258" + }, + "tapEditTextTopRight": "1. Toca Editar texto (arriba a la derecha) y pega las letras, una línea por renglón.\n2. Reproduce la canción.\n3. Elige la línea actual en la lista Líneas.\n4. Toca Marcar y siguiente cuando escuches esa línea.\n5. Cuando termines, guarda los cambios.", + "@tapEditTextTopRight": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:661" + }, + "tapTheHeartIconOnAny": "Toca el ícono del corazón en cualquier canción\npara agregarla a favoritos", + "@tapTheHeartIconOnAny": { + "description": "lib/features/favorites/screens/favorites_screen.dart:361" + }, + "tapToInspect12602280Png": "Toca para inspeccionar · PNG de 1260 × 2280", + "@tapToInspect12602280Png": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:450" + }, + "tapToPreview": "Toca para obtener una vista previa", + "@tapToPreview": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:955" + }, + "targetMs": "objetivo {arg1} ms", + "@targetMs": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1028", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tempo": "Tempo", + "@tempo": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3576" + }, + "tempoX": "Tempo {arg1}x", + "@tempoX": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3519", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "test": "Prueba: {arg1}", + "@test": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1096", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "testConnection": "Probar conexión", + "@testConnection": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:360" + }, + "textGestures": "Texto y gestos", + "@textGestures": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:229" + }, + "textPlacement": "Ubicación del texto", + "@textPlacement": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:293" + }, + "textPlacement2": "Ubicación del texto", + "@textPlacement2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:148" + }, + "textSize": "Tamaño del texto", + "@textSize": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:218" + }, + "textSize2": "Tamaño del texto", + "@textSize2": { + "description": "lib/features/settings/screens/player_layout_settings_screen.dart:132" + }, + "theAppDoesNotKnowinglyCollect": "La app no recopila deliberadamente información de nadie, sin importar su edad.", + "@theAppDoesNotKnowinglyCollect": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:81" + }, + "theAppQueriesPublicApisMusicbrainz": "La app consulta API públicas (MusicBrainz/Cover Art Archive, iTunes y Deezer) para encontrar portadas de álbumes coincidentes. Las búsquedas usan metadatos locales de música. Las imágenes descargadas se guardan en caché local.", + "@theAppQueriesPublicApisMusicbrainz": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:66" + }, + "theAudioEngineDeterminesHowYour": "El motor de audio determina cómo se reproduce la música. Cada opción equilibra de forma distinta la confiabilidad, la calidad y la compatibilidad.", + "@theAudioEngineDeterminesHowYour": { + "description": "lib/features/menu/screens/menu_screen.dart:473" + }, + "theIsochronousUsbEngineWillBe": "El motor USB isócrono se detendrá al cerrar la app.", + "@theIsochronousUsbEngineWillBe": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:541" + }, + "theIsochronousUsbEngineWillStay": "El motor USB isócrono seguirá activo al cerrar la app.", + "@theIsochronousUsbEngineWillStay": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:542" + }, + "theNamesShowingUpAgainAnd": "Los nombres que aparecen una y otra vez en tu cola reciente.", + "@theNamesShowingUpAgainAnd": { + "description": "lib/features/menu/screens/menu_screen.dart:889" + }, + "thePosterIsNotReadyYet": "El póster aún no está listo. Intenta guardarlo de nuevo.", + "@thePosterIsNotReadyYet": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:222" + }, + "theTracksDominatingYourWeeklyAnd": "Las canciones que más sonaron en tu resumen semanal y mensual.", + "@theTracksDominatingYourWeeklyAnd": { + "description": "lib/features/menu/screens/menu_screen.dart:1750" + }, + "thisAppIsBuiltByA": "Esta app la desarrolla una sola persona y no tiene presupuesto. Si te gusta el audio de alta fidelidad, considera apoyar su desarrollo en Ko-fi.", + "@thisAppIsBuiltByA": { + "description": "lib/features/menu/screens/menu_screen.dart:313" + }, + "thisClearsYourCurrentDayStreak": "Esto borrará tu racha actual y los hitos de racha que hayas desbloqueado. Esta acción no se puede deshacer.", + "@thisClearsYourCurrentDayStreak": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:22" + }, + "thisDevice": "Este dispositivo", + "@thisDevice": { + "description": "lib/features/playlists/screens/playlists_screen.dart:383" + }, + "thisFolderAppearsToBeEmpty": "Esta carpeta parece estar vacía", + "@thisFolderAppearsToBeEmpty": { + "description": "lib/features/folders/screens/folders_screen.dart:1370" + }, + "thisFolderHasAlreadyBeenAdded": "Esta carpeta ya se agregó", + "@thisFolderHasAlreadyBeenAdded": { + "description": "l10n pass: user-visible service error" + }, + "thisMonth": "Este mes", + "@thisMonth": { + "description": "lib/data/repositories/recently_played_repository.dart:294" + }, + "thisMonthSRecap": "Resumen de este mes", + "@thisMonthSRecap": { + "description": "lib/data/repositories/recently_played_repository.dart:25" + }, + "thisRemovesAllEntriesFromMemory": "Esto quita de la memoria todas las entradas de {arg1}.", + "@thisRemovesAllEntriesFromMemory": { + "description": "lib/features/settings/screens/logs_screen.dart:232", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "thisSlowsPlaybackTo432440": "Esto baja la reproducción a 432/440 (aprox. 1,8 % menos de tono y tempo) y desactiva el paso directo bit perfecto. La música sonará un poco más grave. Activa esta opción solo si quieres intencionalmente afinar a A=432.", + "@thisSlowsPlaybackTo432440": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1586" + }, + "thisSongHasNoFilePath": "Esta canción no tiene una ruta de archivo y no se puede editar.", + "@thisSongHasNoFilePath": { + "description": "lib/services/metadata_editor_service.dart:61" + }, + "thisSongIsMissingAlbumMetadata": "A esta canción le faltan los metadatos del álbum, por lo que la búsqueda en línea es limitada.", + "@thisSongIsMissingAlbumMetadata": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:491" + }, + "thisSongOnly": "Solo esta canción", + "@thisSongOnly": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:412" + }, + "thisWeek": "Esta semana", + "@thisWeek": { + "description": "lib/data/repositories/recently_played_repository.dart:288" + }, + "thisWeekSRecap": "Resumen de esta semana", + "@thisWeekSRecap": { + "description": "lib/data/repositories/recently_played_repository.dart:24" + }, + "thisYearSRecap": "Resumen de este año", + "@thisYearSRecap": { + "description": "lib/data/repositories/recently_played_repository.dart:26" + }, + "threshold": "Umbral", + "@threshold": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3318" + }, + "thunderRoad": "Thunder Road", + "@thunderRoad": { + "description": "lib/models/song.dart:375" + }, + "tidal": "Tidal", + "@tidal": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:97" + }, + "tidalAppKeyRejected": "Tidal rechazó la clave de inicio de sesión de la app. Estas claves cambian, así que la integrada podría estar desactualizada (una limitación conocida de la integración no oficial).", + "@tidalAppKeyRejected": { + "description": "l10n pass: user-visible service error" + }, + "tidalCouldNotReach": "No se pudo acceder a Tidal (HTTP {status}). Comprueba tu conexión.", + "@tidalCouldNotReach": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "status": { + "type": "int" + } + } + }, + "tidalEncryptedTrack": "La pista {trackId} está cifrada (HiRes/MQA). Solo se admite audio HiFi sin pérdida que no esté cifrado.", + "@tidalEncryptedTrack": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "trackId": { + "type": "String" + } + } + }, + "tidalManifestDecodeFailed": "No se pudo decodificar el manifiesto de Tidal para la pista {trackId}: {error}", + "@tidalManifestDecodeFailed": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "trackId": { + "type": "String" + }, + "error": { + "type": "String" + } + } + }, + "tidalManifestNoStream": "La pista {trackId} no tiene una URL de transmisión en su manifiesto.", + "@tidalManifestNoStream": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "trackId": { + "type": "String" + } + } + }, + "tidalNoPlayableStream": "No hay una transmisión reproducible para esta pista.", + "@tidalNoPlayableStream": { + "description": "l10n pass: user-visible service error" + }, + "tidalNoSignInCode": "Tidal no devolvió un código de inicio de sesión.", + "@tidalNoSignInCode": { + "description": "l10n pass: user-visible service error" + }, + "tidalNotSignedIn": "No iniciaste sesión en Tidal. Toca Iniciar sesión con Tidal.", + "@tidalNotSignedIn": { + "description": "l10n pass: user-visible service error" + }, + "tidalOpenLinkManually": "No se pudo abrir el navegador automáticamente. Abre este enlace en cualquier dispositivo para terminar de iniciar sesión y luego toca Iniciar sesión otra vez:\n\n{uri}", + "@tidalOpenLinkManually": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "uri": { + "type": "String" + } + } + }, + "tidalSessionExpired": "La sesión de Tidal venció. Vuelve a iniciar sesión.", + "@tidalSessionExpired": { + "description": "l10n pass: user-visible service error" + }, + "tidalSignInDenied": "Se rechazó el inicio de sesión en Tidal.", + "@tidalSignInDenied": { + "description": "l10n pass: user-visible service error" + }, + "tidalSignInExpired": "El código de inicio de sesión de Tidal venció. Inténtalo de nuevo.", + "@tidalSignInExpired": { + "description": "l10n pass: user-visible service error" + }, + "tidalSignInRefused": "Tidal rechazó el inicio de sesión. Inténtalo de nuevo.", + "@tidalSignInRefused": { + "description": "l10n pass: user-visible service error" + }, + "tidalSignInTimedOut": "Se agotó el tiempo de espera para iniciar sesión en Tidal.", + "@tidalSignInTimedOut": { + "description": "l10n pass: user-visible service error" + }, + "tidalTokenRefreshFailed": "No se pudo actualizar el token de Tidal.", + "@tidalTokenRefreshFailed": { + "description": "l10n pass: user-visible service error" + }, + "tidalTooManyRequests": "Demasiadas solicitudes a Tidal. Espera un momento e inténtalo de nuevo.", + "@tidalTooManyRequests": { + "description": "l10n pass: user-visible service error" + }, + "tidalUnavailable": "Tidal no está disponible ahora. Inténtalo de nuevo en un momento.", + "@tidalUnavailable": { + "description": "l10n pass: user-visible service error" + }, + "tidalUnsupportedFormat": "La pista {trackId} usa un formato de Tidal no compatible (HiRes/MQA/Atmos). Solo se admite audio HiFi sin pérdida que no esté cifrado.", + "@tidalUnsupportedFormat": { + "description": "l10n pass: user-visible service error", + "placeholders": { + "trackId": { + "type": "String" + } + } + }, + "time": "Hora", + "@time": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1030" + }, + "timeShift": "Desplazamiento de tiempo", + "@timeShift": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1979" + }, + "timestamp": "Marca de tiempo", + "@timestamp": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1315" + }, + "tintedFromTodaySTopCover": "Con tinte de la portada más destacada de hoy", + "@tintedFromTodaySTopCover": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:701" + }, + "tips": "Consejos", + "@tips": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:704" + }, + "title": "Título", + "@title": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:53" + }, + "toRemove": "Por quitar", + "@toRemove": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:636" + }, + "today": "Hoy", + "@today": { + "description": "lib/data/repositories/recently_played_repository.dart:283" + }, + "todaySRecap": "Resumen de hoy", + "@todaySRecap": { + "description": "lib/data/repositories/recently_played_repository.dart:23" + }, + "toneControls": "Controles de tono", + "@toneControls": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1632" + }, + "tools": "Herramientas", + "@tools": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:870" + }, + "top": "Arriba", + "@top": { + "description": "lib/features/recap/screens/replay_studio_screen.dart:626" + }, + "topAlbum": "Álbum destacado", + "@topAlbum": { + "description": "lib/features/recap/widgets/replay_sections.dart:507" + }, + "topArtist": "Artista destacado", + "@topArtist": { + "description": "lib/features/recap/widgets/replay_sections.dart:438" + }, + "topArtists": "Artistas destacados", + "@topArtists": { + "description": "lib/features/recap/widgets/replay_poster.dart:17" + }, + "topSongs": "Canciones destacadas", + "@topSongs": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:456" + }, + "topSongs2": "Canciones destacadas", + "@topSongs2": { + "description": "lib/features/recap/widgets/replay_poster.dart:16" + }, + "total": "Total", + "@total": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1333" + }, + "track": "Pista", + "@track": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:197" + }, + "track2": "Pista {arg1}", + "@track2": { + "description": "lib/features/player/widgets/share/share_cards/album_art_share_card.dart:45", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "track3": "N.º de pista", + "@track3": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:284" + }, + "trackBitDepth": "Profundidad de bits de la pista", + "@trackBitDepth": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:648" + }, + "trackChannels": "Canales de la pista", + "@trackChannels": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:655" + }, + "trackConsecutiveListeningDaysAndShow": "Registrar los días consecutivos de escucha y mostrar la ventana emergente", + "@trackConsecutiveListeningDaysAndShow": { + "description": "lib/features/settings/screens/interface_settings_screen.dart:162" + }, + "trackCount": "Cantidad de pistas", + "@trackCount": { + "description": "lib/features/albums/screens/albums_screen.dart:920" + }, + "trackDsdRate": "Frecuencia DSD de la pista", + "@trackDsdRate": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:641" + }, + "trackNumber": "Número de pista", + "@trackNumber": { + "description": "lib/models/song_tile_thumbnail_mode.dart:20" + }, + "trackSampleRate": "Frecuencia de muestreo de la pista", + "@trackSampleRate": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:641" + }, + "trackThumbnails": "Miniaturas de pistas", + "@trackThumbnails": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:204" + }, + "trackTime": "Duración de la pista", + "@trackTime": { + "description": "lib/features/recap/widgets/replay_card_options.dart:20" + }, + "trackTimeSumsTheFullDuration": "La duración de la pista suma el tiempo total de todas las reproducciones registradas.", + "@trackTimeSumsTheFullDuration": { + "description": "lib/features/recap/widgets/replay_sections.dart:146" + }, + "tracks": "{_totalTracks} pistas", + "@tracks": { + "description": "lib/features/albums/screens/albums_screen.dart:366", + "placeholders": { + "_totalTracks": { + "type": "Object" + } + } + }, + "tracks2": "{arg1} pistas", + "@tracks2": { + "description": "lib/features/albums/screens/albums_screen.dart:704", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tracks3": "{arg1} pistas", + "@tracks3": { + "description": "lib/features/folders/screens/folders_screen.dart:739", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tracks4": "{arg1} pistas", + "@tracks4": { + "description": "lib/features/folders/screens/folders_screen.dart:1581", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tracks5": "{arg1} · {arg2} pistas", + "@tracks5": { + "description": "lib/features/search/screens/search_screen.dart:915", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "tracks6": "{arg1} pistas", + "@tracks6": { + "description": "lib/features/songs/screens/songs_screen.dart:2608", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tracks7": "{trackCount} pistas • {arg1}", + "@tracks7": { + "description": "lib/features/songs/screens/songs_screen.dart:2784", + "placeholders": { + "trackCount": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "tracks8": "{arg1} pistas", + "@tracks8": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:458", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "tracksLikedSongsPlaylists": "{songCount} pistas, {favoriteCount} canciones que te gustan, {playlistCount} listas de reproducción", + "@tracksLikedSongsPlaylists": { + "description": "lib/features/menu/screens/menu_screen.dart:1156", + "placeholders": { + "songCount": { + "type": "Object" + }, + "favoriteCount": { + "type": "Object" + }, + "playlistCount": { + "type": "Object" + } + } + }, + "tracksReadyToRevisit": "{favoritesCount} pistas para volver a escuchar", + "@tracksReadyToRevisit": { + "description": "lib/features/menu/screens/menu_screen.dart:1411", + "placeholders": { + "favoritesCount": { + "type": "Object" + } + } + }, + "tracksThatFitTheQuieterSide": "Canciones que van con el lado más tranquilo de lo que escuchas.", + "@tracksThatFitTheQuieterSide": { + "description": "lib/features/menu/screens/menu_screen.dart:1785" + }, + "transparent": "Transparente", + "@transparent": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:159" + }, + "treble": "Agudos", + "@treble": { + "description": "lib/features/settings/screens/equalizer_screen.dart:1695" + }, + "trueRandomMayRepeatBeforeList": "Aleatorio real (puede repetir antes de terminar la lista)", + "@trueRandomMayRepeatBeforeList": { + "description": "lib/models/shuffle_mode.dart:23" + }, + "truncate": "Recortar", + "@truncate": { + "description": "lib/features/settings/widgets/mini_player_customization.dart:247" + }, + "tryAdjustingYourSearchQuery": "Prueba a modificar la búsqueda", + "@tryAdjustingYourSearchQuery": { + "description": "lib/features/songs/screens/songs_screen.dart:1855" + }, + "tryAgain": "Inténtalo de nuevo", + "@tryAgain": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:213" + }, + "tryAnotherKeywordOrEnableMore": "Prueba con otra palabra clave o activa más categorías", + "@tryAnotherKeywordOrEnableMore": { + "description": "lib/features/search/screens/search_screen.dart:291" + }, + "tryOriginalSearch": "Probar la búsqueda original", + "@tryOriginalSearch": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:782" + }, + "tryPickingALocalImageIf": "Prueba a elegir una imagen local si los metadatos del lanzamiento son poco comunes.", + "@tryPickingALocalImageIf": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:492" + }, + "turnOff432HzTuningTo": "Desactiva la afinación a 432 Hz para usar el fundido cruzado", + "@turnOff432HzTuningTo": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:307" + }, + "turnOff432HzTuningTo2": "Desactiva la afinación a 432 Hz para usar la mezcla entre canales", + "@turnOff432HzTuningTo2": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:421" + }, + "typeABrandAndModelTo": "Escribe la marca y el modelo para buscar en línea.", + "@typeABrandAndModelTo": { + "description": "lib/features/settings/screens/widgets/autoeq_search_sheet.dart:94" + }, + "u162ByteSubslotsLlRr": "U16: subranuras de 2 bytes, LL|RR", + "@u162ByteSubslotsLlRr": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1735" + }, + "u2022": "{arg1} • {valueLabel}", + "@u2022": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2415", + "placeholders": { + "arg1": { + "type": "Object" + }, + "valueLabel": { + "type": "Object" + } + } + }, + "u20223": "{arg1} • {gainLabel}", + "@u20223": { + "description": "lib/features/settings/screens/equalizer_screen.dart:2380", + "placeholders": { + "arg1": { + "type": "Object" + }, + "gainLabel": { + "type": "Object" + } + } + }, + "u2022Bit": " • {arg1} bits", + "@u2022Bit": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:524", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "u324ByteSubslotsLlllRrrr": "U32: subranuras de 4 bytes, LLLL|RRRR (heredado)", + "@u324ByteSubslotsLlllRrrr": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1733" + }, + "u8ByteInterleavedLrlr": "U8: intercalado por bytes LRLR", + "@u8ByteInterleavedLrlr": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1737" + }, + "u8ByteInterleavedRecommendedDefault": "U8: intercalado por bytes, predeterminado recomendado", + "@u8ByteInterleavedRecommendedDefault": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1758" + }, + "uac2AndEqualizer": "UAC2 y ecualizador", + "@uac2AndEqualizer": { + "description": "lib/features/settings/screens/settings_screen.dart:138" + }, + "uac2IsNotAvailableOnThis": "UAC2 no está disponible en esta plataforma", + "@uac2IsNotAvailableOnThis": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:189" + }, + "uac2NotAvailableOnThisPlatform": "UAC2 no está disponible en esta plataforma", + "@uac2NotAvailableOnThisPlatform": { + "description": "lib/widgets/uac2/uac2_device_selector.dart:20" + }, + "uac2Preferences": "Preferencias de UAC2", + "@uac2Preferences": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:162" + }, + "uac2PreferencesResetSuccessfully": "Se restablecieron las preferencias de UAC2", + "@uac2PreferencesResetSuccessfully": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1456" + }, + "uiCustomization": "Personalización de la interfaz", + "@uiCustomization": { + "description": "lib/features/settings/screens/settings_screen.dart:198" + }, + "ultra": "Ultra", + "@ultra": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:166" + }, + "unableToCheckForUpdatesRight": "No se pueden buscar actualizaciones en este momento.", + "@unableToCheckForUpdatesRight": { + "description": "lib/providers/update_check_provider.dart:177" + }, + "unableToLoadPatchNotesRight": "No se pueden cargar las notas de la versión en este momento.", + "@unableToLoadPatchNotesRight": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:300" + }, + "unableToOpenAllFilesAccess": "No se puede abrir la configuración de acceso a todos los archivos", + "@unableToOpenAllFilesAccess": { + "description": "lib/features/settings/screens/library_settings_screen.dart:220" + }, + "unableToOpenBatteryOptimizationSettings": "No se puede abrir la configuración de optimización de batería", + "@unableToOpenBatteryOptimizationSettings": { + "description": "lib/features/settings/screens/library_settings_screen.dart:199" + }, + "unavailable": "{featureName} no disponible", + "@unavailable": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1473", + "placeholders": { + "featureName": { + "type": "Object" + } + } + }, + "unavailable2": "No disponible", + "@unavailable2": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1157" + }, + "underruns": "{arg1} subdesbordamientos", + "@underruns": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1037", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "undo": "Deshacer", + "@undo": { + "description": "lib/features/favorites/screens/favorites_screen.dart:63" + }, + "unfavorite": "Quitar de favoritos", + "@unfavorite": { + "description": "lib/features/favorites/screens/favorites_screen.dart:173" + }, + "unfavoriteSelected": "Quitar la selección de favoritos", + "@unfavoriteSelected": { + "description": "lib/features/favorites/screens/favorites_screen.dart:273" + }, + "uniqueArtists": "Artistas únicos", + "@uniqueArtists": { + "description": "lib/features/milestone/screens/milestones_screen.dart:379" + }, + "universalCompatibility": "Compatibilidad universal", + "@universalCompatibility": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:486" + }, + "unknown": "Desconocido", + "@unknown": { + "description": "lib/features/albums/screens/album_detail_screen.dart:950" + }, + "unknownAlbum": "Álbum desconocido", + "@unknownAlbum": { + "description": "lib/data/repositories/recently_played_repository.dart:588" + }, + "unknownArtist": "Artista desconocido", + "@unknownArtist": { + "description": "lib/data/repositories/recently_played_repository.dart:578" + }, + "unknownBitrate": "Tasa de bits desconocida", + "@unknownBitrate": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1015" + }, + "unknownFolder": "Carpeta desconocida", + "@unknownFolder": { + "description": "lib/features/search/providers/global_search_provider.dart:106" + }, + "unknownLastFmError": "Error desconocido de Last.fm", + "@unknownLastFmError": { + "description": "l10n pass: user-visible service error" + }, + "unknownTitle": "Título desconocido", + "@unknownTitle": { + "description": "lib/services/playlist_service.dart:688" + }, + "unknownTrack": "Pista desconocida", + "@unknownTrack": { + "description": "lib/features/player/widgets/online_lyrics_search_sheet.dart:1051" + }, + "unlocked": "{unlocked} / {arg1} desbloqueados", + "@unlocked": { + "description": "lib/features/milestone/screens/milestones_screen.dart:316", + "placeholders": { + "unlocked": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "unlocked3": "{_milestonesUnlocked} / {arg1} desbloqueados", + "@unlocked3": { + "description": "lib/features/settings/screens/settings_screen.dart:255", + "placeholders": { + "_milestonesUnlocked": { + "type": "Object" + }, + "arg1": { + "type": "Object" + } + } + }, + "unmute": "Activar sonido", + "@unmute": { + "description": "lib/widgets/uac2/iso_volume_popup.dart:260" + }, + "unreported": "No informado", + "@unreported": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:678" + }, + "unsavedChanges": "Cambios sin guardar", + "@unsavedChanges": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:586" + }, + "up": "{arg1} arriba", + "@up": { + "description": "lib/features/player/widgets/player_layout_sheet.dart:566", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "upNext": "A continuación", + "@upNext": { + "description": "lib/features/queue/screens/queue_screen.dart:141" + }, + "upcomingSong": "{count, plural, =1{{count} próxima canción} other{{count} próximas canciones}}", + "@upcomingSong": { + "description": "lib/features/queue/screens/queue_screen.dart:419", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "update": "Actualizar", + "@update": { + "description": "lib/features/menu/screens/menu_screen.dart:1247" + }, + "updateAvailable": "Actualización disponible", + "@updateAvailable": { + "description": "lib/features/menu/screens/menu_screen.dart:1226" + }, + "updateAvailableDownloadFromFlickPlayer": "Hay una actualización disponible: descárgala desde flick-player.site", + "@updateAvailableDownloadFromFlickPlayer": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:87" + }, + "updateAvailableOnThePlayStore": "Hay una actualización disponible en Play Store.", + "@updateAvailableOnThePlayStore": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:85" + }, + "updateNoticeHidden": "Se ocultó el aviso de actualización.", + "@updateNoticeHidden": { + "description": "lib/features/menu/screens/menu_screen.dart:1269" + }, + "updated": "Actualizado: {arg1}", + "@updated": { + "description": "lib/features/playlists/screens/playlist_detail_screen.dart:438", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "updatedAlbumArtFor": "Se actualizó la portada del álbum «{arg1}».", + "@updatedAlbumArtFor": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:150", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "updatedAlbumArtFor2": "Se actualizó la portada del álbum «{arg1}».", + "@updatedAlbumArtFor2": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:151", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "updates": "Actualizaciones", + "@updates": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:602" + }, + "updatesAboutAndSupport": "Actualizaciones, información y ayuda", + "@updatesAboutAndSupport": { + "description": "lib/features/settings/screens/settings_screen.dart:267" + }, + "upload": "Subir", + "@upload": { + "description": "lib/features/settings/screens/logs_screen.dart:132" + }, + "uploadFailed": "Error al subir ({arg1}).", + "@uploadFailed": { + "description": "lib/features/settings/screens/logs_screen.dart:156", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "uploadFailed2": "Error al subir: {e}", + "@uploadFailed2": { + "description": "lib/features/settings/screens/logs_screen.dart:159", + "placeholders": { + "e": { + "type": "Object" + } + } + }, + "uploadLogsAsALink": "¿Subir los registros como enlace?", + "@uploadLogsAsALink": { + "description": "lib/features/settings/screens/logs_screen.dart:128" + }, + "upnpDlna": "UPnP / DLNA", + "@upnpDlna": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:81" + }, + "urbPacket": "Paquete URB", + "@urbPacket": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:1010" + }, + "urbTransfer": "Transferencia URB", + "@urbTransfer": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:867" + }, + "urbanEchoes": "Ecos urbanos", + "@urbanEchoes": { + "description": "lib/models/song.dart:330" + }, + "usbAudioClass20Devices": "Los dispositivos USB Audio Class 2.0 (DAC/amplificadores externos) se usan localmente para reproducir audio bit perfecto. No se transmite información de dispositivos USB a terceros.", + "@usbAudioClass20Devices": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:56" + }, + "usbAudioDevice": "Dispositivo de audio USB", + "@usbAudioDevice": { + "description": "lib/widgets/uac2/uac2_device_selector.dart:36" + }, + "usbAudioDevices": "Dispositivos de audio USB", + "@usbAudioDevices": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:66" + }, + "usbAudioError": "Error de audio USB", + "@usbAudioError": { + "description": "lib/widgets/uac2/uac2_error_notification.dart:55" + }, + "usbAudioUac2": "Audio USB (UAC2)", + "@usbAudioUac2": { + "description": "lib/features/settings/screens/audio_settings_screen.dart:49" + }, + "usbDacAutoBitPerfectOffers": "Se restablecieron las ofertas automáticas de modo bit perfecto para DAC USB.", + "@usbDacAutoBitPerfectOffers": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:522" + }, + "usbDacsHeadphonesAndReferenceGear": "DAC USB, audífonos y equipos de referencia para probar y mejorar la calidad de reproducción.", + "@usbDacsHeadphonesAndReferenceGear": { + "description": "lib/features/settings/screens/support_flick_screen.dart:175" + }, + "usbDeviceAccess": "Acceso al dispositivo USB", + "@usbDeviceAccess": { + "description": "lib/features/settings/screens/privacy_policy_screen.dart:54" + }, + "usbNotConnected": "USB no conectado", + "@usbNotConnected": { + "description": "lib/features/folders/screens/folders_screen.dart:781" + }, + "usbRouteVolume": "Volumen de la ruta USB", + "@usbRouteVolume": { + "description": "lib/widgets/uac2/uac2_volume_control.dart:162" + }, + "usbStorageNotConnected": "Almacenamiento USB no conectado", + "@usbStorageNotConnected": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1244" + }, + "usbVolume": "Volumen USB", + "@usbVolume": { + "description": "lib/features/player/widgets/player_action_button_row.dart:726" + }, + "usbVolumeInSettings": "Volumen USB en Ajustes", + "@usbVolumeInSettings": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:125" + }, + "usbVolumeOnHome": "Volumen USB en Inicio", + "@usbVolumeOnHome": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart:113" + }, + "useAFixed48khz16bitOutput": "Usar una salida fija de 48 kHz/16 bits para mejorar la compatibilidad", + "@useAFixed48khz16bitOutput": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1250" + }, + "useAaudioDirectlyLowestLatencyOn": "Usar AAudio directamente. Menor latencia en Android 8.1 y versiones posteriores.", + "@useAaudioDirectlyLowestLatencyOn": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:682" + }, + "useAlbumArtAsBackground": "Usar la portada del álbum como fondo", + "@useAlbumArtAsBackground": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:519" + }, + "useAutoSource": "Usar fuente automática", + "@useAutoSource": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:225" + }, + "useCurrentTime": "Usar hora actual", + "@useCurrentTime": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1335" + }, + "useExistingFile": "Usar archivo existente", + "@useExistingFile": { + "description": "lib/features/player/widgets/inline_lyrics_panel.dart:214" + }, + "useExistingFileInTheLyrics": "- «Usar archivo existente» en el panel de letras vincula un archivo `.lrc`, `.txt` o `.xml`.\n- Si algunas líneas no tienen tiempo marcado, Flick los completa automáticamente.\n- Al guardar, se escribe junto a la canción cuando es posible; de lo contrario, Flick guarda una copia vinculada.", + "@useExistingFileInTheLyrics": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:712" + }, + "useFilesystemLevelScanningInsteadOf": "Usar análisis a nivel del sistema de archivos en lugar de MediaStore para obtener etiquetas más precisas", + "@useFilesystemLevelScanningInsteadOf": { + "description": "lib/features/settings/screens/library_settings_screen.dart:1870" + }, + "useMmSsCcEG": "Usar mm:ss.cc; por ejemplo, 01:23.45", + "@useMmSsCcEG": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:418" + }, + "useTheCurrentAudioFileS": "Usar el nombre del archivo de audio actual al guardar las letras en la app", + "@useTheCurrentAudioFileS": { + "description": "lib/features/settings/screens/lyrics_settings_screen.dart:27" + }, + "useTheDefaultMonochromeTheme": "Usar el tema monocromático predeterminado.", + "@useTheDefaultMonochromeTheme": { + "description": "lib/models/album_color_mode.dart:33" + }, + "useTheHighestFixedOutputRate": "Usar la frecuencia de salida fija y la profundidad de bits más altas disponibles", + "@useTheHighestFixedOutputRate": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1241" + }, + "useTheLegacyOpenslEsBackend": "Usar el motor OpenSL ES heredado. Alternativa para solucionar problemas en dispositivos antiguos o problemáticos.", + "@useTheLegacyOpenslEsBackend": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:702" + }, + "useTheListSongsBrowser": "Usar la vista de canciones en lista", + "@useTheListSongsBrowser": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:116" + }, + "useTheOrbitalSongsBrowser": "Usar la vista orbital de canciones", + "@useTheOrbitalSongsBrowser": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:104" + }, + "useTheVerifiedDirectUsbPath": "Usar la ruta USB directa verificada y desactivar los controles de DSP por software que impedirían la reproducción bit perfecta en un DAC USB externo.", + "@useTheVerifiedDirectUsbPath": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:399" + }, + "userToken": "Token de usuario", + "@userToken": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:740" + }, + "username": "Nombre de usuario", + "@username": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:450" + }, + "using": "Usando {arg1}", + "@using": { + "description": "lib/features/settings/screens/library_settings_screen.dart:251", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "using2": "Usando {arg1}", + "@using2": { + "description": "lib/features/settings/screens/library_settings_screen.dart:307", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "variableBitrateLowLatency": "Tasa de bits variable y baja latencia", + "@variableBitrateLowLatency": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:490" + }, + "variousArtists2": "Varios artistas", + "@variousArtists2": { + "description": "lib/data/repositories/song_repository.dart:637" + }, + "velvetNoir": "Noir aterciopelado", + "@velvetNoir": { + "description": "lib/models/song.dart:339" + }, + "vendorId": "ID del proveedor", + "@vendorId": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:489" + }, + "verboseDartRustAndCrashLogs": "Registros detallados de Dart, Rust y fallos", + "@verboseDartRustAndCrashLogs": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:379" + }, + "verified": "Verificado", + "@verified": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:704" + }, + "version": "Versión {kAppVersion}", + "@version": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:454", + "placeholders": { + "kAppVersion": { + "type": "Object" + } + } + }, + "version2": "Versión {arg1}", + "@version2": { + "description": "lib/features/whats_new/widgets/whats_new_bottom_sheet.dart:126", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "verticalBarsClassicSpectrumAnalyzer": "Barras verticales: analizador de espectro clásico", + "@verticalBarsClassicSpectrumAnalyzer": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:71" + }, + "verticalBarsThatAnimateAcrossThe": "Barras verticales que se animan por toda la pantalla.", + "@verticalBarsThatAnimateAcrossThe": { + "description": "lib/models/progress_bar_style.dart:25" + }, + "verticalPosition": "Posición vertical", + "@verticalPosition": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:38" + }, + "vibrant": "Intenso", + "@vibrant": { + "description": "lib/models/album_color_mode.dart:26" + }, + "viewAsGrid": "Ver como cuadrícula", + "@viewAsGrid": { + "description": "lib/features/songs/screens/songs_screen.dart" + }, + "viewAsList": "Ver como lista", + "@viewAsList": { + "description": "lib/features/songs/screens/songs_screen.dart" + }, + "viewMetadata": "Ver metadatos", + "@viewMetadata": { + "description": "lib/features/player/widgets/song_actions_sheet.dart:286" + }, + "viewOnboarding": "Ver bienvenida", + "@viewOnboarding": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:679" + }, + "viewQueue": "Ver cola", + "@viewQueue": { + "description": "lib/features/albums/screens/album_detail_screen.dart:265" + }, + "visualizer": "Visualizador", + "@visualizer": { + "description": "lib/features/settings/screens/bottom_bar_settings_screen.dart:36" + }, + "visualizerAlbumColorsDescription": "Seguir los colores de la portada; usar monocromo si no están disponibles", + "visualizerBlocks": "Bloques que se desvanecen", + "visualizerBlocksDescription": "Barras segmentadas con estelas que se desvanecen suavemente", + "visualizerColors": "Colores", + "visualizerMonochrome": "Monocromático", + "visualizerMonochromeDescription": "Blanco y gris, independientemente de la portada del álbum", + "visualizerRainbow": "Arcoíris", + "visualizerRainbowDescription": "Un espectro de colores en todo el visualizador", + "visuals": "Visuales", + "@visuals": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:174" + }, + "volume": "Volumen", + "@volume": { + "description": "lib/features/player/widgets/bit_perfect_indicator.dart:646" + }, + "volumeControl": "Control de volumen", + "@volumeControl": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:95" + }, + "volumeDipsWhileNotificationSoundsPlay": "El volumen baja mientras suenan las notificaciones", + "@volumeDipsWhileNotificationSoundsPlay": { + "description": "lib/features/settings/screens/playback_display_settings_screen.dart:245" + }, + "volumeIsFixedWhileBitPerfect": "El volumen se mantiene fijo durante el paso directo bit perfecto porque Flick no puede controlar el volumen del hardware USB. Usa los controles del dispositivo o reproduce PCM con el modo bit perfecto desactivado para ajustar el volumen por software.", + "@volumeIsFixedWhileBitPerfect": { + "description": "lib/features/player/widgets/volume_bottom_sheet.dart:112" + }, + "volumeIsFixedWhileBitPerfect2": "El volumen se mantiene fijo durante el paso directo bit perfecto porque Flick no puede controlar el volumen del hardware USB. Usa los controles del dispositivo o reproduce PCM con el modo bit perfecto desactivado para ajustar el volumen por software.", + "@volumeIsFixedWhileBitPerfect2": { + "description": "lib/widgets/uac2/uac2_volume_control.dart:236" + }, + "directUsbFormatNotice": "Se detectó un DAC USB directo. La conexión USB directa omite el mezclador y el volumen del sistema Android. El formato mostrado es el formato de contenido solicitado, no una medición de la frecuencia de salida del DAC.", + "@directUsbFormatNotice": { + "description": "Direct USB route notice; registration does not prove streaming or DAC output rate." + }, + "usbVolumeSafetyPaused": "No se pudo confirmar el volumen del DAC. Pulsa Reproducir para volver a intentarlo con un nivel bajo. Si vuelve a fallar, reconecta el DAC.", + "@usbVolumeSafetyPaused": { + "description": "Shown after a DAC control failure; Play retries a low verified hardware volume without requiring a slider gesture." + }, + "usbHardwareVolumeUnavailable": "Flick no puede controlar el volumen del hardware USB. Durante el paso directo bit perfecto, usa los controles físicos del dispositivo. Para ajustar el volumen por software, reproduce PCM con el modo bit perfecto desactivado.", + "@usbHardwareVolumeUnavailable": { + "description": "USB control capability notice, without claiming the DAC physically lacks volume controls or software gain is active." + }, + "usbHardwareVolumeError": "Volumen del hardware USB: {reason}", + "@usbHardwareVolumeError": { + "description": "Native USB volume discovery/control error in audio diagnostics.", + "placeholders": { + "reason": { + "type": "String" + } + } + }, + "wAgo": "hace {arg1} sem", + "@wAgo": { + "description": "lib/features/menu/screens/menu_screen.dart:3200", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "waitingForBrowserAuthorization": "Esperando la autorización del navegador…", + "@waitingForBrowserAuthorization": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:978" + }, + "waitingForPlayback": "Esperando la reproducción", + "@waitingForPlayback": { + "description": "lib/features/settings/screens/uac2_preferences_screen.dart:1110" + }, + "was": "era: {arg1}", + "@was": { + "description": "lib/features/albums/widgets/identify_album_sheet.dart:537", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "wave": "Onda", + "@wave": { + "description": "lib/features/settings/screens/visualizer_settings_screen.dart:86" + }, + "waveform": "Forma de onda", + "@waveform": { + "description": "lib/models/progress_bar_style.dart:16" + }, + "waveformHeight": "Altura de la forma de onda", + "@waveformHeight": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart" + }, + "waveformHeightDescription": "Ajusta la altura de las barras de la forma de onda.", + "@waveformHeightDescription": { + "description": "lib/features/settings/screens/ui_customization_settings_screen.dart" + }, + "waveformSeekbar": "Barra de reproducción con forma de onda", + "@waveformSeekbar": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "weLlKeepTheBestQuality": "Conservaremos la versión de mejor calidad de cada grupo (se prefiere la portada del álbum y luego la tasa de bits más alta) y quitaremos {count, plural, =1{{count} copia} other{{count} copias}}. Los archivos del disco no se eliminarán.", + "@weLlKeepTheBestQuality": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:926", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "weLlKeepYourCheckedVersion": "Conservaremos {kept, plural, =1{{kept} versión que marcaste} other{{kept} versiones que marcaste}} y quitaremos de la biblioteca {removed, plural, =1{{removed} copia restante} other{{removed} copias restantes}}. Los archivos de audio del disco no se eliminarán.", + "@weLlKeepYourCheckedVersion": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:878", + "placeholders": { + "kept": { + "type": "int" + }, + "removed": { + "type": "int" + } + } + }, + "webdav": "WebDAV", + "@webdav": { + "description": "lib/features/settings/screens/network_server_edit_screen.dart:73" + }, + "weekly": "Semanal", + "@weekly": { + "description": "lib/data/repositories/recently_played_repository.dart:15" + }, + "welcomeBackLetSStartA": "¡Qué bueno tenerte de vuelta! Empecemos una racha.", + "@welcomeBackLetSStartA": { + "description": "lib/features/milestone/widgets/streak_popup.dart:93" + }, + "welcomeToFlick": "¡Te damos la bienvenida a Flick!", + "@welcomeToFlick": { + "description": "lib/features/menu/screens/menu_screen.dart:305" + }, + "whatItShows": "Qué muestra", + "@whatItShows": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "whatSNew": "Novedades", + "@whatSNew": { + "description": "lib/features/whats_new/widgets/whats_new_bottom_sheet.dart:22" + }, + "whenBitPerfectOutputIs": "Cuando la salida bit perfecta está activa, una cápsula muestra la frecuencia de muestreo y la profundidad de bits que se envían al DAC.", + "@whenBitPerfectOutputIs": { + "description": "lib/features/manual/data/manual_data.dart" + }, + "whenYouPlayOverBluetoothAndroid": "Al reproducir por Bluetooth, Android negocia el códec con tus audífonos o bocina.", + "@whenYouPlayOverBluetoothAndroid": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:529" + }, + "whereShouldTheLrcFileBe": "¿Dónde quieres guardar el archivo .lrc?", + "@whereShouldTheLrcFileBe": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:491" + }, + "whereTheFocalSongSitsVertically": "Posición vertical de la canción destacada", + "@whereTheFocalSongSitsVertically": { + "description": "lib/features/settings/screens/orbit_settings_screen.dart:39" + }, + "whereYourMoneyGoes": "A dónde va tu dinero", + "@whereYourMoneyGoes": { + "description": "lib/features/settings/screens/support_flick_screen.dart:161" + }, + "whisperWorld": "Mundo susurrante", + "@whisperWorld": { + "description": "lib/models/song.dart:371" + }, + "whisperedSecrets": "Secretos susurrados", + "@whisperedSecrets": { + "description": "lib/models/song.dart:366" + }, + "white": "Blanco", + "@white": { + "description": "lib/features/settings/screens/widget_settings_screen.dart:267" + }, + "wholeAlbum": "Álbum completo", + "@wholeAlbum": { + "description": "lib/features/songs/widgets/album_art_picker_bottom_sheet.dart:404" + }, + "whyDonate": "¿Por qué donar?", + "@whyDonate": { + "description": "lib/features/settings/screens/support_flick_screen.dart:131" + }, + "wide": "{amount}% de ancho", + "@wide": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3493", + "placeholders": { + "amount": { + "type": "Object" + } + } + }, + "widgets": "Widgets", + "@widgets": { + "description": "lib/features/settings/screens/settings_screen.dart:222" + }, + "width": "Ancho", + "@width": { + "description": "lib/features/settings/screens/equalizer_screen.dart:3667" + }, + "wildWeather": "Clima salvaje", + "@wildWeather": { + "description": "lib/models/song.dart:380" + }, + "willBeRemoved": "Se quitará", + "@willBeRemoved": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:1531" + }, + "willKeep": "Se conservará", + "@willKeep": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:647" + }, + "wiredOutput": "Salida por cable", + "@wiredOutput": { + "description": "lib/features/settings/screens/uac2_settings_screen.dart:927" + }, + "word": "Palabra {arg1} · «{arg2}»", + "@word": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1558", + "placeholders": { + "arg1": { + "type": "Object" + }, + "arg2": { + "type": "Object" + } + } + }, + "word2": "Palabra {arg1} · «{token}»", + "@word2": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1788", + "placeholders": { + "arg1": { + "type": "Object" + }, + "token": { + "type": "Object" + } + } + }, + "wordSync": "Sincronizar palabras", + "@wordSync": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:903" + }, + "wordSyncModeKaraoke": "Modo Sincronizar palabras (karaoke)", + "@wordSyncModeKaraoke": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:670" + }, + "wordTimelineLine": "Línea de tiempo de palabras · Línea {arg1}", + "@wordTimelineLine": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:1678", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "wrapAroundAndQueueBehavior": "Repetición y comportamiento de la cola", + "@wrapAroundAndQueueBehavior": { + "description": "lib/features/settings/screens/settings_screen.dart:116" + }, + "wrapAroundQueue": "Cola con repetición", + "@wrapAroundQueue": { + "description": "lib/features/settings/screens/queue_settings_screen.dart:48" + }, + "writeADescription": "Escribe una descripción", + "@writeADescription": { + "description": "lib/features/albums/screens/album_detail_screen.dart:314" + }, + "x": "{min}x", + "@x": { + "description": "lib/features/player/widgets/speed_bottom_sheet.dart:64", + "placeholders": { + "min": { + "type": "Object" + } + } + }, + "x2": "{max}x", + "@x2": { + "description": "lib/features/player/widgets/speed_bottom_sheet.dart:83", + "placeholders": { + "max": { + "type": "Object" + } + } + }, + "x3": "{currentSpeed}x", + "@x3": { + "description": "lib/features/player/widgets/speed_bottom_sheet.dart:94", + "placeholders": { + "currentSpeed": { + "type": "Object" + } + } + }, + "yAgo": "hace {arg1} años", + "@yAgo": { + "description": "lib/features/menu/screens/menu_screen.dart:3205", + "placeholders": { + "arg1": { + "type": "Object" + } + } + }, + "year": "Año", + "@year": { + "description": "lib/features/player/widgets/song_metadata_sheet.dart:72" + }, + "yearly": "Anual", + "@yearly": { + "description": "lib/data/repositories/recently_played_repository.dart:17" + }, + "yesterday": "Ayer", + "@yesterday": { + "description": "lib/data/repositories/recently_played_repository.dart:285" + }, + "youAlreadyHaveTheLatestFlick": "Ya tienes la versión más reciente de Flick", + "@youAlreadyHaveTheLatestFlick": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:168" + }, + "youAlreadyHaveTheLatestPlay": "Ya tienes la versión más reciente de Play Store", + "@youAlreadyHaveTheLatestPlay": { + "description": "lib/features/settings/screens/app_info_settings_screen.dart:167" + }, + "youCanAlsoChangeTheCodec": "También puedes cambiar el códec en Opciones para desarrolladores de Android, en «Códec de audio Bluetooth».", + "@youCanAlsoChangeTheCodec": { + "description": "lib/features/settings/screens/bluetooth_settings_screen.dart:612" + }, + "youCustomizedWhichVersionsToKeep": "Personalizaste cuáles versiones conservar. Bien: tú decides.", + "@youCustomizedWhichVersionsToKeep": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:667" + }, + "youHaveUnsavedChangesAreYou": "Tienes cambios sin guardar. ¿Seguro que quieres descartarlos?", + "@youHaveUnsavedChangesAreYou": { + "description": "lib/features/songs/screens/metadata_editor_screen.dart:564" + }, + "youHaveUnsavedLyricEditsLeave": "Tienes cambios sin guardar en las letras. ¿Quieres salir del Estudio de sincronización sin guardarlos?", + "@youHaveUnsavedLyricEditsLeave": { + "description": "lib/features/player/screens/lyrics_sync_screen.dart:590" + }, + "youReOffline": "No tienes conexión", + "@youReOffline": { + "description": "lib/widgets/common/offline_notice.dart:180" + }, + "youReOfflineSomeOnlineFeatures": "No tienes conexión. Es posible que algunas funciones en línea no estén disponibles.", + "@youReOfflineSomeOnlineFeatures": { + "description": "lib/widgets/common/offline_notice.dart:136" + }, + "youVeHitTheThresholdKeep": "Llegaste al umbral: ¡sigue así!", + "@youVeHitTheThresholdKeep": { + "description": "lib/features/milestone/screens/milestones_screen.dart:619" + }, + "yourCollectionAtAGlance": "Tu colección de un vistazo", + "@yourCollectionAtAGlance": { + "description": "lib/features/albums/screens/albums_screen.dart:333" + }, + "yourCustomCollections": "Tus colecciones personalizadas", + "@yourCustomCollections": { + "description": "lib/features/playlists/screens/playlists_screen.dart:91" + }, + "yourHeaviestRotationRightNow": "Lo que más escuchas ahora", + "@yourHeaviestRotationRightNow": { + "description": "lib/features/menu/screens/menu_screen.dart:1749" + }, + "yourLatestLibraryScans": "Tus análisis de biblioteca más recientes", + "@yourLatestLibraryScans": { + "description": "lib/features/menu/screens/menu_screen.dart:1429" + }, + "yourLibrary": "Tu biblioteca", + "@yourLibrary": { + "description": "lib/features/songs/screens/songs_screen.dart:1883" + }, + "yourLibraryAtAGlance": "Tu biblioteca de un vistazo", + "@yourLibraryAtAGlance": { + "description": "lib/features/artists/screens/artists_screen.dart:363" + }, + "yourLibraryIsTidyWeLl": "Tu biblioteca está ordenada. Te avisaremos si aparecen nuevos duplicados después del próximo análisis.", + "@yourLibraryIsTidyWeLl": { + "description": "lib/features/settings/screens/duplicate_cleaner_screen.dart:274" + }, + "yourListeningHistoryIsStillYours": "Tu historial de escucha sigue siendo tuyo. Intenta cargarlo de nuevo.", + "@yourListeningHistoryIsStillYours": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:249" + }, + "yourListensWillRemainOnListenbrainz": "Tus reproducciones seguirán en ListenBrainz, pero Flick dejará de enviarlas.", + "@yourListensWillRemainOnListenbrainz": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:136" + }, + "yourLogsAreUploadedToDpaste": "Tus registros se suben a dpaste.com como un enlace no listado que vence en 30 días. Cualquier persona con el enlace podrá leerlos; los registros pueden incluir rutas de archivos y detalles del dispositivo.", + "@yourLogsAreUploadedToDpaste": { + "description": "lib/features/settings/screens/logs_screen.dart:130" + }, + "yourMonthlyRecapNeedsABit": "Tu resumen mensual necesita un poco más de tiempo de escucha este mes.", + "@yourMonthlyRecapNeedsABit": { + "description": "lib/data/repositories/recently_played_repository.dart:37" + }, + "yourMostReplayedTrack": "La pista que más repetiste", + "@yourMostReplayedTrack": { + "description": "lib/features/recap/widgets/replay_sections.dart:111" + }, + "yourMusicIsBeingScrobbled": "Se están registrando tus reproducciones", + "@yourMusicIsBeingScrobbled": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:837" + }, + "yourMusicIsBeingSubmitted": "Se están enviando tus reproducciones", + "@yourMusicIsBeingSubmitted": { + "description": "lib/features/settings/widgets/listenbrainz_settings_tile.dart:267" + }, + "yourMusicOnRepeat": "Tu música. Una y otra vez.", + "@yourMusicOnRepeat": { + "description": "lib/features/recap/widgets/replay_poster.dart:108" + }, + "yourNewAudioEngineIsReady": "Tu nuevo motor de audio está listo. Reinicia Flick para aplicarlo.", + "@yourNewAudioEngineIsReady": { + "description": "lib/widgets/common/engine_restart_notice.dart:54" + }, + "yourNextFavoriteIsWaiting": "Tu próximo favorito te espera.", + "@yourNextFavoriteIsWaiting": { + "description": "lib/features/recap/widgets/replay_poster.dart:183" + }, + "yourNextFavoriteNisWaiting": "Tu próximo favorito\nte espera.", + "@yourNextFavoriteNisWaiting": { + "description": "lib/features/recap/screens/listening_recap_screen.dart:295" + }, + "yourPlaylists": "Tus listas de reproducción", + "@yourPlaylists": { + "description": "lib/features/menu/screens/menu_screen.dart:972" + }, + "yourScrobblingHistoryWillRemainOn": "Tu historial de reproducciones seguirá en Last.fm, pero Flick dejará de enviar los registros.", + "@yourScrobblingHistoryWillRemainOn": { + "description": "lib/features/settings/widgets/lastfm_settings_tile.dart:198" + }, + "yourSessionHistory": "Tu historial de sesiones", + "@yourSessionHistory": { + "description": "lib/features/menu/screens/menu_screen.dart:1420" + }, + "yourWeeklyRecapAppearsOnceYou": "Tu resumen semanal aparecerá cuando empieces a escuchar música esta semana.", + "@yourWeeklyRecapAppearsOnceYou": { + "description": "lib/data/repositories/recently_played_repository.dart:35" + }, + "yourYearlyRecapFillsInAs": "Tu resumen anual se completa a medida que escuchas música durante el año.", + "@yourYearlyRecapFillsInAs": { + "description": "lib/data/repositories/recently_played_repository.dart:39" + } +} diff --git a/lib/l10n/app_tl.arb b/lib/l10n/app_tl.arb index bdfb45da..ebd7bf05 100644 --- a/lib/l10n/app_tl.arb +++ b/lib/l10n/app_tl.arb @@ -1427,9 +1427,14 @@ "openslEsLegacy": "OpenSL ES (luma)", "orRemoveAllUsingRecommendedPicks": "O alisin lahat gamit ang mga inirekomendang piliin", "orbital": "Orbital", + "orbitHeaderBoundaryBody": "Ang mga orbital card at orbit path ay nananatili sa ilalim ng Your Library heading at search bar. Kapag itinaas ang orbit, napuputol ito sa hangganang ito.", + "orbitHeaderBoundaryTitle": "Humihinto ang orbit sa library header", "orbitLandscapeHint": "Ginagamit kapag mas malapad kaysa matangkad ang window ng app.", "orbitLayoutProfile": "Profile ng layout", "orbitPortraitHint": "Ginagamit kapag mas matangkad kaysa lapad ang window ng app.", + "orbitPreviewHide": "Itago ang preview", + "orbitPreviewHint": "Mag-swipe upang mag-browse. Walang tumutugtog, naidadagdag sa queue, o nababago sa mga paborito.", + "orbitPreviewShow": "Ipakita ang preview", "orbitSharedVisuals": "Mga shared na visual", "otherPlaylists": "Iba pang talaan ng kanta", "ourRustPoweredEngineCleanerSound": "Ang aming engine na pinapagana ng Rust. Mas malinaw na tunog at mas makinis na pagtugtog — inirerekomenda sa araw-araw na pakikinig.", @@ -2022,6 +2027,7 @@ "sourceRate": "Source rate", "spaceBetweenTheTwoBars": "Pagitan ng dalawang bar", "spaceOdyssey": "Paglalakbay sa kalawakan", + "spanishDraftDescription": "Latin American Spanish. Draft copy para sa review ng native speaker.", "spatialTime": "Espasyo at oras", "speedUp": "Pabilisin", "springPhysicsEnergeticAndReactive": "Galaw na parang spring — masigla at tumutugon", diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb index a6a8e7ef..2270d90a 100644 --- a/lib/l10n/app_zh.arb +++ b/lib/l10n/app_zh.arb @@ -1580,9 +1580,14 @@ "openslEsLegacy": "OpenSL ES（旧版）", "orRemoveAllUsingRecommendedPicks": "或使用推荐选择移除全部", "orbital": "Orbital", + "orbitHeaderBoundaryBody": "轨道卡片和轨道路径始终位于媒体库标题与搜索栏下方。向上移动轨道时，会在此边界处被裁切。", + "orbitHeaderBoundaryTitle": "轨道止于媒体库顶栏", "orbitLandscapeHint": "当应用窗口宽大于高时使用。", "orbitLayoutProfile": "布局配置", "orbitPortraitHint": "当应用窗口高大于宽时使用。", + "orbitPreviewHide": "隐藏预览", + "orbitPreviewHint": "滑动即可浏览。不会播放、加入队列或更改收藏。", + "orbitPreviewShow": "显示预览", "orbitSharedVisuals": "共享视觉效果", "otherPlaylists": "其他播放列表", "ourRustPoweredEngineCleanerSound": "我们基于 Rust 的引擎。声音更干净、播放更流畅，推荐日常聆听。", @@ -2172,6 +2177,7 @@ "sourceRate": "源采样率", "spaceBetweenTheTwoBars": "两条栏之间的间距", "spaceOdyssey": "太空漫游", + "spanishDraftDescription": "拉丁美洲西班牙语，翻译草稿待母语使用者审核。", "spatialTime": "空间与时间", "speedUp": "加速", "springPhysicsEnergeticAndReactive": "弹簧物理效果——活泼灵敏", diff --git a/lib/l10n/generated/app_localizations.dart b/lib/l10n/generated/app_localizations.dart index 73250d7d..98a8f13f 100644 --- a/lib/l10n/generated/app_localizations.dart +++ b/lib/l10n/generated/app_localizations.dart @@ -6,6 +6,7 @@ import 'package:flutter_localizations/flutter_localizations.dart'; import 'package:intl/intl.dart' as intl; import 'app_localizations_en.dart'; +import 'app_localizations_es.dart'; import 'app_localizations_tl.dart'; import 'app_localizations_zh.dart'; @@ -96,6 +97,7 @@ abstract class AppLocalizations { /// A list of this localizations delegate's supported locales. static const List supportedLocales = [ Locale('en'), + Locale('es'), Locale('tl'), Locale.fromSubtags(languageCode: 'tl', scriptCode: 'Tglg'), Locale('zh'), @@ -9532,6 +9534,18 @@ abstract class AppLocalizations { /// **'Orbital'** String get orbital; + /// Explains that orbit cards and the path stay below the library header and search bar. + /// + /// In en, this message translates to: + /// **'Orbital cards and the orbit path stay below the Your Library heading and search bar. Raising the orbit clips it at this boundary.'** + String get orbitHeaderBoundaryBody; + + /// Title of the notice about the orbit's top boundary. + /// + /// In en, this message translates to: + /// **'Orbit stops at the library header'** + String get orbitHeaderBoundaryTitle; + /// Explains when the landscape orbit profile is applied. /// /// In en, this message translates to: @@ -9550,6 +9564,24 @@ abstract class AppLocalizations { /// **'Used when the app window is taller than it is wide.'** String get orbitPortraitHint; + /// Tooltip for collapsing the orbit preview. + /// + /// In en, this message translates to: + /// **'Hide preview'** + String get orbitPreviewHide; + + /// Explains that the orbit preview is browse-only. + /// + /// In en, this message translates to: + /// **'Swipe to browse. Nothing plays, queues, or changes your favorites.'** + String get orbitPreviewHint; + + /// Tooltip for expanding the orbit preview. + /// + /// In en, this message translates to: + /// **'Show preview'** + String get orbitPreviewShow; + /// Header for orbit visuals shared by both orientation profiles. /// /// In en, this message translates to: @@ -13084,6 +13116,12 @@ abstract class AppLocalizations { /// **'Space Odyssey'** String get spaceOdyssey; + /// Language selector notice that the Latin American Spanish translation is a draft awaiting native-speaker review. + /// + /// In en, this message translates to: + /// **'Latin American Spanish. Draft translation pending native-speaker review.'** + String get spanishDraftDescription; + /// lib/features/settings/screens/equalizer_screen.dart:3548 /// /// In en, this message translates to: @@ -15566,7 +15604,7 @@ class _AppLocalizationsDelegate @override bool isSupported(Locale locale) => - ['en', 'tl', 'zh'].contains(locale.languageCode); + ['en', 'es', 'tl', 'zh'].contains(locale.languageCode); @override bool shouldReload(_AppLocalizationsDelegate old) => false; @@ -15589,6 +15627,8 @@ AppLocalizations lookupAppLocalizations(Locale locale) { switch (locale.languageCode) { case 'en': return AppLocalizationsEn(); + case 'es': + return AppLocalizationsEs(); case 'tl': return AppLocalizationsTl(); case 'zh': diff --git a/lib/l10n/generated/app_localizations_en.dart b/lib/l10n/generated/app_localizations_en.dart index 262ccca8..97886808 100644 --- a/lib/l10n/generated/app_localizations_en.dart +++ b/lib/l10n/generated/app_localizations_en.dart @@ -5566,6 +5566,13 @@ class AppLocalizationsEn extends AppLocalizations { @override String get orbital => 'Orbital'; + @override + String get orbitHeaderBoundaryBody => + 'Orbital cards and the orbit path stay below the Your Library heading and search bar. Raising the orbit clips it at this boundary.'; + + @override + String get orbitHeaderBoundaryTitle => 'Orbit stops at the library header'; + @override String get orbitLandscapeHint => 'Used when the app window is wider than it is tall.'; @@ -5577,6 +5584,16 @@ class AppLocalizationsEn extends AppLocalizations { String get orbitPortraitHint => 'Used when the app window is taller than it is wide.'; + @override + String get orbitPreviewHide => 'Hide preview'; + + @override + String get orbitPreviewHint => + 'Swipe to browse. Nothing plays, queues, or changes your favorites.'; + + @override + String get orbitPreviewShow => 'Show preview'; + @override String get orbitSharedVisuals => 'Shared Visuals'; @@ -7711,6 +7728,10 @@ class AppLocalizationsEn extends AppLocalizations { @override String get spaceOdyssey => 'Space Odyssey'; + @override + String get spanishDraftDescription => + 'Latin American Spanish. Draft translation pending native-speaker review.'; + @override String get spatialTime => 'Spatial & Time'; diff --git a/lib/l10n/generated/app_localizations_es.dart b/lib/l10n/generated/app_localizations_es.dart new file mode 100644 index 00000000..7bb5ee7d --- /dev/null +++ b/lib/l10n/generated/app_localizations_es.dart @@ -0,0 +1,9348 @@ +// ignore: unused_import +import 'package:intl/intl.dart' as intl; +import 'app_localizations.dart'; + +// ignore_for_file: type=lint + +/// The translations for Spanish Castilian (`es`). +class AppLocalizationsEs extends AppLocalizations { + AppLocalizationsEs([String locale = 'es']) : super(locale); + + @override + String get tourCore => 'Buscar y reproducir música'; + + @override + String get tourLibrary => 'Herramientas de biblioteca'; + + @override + String get tourPlayer => 'Reproductor y cola'; + + @override + String get tourAppearance => 'Personaliza Flick'; + + @override + String get tourAudio => 'Audio y salida'; + + @override + String get tourGuides => 'Explorar guías'; + + @override + String get tourPickerBody => + 'Elige una guía breve. Prueba los controles reales o continúa a tu ritmo.'; + + @override + String get tourWelcomeTitle => 'Tu música, a un paso'; + + @override + String get tourWelcomeBody => + 'Busca una canción, reprodúcela y conoce tu reproductor. Puedes usar los controles reales, continuar sin probarlos o salir en cualquier momento.'; + + @override + String get tourAddBody => + '¿Aún no tienes música? Abre los ajustes de biblioteca y elige Agregar carpeta de música. El escaneo puede tardar. Puedes cancelar, denegar el permiso o continuar sin agregar nada; podrás volver más tarde.'; + + @override + String get tourSearchBody => + 'Escribe una canción o un artista en el campo de búsqueda resaltado. La búsqueda tiene su propia pestaña cuando la agregas a la navegación. Continúa si prefieres explorar.'; + + @override + String get tourPlayTitle => 'Elige qué escuchar'; + + @override + String get tourPlayBody => + 'Toca una canción que quieras escuchar. La guía avanza cuando comienza la reproducción. Nada se reproduce automáticamente; si no hay música disponible o falla la reproducción, puedes continuar de todos modos.'; + + @override + String get tourMiniBody => + 'El minirreproductor sigue tu música. Tócalo para abrir el reproductor completo o usa Abrir reproductor más abajo. Primero debe haber una canción cargada; puedes continuar sin ella.'; + + @override + String get tourFullBody => + 'Usa el reproductor para pausar, cambiar de canción y desplazarte por la pista. La cola, las letras y las demás acciones dependen del diseño que elegiste. La guía no cambiará el volumen, la cola ni los ajustes de audio.'; + + @override + String get tourFinishTitle => 'Ahora sigue a tu ritmo'; + + @override + String get tourFinishBody => + 'Listo cierra esta guía. Explora otra cuando quieras o vuelve a encontrarlas en Ajustes → Información de la app → Tutorial interactivo.'; + + @override + String get tourSortBody => + 'Abre el control de orden resaltado para explorar las opciones de orden y los filtros. Basta con abrirlo para esta guía; no necesitas cambiar la vista de tu biblioteca.'; + + @override + String get tourActionsBody => + 'Mantén presionada una canción para ver sus acciones, como Reproducir a continuación, agregar a la cola y ver la información de la canción. Abrir el menú no cambia la cola. Continúa si aún no hay canciones.'; + + @override + String get tourPlaylistsBody => + 'Encuentra Listas de reproducción en el menú de biblioteca o en tu navegación personalizada. Usa las acciones de una canción para agregarla a una lista. Lee la guía de listas de reproducción para conocer el proceso completo.'; + + @override + String get tourQueueBody => + 'Abre Cola desde el reproductor completo para ver las próximas canciones. Su botón depende del diseño. Puedes mirar sin reordenar ni quitar nada.'; + + @override + String get tourLyricsBody => + 'Abre Letras en el reproductor completo si tu diseño incluye esta opción. No todas las canciones tienen letras disponibles. Continúa o lee el manual si no encuentras el control o las letras.'; + + @override + String get tourNavBody => + 'Mantén presionada la barra de navegación para personalizarla o abre los ajustes de navegación más abajo. Elige tus pestañas y su orden; esta guía nunca los cambia por ti.'; + + @override + String get tourPlayerLayoutTitle => 'Un reproductor a tu medida'; + + @override + String get tourLayoutBody => + 'Explora Diseño del reproductor para elegir su apariencia y las acciones que muestra. Los cambios son opcionales y tú decides cuáles hacer.'; + + @override + String get tourOutputTitle => 'Conoce tu salida de audio'; + + @override + String get tourOutputBody => + 'Los ajustes de audio muestran las rutas de salida disponibles. La compatibilidad con DAC USB y audio de alta resolución del dispositivo depende del hardware conectado. Esta guía no activa ningún modo ni garantiza una salida bit-perfect; revisa el indicador de salida del reproductor.'; + + @override + String get tourDspTitle => 'Ajusta el sonido con intención'; + + @override + String get tourDspBody => + 'El ecualizador y las demás herramientas DSP son opcionales. El procesamiento modifica la señal y puede impedir una salida bit-perfect. Explora los controles sin activar nada y consulta el manual antes de cambiar la ruta de audio.'; + + @override + String get tourNotNow => 'Ahora no'; + + @override + String get tourEnd => 'Terminar recorrido'; + + @override + String get tourStart => 'Iniciar recorrido'; + + @override + String get tourContinue => 'Continuar'; + + @override + String get tourUseCurrent => 'Usar la canción actual'; + + @override + String get tourReadMore => 'Leer esto en el manual'; + + @override + String get tourOpenNavigation => 'Abrir ajustes de navegación'; + + @override + String get tourOpenLayout => 'Abrir Diseño del reproductor'; + + @override + String get tourOpenAudio => 'Abrir ajustes de audio'; + + @override + String get tourActionConfirmed => 'Listo. Vamos al siguiente paso.'; + + @override + String get tourUnavailable => + '¿No ves el control? Puedes continuar o consultar el manual más abajo.'; + + @override + String get filipinoDonationNote => 'Gracias por apoyar a Flick.'; + + @override + String get playingLabel => 'Reproduciendo'; + + @override + String get aDraggableOverlayShowsWhileUsing => + 'Una ventana flotante que puedes mover aparece mientras usas otras apps.'; + + @override + String get aLittleRecordOfWhatStayed => + 'Un pequeño registro de lo que no dejaste de escuchar.'; + + @override + String get aNewerFlickBuildIsOn => + 'Hay una versión más reciente de Flick en Play Store.'; + + @override + String get aPlaylistWithThisNameAlready => + 'Ya existe una lista de reproducción con ese nombre'; + + @override + String get aPremiumMusicPlayerWithCustom => + 'Reproductor de música prémium con UAC 2.0 personalizado, desarrollado con Rust para ofrecer la mejor experiencia de audio.'; + + @override + String get aSmoothContinuousWaveAcrossFrequencies => + 'Una onda continua y fluida a través de las frecuencias'; + + @override + String get aSongWithALongTitle => + 'Una canción con un título largo para la vista previa'; + + @override + String get aSwipeGestureWhenConfigured => + 'Un gesto de deslizamiento (si está configurado) activa un visualizador integrado en el minirreproductor.'; + + @override + String get aTighterMixOfFavoritesAnd => + 'Una mezcla más equilibrada de tus favoritos y de las canciones a las que siempre vuelves.'; + + @override + String get aWeekAndCountingYourDedication => + 'Una semana y seguimos: se nota tu dedicación.'; + + @override + String get aaudio => 'AAudio'; + + @override + String get aaudioAndroid81 => 'AAudio (Android 8.1+)'; + + @override + String get aaudioWithOpenslEsFallbackDefault => + 'AAudio con alternativa OpenSL ES (predeterminada)'; + + @override + String get about => 'Acerca de'; + + @override + String get aboutFlickPlayer => 'Acerca de Flick Player'; + + @override + String get aboutThisAlbum => 'Acerca de este álbum'; + + @override + String get aboutThem => 'Acerca del artista'; + + @override + String get absoluteVolumeSync => 'Sincronización del volumen absoluto'; + + @override + String get accentColor => 'Color de acento'; + + @override + String get accuraterip => 'AccurateRip'; + + @override + String achieved(Object arg1) { + return 'Logrado: $arg1'; + } + + @override + String get achievementUnlocked => 'LOGRO DESBLOQUEADO'; + + @override + String get activateFallback => 'Activar alternativa'; + + @override + String get active => 'Activo'; + + @override + String activeBands(Object activeCount) { + return '$activeCount bandas activas'; + } + + @override + String get activeDays => 'Días con actividad'; + + @override + String get activeQueue => 'Cola actual'; + + @override + String get adaptive => 'Adaptativo'; + + @override + String get add => 'Agregar'; + + @override + String get addAMusicFolderInSettings => + 'Agrega una carpeta de música en Ajustes'; + + @override + String get addANextTrackButton => 'Agrega un botón de siguiente pista'; + + @override + String get addAPreviousTrackButton => 'Agrega un botón de pista anterior'; + + @override + String get addAtLeastOneLyricLine => + 'Primero, agrega al menos una línea de letra.'; + + @override + String get addDescription => 'Agregar descripción'; + + @override + String get addDescription2 => 'Agregar descripción'; + + @override + String get addMusicFolder => 'Agregar carpeta de música'; + + @override + String get addMusicFoldersInSettings => + 'Agrega carpetas de música en Ajustes'; + + @override + String get addMusicWithAlbumTagsTo => + 'Agrega música con etiquetas de álbum para ver los álbumes aquí'; + + @override + String get addMusicWithArtistTagsTo => + 'Agrega música con etiquetas de artista para verlos aquí'; + + @override + String get addServer => 'Agregar servidor'; + + @override + String get addSongsFromThePlayerMenu => + 'Agrega canciones desde el menú del reproductor'; + + @override + String get addSongsFromThePlayerOr => + 'Agrega canciones desde el menú del reproductor o desde el menú de acciones de una canción.'; + + @override + String addSongsToPlaylist(Object arg1) { + return 'Agregar $arg1 canciones a la lista de reproducción'; + } + + @override + String addSongsToPlaylist2(Object arg1) { + return 'Agregar $arg1 canciones a la lista de reproducción'; + } + + @override + String get addTheSearchTabVia => + 'Agrega la pestaña Buscar desde Ajustes de la barra inferior: mantén presionada la barra de navegación.'; + + @override + String get addToFavorites => 'Agregar a favoritos'; + + @override + String get addToFavorites2 => 'Agregar a favoritos'; + + @override + String get addToPlaylist => 'Agregar a la lista de reproducción'; + + @override + String get addToPlaylist2 => 'Agregar a la lista de reproducción'; + + @override + String get addToQueue => 'Agregar a la cola'; + + @override + String get addToQueue2 => 'Agregar a la cola'; + + @override + String addedSongsTo(Object arg1, Object arg2) { + return 'Se agregaron $arg1 canciones a «$arg2»'; + } + + @override + String addedSongsTo2(Object arg1, Object playlistName) { + return 'Se agregaron $arg1 canciones a $playlistName'; + } + + @override + String addedSongsToFavorites(Object arg1) { + return 'Se agregaron $arg1 canciones a favoritos'; + } + + @override + String addedSongsToFavorites3(Object arg1) { + return 'Se agregaron $arg1 canciones a favoritos'; + } + + @override + String addedTo(Object arg1) { + return 'Se agregó a $arg1'; + } + + @override + String addedTo2(Object arg1) { + return 'Se agregó a «$arg1»'; + } + + @override + String get addedToFavorites => 'Se agregó a favoritos'; + + @override + String addedToFavorites2(Object arg1) { + return 'Se agregó «$arg1» a favoritos'; + } + + @override + String get addingFavorites => 'Agregando a favoritos'; + + @override + String get addingTheWidget => 'Agregando el widget'; + + @override + String get addsPreDriveAndCatchesPeaks => + 'Añade ganancia previa y controla los picos para respetar un límite máximo de salida.'; + + @override + String get adjustAudioFrequencies => 'Ajustar las frecuencias de audio'; + + @override + String get adjustMetadataTextSizeInArtwork => + 'Ajusta el tamaño del texto de los metadatos en el modo de tarjeta con ilustración'; + + @override + String get adjustMetadataTextSizeInImmersive => + 'Ajusta el tamaño del texto de los metadatos en el modo inmersivo'; + + @override + String get adjustPlaybackSpeed05x => + 'Ajusta la velocidad de reproducción (0.5x–2x) desde el control de velocidad. Se conserva el tono.'; + + @override + String get adjustSpacingBetweenButtons => + 'Ajustar el espacio entre los botones'; + + @override + String get adjustTheMiniPlayerSurface => + 'Ajustar la superficie del minirreproductor'; + + @override + String get adjustTheSizeOfTheBottom => + 'Ajustar el tamaño de la barra inferior'; + + @override + String get adjustTheSizeOfTheIcons => 'Ajustar el tamaño de los íconos'; + + @override + String get adjustTheWidthOfTheBottom => + 'Ajusta el ancho de la barra hacia adentro desde los márgenes laterales habituales'; + + @override + String get advanceToARandomCategory => 'Avanzar a una categoría aleatoria'; + + @override + String get advanceToTheNextCategoryAlphabetically => + 'Avanzar a la siguiente categoría en orden alfabético'; + + @override + String get advanceToTheNextMostRecently => + 'Avanzar a la categoría agregada más recientemente'; + + @override + String get advanced => 'Avanzado'; + + @override + String get advancedMode => 'Modo avanzado'; + + @override + String get afterHours => 'A altas horas'; + + @override + String get afterScanningMatchFilesWithMissing => + 'Después de escanear, busca en Apple Music coincidencias para los archivos sin etiquetas. Solo las coincidencias seguras se aplican automáticamente.'; + + @override + String get air => 'Aire'; + + @override + String get alacAudio => 'Audio ALAC'; + + @override + String alacBit(Object arg1) { + return 'ALAC de $arg1 bits'; + } + + @override + String get album => 'Álbum'; + + @override + String get albumArt => 'Portada del álbum'; + + @override + String get albumArt2 => 'Portada del álbum'; + + @override + String get albumArtImport => 'Importar portada del álbum'; + + @override + String get albumArtist => 'Artista del álbum'; + + @override + String get albumArtists => 'Artistas del álbum'; + + @override + String get albumArtwork => 'Portada del álbum'; + + @override + String get albumColors => 'Colores del álbum'; + + @override + String get albumComplete => 'Álbum completo (según las etiquetas)'; + + @override + String get albumCompleteExplanation => + 'Según las etiquetas integradas, tu biblioteca incluye todas las pistas y discos esperados.'; + + @override + String get albumCompleteShort => 'Completo'; + + @override + String get albumCompleteTitle => 'Álbum completo'; + + @override + String get albumCompleteVerificationNote => + 'Verificado con las etiquetas de los archivos, no con una lista de canciones en línea.'; + + @override + String get albumCompletenessUnknown => + 'No se puede verificar si el álbum está completo con las etiquetas de las pistas.'; + + @override + String get albumCount => 'Cantidad de álbumes'; + + @override + String get albumDetail => 'Detalles del álbum'; + + @override + String get albumIncompleteShort => 'Incompleto'; + + @override + String get albumLimit => 'LÍMITE DE ÁLBUMES'; + + @override + String albumMissingDiscNumbers(String numbers) { + return 'Números de disco faltantes: $numbers'; + } + + @override + String albumMissingDiscs(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Faltan $count discos', + one: 'Falta 1 disco', + ); + return '$_temp0'; + } + + @override + String albumMissingPositions(String positions) { + return 'Posiciones faltantes (disco:pista): $positions'; + } + + @override + String albumMissingTrackNumbers(String numbers) { + return 'Números de pista faltantes: $numbers'; + } + + @override + String albumMissingTracks(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Faltan $count pistas', + one: 'Falta 1 pista', + ); + return '$_temp0'; + } + + @override + String get albumName => 'Nombre del álbum'; + + @override + String get albumOptions => 'Opciones del álbum'; + + @override + String get albums => 'Álbumes'; + + @override + String albums2(Object arg1) { + return '$arg1 álbumes'; + } + + @override + String albums3(Object _totalAlbums) { + return '$_totalAlbums álbumes'; + } + + @override + String get albumsAppearAsAGrid => + 'Los álbumes aparecen en una cuadrícula con sus portadas. Toca cualquiera para abrir sus detalles y ver la lista completa de canciones.'; + + @override + String get albumsShownPerPage => 'Álbumes por página'; + + @override + String albumsSongs(Object arg1, Object arg2) { + return '$arg1 álbumes • $arg2 canciones'; + } + + @override + String get alignLyricTextToTheCenter => 'Centrar el texto de las letras'; + + @override + String get alignLyricTextToTheLeft => + 'Alinear el texto de las letras a la izquierda'; + + @override + String get alignLyricTextToTheRight => + 'Alinear el texto de las letras a la derecha'; + + @override + String get all => 'Todo'; + + @override + String get allArtists => 'Todos los artistas'; + + @override + String get allClearNoDuplicates => + 'Todo en orden: no se encontraron duplicados.'; + + @override + String get allDataIsStoredLocallyOn => + 'Todos los datos se guardan únicamente en tu dispositivo: metadatos de la biblioteca de música, historial de reproducción, listas, preajustes del ecualizador y preferencias de la app. Las credenciales de Last.fm se guardan de forma segura en el dispositivo. Estos datos nunca salen de tu dispositivo, salvo que uses una integración de forma explícita.'; + + @override + String get allFavoritedTracksInOne => + 'Todas tus canciones favoritas en un solo lugar. Reprodúcelas, mézclalas o adminístralas desde aquí.'; + + @override + String get allFolders => 'Todas las carpetas'; + + @override + String get allFormats => 'Todos los formatos'; + + @override + String get allFrequenciesEqually => 'Todas las frecuencias por igual'; + + @override + String get allPass => 'Pasa todo'; + + @override + String get allResultsAreHiddenByActive => + 'Los filtros activos ocultan todos los resultados.'; + + @override + String get allSongs => 'Todas las canciones'; + + @override + String get allWordsStamped => 'Todas las palabras sincronizadas'; + + @override + String get allowFlickToRunWithoutAggressive => + 'Permite que Flick se ejecute sin restricciones agresivas en segundo plano para que sigan funcionando los nuevos escaneos y las funciones en segundo plano'; + + @override + String get allowed => 'Permitido'; + + @override + String get alphabetical => 'Alfabético'; + + @override + String get alphabeticalIndexRailOnTheSongs => + 'Índice alfabético en la pantalla de canciones'; + + @override + String get alsoRespectsYourSystemTextSize => + 'También respeta el tamaño de texto del sistema'; + + @override + String alt(Object arg1) { + return 'Alt $arg1'; + } + + @override + String get amber => 'Ámbar'; + + @override + String get analyzeLoudnessAndWriteReplaygainTags => + 'Analizar el volumen y escribir etiquetas ReplayGain en todas las canciones'; + + @override + String get analyzingAudio => 'Analizando el audio'; + + @override + String get analyzingLoudness => 'Analizando el volumen'; + + @override + String get andArtwork => ' y la portada'; + + @override + String andMoreInRotation(Object arg1) { + return '$arg1 y más en rotación'; + } + + @override + String get android => 'Android'; + + @override + String get androidAudioApi => 'API de audio de Android'; + + @override + String get androidBlockedWritingToThisFile => + 'Android bloqueó la escritura en este archivo. Quita la carpeta desde Ajustes y vuelve a agregarla para conceder acceso de edición; luego inténtalo de nuevo.'; + + @override + String get androidDeveloperOptionsTheReliableWay => + 'Opciones para desarrolladores de Android: la forma confiable de cambiar el códec (forzarlo desde la app usa una API del sistema oculta que Android estándar bloquea)'; + + @override + String get androidDidNotReturnGalleryPath => + 'Android no devolvió la ruta de la galería para la imagen guardada.'; + + @override + String get androidDockRoute => 'Ruta de audio de la base de Android'; + + @override + String get androidManagedRustPlaybackPathUsing => + 'Ruta de reproducción administrada por Android con el motor Rust nativo Oboe.'; + + @override + String get androidUsbRoute => 'Ruta de audio USB de Android'; + + @override + String get animatedAlbumArt => 'Portada animada del álbum'; + + @override + String get animationStyle => 'Estilo de animación'; + + @override + String get animationStyleAndFrequencyFocus => + 'Estilo de animación y enfoque de frecuencias'; + + @override + String get animations => 'Animaciones'; + + @override + String get animationsAndHapticFeedback => 'Animaciones y respuesta háptica'; + + @override + String get animationsAndHapticFeedbackToggles => + 'Activar o desactivar las animaciones y la respuesta háptica.'; + + @override + String get apiKey => 'Clave de API'; + + @override + String get appInfo => 'Información de la app'; + + @override + String get appTitle => 'Flick Player'; + + @override + String get appearance => 'Apariencia'; + + @override + String get appearsInTheOverflowMenu => 'Aparece en el menú Más opciones'; + + @override + String get appleMusicDataUnavailable => 'Datos de Apple Music no disponibles'; + + @override + String get appleMusicDataUpdated => 'Datos de Apple Music actualizados'; + + @override + String get appleMusicLookupFailedCheckYour => + 'No se pudo buscar en Apple Music. Comprueba tu conexión.'; + + @override + String get appleMusicMotionArtOnAlbums => + 'Portadas animadas de Apple Music en los álbumes, además de desplazamiento y zoom, brillo ambiental y transiciones suaves en las imágenes destacadas'; + + @override + String appliedAutoeqFor(Object arg1) { + return 'Se aplicó AutoEQ para $arg1'; + } + + @override + String get apply => 'Aplicar'; + + @override + String apply2(Object arg1) { + return 'Aplicar $arg1'; + } + + @override + String get applySelected => 'Aplicar selección'; + + @override + String applyTo(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return 'Aplicar a $_temp0'; + } + + @override + String get applyingNewAudioEngine => 'Aplicando el nuevo motor de audio…'; + + @override + String get apr => 'abr'; + + @override + String get aptxAdaptive => 'aptX Adaptive'; + + @override + String get aptxHd => 'aptX HD'; + + @override + String get areYouSureYouWantTo => + '¿Seguro que quieres eliminar esta lista de reproducción?'; + + @override + String get areYouSureYouWantTo2 => + '¿Seguro que quieres borrar todo el historial de escucha? Esta acción no se puede deshacer.'; + + @override + String get areYouSureYouWantTo3 => + '¿Seguro que quieres restablecer todas las preferencias de UAC2? Esta acción no se puede deshacer.'; + + @override + String get artResolution => 'Resolución de la portada'; + + @override + String get artist => 'Artista'; + + @override + String get artistDetail => 'Detalles del artista'; + + @override + String get artistIsNotAvailableForThis => + 'Este artista no está disponible para esta canción'; + + @override + String get artistList => 'Lista de artistas'; + + @override + String get artistName => 'Nombre del artista'; + + @override + String artistUnit(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'artistas', + one: 'artista', + ); + return '$_temp0'; + } + + @override + String get artists => 'Artistas'; + + @override + String artists2(Object arg1) { + return '$arg1 artistas'; + } + + @override + String get artistsInRotation => 'Artistas en rotación'; + + @override + String get artwork => 'Ilustración'; + + @override + String get artworkCacheCleared => 'Se vació la caché de portadas'; + + @override + String get artworkCard => 'Tarjeta con portada'; + + @override + String artworkLookupFailed(int status) { + return 'No se pudo obtener la portada (HTTP $status).'; + } + + @override + String get artworkLookupInvalidData => + 'La búsqueda de portada devolvió datos no válidos.'; + + @override + String get artworkLookupTemporarilyUnavailable => + 'La búsqueda de portada no está disponible temporalmente.'; + + @override + String get artworkPlacement => 'Ubicación de la portada'; + + @override + String get artworkPlacement2 => 'Ubicación de la portada'; + + @override + String get artworkSize => 'Tamaño de la portada'; + + @override + String get artworkSize2 => 'Tamaño de la portada'; + + @override + String get asmrDreams => 'ASMR Dreams'; + + @override + String atKhzBit(Object arg1, Object arg2) { + return ' a $arg1 kHz/$arg2 bits'; + } + + @override + String get atLeastOneVersionMustStay => 'Debe quedar al menos una versión.'; + + @override + String get attack => 'Ataque'; + + @override + String get audio => 'Audio'; + + @override + String get audioFocus => 'Enfoque de audio'; + + @override + String get audioFormat => 'Formato de audio'; + + @override + String get audioFormatIsDisabled => 'El formato de audio está desactivado'; + + @override + String get audioSignalPath => 'Ruta de señal de audio'; + + @override + String get audioTestingEquipment => 'Equipo de pruebas de audio'; + + @override + String get aug => 'ago'; + + @override + String get auroraSounds => 'Aurora Sounds'; + + @override + String get authenticationResponseMissingToken => + 'Falta el token en la respuesta de autenticación'; + + @override + String get auto => 'Automático'; + + @override + String get autoAdvance => 'Avance automático'; + + @override + String get autoBeMsbDefaultOnlyChange => + 'Automático: BE-MSB predeterminado; cámbialo solo si el DSD nativo produce un siseo'; + + @override + String get autoBitPerfectForUsbDacs => 'Bit perfecto automático para DAC USB'; + + @override + String get autoCollapse => 'Contraer automáticamente'; + + @override + String get autoFill => 'Completar automáticamente'; + + @override + String get autoFocusSearch => 'Enfocar automáticamente la búsqueda'; + + @override + String get autoFullView => 'Vista completa automática'; + + @override + String get autoHideTimeout => 'Tiempo antes de ocultarse automáticamente'; + + @override + String get autoIdentifyUntaggedAlbums => + 'Identificar automáticamente álbumes sin etiquetas'; + + @override + String get autoNativeDsdOnDapsDop => + 'Automático: DSD nativo en reproductores de audio digital (DAP), DoP para DAC USB y PCM en los demás casos'; + + @override + String get autoReconnect => 'Reconexión automática'; + + @override + String get autoShowFullViewAfterInactivity => + 'Mostrar automáticamente la vista completa tras un periodo de inactividad'; + + @override + String get autoShowTheSpotifyStyleImmersive => + 'Mostrar automáticamente la vista completa inmersiva estilo Spotify tras un periodo de inactividad'; + + @override + String get autoU8ByteInterleavedRecommended => + 'Automático: U8 intercalado por bytes (recomendado)'; + + @override + String get autoeqHeadphones => 'Audífonos AutoEQ'; + + @override + String get autoeqHeadphones2 => 'Audífonos AutoEQ'; + + @override + String get automatic => 'Automático'; + + @override + String get automaticUpdateChecks => 'Buscar actualizaciones automáticamente'; + + @override + String get automaticallyOpenKeyboardWhenSwitchingTo => + 'Abrir automáticamente el teclado al cambiar a la búsqueda'; + + @override + String get autoplayOnQueueEnd => + 'Reproducción automática al final de la cola'; + + @override + String get availableDevices => 'Dispositivos disponibles'; + + @override + String b(Object arg1) { + return 'B$arg1'; + } + + @override + String get back => 'Atrás'; + + @override + String get backOnline => 'De nuevo en línea'; + + @override + String get backToLocker => 'Volver a Locker'; + + @override + String get backToReplay => 'Volver a Replay'; + + @override + String get backend => 'Motor'; + + @override + String get background => 'Fondo'; + + @override + String get blurGradient => 'Degradado difuminado'; + + @override + String get colorGradient => 'Degradado de color'; + + @override + String get backgroundOpacity => 'Opacidad del fondo'; + + @override + String get backgroundPlaybackAnchor => + 'Anclaje de reproducción en segundo plano'; + + @override + String get balance => 'Balance'; + + @override + String balance2(Object arg1) { + return 'Balance $arg1'; + } + + @override + String get balanceTempoDampFilterDelaysSize => + 'Controles de balance, tempo, amortiguación, filtro, retardo, tamaño, mezcla y expansión adicional.'; + + @override + String get balancedQualityAndStability => + 'Equilibrio entre calidad y estabilidad'; + + @override + String get band => 'Banda'; + + @override + String get bandControls => 'Controles de banda'; + + @override + String get bandEditors => 'Editores de banda'; + + @override + String get bandPass => 'Filtro pasa banda'; + + @override + String bandU2022(Object arg1, Object arg2) { + return 'Banda $arg1 • $arg2'; + } + + @override + String bands(Object arg1) { + return '$arg1/31 bandas'; + } + + @override + String bandsActive(Object activeCount, Object arg1) { + return '$activeCount/$arg1 bandas activas'; + } + + @override + String bandsAdjusted(Object adjustedBands) { + return '$adjustedBands bandas ajustadas'; + } + + @override + String bandsAdjusted2(Object adjustedCount, Object arg1) { + return '$adjustedCount/$arg1 bandas ajustadas'; + } + + @override + String bandsPreampDb(Object arg1, Object arg2, Object arg3) { + return '$arg1 bandas · preamplificación $arg2 dB · $arg3'; + } + + @override + String get barHeight => 'Altura de la barra'; + + @override + String get bars => 'Barras'; + + @override + String get baseAlbumArtSizeForEach => + 'Tamaño base de la portada para cada tarjeta de canción'; + + @override + String get bass => 'Graves'; + + @override + String get bassMidTreble => 'Graves, medios y agudos'; + + @override + String get bassTreble => 'Graves + agudos'; + + @override + String battery(Object battery) { + return '$battery% de batería'; + } + + @override + String get baybayinHeadings => 'Etiquetas en baybayin'; + + @override + String get baybayinHeadingsDescription => + 'Experimental: encabezados seleccionados, accesos directos para explorar y etiquetas de navegación. Las etiquetas de accesibilidad se mantienen en alfabeto latino.'; + + @override + String get baybayinPilotDescription => + 'Mezcla de tagalo e inglés. Texto preliminar para revisión.'; + + @override + String get beLsbBigEndianSubslotLsb => + 'BE-LSB: subranura en orden big-endian, primero el bit menos significativo'; + + @override + String get beMsbBigEndianSubslotMsb => + 'BE-MSB: subranura en orden big-endian, primero el bit más significativo (predeterminado)'; + + @override + String get beMsbPackingTheDefaultWire => + 'Empaquetado BE-MSB: convención predeterminada de transmisión'; + + @override + String get besideTheSong => 'Junto a la canción'; + + @override + String get bigEndian32BitSubslotMsb => + 'Subranura de 32 bits en orden big-endian, primero el bit más significativo'; + + @override + String get bigEndianSubslotLsbFirstBit => + 'Subranura en orden big-endian, primero el bit menos significativo (bits invertidos)'; + + @override + String bit(Object depth) { + return '$depth bits'; + } + + @override + String get bitDepth => 'Profundidad de bits'; + + @override + String get bitDepth2 => 'Profundidad de bits'; + + @override + String get bitDepths => 'Profundidades de bits'; + + @override + String get bitPerfect => 'BIT PERFECTO'; + + @override + String get bitPerfect2 => 'Bit perfecto'; + + @override + String get bitPerfectCapsule => 'Cápsula de bit perfecto'; + + @override + String get bitPerfectDapInternal => 'Bit perfecto (interno del DAP)'; + + @override + String get bitPerfectDapInternalDisabledSoftware => + 'Bit perfecto (interno del DAP) desactivado: hay efectos de software activos.'; + + @override + String get bitPerfectDapInternalEnabledAll => + 'Bit perfecto (interno del DAP) activado: se omitieron todos los procesos DSP.'; + + @override + String get bitPerfectEnabledParametricEqIs => + 'Bit perfecto activado: el ecualizador paramétrico se omite en la conexión USB directa. Reinicia la app para aplicar los cambios de reproducción.'; + + @override + String get bitPerfectUsbDac => 'Bit perfecto (DAC USB)'; + + @override + String get bitPerfectUsbDacCouldNot => + 'No se pudo activar el modo bit perfecto (DAC USB). Consulta los diagnósticos USB para conocer el motivo.'; + + @override + String bitPerfectUsbDacCouldNot2(Object arg1) { + return 'No se pudo activar el modo bit perfecto (DAC USB) para $arg1. Consulta los diagnósticos USB.'; + } + + @override + String bitPerfectUsbDacEnabledFor(Object arg1) { + return 'Se activó el modo bit perfecto (DAC USB) para $arg1.'; + } + + @override + String get bitPerfectVerified => 'Bit perfecto verificado'; + + @override + String get bitSubslotsLlRrPer => 'Subranuras de 16 bits: LL|RR por trama'; + + @override + String get bitSubslotsLlllRrrrPer => + 'Subranuras de 32 bits: LLLL|RRRR por trama (heredado)'; + + @override + String get bitrateAdjustsToSignalQuality => + 'La tasa de bits se ajusta a la calidad de la señal'; + + @override + String get blocked => 'Bloqueado'; + + @override + String get blue => 'Azul'; + + @override + String get bluetooth => 'Bluetooth'; + + @override + String get bluetoothCodecInfo => 'Información del códec Bluetooth'; + + @override + String get bluetoothOutput => 'Salida Bluetooth'; + + @override + String get boldSaturatedColorsFromAlbumArt => + 'Colores intensos y saturados de la portada del álbum.'; + + @override + String get boostBeyond100UpTo200 => + 'Aumentar por encima del 100 % (hasta el 200 %)'; + + @override + String get border => 'Borde'; + + @override + String get bothBitPerfectOptionsAreOff => + 'Las dos opciones de bit perfecto están desactivadas en este DAP, así que el motor estándar no está disponible. Aún puedes usar Rust con Oboe o USB isócrono.'; + + @override + String get bottom => 'Abajo'; + + @override + String get bottomBar => 'Barra inferior'; + + @override + String get bottomBarAlwaysVisible => 'Barra inferior siempre visible'; + + @override + String get bottomBarWidth => 'Ancho de la barra inferior'; + + @override + String get bouncy => 'Elástico'; + + @override + String get browseAllArtistsInYour => + 'Explora todos los artistas de tu biblioteca. Toca un artista para ver sus álbumes y canciones.'; + + @override + String get browseByArtworkOpenAnyAlbum => + 'Explora las portadas, abre cualquier álbum y ve directamente a la lista de canciones.'; + + @override + String get browseByFolder => 'Explorar por carpeta'; + + @override + String get browseMore => 'Explorar más'; + + @override + String get browseTheFullControlsGuide => + 'Consulta la guía completa de controles'; + + @override + String get browseYourArtistLibrary => 'Explora la biblioteca de artistas'; + + @override + String get browseYourArtistsExploreTheirDiscographies => + 'Explora tus artistas, descubre su discografía y reproduce sus canciones.'; + + @override + String get browsingYourLibrary => 'Explorando tu biblioteca'; + + @override + String get buffer => 'Búfer'; + + @override + String build(Object kAppVersion, Object kAppBuild) { + return '$kAppVersion (compilación $kAppBuild)'; + } + + @override + String get buildFlavor => 'Variante de compilación'; + + @override + String get buildFlavorFull => 'full: versión para descarga directa'; + + @override + String get buildFlavorPlay => 'play: versión de Google Play'; + + @override + String get buildingYourMusicHome => 'Preparando tu espacio musical'; + + @override + String get builtIn => 'Integrado'; + + @override + String get buttonSpacing => 'Espacio entre botones'; + + @override + String get buttons => 'Botones'; + + @override + String get buyMeACoffee => 'Cómprame un café'; + + @override + String by(Object arg1, Object arg2) { + return '«$arg1» de $arg2'; + } + + @override + String get bypassAllDspEqDynamicsCrossfade => + 'Omitir todo el procesamiento DSP (ecualizador, dinámica, fundido cruzado y velocidad) en la ruta interna de alta resolución del DAP nativo. Desactívalo para usar efectos de software. Esto también se desactiva al apagar Bit perfecto (DAC USB).'; + + @override + String get byteInterleavedLrlrStream => 'Intercalado por bytes: flujo LRLR'; + + @override + String get cacheWaveformsAndLoudnessForAll => + 'Guardar en caché las formas de onda y el volumen de todas las canciones'; + + @override + String cachedAlbumArtWillBeRemoved(Object arg1) { + return 'Se eliminarán las portadas en caché ($arg1). Se volverán a cargar automáticamente mientras exploras.'; + } + + @override + String cachedWavConversionsWillBeRemoved(Object size) { + return 'Se eliminarán las conversiones WAV en caché ($size). Los archivos volverán a convertirse la próxima vez que se reproduzcan.'; + } + + @override + String get calculatingSize => 'Calculando el tamaño…'; + + @override + String get calmFrequencies => 'Frecuencias suaves'; + + @override + String get camera => 'Cámara'; + + @override + String get cameraAccessIsNeededYouCan => + 'Se necesita acceso a la cámara. Puedes activarlo en los ajustes de Android.'; + + @override + String get cameraAndPhotoLibraryAccessIs => + 'El acceso a la cámara y a la biblioteca de fotos se usa únicamente para la función Flick Replay, que permite crear fondos personalizados para los pósteres del resumen de escucha. Las fotos solo se usan cuando lo solicitas y permanecen en tu dispositivo. No se suben ni se transmiten imágenes.'; + + @override + String get cameraAndPhotos => 'Cámara y fotos'; + + @override + String get cancel => 'Cancelar'; + + @override + String get capAt60hzBalancedSmoothnessAnd => + 'Limitar a 60 Hz: equilibrio entre fluidez y batería'; + + @override + String capMs(Object arg1) { + return 'límite $arg1 ms'; + } + + @override + String get capabilities => 'Capacidades'; + + @override + String get capabilitiesNotAvailable => 'Capacidades no disponibles'; + + @override + String get capabilityState => 'Estado de las capacidades'; + + @override + String get cardSize => 'Tamaño de tarjeta'; + + @override + String get cardWidth => 'Ancho de tarjeta'; + + @override + String get cast => 'Transmitir'; + + @override + String get casting => 'Transmitiendo'; + + @override + String get castingTapToManage => 'Transmitiendo: toca para administrar'; + + @override + String castingTo(Object deviceName) { + return 'Transmitiendo a $deviceName'; + } + + @override + String castingTo2(Object arg1) { + return 'Transmitiendo a $arg1'; + } + + @override + String get categories => 'Categorías'; + + @override + String get ceiling => 'Límite máximo'; + + @override + String get center => 'Centro'; + + @override + String get centerTheTitleAndInfoIn => + 'Centrar el título y la información en el encabezado de detalles'; + + @override + String get centeredHeaderTitle => 'Título centrado en el encabezado'; + + @override + String get centeredWidensToFitYourControls => + 'Centrado; se amplía para dar cabida a los controles'; + + @override + String get centralTransportControlsPreviousRestarts => + 'Controles de reproducción centrales. El botón Anterior reinicia la pista si ya pasaron más de 3 segundos.'; + + @override + String ch(Object channels) { + return '$channels canales'; + } + + @override + String ch2(Object ch) { + return '$ch canales'; + } + + @override + String ch3(Object arg1, Object arg2) { + return '$arg1 / $arg2 canales'; + } + + @override + String get changeCover => 'Cambiar portada'; + + @override + String get changingSampleRateBitDepthOr => + 'Cambiar la frecuencia de muestreo, la profundidad de bits o el manejo de canales puede remuestrear las canciones y afectar la calidad de reproducción, el tono, la velocidad o la estabilidad en algunos dispositivos.'; + + @override + String get channels => 'Canales'; + + @override + String channels2(Object arg1) { + return '$arg1 canales'; + } + + @override + String channels3(Object ch) { + return '$ch canales'; + } + + @override + String get checkAgain => 'Volver a comprobar'; + + @override + String get checkTheVersionsYouWantTo => + 'Marca las versiones que quieres conservar; las que no marques se eliminarán de tu biblioteca. Debe quedar al menos una.'; + + @override + String get checkVersionsToKeepUncheckedWill => + 'Marca las versiones que quieres conservar; las demás se eliminarán'; + + @override + String get checking => 'Comprobando…'; + + @override + String get checkingForUpdates => 'Buscando actualizaciones'; + + @override + String get checkingForUpdates2 => 'Buscando actualizaciones…'; + + @override + String get childrenSPrivacy => 'Privacidad de los menores'; + + @override + String get chooseAction => 'Elegir acción'; + + @override + String get chooseAudioEngine => 'Elegir motor de audio'; + + @override + String get chooseFromBuiltInPresets => + 'Elige entre los preajustes integrados (Normal, refuerzo de graves, refuerzo de agudos, voz, etc.) o guarda uno propio.'; + + @override + String get chooseLocationU2026 => 'Elegir ubicación…'; + + @override + String get chooseWhichToKeep => 'Elegir cuáles conservar'; + + @override + String get chromecast => 'Chromecast'; + + @override + String get circularDotsRadiusFollowsAmplitude => + 'Puntos circulares: el radio sigue la amplitud'; + + @override + String get cityBeats => 'City Beats'; + + @override + String get claimedByFlick => 'Reclamado por Flick'; + + @override + String get cleanStraightLineWithPrecisionScrubbing => + 'Línea recta y limpia con desplazamiento preciso.'; + + @override + String get clear => 'Borrar'; + + @override + String get clearAll => 'Borrar todo'; + + @override + String get clearAllUac2Settings => 'Borrar todos los ajustes de UAC2'; + + @override + String get clearArtworkCache => '¿Borrar la caché de portadas?'; + + @override + String get clearArtworkCache2 => 'Borrar la caché de portadas'; + + @override + String get clearConvertedAudio => 'Borrar el audio convertido'; + + @override + String get clearConvertedAudioCache => + '¿Borrar la caché de audio convertido?'; + + @override + String get clearFilters => 'Borrar filtros'; + + @override + String get clearHistory => 'Borrar historial'; + + @override + String get clearLogs => '¿Borrar los registros?'; + + @override + String get clearTheCounterAndAnyUnlocked => + 'Borrar el contador y los hitos de racha que ya se desbloquearon'; + + @override + String get clearWord => 'Borrar palabra'; + + @override + String get clearWords => 'Borrar palabras'; + + @override + String get clearing => 'Borrando…'; + + @override + String get close => 'Cerrar'; + + @override + String get closePreview => 'Cerrar vista previa'; + + @override + String codecApplied(Object arg1) { + return 'Códec aplicado: $arg1'; + } + + @override + String get codecControl => 'Control del códec'; + + @override + String get codecForcingUnavailableOnThisDevice => + 'No se puede forzar el códec en este dispositivo. Cámbialo en Opciones para desarrolladores → Códec de audio Bluetooth.'; + + @override + String get codecInfo => 'Información del códec'; + + @override + String get codecU0026Audio => 'Códec y audio'; + + @override + String get collapseAfter => 'Contraer después de'; + + @override + String get collapsed => 'Contraído'; + + @override + String get collection => 'Colección'; + + @override + String get color => 'Color'; + + @override + String get comingSoon => 'Muy pronto'; + + @override + String get compatibility => 'Compatibilidad'; + + @override + String get compatibleWithPowerampEq => 'Compatible con Poweramp EQ'; + + @override + String get completelyHiddenFromTheBottomBar => + 'Completamente oculta en la barra inferior'; + + @override + String get compressor => 'Compresor'; + + @override + String get compressorOff => 'Compresor desactivado'; + + @override + String get compressorOn => 'Compresor activado'; + + @override + String get configureDefaultStyleAndSensitivity => + 'Configura el estilo predeterminado y la sensibilidad en Ajustes → Visualizador.'; + + @override + String get configureLyricsSavingAndFetching => + 'Configura cómo se guardan y buscan las letras.'; + + @override + String get configureSwipeBehaviorInSettings => + 'Configura el gesto de deslizamiento en Ajustes → Diseño del reproductor → Deslizamiento del minirreproductor.'; + + @override + String get configureUsbDacAmpDevices => + 'Configurar dispositivos DAC/amplificadores USB'; + + @override + String get configureWidgetAppearanceAndShown => + 'Configura la apariencia del widget y los controles visibles en Ajustes → Widgets.'; + + @override + String get configureYourMusicExperience => 'Configura tu experiencia musical'; + + @override + String get connect => 'Conectar'; + + @override + String get connectAMusicServer => 'Conectar un servidor de música'; + + @override + String get connectASubsonicJellyfinWebdavUpnp => + 'Conecta un servidor Subsonic, Jellyfin, WebDAV, UPnP o Tidal para transmitir desde tu biblioteca remota.'; + + @override + String get connectAUsbDacOrAudio => + 'Conectar un DAC USB o una interfaz de audio'; + + @override + String get connectListenbrainz => 'Conectar a ListenBrainz'; + + @override + String get connectToScrobbleYourListeningHistory => + 'Conéctate para registrar tu historial de escucha'; + + @override + String get connectToScrobbleYourMusic => + 'Conéctate para registrar lo que escuchas'; + + @override + String get connectToSubmitYourListeningHistory => + 'Conéctate para enviar tu historial de escucha'; + + @override + String get connectToTheInternetToCheck => + 'Conéctate a internet para buscar actualizaciones.'; + + @override + String get connected => 'Conectado'; + + @override + String get connectedAccount => 'Cuenta conectada'; + + @override + String connectedAs(Object username) { + return 'Conectado como $username'; + } + + @override + String get connecting => 'Conectando'; + + @override + String get connection => 'Conexión'; + + @override + String get connectionBehavior => 'Comportamiento de la conexión'; + + @override + String get connectionFailedRetry => 'Falló la conexión: volver a intentar'; + + @override + String get connectionManagement => 'Administración de conexiones'; + + @override + String get connectionNotices => 'Avisos de conexión'; + + @override + String get connectionNoticesDescription => + 'Mostrar avisos cuando no hay conexión y cuando vuelve'; + + @override + String get connectionOk => 'Conexión correcta'; + + @override + String get connectionStatus => 'Estado de la conexión'; + + @override + String containsValuesOutsideTheSupportedRanges(Object presetName) { + return 'El preajuste «$presetName» contiene valores fuera de los límites permitidos; se ajustaron así:\n'; + } + + @override + String get content => 'Contenido'; + + @override + String get contentControls => 'Contenido y controles'; + + @override + String get contentPlacement => 'Ubicación del contenido'; + + @override + String get contentPlacement2 => 'Ubicación del contenido'; + + @override + String get continueLabel => 'Continuar'; + + @override + String get continueThroughTheSearchResults => + 'Seguir recorriendo los resultados de búsqueda'; + + @override + String get continueThroughYourEntireLibrary => + 'Seguir recorriendo toda tu biblioteca'; + + @override + String get controls => 'Controles'; + + @override + String conversionFailed(Object error) { + return 'Error al convertir: $error'; + } + + @override + String get convertedAudioCacheCleared => + 'Se vació la caché de audio convertido'; + + @override + String convertedSuccessfully(Object fileName) { + return '$fileName se convirtió correctamente'; + } + + @override + String get convertingAudio => 'Convirtiendo audio…'; + + @override + String convertingToWav(Object fileName) { + return 'Convirtiendo $fileName a WAV…'; + } + + @override + String get convolverImpulseResponse => 'Convolución / respuesta al impulso'; + + @override + String copies(Object arg1, Object arg2) { + return '$arg1 • $arg2 copias'; + } + + @override + String get copy => 'Copiar'; + + @override + String get copyLink => 'Copiar enlace'; + + @override + String get copyYourUserTokenFromListenbrainz => + 'Copia tu token de usuario desde los ajustes de ListenBrainz y pégalo abajo.'; + + @override + String get copyright => 'Derechos de autor'; + + @override + String get cornerRadius => 'Radio de las esquinas'; + + @override + String get cosmicOrchestra => 'Cosmic Orchestra'; + + @override + String get couldNotCheckForUpdates => 'No se pudieron buscar actualizaciones'; + + @override + String get couldNotConnectToLastFm => + 'No se pudo conectar con Last.fm. Comprueba las credenciales de la API e inténtalo de nuevo.'; + + @override + String get couldNotConnectToListenbrainzCheck => + 'No se pudo conectar con ListenBrainz. Comprueba el token e inténtalo de nuevo.'; + + @override + String get couldNotLoadAlbumSongs => + 'No se pudieron cargar las canciones del álbum'; + + @override + String get couldNotCreateThePosterImage => + 'No se pudo crear la imagen del póster.'; + + @override + String get couldNotLoadArtistSongs => + 'No se pudieron cargar las canciones del artista'; + + @override + String couldNotLoadIr(Object e) { + return 'No se pudo cargar la respuesta al impulso: $e'; + } + + @override + String get couldNotLoadSession => 'No se pudo cargar la sesión'; + + @override + String get couldNotOpenBrowser => 'No se pudo abrir el navegador.'; + + @override + String get couldNotOpenKoFiPlease => + 'No se pudo abrir Ko-fi. Inténtalo de nuevo.'; + + @override + String get couldNotOpenLink => 'No se pudo abrir el enlace'; + + @override + String couldNotOpenLink2(Object e) { + return 'No se pudo abrir el enlace: $e'; + } + + @override + String get couldNotOpenThatPhotoTry => + 'No se pudo abrir esa foto. Prueba con otra imagen.'; + + @override + String get couldNotOpenTheLink => 'No se pudo abrir el enlace'; + + @override + String couldNotOpenTheLink2(Object e) { + return 'No se pudo abrir el enlace: $e'; + } + + @override + String get couldNotOpenThePlayStore => 'No se pudo abrir Play Store.'; + + @override + String couldNotOpenThePlayStore2(Object error) { + return 'No se pudo abrir Play Store: $error'; + } + + @override + String get couldNotOpenThePlayStore3 => 'No se pudo abrir Play Store'; + + @override + String couldNotPrepareTheEditedFile(String error) { + return 'No se pudo preparar el archivo editado: $error'; + } + + @override + String get couldNotReachTheServer => + 'No se pudo acceder al servidor. Comprueba la URL y las credenciales e inténtalo de nuevo.'; + + @override + String get couldNotReadTheCoverColors => + 'No se pudieron leer los colores de la portada. La señal sigue disponible.'; + + @override + String get couldNotReadTheSelectedImage => + 'No se pudo leer la imagen seleccionada.'; + + @override + String get couldNotReadTheSelectedLyrics => + 'No se pudo leer el archivo de letras seleccionado.'; + + @override + String get couldNotResolveTheAlbum => + 'No se pudo identificar el álbum de esta canción.'; + + @override + String get couldNotRenamePlaylist => + 'No se pudo cambiar el nombre de la lista de reproducción.'; + + @override + String get couldNotSaveTheLyricsFile => + 'No se pudo guardar el archivo de letras.'; + + @override + String get couldNotSaveYourRecapPlease => + 'No se pudo guardar el resumen. Inténtalo de nuevo.'; + + @override + String get couldNotUpdatePlaylistCover => + 'No se pudo actualizar la portada de la lista. Prueba con otra imagen.'; + + @override + String get couldNotUseTheSelectedLyrics => + 'No se pudo usar el archivo de letras seleccionado.'; + + @override + String get couldnTOpenTheBrowserAutomatically => + 'No se pudo abrir el navegador automáticamente. Autoriza el acceso desde cualquier dispositivo con este enlace; completaremos el inicio de sesión cuando lo hagas:\n'; + + @override + String get countingFiles => 'Contando archivos…'; + + @override + String covers(Object done, Object total) { + return '$done / $total portadas'; + } + + @override + String get creatingPlaylists => 'Creando listas de reproducción'; + + @override + String get cropCoverHint => 'Pellizca para acercar y arrastra para reubicar'; + + @override + String get customActionButtons => 'Botones de acciones personalizados'; + + @override + String get customizeTheHomeScreenWidget => + 'Personaliza la apariencia del widget de la pantalla de inicio.'; + + @override + String get customizing => 'Personalizando'; + + @override + String get dedicatedSearchTab => 'Pestaña de búsqueda exclusiva'; + + @override + String get drag => 'Arrastrar'; + + @override + String get dragAnywhereOnTheWaveform => + 'Arrastra en cualquier punto de la forma de onda para recorrer la pista. La forma de onda representa el volumen del audio a lo largo del tiempo.'; + + @override + String get dragEachFrequencyBandSlider => + 'Arrastra el control de cada banda de frecuencia para ajustar el sonido. El ecualizador se aplica a todo el audio de Flick.'; + + @override + String get dragScrollHandle => 'Arrastrar el control de desplazamiento'; + + @override + String get dragTheScrollHandleOn => + 'Arrastra el control del borde derecho para avanzar por el alfabeto. Un globo muestra la letra actual.'; + + @override + String get dragTracksByTheirHandle => + 'Arrastra las pistas desde el control para cambiar su orden. Los cambios se aplican de inmediato.'; + + @override + String get eachBrowseTabHasIts => + 'Cada pestaña de exploración tiene arriba su propia barra de búsqueda, que filtra el contenido de esa pestaña mientras escribes.'; + + @override + String get editCover => 'Editar portada'; + + @override + String get crop => 'Recortar'; + + @override + String get adjust => 'Ajustar'; + + @override + String get editing => 'Editando'; + + @override + String get enableDisable => 'Activar / desactivar'; + + @override + String get fastScroll => 'Desplazamiento rápido'; + + @override + String get fastScrollThroughLongLists => + 'Desplázate rápidamente por listas largas (pestaña Canciones).'; + + @override + String get favoritesTab => 'Pestaña Favoritos'; + + @override + String get fetchingLyrics => 'Buscando letras'; + + @override + String get filters => 'Filtros'; + + @override + String get brightness => 'Brillo'; + + @override + String get contrast => 'Contraste'; + + @override + String get flickFetchesLyricsAutomaticallyWhen => + 'Flick busca letras automáticamente cuando están disponibles. También puedes pegarlas o editarlas manualmente.'; + + @override + String get folderPlayback => 'Reproducción por carpeta'; + + @override + String get fromAnySongsLong => + 'En el menú que aparece al mantener presionada cualquier canción, elige Reproducir a continuación para insertarla justo después de la pista actual.'; + + @override + String get gaplessPlaybackCrossfadeViewModes => + 'Reproducción sin pausas, fundido cruzado, modos de vista y apariencia del tema.'; + + @override + String get generateAShareCardWith => + 'Crea una tarjeta para compartir con la portada y la información de la pista, o comparte el archivo directamente.'; + + @override + String get gestures => 'Gestos'; + + @override + String get gridView => 'Vista de cuadrícula'; + + @override + String get homeScreenWidget => 'Widget de pantalla de inicio'; + + @override + String get ifSearchIsInYour => + 'Si agregas Buscar a la barra de navegación, puedes buscar canciones, álbumes y artistas a la vez, con resultados agrupados.'; + + @override + String get immersiveView => 'Vista inmersiva'; + + @override + String get inAppInfoU2192Interactive => + 'En Información de la app → Tutorial interactivo, vuelve a reproducir el recorrido guiado. Ver bienvenida vuelve a mostrar las pantallas de bienvenida.'; + + @override + String get inTabSearch => 'Búsqueda dentro de la pestaña'; + + @override + String get inTheFullPlayerTap => + 'En el reproductor completo, toca el ícono del visualizador para activarlo o desactivarlo.'; + + @override + String get interface => 'Interfaz'; + + @override + String get lastFmAndListenBrainzScrobbling => + 'Configuración del registro de reproducciones en Last.fm y ListenBrainz.'; + + @override + String get layoutModeSizingMiniPlayer => + 'Modo de diseño, tamaño, gesto del minirreproductor y botones de acciones rápidas personalizados.'; + + @override + String get library => 'Biblioteca'; + + @override + String get longPressASong => 'Mantén presionada una canción'; + + @override + String get longPressOrTapAgain => + 'Mantén presionado o vuelve a tocar para cambiar de estilo de visualizador (barras, onda, radial, etc.).'; + + @override + String get longPressTheNavBar => + 'Mantén presionada la barra de navegación o ve a Ajustes → Barra inferior para elegir qué pestañas aparecen y en qué orden.'; + + @override + String get longPressYourHomeScreen => + 'Mantén presionada la pantalla de inicio → Agregar widget → Flick. Elige un tamaño y colócalo en la pantalla de inicio.'; + + @override + String get manageScanFoldersTriggerRescans => + 'Administra las carpetas de análisis, vuelve a analizarlas y usa la herramienta para quitar duplicados.'; + + @override + String get manualBands => 'Bandas manuales'; + + @override + String get manualBitPerfectCapsule => 'Cápsula de bit perfecto'; + + @override + String get manualBottomBar => 'Barra inferior'; + + @override + String get manualLongPress => 'Mantener presionado'; + + @override + String get manualLyricsSyncStudio => 'Estudio de letras y sincronización'; + + @override + String get manualPlayNext => 'Reproducir a continuación'; + + @override + String get manualPlaybackSpeed => 'Velocidad de reproducción'; + + @override + String get manualQueue2 => 'Cola'; + + @override + String get manualRemoving => 'Quitar'; + + @override + String get manualSongs => 'Canciones'; + + @override + String get manualSwipeLeftRightOnThe => + 'Desliza a la izquierda o a la derecha en el área principal para cambiar entre las pestañas de la barra de navegación.'; + + @override + String get manualTap => 'Tocar'; + + @override + String get nextPreviousTrackOrToggle => + 'Pista siguiente/anterior (o activar o desactivar el visualizador, según los ajustes).'; + + @override + String get openAPlaylistToReorder => + 'Abre una lista para reordenar las canciones (arrastra el control), quitarlas (desliza o mantén presionado) o cambiar el nombre o eliminar la lista desde su menú.'; + + @override + String get openFromTheLyricsEdit => + 'Ábrelo desde el ícono de edición de letras. Toca Marcar cuando suene cada línea para sincronizarla con la música. Guarda para conservar la sincronización.'; + + @override + String get openTheActionsSheetFor => + 'Abre la hoja de acciones de una canción o personaliza la barra de navegación.'; + + @override + String get openTheFullPlayer => 'Abrir el reproductor completo'; + + @override + String get openTheQueueFromThe => + 'Abre la cola desde el reproductor completo. La pista que se está reproduciendo aparece resaltada y las siguientes se muestran debajo.'; + + @override + String get openingTheFullPlayer => 'Abriendo el reproductor completo'; + + @override + String get opensTheActionsSheetPlay => + 'Abre la hoja de acciones: Reproducir a continuación, Agregar a la cola, Agregar a la lista, Ir al álbum, Ir al artista, Compartir, Ver información o Eliminar.'; + + @override + String get playASongOpenAn => + 'Reproduce una canción, abre un álbum o activa un control.'; + + @override + String get playPauseNextPrevious => + 'Reproducir / Pausar / Siguiente / Anterior'; + + @override + String get playTheWholeAlbumShuffle => + 'Reproduce el álbum completo, mézclalo o elige canciones individuales. Arriba se muestran la portada, el año y el artista.'; + + @override + String get playing => 'Reproduciendo'; + + @override + String get playingASong => 'Reproduciendo una canción'; + + @override + String get reSyncALineBy => + 'Vuelve a sincronizar una línea tocándola de nuevo en el momento correcto.'; + + @override + String get removeItFromTheQueue => 'Quitar de la cola.'; + + @override + String get reordering => 'Cambiando el orden'; + + @override + String get replayTutorial => 'Volver a reproducir el tutorial'; + + @override + String get saturation => 'Saturación'; + + @override + String get scrubTheWaveformSeekbarReorder => + 'Deslizar la barra de reproducción por la forma de onda; reordenar elementos de la cola y canciones de la lista.'; + + @override + String get seeYourMusicOrganizedBy => + 'Consulta tu música organizada según la estructura de carpetas del disco. Útil si organizas los archivos manualmente.'; + + @override + String get selectionMode => 'Modo de selección'; + + @override + String get setACountdownAfterWhich => + 'Configura una cuenta regresiva para detener la reproducción. Opciones: 5, 10, 15, 30, 45 o 60 minutos, o al terminar la pista.'; + + @override + String get showOrHideHomeScreen => + 'Mostrar u ocultar secciones y pestañas de la pantalla de inicio.'; + + @override + String get showsTheArtistsAlbums => + 'Muestra los álbumes del artista y la lista completa de canciones. Reproduce todo, mézclalo o elige desde qué canción empezar.'; + + @override + String get shuffleFromTheHeaderPlays => + 'El botón Aleatorio del encabezado reproduce toda la biblioteca en orden aleatorio.'; + + @override + String get shuffleRepeat => 'Aleatorio y repetir'; + + @override + String get sort => 'Ordenar'; + + @override + String get sortAlbumsByTitleArtist => + 'Ordena los álbumes por título, artista, año o fecha en que se agregaron desde el ícono de orden.'; + + @override + String get sortPersistsAcrossSessions => + 'El orden se conserva entre sesiones.'; + + @override + String get starRateTheCurrentTrack => + 'Asigna una calificación por estrellas a la pista actual. Las calificaciones se guardan y puedes usarlas para ordenar.'; + + @override + String get styles => 'Estilos'; + + @override + String get swipeATrackLeftOr => + 'Desliza una pista a la izquierda o a la derecha para quitarla de la cola.'; + + @override + String get swipeBetweenTabs => 'Deslizar para cambiar de pestaña'; + + @override + String get swipeHorizontallyOnMiniPlayer => + 'Deslizar horizontalmente sobre el minirreproductor'; + + @override + String get swipeLeftRightOnThe => + 'Desliza el minirreproductor a la izquierda o a la derecha para ir a la pista siguiente o anterior (si está habilitado en Ajustes).'; + + @override + String get swipeOnAQueueItem => 'Deslizar un elemento de la cola'; + + @override + String get swipeToSwitch => 'Deslizar para cambiar'; + + @override + String get syncStudio => 'Estudio de sincronización'; + + @override + String get tapAFolderToPlay => + 'Toca una carpeta para reproducir todas las canciones que contiene, incluidas las subcarpetas.'; + + @override + String get tapAPlaylistToPlay => + 'Toca una lista para reproducirla en orden o usa el botón Aleatorio para mezclar las canciones.'; + + @override + String get tapAnySongToPlay => + 'Toca cualquier canción para reproducirla de inmediato. La cola se reconstruye a partir de esa canción.'; + + @override + String get tapAnywhereOnTheMini => + 'Toca cualquier parte del minirreproductor para ampliarlo y abrir el reproductor completo.'; + + @override + String get tapShuffleToToggleRandom => + 'Toca Aleatorio para activar el orden aleatorio. Toca Repetir para alternar entre desactivado → todo → una canción. Mantén presionado cualquiera de los dos para ver más opciones.'; + + @override + String get tapTheAlbumArtTo => + 'Toca la portada para alternar entre la vista de portada y la de un disco de vinilo giratorio.'; + + @override + String get tapTheButtonToCreate => + 'Toca el botón + para crear una lista de reproducción. Ponle un nombre y agrega canciones manteniendo presionada cualquier canción y eligiendo Agregar a la lista.'; + + @override + String get tapTheCheckIconIn => + 'Toca la marca de verificación del encabezado para entrar en el modo de selección. Elige varias canciones para agregarlas a la cola o a una lista, o para eliminarlas en lote.'; + + @override + String get tapTheEQIconTo => + 'Toca el ícono del ecualizador para abrirlo y ver los preajustes y los controles manuales de bandas.'; + + @override + String get tapTheEditIconIn => + 'Toca el ícono de edición de las letras para abrir el Estudio de letras y sincronización.'; + + @override + String get tapTheHeartOnA => + 'Toca el corazón de una canción (en el reproductor completo o en el menú que aparece al mantenerla presionada) para marcarla como favorita.'; + + @override + String get tapTheLyricsIconIn => + 'Toca el ícono de letras en el reproductor completo. Las letras sincronizadas se desplazan y resaltan automáticamente; las que no están sincronizadas aparecen como texto normal.'; + + @override + String get tapTheLyricsIconTo => + 'Toca el ícono de letras para abrir su vista. Si hay letras sincronizadas, se resaltarán al ritmo de la música.'; + + @override + String get tapTheMiniPlayerThe => + 'Toca el minirreproductor para ampliarlo. Se abrirá el reproductor completo con la portada del álbum, la barra de reproducción con forma de onda y todos los controles.'; + + @override + String get tapTheQueueIconTo => + 'Toca el ícono de la cola para ver y reordenar las próximas pistas. Arrástralas para cambiar el orden o desliza para quitarlas.'; + + @override + String get tapTheSortIconTop => + 'Toca el ícono de orden (arriba a la derecha del encabezado) para abrir el panel Ordenar y filtrar. Ordena por título, artista, álbum, fecha en que se agregó o última reproducción. Filtra por tipo de archivo (FLAC, MP3, etc.).'; + + @override + String get tapToHideControlsFor => + 'Toca para ocultar los controles y dejar solo la portada del álbum. Toca otra vez para mostrarlos.'; + + @override + String get theLeftAndRightAction => + 'Puedes personalizar los botones de acción izquierdo y derecho, sobre la fila de reproducción, en Ajustes → Diseño del reproductor → Acciones rápidas.'; + + @override + String get theMiniPlayerSitsAbove => + 'El minirreproductor aparece sobre la barra de navegación y muestra la portada, el título y el artista de la pista actual, junto con su progreso.'; + + @override + String get theSongsTabListsEvery => + 'La pestaña Canciones muestra todas las pistas que Flick ha analizado. Desplázate para explorar o usa la barra de búsqueda para filtrar por título o artista.'; + + @override + String get theWidgetShowsCurrentTrack => + 'El widget muestra la portada y el título de la pista actual, con controles para reproducir, pausar y avanzar. Toca la portada para abrir la app.'; + + @override + String get thisScreenReopenAnytimeFrom => + 'Esta pantalla. Puedes volver a abrirla en cualquier momento desde Ajustes → Ayuda y manual.'; + + @override + String get toggleTheAudioVisualizerOn => + 'Activa o desactiva el visualizador de audio y cambia su estilo desde el ícono del visualizador.'; + + @override + String get toggleTheMasterSwitchAt => + 'Activa o desactiva el interruptor principal de arriba para omitir el ecualizador sin perder tus ajustes.'; + + @override + String get toggling => 'Activando o desactivando'; + + @override + String get uac2USBDACPreferencesAnd => + 'Preferencias del DAC USB UAC2 y ajustes del ecualizador.'; + + @override + String get useTheWaveformScrubberTo => + 'Usa la barra de reproducción con forma de onda para ir a una línea que te perdiste.'; + + @override + String get viewingLyrics => 'Viendo las letras'; + + @override + String get viewingTheQueue => 'Viendo la cola'; + + @override + String get vinylMorph => 'Efecto de transformación en vinilo'; + + @override + String get visualizerToggle => 'Activar o desactivar el visualizador'; + + @override + String get warmth => 'Calidez'; + + @override + String get vignette => 'Viñeta'; + + @override + String get rotateLeft => 'Girar a la izquierda'; + + @override + String get rotateRight => 'Girar a la derecha'; + + @override + String get flipHorizontal => 'Voltear horizontalmente'; + + @override + String get flipVertical => 'Voltear verticalmente'; + + @override + String get filterOriginal => 'Original'; + + @override + String get filterMono => 'Mono'; + + @override + String get filterWarm => 'Cálido'; + + @override + String get filterCool => 'Frío'; + + @override + String get filterFade => 'Desvanecido'; + + @override + String get filterPunch => 'Intenso'; + + @override + String get filterNoir => 'Noir'; + + @override + String get create => 'Crear'; + + @override + String get createACollection => 'Crear una colección'; + + @override + String get createACustomPreset => 'Crear un preajuste personalizado'; + + @override + String get createAPlaylistImportAnM3u => + 'Crea una lista de reproducción, importa una lista M3U o deja que las mezclas de arriba acompañen la sesión.'; + + @override + String get createLyrics => 'Crear letras'; + + @override + String get createNewPlaylist => 'Crear una lista de reproducción'; + + @override + String get createNewPlaylist2 => 'Crear una lista de reproducción'; + + @override + String get createOrRefreshPlaylistsFoundInside => + 'Crear o actualizar las listas de reproducción encontradas en las carpetas analizadas'; + + @override + String get createPlaylist => 'Crear lista de reproducción'; + + @override + String get createPlaylistFromSelected => 'Crear una lista con la selección'; + + @override + String get createYourFirstPlaylistOrJump => + 'Crea tu primera lista de reproducción o abre una de tus colecciones guardadas.'; + + @override + String get createYourFirstPlaylistToOrganize => + 'Crea tu primera lista de reproducción para organizar\ntus canciones favoritas'; + + @override + String created(Object arg1) { + return 'Creada: $arg1'; + } + + @override + String createdAndAddedSong(Object arg1) { + return 'Se creó $arg1 y se agregó la canción'; + } + + @override + String createdAndAddedSongs(Object name, Object arg1) { + return 'Se creó $name y se agregaron $arg1 canciones'; + } + + @override + String get creativeFx => 'Efectos creativos'; + + @override + String credentialsRejectedByReEnterThe(Object arg1) { + return '$arg1 rechazó las credenciales. Vuelve a ingresar la contraseña.'; + } + + @override + String get credentialsSavedSuccessfully => + 'Las credenciales se guardaron correctamente.'; + + @override + String get crispestHeavierDuringFastScrolling => + 'Más nítido: mayor carga durante el desplazamiento rápido'; + + @override + String get crossfade => 'Fundido cruzado'; + + @override + String get crossfadeIsMostReliableOnThe => + 'El fundido cruzado funciona mejor con el motor Estándar. Puede ser inestable con el motor de alta calidad (Rust); cambia a Estándar para obtener transiciones uniformes.'; + + @override + String get crossfeed => 'Mezcla entre canales'; + + @override + String get crossfeedBs2b => 'Mezcla entre canales (BS2B)'; + + @override + String get crossfeedEasy => 'Mezcla entre canales sencilla'; + + @override + String get crossfeedRunsOnTheHighQuality => + 'La mezcla entre canales solo funciona con el motor de alta calidad (Rust). El motor Estándar reproduce el audio sin este efecto.'; + + @override + String get crystalCaverns => 'Crystal Caverns'; + + @override + String get cueSheetTracksCannotBeEdited => + 'No se pueden editar las pistas de una hoja CUE.'; + + @override + String get cueSheetTracksCannotBeEdited2 => + 'No se pueden editar las pistas de una hoja CUE'; + + @override + String get currentArtwork => 'Portada actual'; + + @override + String get currentCustomArt => 'Imagen personalizada actual'; + + @override + String get currentPlaybackMode => 'Modo de reproducción actual'; + + @override + String currentRoute(Object arg1) { + return 'Ruta actual: $arg1.'; + } + + @override + String get currentSongPreviewOnly => 'Canción actual · solo vista previa'; + + @override + String get currentStreak => 'Racha actual'; + + @override + String get curvature => 'Curvatura'; + + @override + String get curvatureSizingDepthAndVisuals => + 'Curvatura, tamaño, profundidad y efectos visuales'; + + @override + String get curve => 'Curva'; + + @override + String get curveOfTheOrbitArcHigher => + 'Curva del arco orbital: cuanto mayor sea, más suave'; + + @override + String get curvePreview => 'Vista previa de la curva'; + + @override + String get curvedWave => 'Onda curva'; + + @override + String get custom => 'Personalizado'; + + @override + String get customFormat => 'Formato personalizado'; + + @override + String get customFormatForcesPlaybackToThe => + 'El formato personalizado obliga a reproducir en el formato de salida seleccionado. Si la frecuencia de muestreo, la profundidad de bits o los canales elegidos no son adecuados para la canción o el dispositivo, el sonido, el tono, la velocidad o la estabilidad podrían verse afectados.'; + + @override + String get customFormatIsDisabledInBit => + 'El formato personalizado está desactivado en el modo Bit perfecto (DAC USB), que requiere una coincidencia exacta de la frecuencia de muestreo. Desactiva Bit perfecto (DAC USB) para usar formatos personalizados.'; + + @override + String get customFormatIsUnavailableBecauseAudio => + 'El formato personalizado no está disponible porque el formato de audio está desactivado en Ajustes.'; + + @override + String get customWidth => 'Ancho personalizado'; + + @override + String get customizeBottomBar => 'Personalizar la barra inferior'; + + @override + String get customizeHomeScreenWidgets => + 'Personalizar los widgets de la pantalla de inicio'; + + @override + String get customizeOrbital => 'Personalizar Orbital'; + + @override + String get customizeWhichTabsAppearAndTheir => + 'Personaliza qué pestañas aparecen y su tamaño'; + + @override + String dAgo(Object arg1) { + return 'hace $arg1 d'; + } + + @override + String dAgo2(Object arg1) { + return 'hace $arg1 d'; + } + + @override + String get dacClaim => 'Asignación del DAC'; + + @override + String dacWillBeOfferedAgain(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Se volverán a ofrecer $count DAC', + one: 'Se volverá a ofrecer $count DAC', + ); + return '$_temp0.'; + } + + @override + String get daily => 'Diario'; + + @override + String get damp => 'Amortiguación'; + + @override + String get dapNativeBitOrder => 'Orden de bits nativo del DAP'; + + @override + String get dapNativeByteGrouping => 'Agrupación de bytes nativa del DAP'; + + @override + String get dark => 'Oscuro'; + + @override + String get dataCollection => 'Recopilación de datos'; + + @override + String get date => 'Fecha'; + + @override + String get dateAdded => 'Fecha en que se agregó'; + + @override + String get dateAddedNewest => 'Fecha en que se agregó (más reciente)'; + + @override + String get dateAddedOldest => 'Fecha en que se agregó (más antigua)'; + + @override + String get dayStreak => 'días seguidos'; + + @override + String get dayStreak2 => 'Racha diaria'; + + @override + String get dayStreak3 => 'Racha diaria'; + + @override + String get dayStreaks => 'Rachas diarias'; + + @override + String dayUnit(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'días', + one: 'día', + ); + return '$_temp0'; + } + + @override + String db10(Object arg1) { + return '$arg1 dB'; + } + + @override + String db13(Object arg1) { + return '$arg1 dB'; + } + + @override + String db15(Object arg1, Object arg2) { + return '$arg1% $arg2 dB'; + } + + @override + String db2(Object value) { + return '$value dB'; + } + + @override + String db9(Object arg1) { + return '$arg1 dB'; + } + + @override + String dbCut(Object arg1) { + return 'atenuación de $arg1 dB'; + } + + @override + String dbMax(Object arg1) { + return 'máx. $arg1 dB'; + } + + @override + String get deactivateFallback => 'Desactivar alternativa'; + + @override + String get dec => 'dic'; + + @override + String get decode => 'Decodificar'; + + @override + String get decodeSongsAfterScanningToCache => + 'Decodificar las canciones después del análisis para guardar en caché los picos de forma de onda y las métricas de volumen'; + + @override + String get deepEarth => 'Deep Earth'; + + @override + String get deepScan => 'Análisis profundo'; + + @override + String get deepScanOff => 'Análisis profundo desactivado'; + + @override + String get deepScanOn => 'Análisis profundo activado'; + + @override + String get defaultAndroidPlaybackEngineUsedBy => + 'Motor de reproducción predeterminado de Android que Flick usa actualmente.'; + + @override + String get defaultAndroidPlayerPlaysEverything => + 'Reproductor predeterminado de Android: reproduce todo de forma confiable. La opción más segura para la mayoría de las personas.'; + + @override + String get defaultLabel => 'Predeterminado'; + + @override + String get del => 'Supr'; + + @override + String get delays => 'Retardos'; + + @override + String get delete => 'Eliminar'; + + @override + String deleteAndAllSongsAndPlaylists(Object arg1) { + return '¿Eliminar «$arg1» y todas las canciones y listas sincronizadas desde ahí? Se conservarán las descargas en caché.'; + } + + @override + String get deleteFile => 'Eliminar archivo'; + + @override + String get deleteFiles => 'Eliminar archivos'; + + @override + String get deletePlaylist => 'Eliminar lista de reproducción'; + + @override + String get deletePreset => '¿Eliminar el preajuste?'; + + @override + String get deleteSelected => 'Eliminar selección'; + + @override + String get deleteSong => 'Eliminar canción'; + + @override + String get deleteSong2 => '¿Eliminar la canción?'; + + @override + String get deleteSong3 => 'Eliminar canción'; + + @override + String deleteSongs(Object arg1) { + return '¿Eliminar $arg1 canciones?'; + } + + @override + String get deleteSongs2 => 'Eliminar canciones'; + + @override + String deleteThisCannotBeUndone(Object arg1) { + return '¿Eliminar «$arg1»? Esta acción no se puede deshacer.'; + } + + @override + String deleted(Object arg1) { + return 'Se eliminó «$arg1»'; + } + + @override + String deletedSongs(Object arg1) { + return 'Se eliminaron $arg1 canciones'; + } + + @override + String get depth => 'Profundidad'; + + @override + String get deselectAll => 'Anular selección de todo'; + + @override + String get designed => 'Diseñado'; + + @override + String get detailScreens => 'Pantallas de detalles'; + + @override + String get details => 'Detalles'; + + @override + String get developerMode => 'Modo de desarrollador'; + + @override + String get developerOptionsIsDisabledEnableIt => + 'Las Opciones para desarrolladores están desactivadas. Actívalas en Ajustes → Acerca del teléfono (toca 7 veces Número de compilación) y vuelve a intentarlo.'; + + @override + String get device => 'Dispositivo'; + + @override + String get deviceCapabilities => 'Capacidades del dispositivo'; + + @override + String get deviceConnected => 'Dispositivo conectado'; + + @override + String get deviceDac => 'DAC del dispositivo'; + + @override + String get deviceDacVolume => 'Volumen del DAC del dispositivo'; + + @override + String get deviceDisconnected => 'Dispositivo desconectado'; + + @override + String get deviceInformation => 'Información del dispositivo'; + + @override + String get deviceType => 'Tipo de dispositivo'; + + @override + String get devices => 'Dispositivos'; + + @override + String get direct => 'Directo'; + + @override + String get directAlsaOutputIsActiveAnd => + 'La salida ALSA directa está activa y omite el servidor de audio de Android.'; + + @override + String get directLibusbIsochronousUsbEngineBest => + 'Motor USB isócrono directo con libusb. Se recomienda combinarlo con Bit perfecto (DAC USB) para verificar la reproducción en un DAC externo.'; + + @override + String get directUsb => 'USB directo'; + + @override + String get directUsbDeviceManaged => + 'USB directo administrado por el dispositivo'; + + @override + String get directUsbExperimental => 'USB directo experimental'; + + @override + String get disableBatteryOptimization => + 'Desactivar la optimización de batería'; + + @override + String get disableBatteryOptimizationRecommended => + 'Desactivar la optimización de batería (recomendado)'; + + @override + String get disabled => 'Desactivado'; + + @override + String get disabledInBitPerfectMode => 'Desactivado en modo bit perfecto'; + + @override + String get disabledInBitPerfectUsbDac => + 'Desactivado en modo Bit perfecto (DAC USB) (requiere una frecuencia exacta)'; + + @override + String get disabledWhileBothBitPerfectOptions => + 'Desactivado porque las dos opciones de bit perfecto están apagadas en este DAP.'; + + @override + String get disc => 'Disco'; + + @override + String get disc2 => 'Disco n.º'; + + @override + String get discard => 'Descartar'; + + @override + String get discardChanges => '¿Descartar los cambios?'; + + @override + String get discardChanges2 => '¿Descartar los cambios?'; + + @override + String get disconnect => 'Desconectar'; + + @override + String get disconnectBehaviorAndCodecInfo => + 'Comportamiento al desconectarse e información del códec'; + + @override + String disconnectFrom(Object arg1) { + return 'Desconectar de $arg1'; + } + + @override + String get disconnectLastFm => '¿Desconectar Last.fm?'; + + @override + String get disconnectListenbrainz => '¿Desconectar ListenBrainz?'; + + @override + String get discord => 'Discord'; + + @override + String get discoversDlnaUpnpAndChromecastReceivers => + 'Busca receptores DLNA, UPnP y Chromecast en tu red'; + + @override + String get dismiss => 'Descartar'; + + @override + String get display => 'Pantalla'; + + @override + String get displayFileFormatAndBitrateIn => + 'Mostrar el formato de archivo y la tasa de bits en el modo inmersivo'; + + @override + String get displayFileFormatAndBitrateIn2 => + 'Mostrar el formato de archivo y la tasa de bits en el modo de tarjeta con portada'; + + @override + String get displayTextLabelsBelowIcons => + 'Mostrar etiquetas de texto debajo de los íconos'; + + @override + String get displayTheAlbumNameInArtwork => + 'Mostrar el nombre del álbum en el modo de tarjeta con portada'; + + @override + String get displayTheArtistNameInArtwork => + 'Mostrar el nombre del artista en el modo de tarjeta con portada'; + + @override + String get displayTheArtistNameInImmersive => + 'Mostrar el nombre del artista en el modo inmersivo'; + + @override + String get displayTheTrackTitleInArtwork => + 'Mostrar el título de la pista en el modo de tarjeta con portada'; + + @override + String get displayTheTrackTitleInImmersive => + 'Mostrar el título de la pista en el modo inmersivo'; + + @override + String get distanceBetweenSongsAlongTheArc => + 'Distancia entre canciones a lo largo del arco'; + + @override + String get dlnaAndUpnpReceiversAreControlled => + 'Los receptores DLNA y UPnP se controlan directamente con Dart puro, sin dependencias adicionales. La compatibilidad con Chromecast usa el SDK nativo de Cast. Se pueden transmitir fuentes de red (Subsonic, WebDAV, Jellyfin y UPnP), archivos locales y canciones en caché; los archivos locales se sirven directamente desde este teléfono. Mientras transmites, las teclas de volumen y el panel de volumen del sistema controlan el dispositivo conectado.'; + + @override + String get dlnaUpnp => 'DLNA / UPnP'; + + @override + String get dlnaUpnpAndChromecastReceivers => + 'Receptores DLNA, UPnP y Chromecast'; + + @override + String get donTShowAgainToday => 'No volver a mostrar hoy'; + + @override + String get donate => 'Donar'; + + @override + String get donateFundFeaturesAndKeepThe => + 'Contribuye, apoya nuevas funciones y ayuda a mantener viva la app'; + + @override + String get done => 'Listo'; + + @override + String get dop => 'DoP'; + + @override + String get dots => 'Puntos'; + + @override + String get doubleTapABandToReset => + 'Toca dos veces una banda para restablecerla'; + + @override + String get doubleTapToReset => 'Toca dos veces para restablecer'; + + @override + String get doubleTapToResetThisBand => + 'Toca dos veces para restablecer esta banda'; + + @override + String down(Object arg1) { + return '$arg1 abajo'; + } + + @override + String get downloadTheLatestApkFromFlick => + 'Descarga el APK más reciente desde flick-player.site'; + + @override + String get downloadUpdate => 'Descargar actualización'; + + @override + String dp(Object arg1) { + return '$arg1 dp'; + } + + @override + String dp2(Object arg1) { + return '$arg1 dp'; + } + + @override + String dp3(Object arg1) { + return '$arg1 dp'; + } + + @override + String get dragABoundaryToStretchOr => + 'Arrastra un límite para alargar o acortar la palabra anterior. El último límite desplaza la línea siguiente.'; + + @override + String get dragBandsUpOrDown => 'Arrastra las bandas hacia arriba o abajo'; + + @override + String get dragToChangeFrequencyGain => + 'Arrastra para cambiar la frecuencia y la ganancia'; + + @override + String get dragToMovePinchToWiden => + 'Arrastra para mover • Pellizca para ampliar o reducir'; + + @override + String get dragVerticallyToChangeGain => + 'Arrastra verticalmente para cambiar la ganancia'; + + @override + String get drawTheCurvedArcBehindThe => + 'Dibujar el arco curvo detrás de las canciones'; + + @override + String driftMs(Object arg1) { + return 'Desfase de $arg1 ms'; + } + + @override + String get dsdDsfPlayback => 'Reproducción DSD / DSF'; + + @override + String get dsdMode => 'Modo DSD'; + + @override + String get dsdOutputMode => 'Modo de salida DSD'; + + @override + String get dsdStream => 'Flujo DSD'; + + @override + String get duckOnNotifications => 'Atenuar el audio con las notificaciones'; + + @override + String get duplicateCleaner => 'Limpiador de duplicados'; + + @override + String get duplicatesRemovedUsingRecommendedPicks => + 'Se quitaron los duplicados con las selecciones recomendadas.'; + + @override + String get duration => 'Duración'; + + @override + String get durationMatch => 'Coincidencia de duración'; + + @override + String get dynamics => 'Dinámica'; + + @override + String get earlier => 'Anterior'; + + @override + String get earlierStandoutsPulledBackIntoView => + 'Canciones destacadas de antes que vuelven a aparecer gracias a tu historial de escucha.'; + + @override + String get editCredentials => 'Editar credenciales'; + + @override + String get editDescription => 'Editar descripción'; + + @override + String get editDescription2 => 'Editar descripción'; + + @override + String get editMetadata => 'Editar metadatos'; + + @override + String get editServer => 'Editar servidor'; + + @override + String get editSync => 'Editar y sincronizar'; + + @override + String get editText => 'Editar texto'; + + @override + String get editToken => 'Editar token'; + + @override + String get electricSunset => 'Atardecer eléctrico'; + + @override + String get empty => 'Vacío'; + + @override + String get emptyLine => '(Línea vacía)'; + + @override + String get emptyTheLibraryFilesOnDisk => + 'Vaciar la biblioteca; se conservarán los archivos del disco'; + + @override + String get enable => 'Activar'; + + @override + String get enable432HzTuning => '¿Activar la afinación a 432 Hz?'; + + @override + String get enableAnimatedTransitionsAndEffects => + 'Activar transiciones y efectos animados'; + + @override + String get enableEqToEdit => 'Activar el ecualizador para editarlo'; + + @override + String get enableFullLibraryAccess => + 'Activar acceso completo a la biblioteca'; + + @override + String get enableVibrationOnInteractions => + 'Activar la vibración al interactuar'; + + @override + String get enabled => 'Activado'; + + @override + String get endpoint => 'Punto de conexión'; + + @override + String get engine => 'Motor'; + + @override + String get engineSelector => 'Selector de motor'; + + @override + String get english => 'Inglés'; + + @override + String enterAValidNumber(Object label) { + return 'Ingresa un número válido para $label'; + } + + @override + String enterAValueFromTo(Object arg1, Object arg2) { + return 'Ingresa un valor entre $arg1% y $arg2%'; + } + + @override + String get enterAYear19999 => 'Ingresa un año (1–9999)'; + + @override + String get enterYourApiKey => 'Ingresa tu clave de API'; + + @override + String get enterYourSharedSecret => 'Ingresa tu secreto compartido'; + + @override + String ep(Object arg1) { + return 'EP $arg1'; + } + + @override + String get eqDynamics => 'Ecualizador y dinámica'; + + @override + String get equalPower => 'Potencia constante'; + + @override + String get equalizer => 'Ecualizador'; + + @override + String error(Object error) { + return 'Error: $error'; + } + + @override + String error2(Object arg1) { + return 'Error: $arg1'; + } + + @override + String get error3 => 'Error'; + + @override + String errorLoadingCapabilities(Object error) { + return 'Error al cargar las capacidades: $error'; + } + + @override + String get errorLoadingPlaylists => + 'Error al cargar las listas de reproducción'; + + @override + String errorLoadingPlaylists2(Object error) { + return 'Error al cargar las listas de reproducción: $error'; + } + + @override + String get errorLoadingPreference => 'Error al cargar la preferencia'; + + @override + String get errorLoadingSongs => 'Error al cargar las canciones'; + + @override + String get etherealTones => 'Tonos etéreos'; + + @override + String get everyAlbumHasArtistAndAlbum => + 'Todos los álbumes tienen etiquetas de artista y de álbum.'; + + @override + String get everySongIsRemovedFromYour => + 'Se quitarán de tu biblioteca todas las canciones. Se conservarán los archivos del disco; vuelve a analizar las carpetas para agregarlas otra vez.'; + + @override + String get exactMatch => 'Coincidencia exacta'; + + @override + String get excludeTinyClipsPreviewsAndAccidental => + 'Excluir clips muy cortos, vistas previas y fragmentos accidentales'; + + @override + String get exclusiveDirectPcmIsActiveAnd => + 'La salida PCM directa exclusiva está activa y omite el mezclador de Android usando la frecuencia nativa de la pista.'; + + @override + String get exclusiveUsbBitPerfectReEngaged => + 'Se reactivó el modo bit perfecto USB exclusivo.'; + + @override + String get exclusiveUsbDroppedToTheAndroid => + 'La conexión USB exclusiva pasó al mezclador de Android. El modo bit perfecto está en pausa.'; + + @override + String get exclusiveUsbIsActiveAndBypassing => + 'La conexión USB exclusiva está activa y omite el mezclador de Android.'; + + @override + String get exclusiveUsbIsStillUnavailableCheck => + 'USB exclusivo sigue sin estar disponible. Consulta los diagnósticos USB.'; + + @override + String get expanded => 'Expandido'; + + @override + String get expandedHeaderArt => 'Portada del encabezado expandido'; + + @override + String get expectedAJsonObject => 'Se esperaba un objeto JSON.'; + + @override + String get experimental => 'Experimental'; + + @override + String get experimentalDownTunePlaybackBy432 => + 'Experimental: multiplica la velocidad de reproducción por 432/440 para bajar la afinación de 440 a 432 Hz. Esto desactiva el paso directo bit-perfect y usa la ruta DSP.'; + + @override + String get exportAsM3u => 'Exportar como .m3u'; + + @override + String get exportAsM3u8 => 'Exportar como .m3u8'; + + @override + String get exportCsv => 'Exportar CSV'; + + @override + String get exportCurrentPreset => 'Exportar el preajuste actual'; + + @override + String get exportEqualizerPreset => 'Exportar preajuste del ecualizador'; + + @override + String exportFailed(Object e) { + return 'Error al exportar: $e'; + } + + @override + String get exportFormat => 'Formato de exportación'; + + @override + String get exportTxt => 'Exportar TXT'; + + @override + String exportedPresetTo(Object savePath) { + return 'Se exportó el preajuste a $savePath'; + } + + @override + String exportedPresetTo2(Object fallbackPath) { + return 'Se exportó el preajuste a $fallbackPath'; + } + + @override + String exportedSongsTo(Object arg1, Object arg2) { + return 'Se exportaron $arg1 canciones a «$arg2».'; + } + + @override + String get extendedVolume => 'Volumen ampliado'; + + @override + String get externalLabel => 'Externo'; + + @override + String get externalSongsCannotBeEdited => + 'No se pueden editar canciones externas.'; + + @override + String get externalSongsCannotBeEdited2 => + 'No se pueden editar canciones externas'; + + @override + String get extraCovers => 'Portadas adicionales'; + + @override + String get failedToActivateFallback => 'No se pudo activar la alternativa'; + + @override + String failedToAddFolder(Object e) { + return 'No se pudo agregar la carpeta: $e'; + } + + @override + String failedToAddToFavorites(Object arg1) { + return 'No se pudo agregar «$arg1» a favoritos'; + } + + @override + String failedToClearCache(Object e) { + return 'No se pudo borrar la caché: $e'; + } + + @override + String get failedToDeactivateFallback => + 'No se pudo desactivar la alternativa'; + + @override + String failedToDownloadAlbumArt(int status) { + return 'No se pudo descargar la portada del álbum (HTTP $status).'; + } + + @override + String failedToGetPersistedUris(String? error) { + return 'No se pudieron obtener los URI persistentes: $error'; + } + + @override + String get failedToImportPresetFile => + 'No se pudo importar el archivo de preajuste.'; + + @override + String failedToOpenAllFilesAccess(Object e) { + return 'No se pudo abrir la configuración de acceso a todos los archivos: $e'; + } + + @override + String failedToOpenBatteryOptimizationSettings(Object e) { + return 'No se pudo abrir la configuración de optimización de batería: $e'; + } + + @override + String failedToOpenFolderPicker(String? error) { + return 'No se pudo abrir el selector de carpetas: $error'; + } + + @override + String get failedToPersistFolderAccess => + 'No se pudo conservar el acceso a la carpeta'; + + @override + String failedToPersistPermission(String? error) { + return 'No se pudo conservar el permiso: $error'; + } + + @override + String failedToReadBatteryOptimizationStatus(String? error) { + return 'No se pudo leer el estado de optimización de batería: $error'; + } + + @override + String failedToReleasePermission(String? error) { + return 'No se pudo liberar el permiso: $error'; + } + + @override + String failedToRemoveFolder(Object e) { + return 'No se pudo quitar la carpeta: $e'; + } + + @override + String failedToRemoveSongs(Object e) { + return 'No se pudieron quitar las canciones: $e'; + } + + @override + String failedToRequestBatteryOptimizationBypass(String? error) { + return 'No se pudo solicitar la excepción a la optimización de batería: $error'; + } + + @override + String get failedToSave => 'No se pudo guardar'; + + @override + String failedToSaveMetadata(Object e) { + return 'No se pudieron guardar los metadatos: $e'; + } + + @override + String get failedToSaveMetadata2 => 'No se pudieron guardar los metadatos.'; + + @override + String get failedToSaveTheRecapImage => + 'No se pudo guardar la imagen del resumen en la galería.'; + + @override + String get failedToSearchAlbumArtOnline => + 'No se pudo buscar la portada del álbum en línea.'; + + @override + String get failedToStartStreaming => 'No se pudo iniciar la transmisión'; + + @override + String get failedToStopStreaming => 'No se pudo detener la transmisión'; + + @override + String get failedToWritePlaylistFile => + 'No se pudo escribir el archivo de la lista de reproducción'; + + @override + String get failedToWriteTagsToTheFile => + 'No se pudieron escribir las etiquetas en el archivo.'; + + @override + String get faintHueShiftFromAlbumArt => + 'Ligero cambio de tono a partir de la portada del álbum.'; + + @override + String get fallback => 'Alternativa'; + + @override + String get fallbackAudio => 'Audio alternativo'; + + @override + String get fallbackAudioActivated => 'Se activó el audio alternativo'; + + @override + String get fallbackAudioDeactivated => 'Se desactivó el audio alternativo'; + + @override + String get fallbackAudioWillBeUsedIf => + 'Se usará el audio alternativo si falla el dispositivo UAC2'; + + @override + String get fastDirectTrackingImmediateResponse => + 'Seguimiento directo rápido: respuesta inmediata'; + + @override + String get fastIndexScrolling => 'Desplazamiento rápido por el índice'; + + @override + String get favoriteAll => 'Agregar todo a favoritos'; + + @override + String get favoriteRemoval => 'Quitar de favoritos'; + + @override + String get favoriteSongs => 'Canciones favoritas'; + + @override + String get favorites => 'Favoritos'; + + @override + String get favoritesYouHaveNotRevisitedLately => + 'Favoritos que hace tiempo no vuelves a escuchar'; + + @override + String get feb => 'feb'; + + @override + String get feedback => 'Comentarios'; + + @override + String get file => 'Archivo'; + + @override + String get fileInformation => 'Información del archivo'; + + @override + String get fileIsNoLongerAvailable => + 'Este archivo ya no está disponible. Es posible que se haya movido o eliminado. Vuelve a analizar la biblioteca e inténtalo de nuevo.'; + + @override + String get filePath => 'Ruta del archivo'; + + @override + String files(Object done, Object total) { + return '$done / $total archivos'; + } + + @override + String files2(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count archivos', + one: '$count archivo', + ); + return '$_temp0'; + } + + @override + String filesChecked(Object arg1) { + return 'Se revisaron $arg1 archivos…'; + } + + @override + String get filter => 'Filtrar'; + + @override + String get filterByFormat => 'FILTRAR POR FORMATO'; + + @override + String get filterFilesSizeLimitsAndPlaylist => + 'Filtrar archivos, establecer límites de tamaño y configurar la importación de listas de reproducción'; + + @override + String get filterLogs => 'Filtrar registros…'; + + @override + String get filterNonMusicFilesFolders => + 'Filtrar archivos y carpetas que no sean de música'; + + @override + String get findAndCleanUpDuplicateSongs => + 'Buscar y limpiar canciones duplicadas'; + + @override + String get findAndRemoveDuplicateSongs => + 'Buscar y quitar canciones duplicadas'; + + @override + String get findSongsArtistsAlbumsFolders => + 'Buscar canciones, artistas, álbumes y carpetas…'; + + @override + String get fineTuneTheOverallGain => + 'Ajustar con precisión la ganancia general'; + + @override + String get finishingMetadataEnrichment => + 'Finalizando el enriquecimiento de metadatos…'; + + @override + String finishingMetadataForSongs(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Finalizando los metadatos de $count canciones…', + one: 'Finalizando los metadatos de $count canción…', + ); + return '$_temp0'; + } + + @override + String get finishingUp => 'Terminando…'; + + @override + String get fix => 'Corregir'; + + @override + String get fixMissingMetadata => 'Corregir metadatos faltantes'; + + @override + String get fixedBands => '31 bandas fijas'; + + @override + String fixedCenterFrequenciesWithADb(Object arg1) { + return 'Frecuencias centrales fijas con un rango de $arg1 dB. Toca para interactuar.'; + } + + @override + String get flac24Bit96Khz => 'FLAC · 24 bits / 96 kHz'; + + @override + String get flat => 'Plano'; + + @override + String get flatResponse => 'Respuesta plana'; + + @override + String get flick => 'Flick'; + + @override + String get flickCanAttemptToPreferA => + 'Flick puede intentar dar prioridad al códec seleccionado arriba, pero el resultado depende del dispositivo, los audífonos y la versión de Android. Para forzar el códec se usa una API oculta del sistema y puede que no funcione en dispositivos sin root.'; + + @override + String get flickCanReceivePlaybackHandoffsFrom => + 'Flick puede recibir transferencias de reproducción de Locker (otra app de Moss). Las solicitudes de reproducción solo contienen las rutas y los metadatos de los archivos de canciones. No se intercambian datos personales. La integración funciona completamente de forma local.'; + + @override + String get flickChecksFlickPlayerSiteFor => + 'Flick busca actualizaciones en flick-player.site cuando tienes conexión a internet'; + + @override + String get flickIsBuiltAndMaintainedBy => + 'Flick lo desarrolla y mantiene una sola persona, sin presupuesto. No hay equipo, financiación ni anuncios.'; + + @override + String get flickLogs => 'Registros de Flick'; + + @override + String get flickNoLongerHasPermissionToEditThisFile => + 'Flick ya no tiene permiso para editar este archivo. Vuelve a agregar su carpeta en Ajustes para conceder acceso de edición e inténtalo de nuevo.'; + + @override + String get flickPlayer => 'Flick Player'; + + @override + String get flickPlayerDoesNotCollectStore => + 'Flick Player no recopila, almacena ni transmite datos personales. No reúne información personal, estadísticas de uso, informes de fallos ni identificadores publicitarios. No comparte datos con terceros.'; + + @override + String get flickPreview => 'Vista previa de Flick'; + + @override + String get flickReplay => 'Flick Replay'; + + @override + String get flickScansForPlayStoreUpdates => + 'Flick busca actualizaciones en Play Store cuando tienes conexión a internet'; + + @override + String get flickWillAlwaysBeFreeDonations => + 'Flick siempre será gratis. Las donaciones mantienen vivo el proyecto sin muros de pago ni suscripciones.'; + + @override + String get flickWillForceYourChosenCodec => + 'Flick forzará el códec que elegiste al conectarse'; + + @override + String get flickplayer => 'FlickPlayer'; + + @override + String get floatingIsland => 'Isla flotante'; + + @override + String get floatingMiniPlayer => 'Minirreproductor flotante'; + + @override + String get folder => 'Carpeta'; + + @override + String get folderLimit => 'LÍMITE DE CARPETAS'; + + @override + String get folderName => 'Nombre de la carpeta'; + + @override + String folderOf(Object current, Object total) { + return 'Carpeta $current de $total'; + } + + @override + String folderOf2(Object current, Object total) { + return 'Carpeta $current de $total'; + } + + @override + String get folderSongCount => 'Cantidad de canciones en la carpeta'; + + @override + String get folders => 'Carpetas'; + + @override + String folders2(Object arg1) { + return '$arg1 carpetas'; + } + + @override + String get foldersScanningAndDuplicates => 'Carpetas, análisis y duplicados'; + + @override + String get foldersShownPerPage => 'Carpetas por página'; + + @override + String get fontScale => 'Escala de fuente'; + + @override + String get footerLine => 'Línea de pie'; + + @override + String get forceDop => 'Forzar DoP'; + + @override + String get forceDopAlwaysUseDsdOver => + 'Forzar DoP: usar siempre DSD sobre PCM (DAC USB)'; + + @override + String get forcePcm => 'Forzar PCM'; + + @override + String get forcePcmAlwaysConvertDsdTo => + 'Forzar PCM: convertir siempre DSD a PCM'; + + @override + String get format => 'Formato'; + + @override + String get formatControlsAreDisabledTheEngine => + 'Los controles de formato están desactivados. El motor usa el formato predeterminado.'; + + @override + String get formatStrategy => 'Estrategia de formato'; + + @override + String get formatStrategyAndCustomFormatControls => + 'La estrategia de formato y los controles de formato personalizado están activos.'; + + @override + String get formatStrategyIsDisabledInBit => + 'La estrategia de formato está desactivada en el modo Bit perfecto (DAC USB), que requiere una coincidencia exacta de la frecuencia de muestreo. Desactiva Bit perfecto (DAC USB) para cambiar las preferencias de formato.'; + + @override + String get formatStrategyIsUnavailableBecauseAudio => + 'La estrategia de formato no está disponible porque el formato de audio está desactivado en Ajustes.'; + + @override + String foundOnline(Object arg1) { + return 'Se encontró «$arg1» en línea.'; + } + + @override + String frPkt(Object arg1) { + return '$arg1 tramas/paquete'; + } + + @override + String get freeOpenSource => 'Gratis y de código abierto'; + + @override + String get freq => 'Frec.'; + + @override + String get frequency => 'Frecuencia'; + + @override + String get frequencyFocus => 'Enfoque de frecuencias'; + + @override + String get freshAdditions => 'Novedades recientes'; + + @override + String from(Object sourceLabel) { + return 'De $sourceLabel'; + } + + @override + String get fromSquareCornersToARounded => + 'De esquinas cuadradas a una barra redondeada'; + + @override + String get fullBleedAlbumArtWithThe => + 'Portada del álbum a sangre, con la estética cinematográfica actual.'; + + @override + String get fullLibrary => 'Biblioteca completa'; + + @override + String get fullLibraryAccess => 'Acceso completo a la biblioteca'; + + @override + String get fullPlayer => 'Reproductor completo'; + + @override + String get fullScan => 'Análisis completo'; + + @override + String get fullSpectrum => 'Espectro completo'; + + @override + String get fullViewCardSize => 'Tamaño de tarjeta en vista completa'; + + @override + String get fullViewCardSize2 => 'Tamaño de tarjeta en vista completa'; + + @override + String get fullscreen => 'Pantalla completa'; + + @override + String get fundingNativeDsdDsfPlaybackDevelopment => + 'Financia el desarrollo de la reproducción DSD/DSF nativa, una función muy solicitada por los audiófilos.'; + + @override + String get fxOff => 'Efectos desactivados'; + + @override + String get fxOn => 'Efectos activados'; + + @override + String get gain => 'Ganancia'; + + @override + String get gallery => 'Galería'; + + @override + String get gapAboveNavigation => 'Espacio sobre la navegación'; + + @override + String get gaplessPlayback => 'Reproducción sin pausas'; + + @override + String get gaplessViewModeAndAppearance => + 'Reproducción sin pausas, modo de vista y apariencia'; + + @override + String gb(Object arg1) { + return '$arg1 GB'; + } + + @override + String get generatedFromYourListeningHabitsFavorites => + 'Se generan a partir de tus hábitos de escucha, tus favoritos y lo que agregaste recientemente.'; + + @override + String get genre => 'Género'; + + @override + String get geometry => 'Geometría'; + + @override + String get getStarted => 'Comenzar'; + + @override + String get getTheLatestApkFromFlick => + 'Descarga el APK más reciente desde flick-player.site'; + + @override + String get getYourApiCredentials => 'Obtener credenciales de API'; + + @override + String get github => 'GitHub'; + + @override + String get goToAlbum => 'Ir al álbum'; + + @override + String get goToArtist => 'Ir al artista'; + + @override + String get goodAfternoon => 'Buenas tardes'; + + @override + String get goodEvening => 'Buenas noches'; + + @override + String get goodMorning => 'Buenos días'; + + @override + String get gotIt => 'Entendido'; + + @override + String get grantBluetoothAccess => 'Conceder acceso a Bluetooth'; + + @override + String get grantedScansReadEveryVolumeDirectly => + 'Concedido: el análisis lee directamente todos los volúmenes, incluidos DSD, DSF y WavPack'; + + @override + String get graphic => 'Gráfico'; + + @override + String get graphicEq => 'Ecualizador gráfico'; + + @override + String get green => 'Verde'; + + @override + String get groupingByTitleArtistThisIs => + 'Agrupar por título y artista suele ser rápido.'; + + @override + String get groups => 'Grupos'; + + @override + String groupsToRemove(Object arg1, Object arg2) { + return '$arg1 grupos • $arg2 por quitar'; + } + + @override + String groupsToRemove2(Object arg1, Object toRemove) { + return '$arg1 grupos • $toRemove por quitar'; + } + + @override + String get growsFurtherIfLargerSystemText => + 'Se amplía si el texto grande del sistema necesita más espacio'; + + @override + String hAgo(Object arg1) { + return 'hace $arg1 h'; + } + + @override + String get hapticFeedback => 'Respuesta háptica'; + + @override + String get hardwareUsbDac => 'Hardware (DAC USB)'; + + @override + String get hardwareVolumeIsDetectedButWrites => + 'Se detecta el volumen del hardware, pero no se permiten cambios mientras está activa la reproducción USB directa.'; + + @override + String get hasArtwork => 'Tiene portada'; + + @override + String get havingMoreThan4ButtonsMay => + 'Más de 4 botones pueden comprimir sus etiquetas de texto. Prueba a reducir el espacio entre los botones más abajo.'; + + @override + String get heavyRotation => 'En rotación frecuente'; + + @override + String get held => 'En espera'; + + @override + String get help => 'Ayuda'; + + @override + String get helpManual => 'Ayuda y manual'; + + @override + String get hiResDirect => 'Directo de alta resolución'; + + @override + String get hidden => 'Oculto'; + + @override + String get hideLyrics => 'Ocultar letras'; + + @override + String get hideNavigationButtonsAfterBeingIdle => + 'Ocultar los botones de navegación tras un periodo de inactividad'; + + @override + String get hidePassword => 'Ocultar contraseña'; + + @override + String get hideShortStingersRingtonesAndVoice => + 'Ocultar fragmentos cortos, tonos de llamada y fragmentos de voz'; + + @override + String get hideTheFloatingMiniPlayerPill => + 'Ocultar la pastilla flotante del minirreproductor'; + + @override + String get hideTheIndexRailAfterInactivity => + 'Ocultar el índice tras un periodo de inactividad'; + + @override + String get hideVisualizer => 'Ocultar visualizador'; + + @override + String get hideVisualizer2 => 'Ocultar visualizador'; + + @override + String get high => 'Alto'; + + @override + String get high120hz => 'Alto (120 Hz)'; + + @override + String get highFrequenciesOnly => 'Solo frecuencias altas'; + + @override + String get highPass => 'Filtro pasa altos'; + + @override + String get highQuality => 'Alta calidad'; + + @override + String get highQualityEngine => 'Motor de alta calidad'; + + @override + String get highQualityWidelySupported => + 'Alta calidad y amplia compatibilidad'; + + @override + String get highResolutionAptx => 'aptX de alta resolución'; + + @override + String get highShelf => 'Filtro shelving de agudos'; + + @override + String get highestBitrateUpTo990Kbps => + 'La tasa de bits más alta (hasta 990 kbps)'; + + @override + String get highestQuality => 'Máxima calidad'; + + @override + String get historyCleared => 'Se borró el historial'; + + @override + String get holdASongToUnfavorite => + 'Mantén presionada una canción para quitarla de favoritos'; + + @override + String get homeScreenSections => 'Secciones de la pantalla de inicio'; + + @override + String get horizontalReach => 'Alcance horizontal'; + + @override + String hourUnit(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'horas', + one: 'hora', + ); + return '$_temp0'; + } + + @override + String get howFarTheArcOpensFrom => + 'Qué tanto se abre el arco desde el borde izquierdo'; + + @override + String get howMuchSideCardsShrinkAway => + 'Cuánto se reducen las tarjetas laterales al alejarse del centro'; + + @override + String get howWeHandleYourData => 'Cómo tratamos tus datos'; + + @override + String get howWideEachCardSpansAcross => + 'Qué ancho ocupa cada tarjeta en la pantalla'; + + @override + String get httpBasicNeedsItRecoverableStored => + 'HTTP Basic necesita poder recuperar la contraseña; se guarda codificada'; + + @override + String hz(Object rate) { + return '$rate Hz'; + } + + @override + String hz3(Object hz) { + return '$hz Hz'; + } + + @override + String get hz5 => 'Hz'; + + @override + String hz6(Object arg1) { + return '$arg1 Hz'; + } + + @override + String get hzTuning => 'Afinación a 432 Hz'; + + @override + String get iconSize => 'Tamaño de ícono'; + + @override + String identified(int count, Object note) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Se identificaron $count canciones', + one: 'Se identificó $count canción', + ); + return '$_temp0$note.'; + } + + @override + String get identifyAlbum => 'Identificar álbum'; + + @override + String get identifyAlbum2 => 'Identificar álbum'; + + @override + String get identifyAlbumsWithUnknownArtistOr => + 'Identificar álbumes con etiquetas de artista o título desconocidas'; + + @override + String get idle => 'Inactivo'; + + @override + String get ifYouConnectYourLastFm => + 'Si conectas tu cuenta de Last.fm, las credenciales se guardan de forma segura en el dispositivo. Los datos de reproducción solo se envían a Last.fm. No recibimos ni procesamos esos datos.'; + + @override + String get ignoreTracksUnder500Kb => 'Ignorar pistas de menos de 500 KB'; + + @override + String get ignoreTracksUnder60Seconds => + 'Ignorar pistas de menos de 60 segundos'; + + @override + String get immersive => 'Inmersivo'; + + @override + String get immersiveFullViewTimer => + 'Temporizador de vista completa inmersiva'; + + @override + String importFailed(Object e) { + return 'Error al importar: $e'; + } + + @override + String get importM3uM3u8 => 'Importar M3U/M3U8'; + + @override + String get importM3uM3u8Playlists => 'Importar listas M3U/M3U8'; + + @override + String get importPresetFile => 'Importar archivo de preajuste'; + + @override + String imported(Object arg1) { + return 'Se importó «$arg1»'; + } + + @override + String get importedArtIsSavedInsideThe => + 'La portada importada se guarda en la app y se sincroniza con todas las canciones de este álbum.'; + + @override + String get importedArtIsSavedInsideThe2 => + 'La portada importada se guarda en la app solo para esta canción.'; + + @override + String get importedPreset => 'Preajuste importado'; + + @override + String importedWithSongs(Object arg1, Object arg2, Object unmatchedText) { + return 'Se importó «$arg1» con $arg2 canciones.$unmatchedText'; + } + + @override + String get impulseResponse => 'Respuesta al impulso'; + + @override + String get inAppUpdates => 'Actualizaciones desde la app'; + + @override + String inLabel(Object folder) { + return 'en $folder'; + } + + @override + String inYourLibrary(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return '$_temp0 en tu biblioteca'; + } + + @override + String get inactive => 'Inactivo'; + + @override + String get incredibleOverAMonthOfDaily => + 'Increíble: más de un mes escuchando música todos los días.'; + + @override + String get info2 => 'Información'; + + @override + String get initializing => 'Inicializando…'; + + @override + String get inkCardWithTheReplaySignature => + 'Tarjeta de tinta con los acentos característicos de Replay'; + + @override + String get inputGain => 'Ganancia de entrada'; + + @override + String get insertIntoTheCurrentQueueFallBackToResults => + 'Insertar en la cola actual; si no, volver a los resultados'; + + @override + String get inst => 'Inst.'; + + @override + String get instructions => 'Instrucciones'; + + @override + String get instrumental => 'Instrumental'; + + @override + String get integrations => 'Integraciones'; + + @override + String get interactiveEq => 'Ecualizador interactivo'; + + @override + String get interactiveTutorial => 'Tutorial interactivo'; + + @override + String get interfaceClaimed => 'Interfaz asignada'; + + @override + String get interfaceLabel => 'Interfaz'; + + @override + String get invalidToken => 'Token no válido'; + + @override + String isOfflineRetainedSongsStillListed(Object folder) { + return '$folder está sin conexión; las canciones guardadas siguen en la lista'; + } + + @override + String get isochronousUsb => 'USB isócrono'; + + @override + String get itemSpacing => 'Espacio entre elementos'; + + @override + String items(Object count) { + return '$count elementos'; + } + + @override + String get jan => 'ene'; + + @override + String get jellyfin => 'Jellyfin'; + + @override + String get jellyfinEmby => 'Jellyfin · Emby'; + + @override + String get jul => 'jul'; + + @override + String get jumpBackIn => 'Retomar'; + + @override + String get jumpToTheFlickListingAnd => + 'Ve a la ficha de Flick y actualiza desde allí'; + + @override + String get jun => 'jun'; + + @override + String get justAudioExoplayer => 'just_audio / ExoPlayer'; + + @override + String get justAudioExoplayerDefault => + 'just_audio / ExoPlayer (predeterminado)'; + + @override + String get justNow => 'Ahora mismo'; + + @override + String get karaokeEffect => 'Efecto de karaoke'; + + @override + String get karaokePreview => 'Vista previa de karaoke'; + + @override + String kb(Object arg1) { + return '$arg1 KB'; + } + + @override + String get keepAll => 'Conservar todo'; + + @override + String get keepEditing => 'Seguir editando'; + + @override + String get keepItGoingOpenTomorrowTo => + 'Sigue así. Abre la app mañana para sumar otro día.'; + + @override + String get keepListeningWithFlick => 'Sigue escuchando con Flick'; + + @override + String get keepMiniPlayerAndNavVisible => + 'Mantener visible el minirreproductor y la navegación'; + + @override + String get keepPlaybackPausedWhenADevice => + 'Mantener la reproducción en pausa cuando se reconecte un dispositivo'; + + @override + String get keepPlayingOnQuit => 'Seguir reproduciendo al salir'; + + @override + String get keepRelativeLevelsInsideEachAlbum => + 'Conservar los niveles relativos dentro de cada álbum'; + + @override + String get keepTheSessionMovingOrHead => + 'Sigue con la sesión o vuelve directamente al reproductor.'; + + @override + String get keepYourReplay => 'Conserva tu Replay.'; + + @override + String keeping(Object type, Object br) { + return 'Conservando • $type • $br'; + } + + @override + String keepingOfToRemove(Object keptCount, Object arg1, Object removeCount) { + return 'Se conservan $keptCount de $arg1 • se quitarán $removeCount'; + } + + @override + String get keepingThisVersion => 'Conservar esta versión'; + + @override + String get keepsBitPerfectAudioAliveIn => + 'Mantiene el audio bit perfecto activo en segundo plano'; + + @override + String get keepsSoftwareVolumeAndDspActive => + 'Mantiene activos el volumen por software y el DSP en la ruta compartida del DAP.'; + + @override + String get keptInSecureStorageToRe => + 'Se conserva en el almacenamiento seguro para volver a iniciar sesión cuando venza el token'; + + @override + String keptWillBeRemoved(Object keptCount, Object removeCount) { + return '$keptCount se conservan • se quitarán $removeCount'; + } + + @override + String khz(Object arg1) { + return '$arg1 kHz'; + } + + @override + String khz2(Object arg1) { + return '$arg1 kHz'; + } + + @override + String khzBit(Object arg1, Object arg2) { + return '$arg1 kHz/$arg2 bits'; + } + + @override + String khzBit2(Object arg1, Object arg2) { + return '$arg1 kHz/$arg2 bits'; + } + + @override + String khzBitCh(Object arg1, Object arg2, Object arg3) { + return '$arg1 kHz / $arg2 bits / $arg3 canales'; + } + + @override + String get koFi => 'Ko-fi'; + + @override + String get label => 'Etiqueta'; + + @override + String get labelOrganization => 'Sello discográfico / organización'; + + @override + String get landscape => 'Horizontal'; + + @override + String get landscapeLayoutReset => 'Se restableció el diseño horizontal'; + + @override + String get language => 'Idioma'; + + @override + String get languageSectionDescription => + 'Elige el idioma que se usará en toda la app.'; + + @override + String get languageSystemDefault => 'Predeterminado del sistema'; + + @override + String get lastFm => 'Last.fm'; + + @override + String get lastFmConfiguration => 'Configuración de Last.fm'; + + @override + String get lastFmConnected => 'Last.fm conectado'; + + @override + String get lastFmConnected2 => 'Se conectó Last.fm.'; + + @override + String get lastFmListenbrainzScrobbling => + 'Registro de reproducciones en Last.fm y ListenBrainz'; + + @override + String get lastFmScrobbling => 'Registro de reproducciones en Last.fm'; + + @override + String get lastPick => 'Última selección'; + + @override + String get lastUpdated => 'Última actualización'; + + @override + String get lastWeek => 'La semana pasada'; + + @override + String get lateNightSessions => 'Sesiones nocturnas'; + + @override + String get latestArrivalsFromYourLibrary => + 'Lo último que llegó a tu biblioteca'; + + @override + String get latestUpdate => 'Última actualización'; + + @override + String get layered => 'En capas'; + + @override + String get layoutMode => 'Modo de diseño'; + + @override + String get layoutModeSizingAndQuickActions => + 'Modo de diseño, tamaño y acciones rápidas'; + + @override + String get ldac330Kbps => 'LDAC 330 kbps'; + + @override + String get ldac660Kbps => 'LDAC 660 kbps'; + + @override + String get ldac990Kbps => 'LDAC 990 kbps'; + + @override + String get ldacAdaptive => 'LDAC adaptable'; + + @override + String get ldacBitsPerSample => 'Bits por muestra de LDAC'; + + @override + String get leLsbLittleEndianSubslotLsb => + 'LE-LSB: subranura en orden little-endian, primero el bit menos significativo'; + + @override + String get leMsbLittleEndianSubslotMsb => + 'LE-MSB: subranura en orden little-endian, primero el bit más significativo'; + + @override + String get leaveEmptyToKeepTheCurrent => + 'Déjalo vacío para conservar las credenciales actuales'; + + @override + String get left => 'Izquierda'; + + @override + String get leftBottom => 'Izquierda (abajo)'; + + @override + String get leftBottomButton => 'Botón izquierdo (abajo)'; + + @override + String get leftTop => 'Izquierda (arriba)'; + + @override + String get leftTopButton => 'Botón izquierdo (arriba)'; + + @override + String get length => 'Duración:'; + + @override + String get lengthOfTheOverlap => 'Duración del solapamiento'; + + @override + String lengthS(Object arg1) { + return 'Duración: $arg1 s'; + } + + @override + String get letAndroidChooseTheBestCodec => + 'Permitir que Android elija el mejor códec'; + + @override + String get letAndroidChooseTheOutputDevice => + 'Permitir que Android elija el dispositivo de salida'; + + @override + String get letAndroidNegotiateTheCodecAutomatically => + 'Permitir que Android negocie el códec automáticamente'; + + @override + String get letOboePickTheBestApi => + 'Permitir que Oboe elija la mejor API. Primero AAudio y luego OpenSL ES como alternativa.'; + + @override + String get letTheSystemDecideBestBattery => + 'Dejar que el sistema decida: máximo ahorro de batería'; + + @override + String get letsFlickScanYourEntireLibrary => + 'Permite que Flick analice directamente toda tu biblioteca, incluidos los archivos DSD, DSF y WavPack que algunos dispositivos ocultan del índice multimedia del sistema'; + + @override + String get level => 'Nivel'; + + @override + String get libraryEmptied => 'Se vació la biblioteca'; + + @override + String get libraryGlanceCard => 'Tarjeta de resumen de la biblioteca'; + + @override + String get libraryLabel => 'Biblioteca'; + + @override + String get licenses => 'Licencias'; + + @override + String get light => 'Claro'; + + @override + String likedSongs(Object arg1) { + return '$arg1 canciones que te gustan'; + } + + @override + String get likedSongsLiveHere => 'Aquí están tus canciones favoritas'; + + @override + String get likesAndReplaysBlendedTogether => + 'Me gusta y repeticiones combinados'; + + @override + String get limit => 'Límite'; + + @override + String get limitPositiveGainSoTheLevel => + 'Limitar la ganancia positiva para que el nivel nunca supere el máximo'; + + @override + String get limiter => 'Limitador'; + + @override + String get limiterOff => 'Limitador desactivado'; + + @override + String get limiterOn => 'Limitador activado'; + + @override + String get line => 'Línea'; + + @override + String lineOf(Object arg1, Object arg2) { + return 'Línea $arg1 de $arg2'; + } + + @override + String lineOfWords( + Object arg1, + Object arg2, + Object captured, + Object segmentCount, + ) { + return 'Línea $arg1 de $arg2 · $captured/$segmentCount palabras'; + } + + @override + String get lineThickness => 'Grosor de línea'; + + @override + String get lineThicknessDescription => + 'Ajusta el grosor de la línea de progreso.'; + + @override + String get linear => 'Lineal'; + + @override + String get lines => 'Líneas'; + + @override + String lines2(Object arg1) { + return '$arg1 líneas'; + } + + @override + String get linkReady => 'Enlace listo'; + + @override + String linkedToThisSong(Object arg1) { + return 'Se vinculó «$arg1» con esta canción.'; + } + + @override + String get list => 'Lista'; + + @override + String get listAvailableLocalAudioOutputDevices => + 'Mostrar los dispositivos locales de salida de audio disponibles'; + + @override + String get listenbrainz => 'ListenBrainz'; + + @override + String get listenbrainzConnected => 'ListenBrainz conectado'; + + @override + String get listenbrainzConnected2 => 'Se conectó ListenBrainz.'; + + @override + String get listeningHours => 'Horas de escucha'; + + @override + String listeningToByOnFlick(Object arg1, Object arg2) { + return 'Escuchando $arg1 de $arg2 en Flick'; + } + + @override + String get littleEndianSubslotLsbFirstBits => + 'Subranura en orden little-endian, primero los bits menos significativos'; + + @override + String get littleEndianSubslotMsbFirstBits => + 'Subranura en orden little-endian, primero los bits más significativos'; + + @override + String get livePreview => 'Vista previa en tiempo real'; + + @override + String get livingOrnament => 'Adorno animado'; + + @override + String get loadAJsonOrTxtPreset => 'Cargar un preajuste JSON o TXT'; + + @override + String get loadAnImpulseResponseForRoom => + 'Cargar una respuesta al impulso para reverberación de sala, mezcla entre canales, gabinete o corrección.'; + + @override + String get loadIr => 'Cargar respuesta al impulso'; + + @override + String loadedIr(Object displayName) { + return 'Respuesta al impulso cargada: $displayName'; + } + + @override + String get loadingArtwork => 'Cargando portada'; + + @override + String get loadingArtwork2 => 'Cargando portada…'; + + @override + String get loadingFavoritesRecentSessionsGenerated => + 'Cargando favoritos, sesiones recientes, mezclas generadas y listas de reproducción.'; + + @override + String get loadingPatchNotes => 'Cargando notas de la versión…'; + + @override + String get loadingReplay => 'Cargando Replay'; + + @override + String get loadingSession => 'Cargando sesión…'; + + @override + String get localData => 'Datos locales'; + + @override + String get locked => 'Bloqueado'; + + @override + String get logFrequencyControl => 'Control de frecuencia logarítmica'; + + @override + String get logs => 'Registros'; + + @override + String get logsCopied => 'Registros copiados'; + + @override + String get longPress => 'Mantener presionado'; + + @override + String get longSongTitles => 'Títulos de canciones largos'; + + @override + String get look => 'Apariencia'; + + @override + String get lookingForCoverArtFromMusicbrainz => + 'Buscando portadas en MusicBrainz y Cover Art Archive.'; + + @override + String get lookingForTheLatestFlickRelease => + 'Buscando la versión más reciente de Flick'; + + @override + String get lookingForTheLatestPlayStore => + 'Buscando la actualización más reciente de Play Store'; + + @override + String get lossless => ' Sin pérdida'; + + @override + String get losslessQualityPreservedDuringConversion => + 'Se conserva la calidad sin pérdida durante la conversión'; + + @override + String get low => 'Bajo'; + + @override + String get lowAndHighFrequenciesScoopedMids => + 'Graves y agudos realzados, medios atenuados'; + + @override + String get lowFrequenciesOnly => 'Solo frecuencias bajas'; + + @override + String get lowLatencyGoodQuality => 'Baja latencia, buena calidad'; + + @override + String get lowLatencyMode => 'Modo de baja latencia'; + + @override + String get lowPass => 'Filtro pasa bajos'; + + @override + String get lowShelf => 'Filtro shelving de graves'; + + @override + String get lrclib => 'LRCLib'; + + @override + String get lyric => 'Letra'; + + @override + String get lyrics => 'Letras'; + + @override + String get lyricsPreview => 'Vista previa de letras'; + + @override + String get lyricsSavedFromLrclib => 'Letras guardadas desde LRCLib.'; + + @override + String get lyricsSavingBehavior => 'Comportamiento al guardar letras'; + + @override + String get lyricsSyncHelp => 'Ayuda para sincronizar letras'; + + @override + String get lyricsSyncStudio => 'Estudio de letras y sincronización'; + + @override + String get lyricsText => 'Texto de las letras'; + + @override + String m(Object arg1) { + return '$arg1 min'; + } + + @override + String m2(Object arg1) { + return '$arg1 min'; + } + + @override + String mAgo(Object arg1) { + return 'hace $arg1 min'; + } + + @override + String get madeForYou => 'Hecho para ti'; + + @override + String get makeup => 'Compensación'; + + @override + String get manual => 'Manual'; + + @override + String get manualOrder => 'Orden manual'; + + @override + String get manualQueue => 'Cola manual'; + + @override + String get manufacturer => 'Fabricante'; + + @override + String get mar => 'mar'; + + @override + String get masterBypassed => 'Ecualizador principal omitido'; + + @override + String get matchAudioFilename => + 'Coincidir con el nombre del archivo de audio'; + + @override + String matchByArtistAlbumAndTrack(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count archivos', + one: '$count archivo', + ); + return 'Identificar $_temp0 por artista, álbum y duración de la pista'; + } + + @override + String get matchEqToYourHeadphoneModel => + 'Ajustar el ecualizador a tu modelo de audífonos'; + + @override + String get matchNavigation => 'Igualar navegación'; + + @override + String get matches => 'Coincidencias'; + + @override + String maxB(Object arg1) { + return 'Máx. $arg1 B'; + } + + @override + String get maximumAudioQuality => 'Máxima calidad de audio'; + + @override + String get maximumSmoothnessUsesMoreBattery => + 'Máxima fluidez: consume más batería'; + + @override + String get may => 'may'; + + @override + String get may42026 => '4 de mayo de 2026'; + + @override + String get mayStopInTheBackgroundOn => + 'Puede que en algunos dispositivos deje de funcionar en segundo plano'; + + @override + String mb(Object arg1) { + return '$arg1 MB'; + } + + @override + String get media => 'Multimedia'; + + @override + String get medium => 'Medio'; + + @override + String get menu => 'Menú'; + + @override + String get metadata => 'Metadatos'; + + @override + String get metropolitan => 'Metropolitano'; + + @override + String mhz(Object arg1) { + return '$arg1 MHz'; + } + + @override + String get mid => 'Medios'; + + @override + String get midFrequenciesOnly => 'Solo frecuencias medias'; + + @override + String get midnightCityDreams => 'Sueños de ciudad a medianoche'; + + @override + String get midnightDreams => 'Sueños de medianoche'; + + @override + String get midnightSignal => 'Señal de medianoche'; + + @override + String get milestone => 'Hito'; + + @override + String get milestones => 'Hitos'; + + @override + String min(Object arg1) { + return '$arg1 min'; + } + + @override + String get miniPlayer => 'Minirreproductor'; + + @override + String get miniPlayerAppearance => 'Apariencia del minirreproductor'; + + @override + String get miniPlayerDefaultsRestored => + 'Se restablecieron los valores predeterminados del minirreproductor'; + + @override + String get miniPlayerHeight => 'Altura del minirreproductor'; + + @override + String get miniPlayerLayout => 'Diseño del minirreproductor'; + + @override + String get minimal => 'Mínimo'; + + @override + String get minimize => 'Minimizar'; + + @override + String get minimserverServiioKodi => 'MinimServer · Serviio · Kodi'; + + @override + String get mirrorTest => 'Prueba de espejo'; + + @override + String get mirrored => 'En espejo'; + + @override + String get mitLicenseCopyrightC2026Flick => + 'Licencia MIT\n\nCopyright (c) 2026 Colaboradores de Flick Player\n\nPor la presente se concede permiso, sin cargo, a toda persona que obtenga una copia de este software y de los archivos de documentación asociados (el «Software») para tratar el Software sin restricciones, incluidos, entre otros, los derechos de usar, copiar, modificar, combinar, publicar, distribuir, sublicenciar o vender copias del Software, y permitir que las personas a quienes se proporcione el Software lo hagan, sujeto a las siguientes condiciones:\n\nEl aviso de derechos de autor anterior y este aviso de permiso deben incluirse en todas las copias o partes sustanciales del Software.\n\nEL SOFTWARE SE PROPORCIONA «TAL CUAL», SIN GARANTÍAS DE NINGÚN TIPO, EXPRESAS O IMPLÍCITAS, INCLUIDAS, ENTRE OTRAS, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN FIN DETERMINADO Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE LOS DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGUNA RECLAMACIÓN, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, EXTRACONTRACTUAL O DE OTRO TIPO, QUE SURJA DE, SE DERIVE DE O ESTÉ RELACIONADA CON EL SOFTWARE O SU USO U OTRAS OPERACIONES CON EL SOFTWARE.\n'; + + @override + String get mix => 'Mezcla'; + + @override + String mix2(Object arg1) { + return 'Mezcla $arg1'; + } + + @override + String get mixer => 'Mezclador'; + + @override + String get mixerManagement => 'Administración del mezclador'; + + @override + String moAgo(Object arg1) { + return 'hace $arg1 meses'; + } + + @override + String get mod => 'Mod'; + + @override + String get moderate => 'Moderado'; + + @override + String get mono => 'Mono'; + + @override + String get monthly => 'Mensual'; + + @override + String get more => 'Más'; + + @override + String more2(Object arg1, Object arg2) { + return '$arg1 + $arg2 más'; + } + + @override + String get moreActions => 'Más acciones'; + + @override + String get moreArtists => 'Más artistas'; + + @override + String get moreArtists2 => 'Más artistas'; + + @override + String get moreExportOptions => 'Más opciones de exportación'; + + @override + String moreFrom(Object arg1) { + return 'Más de $arg1'; + } + + @override + String get moreFromArtist => 'Más de este artista'; + + @override + String get moreFromArtist2 => 'Más de este artista'; + + @override + String moreTo(Object arg1, Object arg2) { + return '$arg1 más para $arg2'; + } + + @override + String moreToUnlock(Object remaining, Object unit) { + return '$remaining $unit más para desbloquear.'; + } + + @override + String get mossEcosystem => 'Ecosistema Moss'; + + @override + String get mostDlnaServersNeedNoPassword => + 'La mayoría de los servidores DLNA no requieren contraseña'; + + @override + String get mostPlayed => 'Más reproducidas'; + + @override + String mostReplayed(Object arg1) { + return 'Más repetida · $arg1'; + } + + @override + String get motionArtInBitPerfect => 'Motion Art en modo bit perfecto'; + + @override + String get motionArtIsReplacedWhileBit => + 'La animación de portada se reemplaza mientras está activa la salida bit perfecta'; + + @override + String get motionArtPlaysDuringBitPerfect => + 'La animación de portada se reproduce con audio bit perfecto (puede interrumpir la reproducción en algunos DAP)'; + + @override + String get motionArtRefreshed => 'Se actualizó la animación de portada'; + + @override + String get moveEveryStampedLyricForwardOr => + 'Desplazar todas las líneas de letras sincronizadas hacia adelante o hacia atrás a la vez.'; + + @override + String get movement => 'Movimiento'; + + @override + String ms(Object arg1) { + return '$arg1 ms'; + } + + @override + String ms2(Object arg1) { + return '$arg1 ms'; + } + + @override + String ms3(Object arg1) { + return '$arg1 ms'; + } + + @override + String ms4(Object arg1) { + return '$arg1 ms'; + } + + @override + String ms5(Object arg1) { + return '$arg1 ms'; + } + + @override + String get multiFilterBands => 'Bandas con varios filtros'; + + @override + String musicFolders(Object arg1) { + return '$arg1 carpetas de música'; + } + + @override + String get mute => 'Silenciar'; + + @override + String my(Object arg1) { + return 'Mi $arg1'; + } + + @override + String nDb(Object arg1, Object arg2) { + return '$arg1%\n$arg2 dB'; + } + + @override + String get nameAZ => 'Nombre (A-Z)'; + + @override + String narrow(Object amount) { + return '$amount% más estrecho'; + } + + @override + String get nativeDsd => 'DSD nativo'; + + @override + String get nativeDsdExperimental => 'DSD nativo (experimental)'; + + @override + String get nativeDsdExperimentalMayBeBuggy => + 'DSD nativo: experimental (puede tener errores)'; + + @override + String get nativeFlickPresetFormat => 'Formato nativo de preajustes de Flick'; + + @override + String get naturalEqualizerFeelResponsiveYetSmooth => + 'Ecualizador natural: respuesta rápida y a la vez fluida'; + + @override + String get natureAmbient => 'Ambiente natural'; + + @override + String get navidromeAirsonicGonic => 'Navidrome · Airsonic · Gonic'; + + @override + String get navigationAppearance => 'Apariencia de navegación'; + + @override + String get navigationBar => 'Barra de navegación'; + + @override + String get navigationDefaultsRestored => + 'Se restablecieron los valores predeterminados de navegación'; + + @override + String get needsMetadata => 'Faltan metadatos'; + + @override + String negotiated(Object arg1) { + return 'Negociado: $arg1'; + } + + @override + String get neonLimeWithSignalOrangeReplay => + 'Verde neón con acentos naranja señal de Replay'; + + @override + String get neonNights => 'Noches de neón'; + + @override + String get neonPulse => 'Pulso de neón'; + + @override + String get neonSkyline => 'Horizonte de neón'; + + @override + String get network => 'Red'; + + @override + String get networkSources => 'Fuentes de red'; + + @override + String neutral(Object amount) { + return '$amount% neutral'; + } + + @override + String get neverSynced => 'Nunca sincronizado'; + + @override + String get newLabel => 'Nuevo'; + + @override + String get next => 'Siguiente'; + + @override + String get nextSong => 'Canción siguiente'; + + @override + String get nextSong2 => 'Canción siguiente'; + + @override + String nextToGo(Object arg1, Object remaining, Object unit) { + return 'Siguiente: $arg1 — faltan $remaining $unit'; + } + + @override + String get nextcloudOwncloudSabredav => 'Nextcloud · ownCloud · SabreDAV'; + + @override + String get night => 'Noche'; + + @override + String get no => 'No'; + + @override + String get noAchievementsYetKeepListening => + 'Aún no hay logros: sigue escuchando'; + + @override + String get noAlbumDataYet => 'Aún no hay datos del álbum'; + + @override + String get noAlbumsFound => 'No se encontraron álbumes'; + + @override + String get noAppleMusicReleaseFoundTry => + 'No se encontró el lanzamiento en Apple Music. Prueba a editar el nombre del artista o del álbum y vuelve a buscar.'; + + @override + String get noArtistsFound => 'No se encontraron artistas'; + + @override + String noArtistsMatch(Object _searchQuery) { + return 'Ningún artista coincide con «$_searchQuery»'; + } + + @override + String get noAudioWasFoundIfThis => + 'No se encontró audio. Si esta carpeta contiene música, es posible que un archivo .nomedia la esté ocultando o que Android aún no la haya indexado. Prueba a activar el análisis profundo o quita cualquier archivo .nomedia y vuelve a analizarla.'; + + @override + String get noCastingDevicesFoundMakeSure => + 'No se encontraron dispositivos para transmitir. Asegúrate de que el teléfono y el receptor estén conectados a la misma red.'; + + @override + String get noCategoriesSelected => 'No hay categorías seleccionadas'; + + @override + String get noChangelogNotesForThisVersion => + 'Aún no hay notas de cambios para esta versión.'; + + @override + String get noCustomAlbumArtIsSet => + 'Todavía no hay una portada personalizada para el álbum.'; + + @override + String get noCustomPresetsYet => 'Aún no hay preajustes personalizados.'; + + @override + String get noDuplicatesFound => 'No se encontraron duplicados'; + + @override + String get noFavoritesYet => 'Aún no tienes favoritos'; + + @override + String get noFeaturedTrackYet => 'Aún no hay una pista destacada'; + + @override + String get noFiltersFoundInPresetFile => + 'No se encontraron filtros en el archivo de preajuste.'; + + @override + String get noFoldersAdded => 'No se agregaron carpetas'; + + @override + String get noHistoryYet => 'Aún no hay historial'; + + @override + String get noInternetConnectionPleaseCheckYour => + 'No hay conexión a internet. Comprueba la red e inténtalo de nuevo.'; + + @override + String get noLibraryFilesForThisAlbum => + 'No se encontraron archivos de la biblioteca para este álbum.'; + + @override + String get noLogsYet => 'Aún no hay registros.'; + + @override + String get noLyricsFoundOnlineForThis => + 'No se encontraron letras en línea para esta canción.'; + + @override + String get noLyricsYet => 'Aún no hay letras'; + + @override + String get noMatchFound => 'No se encontró ninguna coincidencia'; + + @override + String get noMatches => 'No hay coincidencias.'; + + @override + String noMatchesFor(Object _query) { + return 'No hay coincidencias para «$_query»'; + } + + @override + String get noMatchesFound => 'No se encontraron coincidencias'; + + @override + String get noMatchesTryFewerWordsOr => + 'No hay coincidencias. Prueba con menos palabras o busca en línea.'; + + @override + String get noMusicYet => 'Aún no hay música'; + + @override + String get noNewAdditionsYet => 'Todavía no hay canciones nuevas'; + + @override + String get noNewUpdateFound => 'No se encontraron actualizaciones nuevas.'; + + @override + String get noOnlineArtworkFound => 'No se encontraron portadas en línea'; + + @override + String get noOutputDevicesAvailable => + 'No hay dispositivos de salida disponibles.'; + + @override + String get noPatchNotesAvailableYet => 'Aún no hay notas de la versión.'; + + @override + String get noPlaybackYet => 'Aún no hay reproducciones'; + + @override + String get noPlaylistsYet => 'Aún no hay listas de reproducción'; + + @override + String get noPlaylistsYet2 => 'Aún no hay listas de reproducción'; + + @override + String get noPlaylistsYetNcreateOneIn => + 'Aún no hay listas de reproducción.\nCrea una en la pestaña Listas.'; + + @override + String get noRankingDataYet => 'Aún no hay datos de clasificación'; + + @override + String noResultsFor(Object query) { + return 'No hay resultados para «$query»'; + } + + @override + String noResultsFoundFor(Object query) { + return 'No se encontraron resultados para «$query».'; + } + + @override + String get noRipData => 'No hay datos de extracción'; + + @override + String get noScanResultsYet => 'Aún no hay resultados del análisis'; + + @override + String get noServerPlaylistsFound => + 'No se encontraron listas de reproducción en el servidor'; + + @override + String get noServersConnected => 'No hay servidores conectados'; + + @override + String get noSongPlaying => 'No se está reproduciendo ninguna canción'; + + @override + String get noSongsFound => 'No se encontraron canciones'; + + @override + String get noSongsInThisPlaylist => + 'Esta lista de reproducción no tiene canciones'; + + @override + String get noUpcomingQueueItemsYet => + 'Aún no hay canciones siguientes en la cola.'; + + @override + String get noUpdateAvailable => 'No hay actualizaciones disponibles'; + + @override + String get noUrbData => 'No hay datos URB'; + + @override + String get noUsbAudioDevicesFound => + 'No se encontraron dispositivos de audio USB'; + + @override + String get noWordTimingYetAutoFill => + 'Aún no hay tiempos para las palabras. El autorrelleno las distribuye uniformemente como punto de partida; también puedes marcarlas en el modo Sincronizar palabras.'; + + @override + String get nocturnal => 'Nocturno'; + + @override + String get none => 'Ninguno'; + + @override + String get normalizeEachTrackToMatchLoudness => + 'Normalizar cada pista para igualar el volumen'; + + @override + String get notAnAlacFile => 'No es un archivo ALAC'; + + @override + String get notAvailableInBitPerfectMode => + 'No disponible en modo bit perfecto'; + + @override + String get notFoundOnlineTryADifferent => + 'No se encontró en línea. Prueba con otra forma de escribirlo.'; + + @override + String get notGrantedEnableSoScansCover => + 'Permiso no concedido: actívalo para que el análisis incluya archivos DSD, DSF y WavPack que el índice del sistema podría omitir'; + + @override + String get notHeld => 'No retenido'; + + @override + String get notRecommendedForNormalUsageDsd => + 'No se recomienda para el uso normal. La reproducción DSD es inestable y puede causar cortes de audio.'; + + @override + String get notRegistered => 'No registrado'; + + @override + String get notSet => 'No establecido'; + + @override + String get notStampedYet => 'Aún no sincronizado'; + + @override + String get notVerified => 'No verificado'; + + @override + String get notch => 'Muesca'; + + @override + String get notchDepth => 'Profundidad de muesca'; + + @override + String get noticeableTintingFromAlbumArt => + 'Tinte perceptible a partir de la portada del álbum.'; + + @override + String get nov => 'nov'; + + @override + String get now => 'Ahora'; + + @override + String get nowPlaying => 'En reproducción'; + + @override + String get nowPlaying2 => 'En reproducción'; + + @override + String get numberOnArt => 'Número en la portada'; + + @override + String get oauthSignInNoPasswordStored => + 'Inicio de sesión con OAuth; aquí no se guarda ninguna contraseña'; + + @override + String get oceanWaves => 'Olas del océano'; + + @override + String get oct => 'oct'; + + @override + String get off => 'Desactivado'; + + @override + String get offCropsToFillTheSquare => + 'Desactivado: recorta la imagen para llenar el cuadrado; activado: estira la portada de borde a borde'; + + @override + String get offline => 'Sin conexión'; + + @override + String get onAndroidTheStandardJustAudio => + 'En Android, la ruta de reproducción estándar de just_audio ahora aplica equivalentes nativos del ecualizador, la dinámica, el balance y los efectos espaciales en los dispositivos compatibles. El motor Rust sigue ofreciendo la versión más precisa de estos controles, por lo que algunos resultados en Android son aproximados.'; + + @override + String get onRepeat => 'En repetición'; + + @override + String get onboardingBrowseBody => + 'Desliza entre pestañas para explorar\nCanciones, Artistas, Álbumes y\nListas. Ordena y busca en\ntoda tu colección.'; + + @override + String get onboardingBrowseTitle => 'Explora\ntu música'; + + @override + String get onboardingLibraryBody => + 'Ve a Ajustes y toca\nCarpetas de música para analizar\ntu dispositivo. Compatible con MP3, FLAC,\nAAC, WAV y más.'; + + @override + String get onboardingLibraryTitle => 'Crea tu\nbiblioteca'; + + @override + String get onboardingPlaybackBody => + 'Toca cualquier canción para abrir el reproductor\ncompleto con barra de reproducción de forma de onda,\necualizador, letras y visuales\nde portada ambiental.'; + + @override + String get onboardingPlaybackTitle => 'Reproducción\ncompleta'; + + @override + String get onboardingReadyBody => + 'Empieza a explorar tu música.\nRelájate y disfruta\ndel sonido de Flick Player.'; + + @override + String get onboardingReadyTitle => 'Ya\nestá todo listo'; + + @override + String get onboardingWelcomeBody => + 'Un reproductor de música atractivo y rápido\npara tu biblioteca local.\nSin anuncios. Sin rastreo. Solo música.'; + + @override + String get onboardingWelcomeTitle => 'Te damos la bienvenida a\nFlick Player'; + + @override + String get onlineArtistAlbumInformation => + 'Información de artistas y álbumes en línea'; + + @override + String get onlineResults => 'Resultados en línea'; + + @override + String get onlyLibraryEntriesAreRemovedYour => + 'Solo se quitan las entradas de la biblioteca; los archivos de audio permanecen en el disco.'; + + @override + String get onlyReReadFilesThatAre => + 'Volver a leer solo los archivos nuevos o modificados.'; + + @override + String get open => 'Abrir'; + + @override + String get openAndroidSettings => 'Abrir ajustes de Android'; + + @override + String get openBluetoothCodecSettings => 'Abrir ajustes del códec Bluetooth'; + + @override + String get openFullNotes => 'Abrir notas completas'; + + @override + String get openInAppleMusic => 'Abrir en Apple Music'; + + @override + String get openInBrowser => 'Abrir en el navegador'; + + @override + String get openInPlayStore => 'Abrir en Play Store'; + + @override + String get openLibrary => 'Abrir biblioteca'; + + @override + String get openListenbrainzOrgSettings => 'Abrir listenbrainz.org/settings'; + + @override + String get openManual => 'Abrir manual'; + + @override + String get openPlayer => 'Abrir reproductor'; + + @override + String get openReleaseNotes => 'Abrir notas de la versión'; + + @override + String get openSourceLicenses => 'Abrir licencias de código abierto'; + + @override + String get openThePlayStoreToInstall => + 'Abre Play Store para instalar la versión más reciente de Flick'; + + @override + String get openedFromLocker => 'Abierto desde Locker'; + + @override + String get openslEs => 'OpenSL ES'; + + @override + String get openslEsLegacy => 'OpenSL ES (heredado)'; + + @override + String get orRemoveAllUsingRecommendedPicks => + 'O quitar todos con las selecciones recomendadas'; + + @override + String get orbital => 'Orbital'; + + @override + String get orbitHeaderBoundaryBody => + 'Las tarjetas orbitales y la trayectoria de la órbita permanecen debajo del encabezado Tu biblioteca y de la barra de búsqueda. Si elevas la órbita, se recorta en este límite.'; + + @override + String get orbitHeaderBoundaryTitle => + 'La órbita se detiene en la cabecera de la biblioteca'; + + @override + String get orbitLandscapeHint => + 'Se usa cuando la ventana de la app es más ancha que alta.'; + + @override + String get orbitLayoutProfile => 'Perfil de diseño'; + + @override + String get orbitPortraitHint => + 'Se usa cuando la ventana de la app es más alta que ancha.'; + + @override + String get orbitPreviewHide => 'Ocultar vista previa'; + + @override + String get orbitPreviewHint => + 'Desliza para explorar. No se reproduce, no se añade a la cola ni se cambian los favoritos.'; + + @override + String get orbitPreviewShow => 'Mostrar vista previa'; + + @override + String get orbitSharedVisuals => 'Elementos visuales compartidos'; + + @override + String get otherPlaylists => 'Otras listas de reproducción'; + + @override + String get ourRustPoweredEngineCleanerSound => + 'Nuestro motor con tecnología Rust ofrece un sonido más limpio y una reproducción más fluida. Recomendado para escuchar a diario.'; + + @override + String get outlineTheMiniPlayer => 'Delinear el minirreproductor'; + + @override + String get output => 'Salida'; + + @override + String get outputDevice => 'Dispositivo de salida'; + + @override + String get outputMode => 'Modo de salida'; + + @override + String get outputRate => 'Frecuencia de salida'; + + @override + String get overlapTheEndOfATrack => + 'Superponer el final de una pista con la siguiente'; + + @override + String get overlayPermissionIsRequiredToShow => + 'Se requiere permiso de superposición para mostrar el reproductor flotante'; + + @override + String get overviewMetricsChooseUpTo3 => 'Métricas generales · elige hasta 3'; + + @override + String get paired => 'Emparejado'; + + @override + String get parametric => 'Paramétrico'; + + @override + String parametricBandsWithIndependentFrequency(Object arg1) { + return '$arg1 bandas paramétricas con controles independientes de frecuencia, ganancia y Q. Toca para interactuar.'; + } + + @override + String get parametricEq => 'Ecualizador paramétrico'; + + @override + String get passthrough => 'Paso directo'; + + @override + String get password => 'Contraseña'; + + @override + String get pasteOrTypeTheSongLyrics => + 'Pega o escribe aquí la letra de la canción, una línea por renglón'; + + @override + String get pasteYourListenbrainzToken => 'Pega tu token de ListenBrainz'; + + @override + String get patchNotes => 'Notas de la versión'; + + @override + String get pause => 'Pausar'; + + @override + String get pauseOnBluetoothConnect => 'Pausar al conectarse por Bluetooth'; + + @override + String get pauseOnDisconnect => 'Pausar al desconectarse'; + + @override + String get pauseOnUsbDacAttach => 'Pausar al conectar un DAC USB'; + + @override + String get pauseOnUsbDacDetach => 'Pausar al desconectar un DAC USB'; + + @override + String get pcmFrames => 'Tramas PCM'; + + @override + String get peakHour => 'Hora de mayor actividad'; + + @override + String get peaking => 'Pico'; + + @override + String get permission => 'Permiso'; + + @override + String get personalPlaylist => 'Lista de reproducción personal'; + + @override + String get phoneAndHeadsetVolumeAreIndependent => + 'El volumen del teléfono y el de los audífonos son independientes'; + + @override + String get phoneAndHeadsetVolumeAreLinked => + 'El volumen del teléfono y el de los audífonos están vinculados'; + + @override + String get photoFraming => 'Encuadre de la foto'; + + @override + String get pickALineWithLyrics => 'Elige una línea con letra'; + + @override + String get pickALyricLineIn => + '1. En Líneas, elige una línea de la letra y luego cambia a Herramientas.\n2. Pulsa reproducir y toca el botón grande «Marcar palabra» al oír cada palabra. El primer toque también marca el tiempo de la línea.\n3. Toca una etiqueta de palabra para ajustarla, cambiarle el tiempo o borrarla.\n4. Las líneas con todas las palabras marcadas se guardan con tiempos de karaoke para cada palabra.'; + + @override + String get pickAgain => 'Elegir de nuevo'; + + @override + String get pickImage => 'Elegir imagen'; + + @override + String get pickUpExactlyWhereYourLast => + 'Retoma justo donde terminaste en tus últimas sesiones.'; + + @override + String get pinchApartNarrowerHigherQNpinch => + 'Pellizca hacia afuera para estrechar (Q más alto)\nPellizca hacia adentro para ensanchar (Q más bajo)'; + + @override + String get pitch => 'Tono'; + + @override + String pitchSemitones(int semitones) { + String _temp0 = intl.Intl.pluralLogic( + semitones, + locale: localeName, + other: '$semitones semitonos', + one: '$semitones semitono', + ); + return '$_temp0'; + } + + @override + String get pixelatedLightestOnMemory => 'Pixelado: consume menos memoria'; + + @override + String get plain => 'Normal'; + + @override + String get plainText => 'Texto sin formato'; + + @override + String get play => 'Reproducir'; + + @override + String get playAFewSongsAndThis => + 'Reproduce algunas canciones y esta página empezará a mostrar mezclas, artistas y accesos directos.'; + + @override + String get playAFewTracksTodayTo => + 'Reproduce algunas canciones hoy para crear el resumen diario.'; + + @override + String get playARandomLibrarySongWhen => + 'Reproducir una canción aleatoria de la biblioteca cuando termine la cola'; + + @override + String get playAgain => 'Reproducir de nuevo'; + + @override + String get playAtTheRecordedLevel => 'Reproducir al nivel grabado'; + + @override + String get playBadges => 'Insignias de reproducción'; + + @override + String get playCategoriesInRandomOrderTracks => + 'Reproducir las categorías en orden aleatorio y las pistas en secuencia'; + + @override + String get playInOrder => 'Reproducir en orden'; + + @override + String get playNext => 'Reproducir a continuación'; + + @override + String get playStoreUpdatesUseGooglePlay => + 'Las actualizaciones de Play Store usan la API de actualización dentro de Google Play (sujeta a las políticas de privacidad de Google). Las notas de la versión se obtienen desde la API de GitHub Releases sin enviar datos personales.'; + + @override + String get playback => 'Reproducción'; + + @override + String get playbackCacheLimit => 'Límite de caché de reproducción'; + + @override + String playbackCacheLimit2(Object arg1) { + return 'Límite de caché de reproducción: $arg1'; + } + + @override + String get playbackCacheUnlimited => 'Caché de reproducción ilimitada'; + + @override + String get playbackContinuesWhenABluetoothDevice => + 'La reproducción continúa cuando se conecta un dispositivo Bluetooth'; + + @override + String get playbackContinuesWhenAUsbDac => + 'La reproducción continúa cuando se conecta un DAC USB'; + + @override + String get playbackContinuesWhenAUsbDac2 => + 'La reproducción continúa cuando se desconecta un DAC USB'; + + @override + String get playbackContinuesWhenAudioOutput => + 'La reproducción continúa cuando se desconecta la salida de audio'; + + @override + String get playbackContinuesWhenTheAppIs => + 'La reproducción continúa cuando cierras la app al deslizarla fuera de la pantalla'; + + @override + String get playbackDesynced => 'Reproducción desincronizada'; + + @override + String get playbackDisplay => 'Reproducción y pantalla'; + + @override + String get playbackEngine => 'Motor de reproducción'; + + @override + String get playbackIsUsingAndroidManagedOutput => + 'La reproducción usa la salida administrada por Android y es posible que se remuestree.'; + + @override + String get playbackIsUsingTheStandardAndroid => + 'La reproducción usa la ruta de salida estándar de Android.'; + + @override + String get playbackModeWillUpdateAfterThe => + 'El modo de reproducción se actualizará después de la próxima actualización de la ruta o de la reproducción.'; + + @override + String get playbackPath => 'Ruta de reproducción'; + + @override + String get playbackPausesWhenABluetoothAudio => + 'La reproducción se pausa cuando se conecta un dispositivo de audio Bluetooth'; + + @override + String get playbackPausesWhenAUsbDac => + 'La reproducción se pausa cuando se conecta un DAC USB'; + + @override + String get playbackPausesWhenAUsbDac2 => + 'La reproducción se pausa cuando se desconecta físicamente un DAC USB'; + + @override + String get playbackPausesWhenBluetoothOrHeadphones => + 'La reproducción se pausa cuando se desconectan los audífonos o Bluetooth'; + + @override + String get playbackPausesWhileNotificationSoundsPlay => + 'La reproducción se pausa mientras suenan las notificaciones'; + + @override + String get playbackResumesWhenADeviceReconnects => + 'La reproducción se reanuda si un dispositivo vuelve a conectarse en 30 segundos'; + + @override + String get playbackSpeed => 'Velocidad de reproducción'; + + @override + String get playbackStopsWhenTheAppIs => + 'La reproducción se detiene cuando cierras la app al deslizarla fuera de la pantalla'; + + @override + String played(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Se reprodujeron $count canciones', + one: 'Se reprodujo 1 canción', + ); + return '$_temp0'; + } + + @override + String get playerLayout => 'Diseño del reproductor'; + + @override + String get playerMenuAddToPlaylist => 'Agregar a la lista de reproducción'; + + @override + String get playerMenuAddToQueue => 'Agregar a la cola'; + + @override + String get playerMenuEditMetadata => 'Editar metadatos'; + + @override + String get playerMenuRefreshAlbumArt => 'Actualizar portada animada'; + + @override + String get playerMenuSetAlbumArt => 'Establecer portada del álbum'; + + @override + String get playerMenuShare => 'Compartir'; + + @override + String get playerMenuSleepTimer => 'Temporizador de apagado'; + + @override + String playlist(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count listas de reproducción', + one: '$count lista de reproducción', + ); + return '$_temp0'; + } + + @override + String get playlist2 => 'Lista de reproducción'; + + @override + String get playlistCoverRemoved => + 'Se quitó la portada de la lista de reproducción'; + + @override + String get playlistCoverUpdated => + 'Se actualizó la portada de la lista de reproducción'; + + @override + String playlistCreated(Object arg1) { + return 'Se creó la lista de reproducción «$arg1»'; + } + + @override + String get playlistExportAndroidOnly => + 'Por ahora, la exportación de listas de reproducción solo está disponible en Android.'; + + @override + String get playlistImportAndroidOnly => + 'Por ahora, la importación de listas de reproducción solo está disponible en Android.'; + + @override + String get playlistName => 'Nombre de la lista de reproducción'; + + @override + String get playlistNotFound => 'No se encontró la lista de reproducción'; + + @override + String playlistRenamed(Object arg1) { + return 'Se cambió el nombre de la lista a «$arg1»'; + } + + @override + String get playlists => 'Listas de reproducción'; + + @override + String plays(Object arg1) { + return '$arg1 reproducciones'; + } + + @override + String plays2(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count reproducciones', + one: '1 reproducción', + ); + return '$_temp0'; + } + + @override + String get playsInRotation => 'reproducciones en rotación'; + + @override + String get pleaseEnterAPlaylistName => + 'Ingresa un nombre para la lista de reproducción'; + + @override + String get pleaseEnterYourListenbrainzUserToken => + 'Ingresa tu token de usuario de ListenBrainz.'; + + @override + String get portrait => 'Vertical'; + + @override + String get portraitLayoutReset => 'Se restableció el diseño vertical'; + + @override + String posterPreviewPlays(Object arg1, Object arg2) { + return 'Vista previa del póster $arg1. $arg2 reproducciones.'; + } + + @override + String get preAmp => 'Preamplificación'; + + @override + String get preamp => 'Preamplificador'; + + @override + String get preferences => 'Preferencias'; + + @override + String get preloadAudioData => 'Precargar datos de audio'; + + @override + String get preloadLibraryAudio => 'Precargar el audio de la biblioteca'; + + @override + String get preloadingAudio => 'Precargando audio'; + + @override + String preloadingAudio2(Object arg1, Object arg2) { + return 'Precargando audio $arg1/$arg2'; + } + + @override + String get preloadingAudio3 => 'Precargando audio'; + + @override + String get preparing => 'Preparando…'; + + @override + String get presence => 'Presencia'; + + @override + String preset(Object activePresetName) { + return 'Preajuste: $activePresetName'; + } + + @override + String get presetFileIsEmpty => 'El archivo de preajuste está vacío.'; + + @override + String get presetImportedWithAdjustments => 'Preajuste importado con ajustes'; + + @override + String get presetName => 'Nombre del preajuste'; + + @override + String get presets => 'Preajustes'; + + @override + String get pressBackAgainToExit => 'Pulsa atrás otra vez para salir'; + + @override + String get preventClipping => 'Evitar la saturación'; + + @override + String get preview => 'Vista previa'; + + @override + String get previewUse => 'Vista previa y usar'; + + @override + String get previousSong => 'Canción anterior'; + + @override + String get previousSong2 => 'Canción anterior'; + + @override + String get prewarming => 'Calentando'; + + @override + String get prioritiseConnectionStability => + 'Priorizar la estabilidad de la conexión'; + + @override + String get privacyPolicy => 'Política de privacidad'; + + @override + String get processingLive => 'Procesamiento en tiempo real'; + + @override + String get product => 'Producto'; + + @override + String get productId => 'ID del producto'; + + @override + String get progress => 'Progreso'; + + @override + String get progressBar => 'Barra de progreso'; + + @override + String get protocol => 'Protocolo'; + + @override + String get pulledFromYourLateSessionPlays => + 'Basado en las canciones que escuchaste en tus últimas sesiones nocturnas'; + + @override + String get purple => 'Morado'; + + @override + String get queue => 'Cola'; + + @override + String queue2(Object count) { + return 'Cola $count'; + } + + @override + String get queueIsEmpty => 'La cola está vacía'; + + @override + String queued(Object arg1) { + return 'Se agregó «$arg1» a la cola'; + } + + @override + String queuedSongs(Object arg1) { + return 'Se agregaron $arg1 canciones a la cola'; + } + + @override + String queuedSongs3(Object arg1) { + return 'Se agregaron $arg1 canciones a la cola'; + } + + @override + String get quickAccess => 'Acceso rápido'; + + @override + String get quickActions => 'Acciones rápidas'; + + @override + String get quickOrFullReIndexOf => + 'Análisis rápido o completo de todas las carpetas'; + + @override + String get quickScan => 'Análisis rápido'; + + @override + String get random => 'Aleatorio'; + + @override + String get rate => 'Calificar'; + + @override + String get rating => 'Calificación'; + + @override + String get ratio => 'Proporción'; + + @override + String get rawDsdStreamToDacRequires => + 'La transmisión DSD sin procesar al DAC requiere compatibilidad de hardware con ENCODING_DSD; de lo contrario, se cambia automáticamente a DoP o PCM.'; + + @override + String get rawPcm => '→ PCM sin procesar'; + + @override + String get reReadMetadataForEveryFile => + 'Volver a leer los metadatos de todos los archivos. Es más lento; úsalo si las etiquetas parecen desactualizadas.'; + + @override + String get readMode => 'Modo de lectura'; + + @override + String get readingTheCoverColors => 'Leyendo los colores de la portada…'; + + @override + String readyToRemoveSongKeepingIn(int count, Object kept) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return 'Todo listo para quitar $_temp0. Total a conservar: $kept.'; + } + + @override + String recapSavedAs(Object format) { + return 'Resumen guardado como $format'; + } + + @override + String recentPicksOnHand(Object arg1) { + return '$arg1 selecciones recientes disponibles'; + } + + @override + String get recentlyAdded => 'Agregadas recientemente'; + + @override + String get recentlyAddedTracksWaitingForMore => + 'Canciones agregadas recientemente que aún necesitan más reproducciones.'; + + @override + String get recentlyPlayed => 'Reproducidas recientemente'; + + @override + String get recommended => 'Recomendado'; + + @override + String get recommendedOnly => 'Solo recomendados'; + + @override + String get reconnectAttempts => 'Intentos de reconexión'; + + @override + String get reconnectNow => 'Reconectar ahora'; + + @override + String get reconnectToTheInternetToScan => + 'Vuelve a conectarte a internet para buscar actualizaciones'; + + @override + String get reconnectToWiFiOrMobile => + 'Vuelve a conectarte a Wi-Fi o a los datos móviles para que Flick pueda buscar de nuevo'; + + @override + String get reconnectionFailed => 'No se pudo reconectar'; + + @override + String get reconnectionSuccessful => 'Reconexión correcta'; + + @override + String get recorded => 'Grabado'; + + @override + String get refreshAppleMusic => 'Actualizar Apple Music'; + + @override + String get refreshDevices => 'Actualizar dispositivos'; + + @override + String get refreshDevices2 => 'Actualizar dispositivos'; + + @override + String get refreshOutputs => 'Actualizar salidas'; + + @override + String get refreshRate => 'Frecuencia de actualización'; + + @override + String get refreshingAppleMusicData => + 'Actualizando los datos de Apple Music'; + + @override + String get registeredNotClaimed => 'Registrado, sin asignar'; + + @override + String get reinitializingPlayback => 'Reiniciando la reproducción…'; + + @override + String get release => 'Liberación'; + + @override + String get remove => 'Quitar'; + + @override + String get removeAll => 'Quitar todo'; + + @override + String get removeAllSongs => '¿Quitar todas las canciones?'; + + @override + String get removeAllSongs2 => 'Quitar todas las canciones'; + + @override + String get removeAllWithBestPicks => + '¿Quitar todo con las mejores selecciones?'; + + @override + String removeAndAllOfItsSongs(Object arg1) { + return '¿Quitar «$arg1» y todas sus canciones de la biblioteca? Los archivos del disco no se eliminarán.'; + } + + @override + String get removeCustomArt => 'Quitar imagen personalizada'; + + @override + String get removeCover => 'Quitar portada'; + + @override + String get removeDuplicates => 'Quitar duplicados'; + + @override + String removeDuplicates2(Object toRemove) { + return '¿Quitar $toRemove duplicados?'; + } + + @override + String removeDuplicates3(Object toRemove) { + return 'Quitar $toRemove duplicados'; + } + + @override + String get removeFolder => '¿Quitar la carpeta?'; + + @override + String get removeFromFavorites => 'Quitar de favoritos'; + + @override + String get removeFromFavorites2 => 'Quitar de favoritos'; + + @override + String get removeFromLibrary => 'Quitar de la biblioteca'; + + @override + String get removeFromPlaylist => 'Quitar de la lista de reproducción'; + + @override + String get removeSelected => 'Quitar selección'; + + @override + String get removeServer => '¿Quitar el servidor?'; + + @override + String get removeServer2 => 'Quitar servidor'; + + @override + String get removeTheDatabaseEntriesOrDelete => + 'Quitar las entradas de la base de datos o eliminar los archivos del dispositivo. Esta acción no se puede deshacer.'; + + @override + String get removeTheDatabaseEntryOrDelete => + 'Quitar la entrada de la base de datos o eliminar el archivo del dispositivo. Esta acción no se puede deshacer.'; + + @override + String get removeTheseSongsFromYourLibrary => + 'Quita estas canciones de la biblioteca. Los archivos del dispositivo no se verán afectados.'; + + @override + String get removeThisSongFromYourLibrary => + 'Quita esta canción de la biblioteca. El archivo del dispositivo no se verá afectado.'; + + @override + String removedCustomAlbumArtFor(Object arg1) { + return 'Se quitó la portada personalizada de «$arg1».'; + } + + @override + String removedCustomAlbumArtFor2(Object arg1) { + return 'Se quitó la portada personalizada de «$arg1».'; + } + + @override + String removedDuplicatesKept(Object arg1, Object arg2) { + return 'Se quitaron $arg1 duplicados; se conservaron $arg2.'; + } + + @override + String removedFromFavorites(Object arg1) { + return 'Se quitó «$arg1» de favoritos'; + } + + @override + String removedFromFavorites2(Object arg1) { + return 'Se quitó $arg1 de favoritos'; + } + + @override + String get removedFromFavorites3 => 'Se quitó de favoritos'; + + @override + String removedFromLibrary(Object arg1) { + return 'Se quitó «$arg1» de la biblioteca'; + } + + @override + String removedSongsFromFavorites(Object arg1) { + return 'Se quitaron $arg1 canciones de favoritos'; + } + + @override + String removedSongsFromLibrary(Object arg1) { + return 'Se quitaron $arg1 canciones de la biblioteca'; + } + + @override + String get removing => 'Quitando…'; + + @override + String get removingDuplicates => 'Quitando duplicados…'; + + @override + String get rename => 'Cambiar nombre'; + + @override + String get renamePreset => 'Cambiar nombre del preajuste'; + + @override + String repeat(Object arg1) { + return 'Repetir: $arg1'; + } + + @override + String get repeatMode => 'Modo de repetición'; + + @override + String get repeatRewind => 'Rebobinar al repetir'; + + @override + String get replaceAlbumNameWithAVerified => + 'Reemplazar el nombre del álbum con una cápsula bit-perfect verificada durante la transmisión bit-perfect'; + + @override + String get replay => 'Replay'; + + @override + String get replayCouldnTLoad => 'No se pudo cargar Replay.'; + + @override + String get replayStudio => 'Estudio de Replay'; + + @override + String get replayTheTutorialAndFeatureGuide => + 'Volver a reproducir el tutorial y la guía de funciones'; + + @override + String get replaygain => 'ReplayGain'; + + @override + String get replaygainScan => 'Análisis de ReplayGain'; + + @override + String get reportedOutputRate => 'Frecuencia de salida informada'; + + @override + String get requestedOutputRate => 'Frecuencia de salida solicitada'; + + @override + String get requiredToDetectDevicesCodecsAnd => + 'Se necesita para detectar dispositivos, códecs y niveles de batería'; + + @override + String get resampler => 'Remuestreador'; + + @override + String get rescanLibrary => 'Volver a analizar la biblioteca'; + + @override + String get reset => 'Restablecer'; + + @override + String get resetArtwork => 'Restablecer portada'; + + @override + String get resetArtworkDescription => + '¿Volver a detectar la portada a partir de los archivos de este álbum? Las portadas detectadas automáticamente se reemplazarán con las que se lean de los archivos; las personalizadas se conservarán.'; + + @override + String resetArtworkFor(Object arg1) { + return 'Restablecer la portada de «$arg1».'; + } + + @override + String resetArtworkFor2(Object arg1) { + return 'Restablecer la portada de «$arg1».'; + } + + @override + String get resetCardDesign => 'Restablecer diseño de tarjeta'; + + @override + String get resetDeclinedUsbDacs => 'Restablecer los DAC USB rechazados'; + + @override + String get resetDynamics => 'Restablecer dinámica'; + + @override + String get resetFx => 'Restablecer efectos'; + + @override + String get resetMiniPlayerToDefaults => + 'Restablecer los valores predeterminados del minirreproductor'; + + @override + String get resetNavigationToDefaults => + 'Restablecer los valores predeterminados de navegación'; + + @override + String get resetPreferences => 'Restablecer preferencias'; + + @override + String get resetStreakData => '¿Restablecer los datos de racha?'; + + @override + String get resetStreakData2 => 'Restablecer datos de racha'; + + @override + String get resetTo0Db => 'Restablecer a 0 dB'; + + @override + String get resetToDefaults => 'Restablecer valores predeterminados'; + + @override + String get resolution => 'Resolución'; + + @override + String get resonance => 'Resonancia'; + + @override + String get restart => 'Reiniciar'; + + @override + String get restartRequired => 'Es necesario reiniciar'; + + @override + String get restartTheAppToApplyPlayback => + 'Reinicia la app para aplicar los cambios de reproducción.'; + + @override + String get restartYourDeviceToApplyOutput => + 'Reinicia el dispositivo para aplicar los cambios de formato de salida.'; + + @override + String get restartingFlick => 'Reiniciando Flick'; + + @override + String get restoreDefaultProgressBarSize => + 'Restablece el tamaño predeterminado del estilo de barra de progreso seleccionado.'; + + @override + String get restoreThisProfilesOrbitLayout => + 'Restablecer el diseño orbital original de este perfil'; + + @override + String results(Object arg1) { + return 'Resultados ($arg1)'; + } + + @override + String get resumeAFamiliarFavoriteOrShuffle => + 'Retoma un favorito conocido o mezcla una de las listas que se crearon a partir de lo que escuchas.'; + + @override + String get resumeOnReconnect => 'Reanudar al reconectarse'; + + @override + String get retakePhoto => 'Volver a tomar la foto'; + + @override + String get retroFuture => 'Futuro retro'; + + @override + String get retry => 'Reintentar'; + + @override + String get reviewBeforeYouClean => 'Revisar antes de limpiar'; + + @override + String get right => 'Derecha'; + + @override + String get rightBottom => 'Derecha (abajo)'; + + @override + String get rightBottomButton => 'Botón derecho (abajo)'; + + @override + String get rightTop => 'Derecha (arriba)'; + + @override + String get rightTopButton => 'Botón derecho (arriba)'; + + @override + String get ripSource => 'Fuente de extracción'; + + @override + String get root => 'Raíz'; + + @override + String get rotationSeek => 'búsqueda rotatoria'; + + @override + String get roundedAlbumArtCardWithA => + 'Tarjeta redondeada con portada y fondo difuminado de la misma imagen.'; + + @override + String get route => 'Ruta'; + + @override + String get routesBluetoothThroughTheHiRes => + 'Enruta el audio Bluetooth por el motor Rust de alta resolución'; + + @override + String get routesBluetoothThroughTheRustEngine => + 'Enruta el audio Bluetooth por el motor Rust'; + + @override + String get runAnotherPlayStoreUpdateScan => + 'Buscar actualizaciones de Play Store ahora mismo'; + + @override + String get runAnotherUpdateScanRightNow => + 'Buscar actualizaciones ahora mismo'; + + @override + String get rustViaOboe => 'Rust mediante Oboe'; + + @override + String get rustViaOboeHighRes => 'Rust mediante Oboe (alta resolución)'; + + @override + String s(Object arg1) { + return '$arg1 s'; + } + + @override + String s2(Object arg1) { + return '$arg1 s'; + } + + @override + String sAgo(Object arg1) { + return 'hace $arg1 s'; + } + + @override + String get sCurve => 'Curva en S'; + + @override + String get sambaWindowsShareTransportPending => + 'Samba · recurso compartido de Windows'; + + @override + String get sampleArtist => 'Artista de ejemplo'; + + @override + String get samplePreview => 'Vista previa de muestra'; + + @override + String get sampleRate => 'Frecuencia de muestreo'; + + @override + String get sampleRate2 => 'Frecuencia de muestreo'; + + @override + String get sampleRates => 'Frecuencias de muestreo'; + + @override + String get sampleSongPreviewOnly => 'Canción de ejemplo · solo vista previa'; + + @override + String get samples => 'Muestras'; + + @override + String get save => 'Guardar'; + + @override + String get saveAsText => 'Guardar como texto'; + + @override + String get saveChanges => 'Guardar cambios'; + + @override + String get saveConnect => 'Guardar y conectar'; + + @override + String get saveCreatesAnLrcFileIf => + 'Al guardar, se crea un archivo `.lrc`. Si algunas líneas aún no tienen tiempo marcado, Flick lo completa automáticamente para que el archivo siga funcionando. Las líneas con todas las palabras marcadas se exportan con tiempos de karaoke para cada palabra.'; + + @override + String get saveCurrentAsPreset => 'Guardar como preajuste'; + + @override + String get saveCustomizeReplay => 'Guardar / personalizar Replay'; + + @override + String get saveInFlick => 'Guardar en Flick'; + + @override + String get saveLogs => 'Guardar registros'; + + @override + String get saveLrcFile => 'Guardar archivo LRC'; + + @override + String get saveLrcFile2 => 'Guardar archivo LRC'; + + @override + String get saveLyrics => 'Guardar letras'; + + @override + String get savePng => 'Guardar PNG'; + + @override + String get savePreset => 'Guardar preajuste'; + + @override + String get saveTheCurrentEqAsJson => + 'Guardar el ecualizador actual como JSON o TXT'; + + @override + String get saved => 'Guardado'; + + @override + String get savedAgain => 'Guardado · otra vez'; + + @override + String get savedAndVerified => 'Guardado y verificado'; + + @override + String savedCollections(Object playlistCount) { + return '$playlistCount colecciones guardadas'; + } + + @override + String get savedLyricsAndLinkedThemTo => + 'Se guardaron las letras y se vincularon con esta canción.'; + + @override + String get savedLyricsBesideTheSongAs => + 'Se guardaron las letras junto a la canción como archivo `.lrc`.'; + + @override + String get savedLyricsToTheChosenLocation => + 'Se guardaron las letras en la ubicación seleccionada.'; + + @override + String get savedPlaylistsAndQuickJumpsInto => + 'Listas guardadas y accesos rápidos a la organización de tu biblioteca.'; + + @override + String get savedToGallery => 'Guardado en la galería'; + + @override + String savedToNNNshareIt(Object path) { + return 'Guardado en:\n$path\n\n¿Quieres compartirlo ahora?'; + } + + @override + String savedToYourGallery(Object arg1) { + return '$arg1 se guardó en la galería'; + } + + @override + String get savedVerificationPending => 'Guardado (verificación pendiente)'; + + @override + String get saving => 'Guardando…'; + + @override + String get saving2 => 'Guardando'; + + @override + String get savingRecapAndroidOnly => + 'Por ahora, guardar imágenes del resumen solo está disponible en Android.'; + + @override + String get scaleOfTheCenteredFocusedSong => + 'Tamaño de la tarjeta de canción centrada y enfocada'; + + @override + String get scaleTheAlbumArtCard => + 'Ajustar el tamaño de la tarjeta con portada'; + + @override + String get scaleTheFullViewAlbumArt => + 'Ajustar el tamaño de la tarjeta con portada en vista completa'; + + @override + String get scalesWithWidgetSizeAutomatically => + 'Se ajusta automáticamente al tamaño del widget'; + + @override + String get scanAgain => 'Analizar de nuevo'; + + @override + String get scanComplete => 'Análisis completo'; + + @override + String get scanFailedPleaseTryAgain => + 'No se pudo completar el análisis. Inténtalo de nuevo.'; + + @override + String get scanForDevices => 'Buscar dispositivos'; + + @override + String get scanProgress => 'Progreso del análisis'; + + @override + String get scanReplaygain => 'Analizar ReplayGain'; + + @override + String get scanningForDuplicates => 'Buscando duplicados…'; + + @override + String get scanningSettings => 'Ajustes del análisis'; + + @override + String scanningSongsFound(Object count) { + return 'Analizando… Se encontraron $count canciones'; + } + + @override + String get scanningYourLibrary => 'Analizando tu biblioteca…'; + + @override + String get scroll => 'Desplazarse'; + + @override + String get scrollForMore => 'Desplázate para ver más'; + + @override + String get scrollingPausesWhenReducedMotionIs => + 'El desplazamiento se pausa si está activada la opción para reducir el movimiento'; + + @override + String get seamlessTransitionBetweenTracks => + 'Transición fluida entre pistas'; + + @override + String get search => 'Buscar'; + + @override + String get searchAgain => 'Buscar de nuevo'; + + @override + String get searchArtistTitle => 'Buscar artista + título…'; + + @override + String get searchArtists => 'Buscar artistas…'; + + @override + String get searchFailed => 'Error en la búsqueda'; + + @override + String searchFailed2(Object e) { + return 'Error en la búsqueda: $e'; + } + + @override + String get searchHeadphones => 'Buscar audífonos…'; + + @override + String searchModelCount(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count modelos', + one: '$count modelo', + ); + return 'Buscar $_temp0…'; + } + + @override + String get searchOnline => 'Buscar en línea'; + + @override + String get searchOnline2 => 'Buscar en línea'; + + @override + String get searchOnlineCreateYourOwnSynced => + 'Busca letras en línea, crea tus propias letras sincronizadas o importa un archivo existente.'; + + @override + String get searchOnlineLyrics => 'Buscar letras en línea'; + + @override + String get searchPlayback => 'Buscar en reproducción'; + + @override + String get searchResults => 'Resultados de búsqueda'; + + @override + String get searchSongsArtists => 'Buscar canciones, artistas…'; + + @override + String get searchSongsArtistsAlbums => + 'Buscar canciones, artistas y álbumes…'; + + @override + String get searchTheManual => 'Buscar en el manual…'; + + @override + String get searchSettings => 'Buscar ajustes…'; + + @override + String get searchYourLibrary => 'Buscar en tu biblioteca'; + + @override + String get searching => 'Buscando…'; + + @override + String get searchingOnline => 'Buscando en línea'; + + @override + String get searchingTheLocalNetwork => 'Buscando en la red local…'; + + @override + String get secondsOfInactivityBeforeCollapsing => + 'Segundos de inactividad antes de contraer'; + + @override + String get seeAll => 'Ver todo'; + + @override + String seeAll2(Object count) { + return 'Ver los $count'; + } + + @override + String get seeWhatIsNewInThis => + 'Descubre las novedades de esta actualización'; + + @override + String get select => 'Seleccionar'; + + @override + String get selectAFolderToScan => 'Selecciona una carpeta para analizar'; + + @override + String get selectALineAndEdit => + '1. Selecciona una línea y edita directamente su marca de tiempo o usa «Usar hora actual».\n2. En la línea de tiempo de palabras, arrastra un límite para alargar o acortar el segmento anterior; los cambios se ajustan a intervalos de 10 ms.\n3. Toca letras en el inspector para dividir una palabra en sílabas con tiempos separados (ritmo lento y luego rápido) y después arrastra sus límites.\n4. Arrastra el último límite (o usa Duración ±) para cambiar el tiempo de la línea siguiente. Usa Autorrellenar para distribuir las palabras uniformemente.\n5. Usa los controles de desplazamiento para mover a la vez todas las letras marcadas.\n6. Guarda para generar el archivo `.lrc` final.'; + + @override + String get selectARelease => 'Seleccionar un lanzamiento'; + + @override + String get selectAll => 'Seleccionar todo'; + + @override + String get selectAll2 => 'Seleccionar todo'; + + @override + String get selectDevice => 'Seleccionar dispositivo'; + + @override + String selected(Object count) { + return '$count seleccionados'; + } + + @override + String get selectedFileIsNotASupported => + 'El archivo seleccionado no es una imagen compatible.'; + + @override + String selectedOfSong(Object selected, int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return 'Selección: $selected de $_temp0'; + } + + @override + String get selectedPlaylistFileIsEmpty => + 'El archivo de lista de reproducción seleccionado está vacío'; + + @override + String get selectedSize => 'Tamaño seleccionado'; + + @override + String get sep => 'sep'; + + @override + String get separateFromNavBar => 'Separar de la barra de navegación'; + + @override + String get separateTheMiniPlayerToCustomize => + 'Separa el minirreproductor para personalizar su ancho y el espacio. Tus valores personalizados se conservan al volver a unirlo.'; + + @override + String get serialNumber => 'Número de serie'; + + @override + String serverPlaylistSyncFailed(Object e) { + return 'No se pudo sincronizar la lista de reproducción del servidor: $e'; + } + + @override + String get serverUrl => 'URL del servidor'; + + @override + String get session => 'Sesión'; + + @override + String get setAlbumArt => 'Establecer portada del álbum'; + + @override + String get setCover => 'Establecer portada'; + + @override + String get setToNow => 'Establecer en ahora'; + + @override + String get settings => 'Ajustes'; + + @override + String get shadow => 'Sombra'; + + @override + String get shadowJazz => 'Shadow Jazz'; + + @override + String get share => 'Compartir'; + + @override + String shareFailed(Object e) { + return 'No se pudo compartir: $e'; + } + + @override + String get sharedSecret => 'Secreto compartido'; + + @override + String get sharpRecommended => 'Nítido (recomendado)'; + + @override + String get shiftMetadataTextUpOrDown => + 'Mover el texto de metadatos hacia arriba o abajo'; + + @override + String get shiftOnlyTheAlbumArtUp => + 'Mover solo la portada del álbum hacia arriba o abajo'; + + @override + String get shiftOnlyTheSongDetailsUp => + 'Mover solo los detalles de la canción hacia arriba o abajo'; + + @override + String get showASystemOverlayMiniPlayer => + 'Mostrar un minirreproductor superpuesto sobre otras apps'; + + @override + String get showAThinPlaybackProgressLine => + 'Mostrar una línea delgada con el progreso de reproducción'; + + @override + String get showAlbum => 'Mostrar álbum'; + + @override + String get showAlbum2 => 'Mostrar álbum'; + + @override + String get showAlbumArtwork => 'Mostrar la portada del álbum.'; + + @override + String get showAlbumArtworkOnTheMini => + 'Mostrar la portada del álbum en el minirreproductor'; + + @override + String get showAppleMusicBiographiesRecommendationsAnd => + 'Mostrar biografías de Apple Music, artistas similares, canciones destacadas, notas de los álbumes y retratos de los artistas.'; + + @override + String get showArtist => 'Mostrar artista'; + + @override + String get showArtist2 => 'Mostrar artista'; + + @override + String get showArtistBelowSongTitle => + 'Mostrar el artista debajo del título de la canción'; + + @override + String get showFileInfo => 'Mostrar información del archivo'; + + @override + String get showFileInfo2 => 'Mostrar información del archivo'; + + @override + String get showFrame => 'Mostrar cuadro'; + + @override + String get showFrame2 => 'Mostrar cuadro'; + + @override + String get showGlow => 'Mostrar brillo'; + + @override + String get showLabels => 'Mostrar etiquetas'; + + @override + String get showLess => 'Mostrar menos'; + + @override + String get showLyrics => 'Mostrar letras'; + + @override + String get showMore => 'Mostrar más'; + + @override + String get showMoreArtByFadingOnly => + 'Mostrar más portada desvaneciendo solo la parte inferior del encabezado y bajando el contenido'; + + @override + String get showOrHideHomeScreenSections => + 'Mostrar u ocultar secciones de la pantalla de inicio'; + + @override + String get showOrbitPath => 'Mostrar la trayectoria orbital'; + + @override + String get showOtherArtistsOnAlbumPages => + 'Mostrar otros artistas en las páginas de álbumes'; + + @override + String get showPassword => 'Mostrar contraseña'; + + @override + String get showPlaylistPreviewsOnTheHome => + 'Mostrar vistas previas de listas en la pantalla de inicio'; + + @override + String get showRecentlyPlayedArtistsOnThe => + 'Mostrar los artistas reproducidos recientemente en la pantalla de inicio'; + + @override + String get showRelatedAlbumsOnAlbumPages => + 'Mostrar álbumes relacionados en las páginas de álbumes'; + + @override + String get showSmartMixesGeneratedFromYour => + 'Mostrar mezclas inteligentes generadas a partir de tus hábitos de escucha'; + + @override + String get showTheArtistBelowTheSong => + 'Mostrar el artista debajo del título de la canción'; + + @override + String get showTheAtAGlanceSummary => + 'Mostrar el resumen rápido en Artistas/Álbumes'; + + @override + String get showTheAudioEnginePickerCard => + 'Mostrar la tarjeta para elegir el motor de audio en la pantalla de inicio'; + + @override + String get showTheAudioVisualizerOffSaves => + 'Mostrar el visualizador de audio (desactivarlo ahorra batería)'; + + @override + String get showTheBrowseChipsForLibrary => + 'Mostrar los accesos rápidos para explorar las secciones de la biblioteca en la pantalla de inicio'; + + @override + String get showTheFloatingMiniPlayerPill => + 'Mostrar la pastilla flotante del minirreproductor en las pantallas'; + + @override + String get showTheGlassFrameAroundAlbum => + 'Mostrar el marco de vidrio alrededor de la portada del álbum'; + + @override + String get showTheGridOfShortcutCards => + 'Mostrar la cuadrícula de tarjetas de acceso directo en la pantalla de inicio'; + + @override + String get showTheMiniPlayerAsIts => + 'Mostrar el minirreproductor como una barra independiente sobre los botones'; + + @override + String get showTheNumberOverBlurredArt => + 'Mostrar el número sobre la portada difuminada.'; + + @override + String showTheTabInTheBottom(Object arg1) { + return 'Mostrar la pestaña $arg1 en la barra inferior'; + } + + @override + String get showTheTrackNumber => 'Mostrar el número de pista.'; + + @override + String get showTheUsbVolumeBarOn => + 'Mostrar la barra de volumen USB en la pantalla de inicio'; + + @override + String get showTheUsbVolumeBarOn2 => + 'Mostrar la barra de volumen USB en la pantalla de ajustes UAC2'; + + @override + String get showTitle => 'Mostrar título'; + + @override + String get showTitle2 => 'Mostrar título'; + + @override + String get showVerboseAudioDiagnosticsAndEngine => + 'Mostrar diagnósticos de audio detallados y registros de seguimiento del motor y la sesión.'; + + @override + String get showVisualizer => 'Mostrar visualizador'; + + @override + String get showYourRecentListeningHistoryOn => + 'Mostrar el historial de escucha reciente en la pantalla de inicio'; + + @override + String showingAllAlbums(Object totalCount) { + return 'Se muestran los $totalCount álbumes'; + } + + @override + String showingOfAlbums(Object visibleCount, Object totalCount) { + return 'Se muestran $visibleCount de $totalCount álbumes'; + } + + @override + String get showingYourLastLoadedReplay => + 'Se muestra el último Replay que cargaste.'; + + @override + String get shownWhenThereIsRoomBeside => + 'Se muestra cuando hay espacio junto a los controles'; + + @override + String get shuffle => 'Aleatorio'; + + @override + String shuffle2(Object arg1) { + return 'Aleatorio: $arg1'; + } + + @override + String get shuffleFavorites => 'Mezclar favoritos'; + + @override + String get shuffleMode => 'Modo aleatorio'; + + @override + String get shuffleSongsAndJumpBetweenCategories => + 'Mezclar canciones y saltar entre categorías'; + + @override + String get shuffleSongsInCurrentList => + 'Mezclar canciones de la lista actual'; + + @override + String get signInFailedRetry => 'Error al iniciar sesión: volver a intentar'; + + @override + String get signInWithTidal => 'Iniciar sesión con Tidal'; + + @override + String get signInWithYourAccountHifi => + 'Inicia sesión con tu cuenta · HiFi sin pérdida'; + + @override + String get signInWithYourOwnTidal => + 'Inicia sesión con tu cuenta de Tidal. El audio sin pérdida HiFi (FLAC/ALAC) se reproduce con el motor bit perfecto; Tidal restringe HiRes/MQA y Atmos, que mostrarán un error en lugar de reproducirse.'; + + @override + String get signal => 'Señal'; + + @override + String get signalAccurateUnverified => 'AccurateRip sin verificar'; + + @override + String get signalAccurateVerified => 'AccurateRip verificado en el registro'; + + @override + String get signalAltSetting => 'Ajuste alternativo'; + + @override + String get signalBufferCapacity => 'Capacidad del búfer'; + + @override + String get signalBufferFill => 'Nivel del búfer'; + + @override + String get signalBufferOccupancy => 'Ocupación del búfer al abrir'; + + @override + String get signalBufferTarget => 'Objetivo del búfer'; + + @override + String get signalCopyCrc => 'CRC de copia'; + + @override + String get signalCrcCannotCompare => 'No se puede comparar'; + + @override + String get signalCrcComparison => 'Comparación de CRC'; + + @override + String get signalCrcMatch => 'Coincide'; + + @override + String get signalCrcMismatch => 'No coincide'; + + @override + String get signalDriftFromTarget => 'Desfase respecto al objetivo'; + + @override + String get signalDsdBitRate => 'Tasa de bits DSD'; + + @override + String get signalFileFormat => 'Formato del archivo'; + + @override + String get signalFramesPerPacket => 'Tramas / paquete'; + + @override + String get signalMaxPacket => 'Paquete máximo'; + + @override + String get signalNoRipDescription => + 'No se encontró información de extracción ni de verificación para esta pista.'; + + @override + String get signalNotReported => 'No informado'; + + @override + String get signalNotVerified => 'No verificado'; + + @override + String get signalOrangeSurfaceFromTheReplay => + 'Superficie naranja señal de la portada de Replay'; + + @override + String get signalRecordingUnavailable => + 'Historial de extracción no disponible'; + + @override + String get signalRipDescription => + 'Información del registro de extracción; no corresponde a una etapa de la ruta de reproducción actual.'; + + @override + String get signalRipProvenance => 'Procedencia de la extracción'; + + @override + String get signalRipper => 'Extractor'; + + @override + String get signalServiceInterval => 'Intervalo de servicio'; + + @override + String get signalSnapshot => 'Instantánea'; + + @override + String get signalSnapshotAtOpen => 'Instantánea al abrir'; + + @override + String get signalSourceDescription => + 'Propiedades del archivo de origen, no de la salida enviada al dispositivo.'; + + @override + String get signalSourceDetails => 'Detalles del formato de origen'; + + @override + String get signalSubslot => 'Subranura'; + + @override + String get signalSyncType => 'Tipo de sincronización'; + + @override + String get signalTarget => 'objetivo'; + + @override + String get signalTestCrc => 'CRC de prueba'; + + @override + String get signalTransportFormat => 'Transporte'; + + @override + String get signalUnderruns => 'Subdesbordamientos'; + + @override + String get signalUsageType => 'Tipo de uso'; + + @override + String get signalUsbDescription => + 'Valores de transporte disponibles cuando se abrió este panel. No es un registro en tiempo real de paquetes.'; + + @override + String get signalUsbMissingDescription => + 'Los detalles URB solo se informan en la ruta USB directa. No se infiere ninguna actividad de transferencia.'; + + @override + String get signalUsbTransport => 'Transporte USB'; + + @override + String get signalUsbUnavailable => + 'Detalles del transporte USB no disponibles'; + + @override + String get signalVerificationMissing => 'Verificación no informada'; + + @override + String get signalVerifiedInLog => 'Verificado en el registro'; + + @override + String get signedIn => 'Sesión iniciada'; + + @override + String get silkySmoothBZierCurvesFluid => + 'Curvas de Bézier muy suaves y fluidas, con un movimiento natural'; + + @override + String get similarArtists => 'Artistas similares'; + + @override + String get simple => 'Simple'; + + @override + String get simpleMode => 'Modo simple'; + + @override + String get simplifiedChinese => 'Chino simplificado'; + + @override + String get single => 'Sencillo'; + + @override + String get size => 'Tamaño'; + + @override + String get sizing => 'Ajuste de tamaño'; + + @override + String get skip => 'Omitir'; + + @override + String get skipUnsupportedFilesAndHiddenNomedia => + 'Omitir archivos no compatibles y directorios .nomedia ocultos'; + + @override + String skippedUnmatchedEntr(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Se omitieron $count entradas sin coincidencia', + one: 'Se omitió $count entrada sin coincidencia', + ); + return ' $_temp0.'; + } + + @override + String get sleepTimer => 'Temporizador de apagado'; + + @override + String get sleepTimer2 => 'Temporizador de apagado'; + + @override + String get sleeves => 'Fundas'; + + @override + String get slope => 'Pendiente'; + + @override + String get smbInvalidServerUrl => + 'Usa smb://servidor/recurso o smb://servidor/recurso/carpeta. Ingresa las credenciales en los campos de usuario y contraseña, no en la URL.'; + + @override + String get smbSigningRequired => + 'El servidor requiere firma SMB. Usa una cuenta permitida por la política de seguridad del servidor; es posible que no se permita el acceso de invitado.'; + + @override + String get smbCacheWriteFailed => + 'No se pudo guardar la descarga SMB. Comprueba el espacio libre en el teléfono e inténtalo de nuevo.'; + + @override + String get smbDownloadIncomplete => + 'La descarga SMB no terminó. Comprueba la conexión e inténtalo de nuevo; no se reproducirá ningún archivo parcial.'; + + @override + String get smbPathNotFound => + 'No se encontró la carpeta o el archivo SMB. Comprueba la carpeta en la URL del servidor o vuelve a sincronizar la biblioteca.'; + + @override + String get smbDecodeFailed => + 'Se descargó el archivo SMB, pero no se pudo iniciar la reproducción. Prueba el mismo archivo localmente en Flick y comprueba la salida de audio seleccionada.'; + + @override + String get smbOperationFailed => + 'Falló la operación SMB. Ejecuta Probar conexión y comprueba la etapa o el código SMB en el registro antes de volver a intentarlo.'; + + @override + String get smbAccessDenied => + 'Acceso denegado. Comprueba que la cuenta tenga permiso para leer este recurso compartido.'; + + @override + String get smbAuthFailed => + 'El servidor rechazó el nombre de usuario o la contraseña. Comprueba la cuenta: Samba podría asignar los usuarios desconocidos como invitados.'; + + @override + String get smbConnectionRefused => + 'Se rechazó la conexión. Comprueba que el uso compartido de archivos esté activado y que el puerto 445 esté accesible.'; + + @override + String get smbCouldNotReach => + 'No se pudo acceder al servidor. Comprueba la dirección IP y que el teléfono esté conectado a la misma red.'; + + @override + String get smbHostNotResolved => + 'No se pudo encontrar el nombre del servidor. Prueba con la dirección IP; Android no puede resolver nombres NetBIOS ni .local.'; + + @override + String get smbMissingServerAddress => + 'Falta la dirección del servidor: usa smb://host/recurso (por ejemplo, smb://nas/musica).'; + + @override + String get smbMissingShareName => + 'Falta el nombre del recurso compartido: usa smb://host/recurso (por ejemplo, smb://nas/musica).'; + + @override + String get smbServerUnresponsive => + 'El servidor dejó de responder. Comprueba el servidor e inténtalo de nuevo.'; + + @override + String get smbShareNotFound => + 'El servidor respondió, pero no se encontró el recurso compartido. Comprueba su nombre en la URL.'; + + @override + String get smbSharesCanBeAddedNow => + 'Los recursos SMB2/3 se conectan con el cliente integrado. Ingresa la URL del recurso (smb://host/recurso) e inicia sesión si el servidor lo solicita.'; + + @override + String get smbTimedOut => + 'Se agotó el tiempo de espera. Usa la IP del servidor (no un nombre NetBIOS o .local), comprueba el puerto 445 y asegúrate de que el teléfono esté en la misma red.'; + + @override + String get smooth => 'Suave'; + + @override + String get smoothsPeaksAndRaisesBodyBefore => + 'Suaviza los picos y realza el cuerpo del sonido antes de que el limitador controle los transitorios.'; + + @override + String get snappy => 'Ágil'; + + @override + String get softDetailBalanced => 'Detalle suave y equilibrado'; + + @override + String get softHighlightBehindTheSelectedSong => + 'Resaltado suave detrás de la canción seleccionada'; + + @override + String get softwareAppControlled => 'Software (controlado por la app)'; + + @override + String get solid => 'Sólido'; + + @override + String get soloDeveloper => 'Desarrollador independiente'; + + @override + String get someOnlineFeaturesMayNotWork => + ' · Es posible que algunas funciones en línea no estén disponibles'; + + @override + String get someWordsAreStillUntimedFinish => + 'Aún faltan tiempos para algunas palabras. Termina de marcarlas en el modo Sincronizar palabras.'; + + @override + String get somethingWentWrong => 'Algo salió mal'; + + @override + String song2(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return '$_temp0'; + } + + @override + String song3(int count, Object server) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return '$_temp0 · $server'; + } + + @override + String get songActions => 'Acciones de la canción'; + + @override + String get songArtist => 'Artista de la canción'; + + @override + String get songCount => 'Cantidad de canciones'; + + @override + String get songGestures => 'Gestos de canción'; + + @override + String get songHasNoFilePath => 'La canción no tiene una ruta de archivo.'; + + @override + String get songMetadata => 'Metadatos de la canción'; + + @override + String get songTitle => 'Título de la canción'; + + @override + String songUnit(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'canciones', + one: 'canción', + ); + return '$_temp0'; + } + + @override + String get songViewList => 'Vista de canciones: lista'; + + @override + String get songViewOrbital => 'Vista de canciones: orbital'; + + @override + String songs(Object arg1, Object arg2) { + return '$arg1 • $arg2 canciones'; + } + + @override + String songs12(Object arg1) { + return '$arg1 canciones'; + } + + @override + String songs13(Object count) { + return '$count canciones'; + } + + @override + String get songs14 => 'Canciones'; + + @override + String songs15(Object arg1) { + return '$arg1 canciones'; + } + + @override + String songs2(Object songCount) { + return '$songCount canciones'; + } + + @override + String songs3(Object arg1) { + return '$arg1 canciones'; + } + + @override + String songs4(Object _totalSongs) { + return '$_totalSongs canciones'; + } + + @override + String songs5(Object arg1) { + return '$arg1 canciones'; + } + + @override + String songs9(Object arg1) { + return '$arg1 canciones'; + } + + @override + String songsAlbums(Object arg1, Object uniqueAlbums) { + return '$arg1 canciones • $uniqueAlbums álbumes'; + } + + @override + String songsAlbums2(Object arg1, Object albumCount) { + return '$arg1 canciones · $albumCount álbumes'; + } + + @override + String get songsBeforeTheTappedTrackQueue => + 'Las canciones anteriores a la pista seleccionada se agregan al final de la cola'; + + @override + String get songsCategories => 'Canciones y categorías'; + + @override + String songsCount(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones', + one: '$count canción', + ); + return '$_temp0'; + } + + @override + String songsFound(Object arg1) { + return 'Se encontraron $arg1 canciones'; + } + + @override + String songsIn(int songs, int folders) { + String _temp0 = intl.Intl.pluralLogic( + songs, + locale: localeName, + other: '$songs canciones', + one: '$songs canción', + ); + String _temp1 = intl.Intl.pluralLogic( + folders, + locale: localeName, + other: '$folders carpetas', + one: '$folders carpeta', + ); + return '$_temp0 en $_temp1'; + } + + @override + String songsInRotation(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count canciones en tu rotación', + one: '$count canción en tu rotación', + ); + return '$_temp0'; + } + + @override + String songsU2022Albums(Object arg1, Object uniqueAlbums) { + return '$arg1 canciones • $uniqueAlbums álbumes'; + } + + @override + String get songsYouPlayWillAppearHere => + 'Las canciones que reproduzcas aparecerán aquí'; + + @override + String get songsYouScanIntoYourLibrary => + 'Las canciones que analices para agregarlas a tu biblioteca aparecerán aquí'; + + @override + String get sortBy => 'ORDENAR POR'; + + @override + String get sortFilter => 'Ordenar y filtrar'; + + @override + String get sortSongs => 'Ordenar canciones'; + + @override + String get source => 'Origen'; + + @override + String get sourceRate => 'Frecuencia de origen'; + + @override + String get spaceBetweenTheTwoBars => 'Espacio entre las dos barras'; + + @override + String get spaceOdyssey => 'Odisea espacial'; + + @override + String get spanishDraftDescription => + 'Español latinoamericano. Traducción preliminar pendiente de revisión por hablantes nativos.'; + + @override + String get spatialTime => 'Espacial y tiempo'; + + @override + String get speedUp => 'Acelerar'; + + @override + String get springPhysicsEnergeticAndReactive => + 'Física de resorte: dinámica y reactiva'; + + @override + String get squareRoot => 'Raíz cuadrada'; + + @override + String get stampNext => 'Marcar y siguiente'; + + @override + String get stampNow => 'Marcar ahora'; + + @override + String get stampThisLineFirstToEdit => + 'Primero marca el tiempo de esta línea para editar su línea de tiempo de palabras.'; + + @override + String get standard => 'Estándar'; + + @override + String get standard60hz => 'Estándar (60 Hz)'; + + @override + String get standardBluetoothRoutingViaAndroid => + 'Enrutamiento Bluetooth estándar mediante Android'; + + @override + String get standardEngine => 'Motor estándar'; + + @override + String get starlightSerenade => 'Serenata de luz estelar'; + + @override + String get start => 'Iniciar'; + + @override + String get startAtNow => 'Empezar ahora'; + + @override + String get startBuildingYourHome => 'Empieza a crear tu pantalla de inicio'; + + @override + String get startPlayingToPopulateThisSpace => + 'Empieza a reproducir música para llenar este espacio'; + + @override + String get startStreaming => 'Iniciar transmisión'; + + @override + String get startedPresetDownload => 'Se inició la descarga del preajuste.'; + + @override + String get state => 'Estado'; + + @override + String get status => 'Estado'; + + @override + String get stepByStepWalkthroughOfThe => + 'Recorrido guiado paso a paso por la app'; + + @override + String get stereo => 'Estéreo'; + + @override + String get stop => 'Detener'; + + @override + String get stopAtTheEndOfThe => 'Detener al final de la lista actual'; + + @override + String get stopCasting => 'Detener transmisión'; + + @override + String get stopStreaming => 'Detener transmisión'; + + @override + String get stopUsbOnQuit => 'Detener USB al salir'; + + @override + String get stopWhenTheQueueEnds => 'Detener al terminar la cola'; + + @override + String stoppingIn(Object arg1) { + return 'Se detendrá en $arg1'; + } + + @override + String get storage => 'Almacenamiento'; + + @override + String get storageAccessIsRequiredToScan => + 'Se necesita acceso al almacenamiento para analizar y leer archivos de música, extraer metadatos, importar o exportar preajustes del ecualizador y guardar imágenes del resumen. Todo el procesamiento se realiza en el dispositivo.'; + + @override + String get storagePermissionIsRequiredToAdd => + 'Se necesita permiso de almacenamiento para agregar carpetas de música'; + + @override + String get storagePermissionRequiredForRecap => + 'Se necesita permiso de almacenamiento para guardar imágenes del resumen en esta versión de Android.'; + + @override + String get storagePermissions => 'Permisos de almacenamiento'; + + @override + String get storeOn => 'Guardar en'; + + @override + String get storedAsASaltedHashNever => + 'Se guarda como un hash con sal, nunca como texto sin cifrar'; + + @override + String get storedEncodedPlaybackUnavailableInThis => + 'Se guarda codificado en Base64; es necesario para iniciar sesión con NTLM'; + + @override + String get stormChasers => 'Cazatormentas'; + + @override + String get strategy => 'Estrategia'; + + @override + String get stream => 'Flujo'; + + @override + String get streamConfigurationNotAvailable => + 'Configuración del flujo no disponible'; + + @override + String get streamStable => 'Flujo estable'; + + @override + String get streaming => 'Transmitiendo'; + + @override + String get streamingFromQueue => 'Transmitiendo desde la cola'; + + @override + String get stretchNonSquareArt => 'Estirar portadas no cuadradas'; + + @override + String get strong => 'Fuerte'; + + @override + String get studioGradeOutputForExternalDacs => + 'Salida de calidad de estudio para DAC externos y amplificadores de audífonos. Omite el procesamiento de audio de Android para ofrecer un sonido puro.'; + + @override + String get sub => 'Subgraves'; + + @override + String subfolderCount(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count subcarpetas', + one: '$count subcarpeta', + ); + return '$_temp0'; + } + + @override + String get subsonic => 'Subsonic'; + + @override + String get subsonicServersSyncAndStreaming => + 'Servidores Subsonic, sincronización y transmisión'; + + @override + String get subtle => 'Sutil'; + + @override + String get support => 'Ayuda'; + + @override + String get supportDevelopmentOnBuyMeACoffee => + 'Apoya el desarrollo en Buy Me a Coffee'; + + @override + String get supportDevelopmentOnKoFi => 'Apoya el desarrollo en Ko-fi'; + + @override + String get supportFlick => 'Apoyar Flick'; + + @override + String get supportFlickOnKoFi => 'Apoya Flick en Ko-fi'; + + @override + String get surfaceShading => 'Sombreado de superficie'; + + @override + String get sweepAHighlightThroughWordsAs => + 'Resalta las palabras al ritmo de la voz'; + + @override + String get swipe => 'Deslizar'; + + @override + String get swipeActions => 'Acciones al deslizar'; + + @override + String get swipeHorizontallyToFineTuneEach => + 'Desliza horizontalmente para ajustar con precisión cada banda central.'; + + @override + String get swipeLeftRightToSkipTracks => + 'Desliza a la izquierda o a la derecha para cambiar de pista'; + + @override + String get swipeLeftToUnfavoriteASong => + 'Desliza a la izquierda para quitar una canción de favoritos'; + + @override + String get swipeSongsLeftToQueueOr => + 'Desliza canciones a la izquierda para agregarlas a la cola o a la derecha para marcarlas como favoritas'; + + @override + String get swipeToShowOrHideThe => + 'Desliza para mostrar u ocultar el visualizador'; + + @override + String get switchSongs => 'Cambiar canciones'; + + @override + String get switchToTheExclusiveUsbPath => + 'Cambiar automáticamente a la ruta USB exclusiva cuando se conecte un DAC. Se recuerdan los DAC rechazados.'; + + @override + String get switchedBackToTheAutomaticLyrics => + 'Se volvió a la fuente automática de letras.'; + + @override + String get syllablesTapALetterToSplit => + 'Sílabas: toca una letra para separar o unir:\n'; + + @override + String get symmetricalBarsMirroredFromTheCenter => + 'Barras simétricas reflejadas desde el centro'; + + @override + String get sync => 'Sincronizar'; + + @override + String syncFailed(Object e) { + return 'Error al sincronizar: $e'; + } + + @override + String get syncNow => 'Sincronizar ahora'; + + @override + String get syncServerPlaylists => 'Sincronizar listas del servidor'; + + @override + String get synced => 'Sincronizado'; + + @override + String synced2(Object arg1) { + return 'Sincronizado: $arg1'; + } + + @override + String get syncedLrc => 'LRC sincronizado'; + + @override + String syncedPlaylistFromServers(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Se sincronizaron $count listas de reproducción', + one: 'Se sincronizó $count lista de reproducción', + ); + return '$_temp0 desde los servidores'; + } + + @override + String get syncing => 'Sincronizando…'; + + @override + String get synthwaveCity => 'Ciudad synthwave'; + + @override + String get system => 'Sistema'; + + @override + String get systemAndroidMixer => 'Sistema (mezclador de Android)'; + + @override + String get tagsWereWrittenButCouldNot => + 'Se escribieron las etiquetas, pero no se pudieron confirmar al volver a leer el archivo. Al volver a analizar la biblioteca se corregirán las diferencias.'; + + @override + String tap(Object label) { + return 'Tocar: «$label»'; + } + + @override + String get tapABandToExpandDrag => + 'Toca una banda para ampliarla. Arrastra una perilla para ajustarla. Toca un valor para ingresarlo directamente.'; + + @override + String get tapAllOrEnableAChip => + 'Toca Todo o activa un filtro para ver resultados'; + + @override + String get tapChipsToFilterCategories => + 'Toca los filtros para elegir categorías'; + + @override + String get tapEditTextTopRight => + '1. Toca Editar texto (arriba a la derecha) y pega las letras, una línea por renglón.\n2. Reproduce la canción.\n3. Elige la línea actual en la lista Líneas.\n4. Toca Marcar y siguiente cuando escuches esa línea.\n5. Cuando termines, guarda los cambios.'; + + @override + String get tapTheHeartIconOnAny => + 'Toca el ícono del corazón en cualquier canción\npara agregarla a favoritos'; + + @override + String get tapToInspect12602280Png => + 'Toca para inspeccionar · PNG de 1260 × 2280'; + + @override + String get tapToPreview => 'Toca para obtener una vista previa'; + + @override + String targetMs(Object arg1) { + return 'objetivo $arg1 ms'; + } + + @override + String get tempo => 'Tempo'; + + @override + String tempoX(Object arg1) { + return 'Tempo ${arg1}x'; + } + + @override + String test(Object arg1) { + return 'Prueba: $arg1'; + } + + @override + String get testConnection => 'Probar conexión'; + + @override + String get textGestures => 'Texto y gestos'; + + @override + String get textPlacement => 'Ubicación del texto'; + + @override + String get textPlacement2 => 'Ubicación del texto'; + + @override + String get textSize => 'Tamaño del texto'; + + @override + String get textSize2 => 'Tamaño del texto'; + + @override + String get theAppDoesNotKnowinglyCollect => + 'La app no recopila deliberadamente información de nadie, sin importar su edad.'; + + @override + String get theAppQueriesPublicApisMusicbrainz => + 'La app consulta API públicas (MusicBrainz/Cover Art Archive, iTunes y Deezer) para encontrar portadas de álbumes coincidentes. Las búsquedas usan metadatos locales de música. Las imágenes descargadas se guardan en caché local.'; + + @override + String get theAudioEngineDeterminesHowYour => + 'El motor de audio determina cómo se reproduce la música. Cada opción equilibra de forma distinta la confiabilidad, la calidad y la compatibilidad.'; + + @override + String get theIsochronousUsbEngineWillBe => + 'El motor USB isócrono se detendrá al cerrar la app.'; + + @override + String get theIsochronousUsbEngineWillStay => + 'El motor USB isócrono seguirá activo al cerrar la app.'; + + @override + String get theNamesShowingUpAgainAnd => + 'Los nombres que aparecen una y otra vez en tu cola reciente.'; + + @override + String get thePosterIsNotReadyYet => + 'El póster aún no está listo. Intenta guardarlo de nuevo.'; + + @override + String get theTracksDominatingYourWeeklyAnd => + 'Las canciones que más sonaron en tu resumen semanal y mensual.'; + + @override + String get thisAppIsBuiltByA => + 'Esta app la desarrolla una sola persona y no tiene presupuesto. Si te gusta el audio de alta fidelidad, considera apoyar su desarrollo en Ko-fi.'; + + @override + String get thisClearsYourCurrentDayStreak => + 'Esto borrará tu racha actual y los hitos de racha que hayas desbloqueado. Esta acción no se puede deshacer.'; + + @override + String get thisDevice => 'Este dispositivo'; + + @override + String get thisFolderAppearsToBeEmpty => 'Esta carpeta parece estar vacía'; + + @override + String get thisFolderHasAlreadyBeenAdded => 'Esta carpeta ya se agregó'; + + @override + String get thisMonth => 'Este mes'; + + @override + String get thisMonthSRecap => 'Resumen de este mes'; + + @override + String thisRemovesAllEntriesFromMemory(Object arg1) { + return 'Esto quita de la memoria todas las entradas de $arg1.'; + } + + @override + String get thisSlowsPlaybackTo432440 => + 'Esto baja la reproducción a 432/440 (aprox. 1,8 % menos de tono y tempo) y desactiva el paso directo bit perfecto. La música sonará un poco más grave. Activa esta opción solo si quieres intencionalmente afinar a A=432.'; + + @override + String get thisSongHasNoFilePath => + 'Esta canción no tiene una ruta de archivo y no se puede editar.'; + + @override + String get thisSongIsMissingAlbumMetadata => + 'A esta canción le faltan los metadatos del álbum, por lo que la búsqueda en línea es limitada.'; + + @override + String get thisSongOnly => 'Solo esta canción'; + + @override + String get thisWeek => 'Esta semana'; + + @override + String get thisWeekSRecap => 'Resumen de esta semana'; + + @override + String get thisYearSRecap => 'Resumen de este año'; + + @override + String get threshold => 'Umbral'; + + @override + String get thunderRoad => 'Thunder Road'; + + @override + String get tidal => 'Tidal'; + + @override + String get tidalAppKeyRejected => + 'Tidal rechazó la clave de inicio de sesión de la app. Estas claves cambian, así que la integrada podría estar desactualizada (una limitación conocida de la integración no oficial).'; + + @override + String tidalCouldNotReach(int status) { + return 'No se pudo acceder a Tidal (HTTP $status). Comprueba tu conexión.'; + } + + @override + String tidalEncryptedTrack(String trackId) { + return 'La pista $trackId está cifrada (HiRes/MQA). Solo se admite audio HiFi sin pérdida que no esté cifrado.'; + } + + @override + String tidalManifestDecodeFailed(String trackId, String error) { + return 'No se pudo decodificar el manifiesto de Tidal para la pista $trackId: $error'; + } + + @override + String tidalManifestNoStream(String trackId) { + return 'La pista $trackId no tiene una URL de transmisión en su manifiesto.'; + } + + @override + String get tidalNoPlayableStream => + 'No hay una transmisión reproducible para esta pista.'; + + @override + String get tidalNoSignInCode => + 'Tidal no devolvió un código de inicio de sesión.'; + + @override + String get tidalNotSignedIn => + 'No iniciaste sesión en Tidal. Toca Iniciar sesión con Tidal.'; + + @override + String tidalOpenLinkManually(String uri) { + return 'No se pudo abrir el navegador automáticamente. Abre este enlace en cualquier dispositivo para terminar de iniciar sesión y luego toca Iniciar sesión otra vez:\n\n$uri'; + } + + @override + String get tidalSessionExpired => + 'La sesión de Tidal venció. Vuelve a iniciar sesión.'; + + @override + String get tidalSignInDenied => 'Se rechazó el inicio de sesión en Tidal.'; + + @override + String get tidalSignInExpired => + 'El código de inicio de sesión de Tidal venció. Inténtalo de nuevo.'; + + @override + String get tidalSignInRefused => + 'Tidal rechazó el inicio de sesión. Inténtalo de nuevo.'; + + @override + String get tidalSignInTimedOut => + 'Se agotó el tiempo de espera para iniciar sesión en Tidal.'; + + @override + String get tidalTokenRefreshFailed => + 'No se pudo actualizar el token de Tidal.'; + + @override + String get tidalTooManyRequests => + 'Demasiadas solicitudes a Tidal. Espera un momento e inténtalo de nuevo.'; + + @override + String get tidalUnavailable => + 'Tidal no está disponible ahora. Inténtalo de nuevo en un momento.'; + + @override + String tidalUnsupportedFormat(String trackId) { + return 'La pista $trackId usa un formato de Tidal no compatible (HiRes/MQA/Atmos). Solo se admite audio HiFi sin pérdida que no esté cifrado.'; + } + + @override + String get time => 'Hora'; + + @override + String get timeShift => 'Desplazamiento de tiempo'; + + @override + String get timestamp => 'Marca de tiempo'; + + @override + String get tintedFromTodaySTopCover => + 'Con tinte de la portada más destacada de hoy'; + + @override + String get tips => 'Consejos'; + + @override + String get title => 'Título'; + + @override + String get toRemove => 'Por quitar'; + + @override + String get today => 'Hoy'; + + @override + String get todaySRecap => 'Resumen de hoy'; + + @override + String get toneControls => 'Controles de tono'; + + @override + String get tools => 'Herramientas'; + + @override + String get top => 'Arriba'; + + @override + String get topAlbum => 'Álbum destacado'; + + @override + String get topArtist => 'Artista destacado'; + + @override + String get topArtists => 'Artistas destacados'; + + @override + String get topSongs => 'Canciones destacadas'; + + @override + String get topSongs2 => 'Canciones destacadas'; + + @override + String get total => 'Total'; + + @override + String get track => 'Pista'; + + @override + String track2(Object arg1) { + return 'Pista $arg1'; + } + + @override + String get track3 => 'N.º de pista'; + + @override + String get trackBitDepth => 'Profundidad de bits de la pista'; + + @override + String get trackChannels => 'Canales de la pista'; + + @override + String get trackConsecutiveListeningDaysAndShow => + 'Registrar los días consecutivos de escucha y mostrar la ventana emergente'; + + @override + String get trackCount => 'Cantidad de pistas'; + + @override + String get trackDsdRate => 'Frecuencia DSD de la pista'; + + @override + String get trackNumber => 'Número de pista'; + + @override + String get trackSampleRate => 'Frecuencia de muestreo de la pista'; + + @override + String get trackThumbnails => 'Miniaturas de pistas'; + + @override + String get trackTime => 'Duración de la pista'; + + @override + String get trackTimeSumsTheFullDuration => + 'La duración de la pista suma el tiempo total de todas las reproducciones registradas.'; + + @override + String tracks(Object _totalTracks) { + return '$_totalTracks pistas'; + } + + @override + String tracks2(Object arg1) { + return '$arg1 pistas'; + } + + @override + String tracks3(Object arg1) { + return '$arg1 pistas'; + } + + @override + String tracks4(Object arg1) { + return '$arg1 pistas'; + } + + @override + String tracks5(Object arg1, Object arg2) { + return '$arg1 · $arg2 pistas'; + } + + @override + String tracks6(Object arg1) { + return '$arg1 pistas'; + } + + @override + String tracks7(Object trackCount, Object arg1) { + return '$trackCount pistas • $arg1'; + } + + @override + String tracks8(Object arg1) { + return '$arg1 pistas'; + } + + @override + String tracksLikedSongsPlaylists( + Object songCount, + Object favoriteCount, + Object playlistCount, + ) { + return '$songCount pistas, $favoriteCount canciones que te gustan, $playlistCount listas de reproducción'; + } + + @override + String tracksReadyToRevisit(Object favoritesCount) { + return '$favoritesCount pistas para volver a escuchar'; + } + + @override + String get tracksThatFitTheQuieterSide => + 'Canciones que van con el lado más tranquilo de lo que escuchas.'; + + @override + String get transparent => 'Transparente'; + + @override + String get treble => 'Agudos'; + + @override + String get trueRandomMayRepeatBeforeList => + 'Aleatorio real (puede repetir antes de terminar la lista)'; + + @override + String get truncate => 'Recortar'; + + @override + String get tryAdjustingYourSearchQuery => 'Prueba a modificar la búsqueda'; + + @override + String get tryAgain => 'Inténtalo de nuevo'; + + @override + String get tryAnotherKeywordOrEnableMore => + 'Prueba con otra palabra clave o activa más categorías'; + + @override + String get tryOriginalSearch => 'Probar la búsqueda original'; + + @override + String get tryPickingALocalImageIf => + 'Prueba a elegir una imagen local si los metadatos del lanzamiento son poco comunes.'; + + @override + String get turnOff432HzTuningTo => + 'Desactiva la afinación a 432 Hz para usar el fundido cruzado'; + + @override + String get turnOff432HzTuningTo2 => + 'Desactiva la afinación a 432 Hz para usar la mezcla entre canales'; + + @override + String get typeABrandAndModelTo => + 'Escribe la marca y el modelo para buscar en línea.'; + + @override + String get u162ByteSubslotsLlRr => 'U16: subranuras de 2 bytes, LL|RR'; + + @override + String u2022(Object arg1, Object valueLabel) { + return '$arg1 • $valueLabel'; + } + + @override + String u20223(Object arg1, Object gainLabel) { + return '$arg1 • $gainLabel'; + } + + @override + String u2022Bit(Object arg1) { + return ' • $arg1 bits'; + } + + @override + String get u324ByteSubslotsLlllRrrr => + 'U32: subranuras de 4 bytes, LLLL|RRRR (heredado)'; + + @override + String get u8ByteInterleavedLrlr => 'U8: intercalado por bytes LRLR'; + + @override + String get u8ByteInterleavedRecommendedDefault => + 'U8: intercalado por bytes, predeterminado recomendado'; + + @override + String get uac2AndEqualizer => 'UAC2 y ecualizador'; + + @override + String get uac2IsNotAvailableOnThis => + 'UAC2 no está disponible en esta plataforma'; + + @override + String get uac2NotAvailableOnThisPlatform => + 'UAC2 no está disponible en esta plataforma'; + + @override + String get uac2Preferences => 'Preferencias de UAC2'; + + @override + String get uac2PreferencesResetSuccessfully => + 'Se restablecieron las preferencias de UAC2'; + + @override + String get uiCustomization => 'Personalización de la interfaz'; + + @override + String get ultra => 'Ultra'; + + @override + String get unableToCheckForUpdatesRight => + 'No se pueden buscar actualizaciones en este momento.'; + + @override + String get unableToLoadPatchNotesRight => + 'No se pueden cargar las notas de la versión en este momento.'; + + @override + String get unableToOpenAllFilesAccess => + 'No se puede abrir la configuración de acceso a todos los archivos'; + + @override + String get unableToOpenBatteryOptimizationSettings => + 'No se puede abrir la configuración de optimización de batería'; + + @override + String unavailable(Object featureName) { + return '$featureName no disponible'; + } + + @override + String get unavailable2 => 'No disponible'; + + @override + String underruns(Object arg1) { + return '$arg1 subdesbordamientos'; + } + + @override + String get undo => 'Deshacer'; + + @override + String get unfavorite => 'Quitar de favoritos'; + + @override + String get unfavoriteSelected => 'Quitar la selección de favoritos'; + + @override + String get uniqueArtists => 'Artistas únicos'; + + @override + String get universalCompatibility => 'Compatibilidad universal'; + + @override + String get unknown => 'Desconocido'; + + @override + String get unknownAlbum => 'Álbum desconocido'; + + @override + String get unknownArtist => 'Artista desconocido'; + + @override + String get unknownBitrate => 'Tasa de bits desconocida'; + + @override + String get unknownFolder => 'Carpeta desconocida'; + + @override + String get unknownLastFmError => 'Error desconocido de Last.fm'; + + @override + String get unknownTitle => 'Título desconocido'; + + @override + String get unknownTrack => 'Pista desconocida'; + + @override + String unlocked(Object unlocked, Object arg1) { + return '$unlocked / $arg1 desbloqueados'; + } + + @override + String unlocked3(Object _milestonesUnlocked, Object arg1) { + return '$_milestonesUnlocked / $arg1 desbloqueados'; + } + + @override + String get unmute => 'Activar sonido'; + + @override + String get unreported => 'No informado'; + + @override + String get unsavedChanges => 'Cambios sin guardar'; + + @override + String up(Object arg1) { + return '$arg1 arriba'; + } + + @override + String get upNext => 'A continuación'; + + @override + String upcomingSong(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count próximas canciones', + one: '$count próxima canción', + ); + return '$_temp0'; + } + + @override + String get update => 'Actualizar'; + + @override + String get updateAvailable => 'Actualización disponible'; + + @override + String get updateAvailableDownloadFromFlickPlayer => + 'Hay una actualización disponible: descárgala desde flick-player.site'; + + @override + String get updateAvailableOnThePlayStore => + 'Hay una actualización disponible en Play Store.'; + + @override + String get updateNoticeHidden => 'Se ocultó el aviso de actualización.'; + + @override + String updated(Object arg1) { + return 'Actualizado: $arg1'; + } + + @override + String updatedAlbumArtFor(Object arg1) { + return 'Se actualizó la portada del álbum «$arg1».'; + } + + @override + String updatedAlbumArtFor2(Object arg1) { + return 'Se actualizó la portada del álbum «$arg1».'; + } + + @override + String get updates => 'Actualizaciones'; + + @override + String get updatesAboutAndSupport => 'Actualizaciones, información y ayuda'; + + @override + String get upload => 'Subir'; + + @override + String uploadFailed(Object arg1) { + return 'Error al subir ($arg1).'; + } + + @override + String uploadFailed2(Object e) { + return 'Error al subir: $e'; + } + + @override + String get uploadLogsAsALink => '¿Subir los registros como enlace?'; + + @override + String get upnpDlna => 'UPnP / DLNA'; + + @override + String get urbPacket => 'Paquete URB'; + + @override + String get urbTransfer => 'Transferencia URB'; + + @override + String get urbanEchoes => 'Ecos urbanos'; + + @override + String get usbAudioClass20Devices => + 'Los dispositivos USB Audio Class 2.0 (DAC/amplificadores externos) se usan localmente para reproducir audio bit perfecto. No se transmite información de dispositivos USB a terceros.'; + + @override + String get usbAudioDevice => 'Dispositivo de audio USB'; + + @override + String get usbAudioDevices => 'Dispositivos de audio USB'; + + @override + String get usbAudioError => 'Error de audio USB'; + + @override + String get usbAudioUac2 => 'Audio USB (UAC2)'; + + @override + String get usbDacAutoBitPerfectOffers => + 'Se restablecieron las ofertas automáticas de modo bit perfecto para DAC USB.'; + + @override + String get usbDacsHeadphonesAndReferenceGear => + 'DAC USB, audífonos y equipos de referencia para probar y mejorar la calidad de reproducción.'; + + @override + String get usbDeviceAccess => 'Acceso al dispositivo USB'; + + @override + String get usbNotConnected => 'USB no conectado'; + + @override + String get usbRouteVolume => 'Volumen de la ruta USB'; + + @override + String get usbStorageNotConnected => 'Almacenamiento USB no conectado'; + + @override + String get usbVolume => 'Volumen USB'; + + @override + String get usbVolumeInSettings => 'Volumen USB en Ajustes'; + + @override + String get usbVolumeOnHome => 'Volumen USB en Inicio'; + + @override + String get useAFixed48khz16bitOutput => + 'Usar una salida fija de 48 kHz/16 bits para mejorar la compatibilidad'; + + @override + String get useAaudioDirectlyLowestLatencyOn => + 'Usar AAudio directamente. Menor latencia en Android 8.1 y versiones posteriores.'; + + @override + String get useAlbumArtAsBackground => 'Usar la portada del álbum como fondo'; + + @override + String get useAutoSource => 'Usar fuente automática'; + + @override + String get useCurrentTime => 'Usar hora actual'; + + @override + String get useExistingFile => 'Usar archivo existente'; + + @override + String get useExistingFileInTheLyrics => + '- «Usar archivo existente» en el panel de letras vincula un archivo `.lrc`, `.txt` o `.xml`.\n- Si algunas líneas no tienen tiempo marcado, Flick los completa automáticamente.\n- Al guardar, se escribe junto a la canción cuando es posible; de lo contrario, Flick guarda una copia vinculada.'; + + @override + String get useFilesystemLevelScanningInsteadOf => + 'Usar análisis a nivel del sistema de archivos en lugar de MediaStore para obtener etiquetas más precisas'; + + @override + String get useMmSsCcEG => 'Usar mm:ss.cc; por ejemplo, 01:23.45'; + + @override + String get useTheCurrentAudioFileS => + 'Usar el nombre del archivo de audio actual al guardar las letras en la app'; + + @override + String get useTheDefaultMonochromeTheme => + 'Usar el tema monocromático predeterminado.'; + + @override + String get useTheHighestFixedOutputRate => + 'Usar la frecuencia de salida fija y la profundidad de bits más altas disponibles'; + + @override + String get useTheLegacyOpenslEsBackend => + 'Usar el motor OpenSL ES heredado. Alternativa para solucionar problemas en dispositivos antiguos o problemáticos.'; + + @override + String get useTheListSongsBrowser => 'Usar la vista de canciones en lista'; + + @override + String get useTheOrbitalSongsBrowser => 'Usar la vista orbital de canciones'; + + @override + String get useTheVerifiedDirectUsbPath => + 'Usar la ruta USB directa verificada y desactivar los controles de DSP por software que impedirían la reproducción bit perfecta en un DAC USB externo.'; + + @override + String get userToken => 'Token de usuario'; + + @override + String get username => 'Nombre de usuario'; + + @override + String using(Object arg1) { + return 'Usando $arg1'; + } + + @override + String using2(Object arg1) { + return 'Usando $arg1'; + } + + @override + String get variableBitrateLowLatency => + 'Tasa de bits variable y baja latencia'; + + @override + String get variousArtists2 => 'Varios artistas'; + + @override + String get velvetNoir => 'Noir aterciopelado'; + + @override + String get vendorId => 'ID del proveedor'; + + @override + String get verboseDartRustAndCrashLogs => + 'Registros detallados de Dart, Rust y fallos'; + + @override + String get verified => 'Verificado'; + + @override + String version(Object kAppVersion) { + return 'Versión $kAppVersion'; + } + + @override + String version2(Object arg1) { + return 'Versión $arg1'; + } + + @override + String get verticalBarsClassicSpectrumAnalyzer => + 'Barras verticales: analizador de espectro clásico'; + + @override + String get verticalBarsThatAnimateAcrossThe => + 'Barras verticales que se animan por toda la pantalla.'; + + @override + String get verticalPosition => 'Posición vertical'; + + @override + String get vibrant => 'Intenso'; + + @override + String get viewAsGrid => 'Ver como cuadrícula'; + + @override + String get viewAsList => 'Ver como lista'; + + @override + String get viewMetadata => 'Ver metadatos'; + + @override + String get viewOnboarding => 'Ver bienvenida'; + + @override + String get viewQueue => 'Ver cola'; + + @override + String get visualizer => 'Visualizador'; + + @override + String get visualizerAlbumColorsDescription => + 'Seguir los colores de la portada; usar monocromo si no están disponibles'; + + @override + String get visualizerBlocks => 'Bloques que se desvanecen'; + + @override + String get visualizerBlocksDescription => + 'Barras segmentadas con estelas que se desvanecen suavemente'; + + @override + String get visualizerColors => 'Colores'; + + @override + String get visualizerMonochrome => 'Monocromático'; + + @override + String get visualizerMonochromeDescription => + 'Blanco y gris, independientemente de la portada del álbum'; + + @override + String get visualizerRainbow => 'Arcoíris'; + + @override + String get visualizerRainbowDescription => + 'Un espectro de colores en todo el visualizador'; + + @override + String get visuals => 'Visuales'; + + @override + String get volume => 'Volumen'; + + @override + String get volumeControl => 'Control de volumen'; + + @override + String get volumeDipsWhileNotificationSoundsPlay => + 'El volumen baja mientras suenan las notificaciones'; + + @override + String get volumeIsFixedWhileBitPerfect => + 'El volumen se mantiene fijo durante el paso directo bit perfecto porque Flick no puede controlar el volumen del hardware USB. Usa los controles del dispositivo o reproduce PCM con el modo bit perfecto desactivado para ajustar el volumen por software.'; + + @override + String get volumeIsFixedWhileBitPerfect2 => + 'El volumen se mantiene fijo durante el paso directo bit perfecto porque Flick no puede controlar el volumen del hardware USB. Usa los controles del dispositivo o reproduce PCM con el modo bit perfecto desactivado para ajustar el volumen por software.'; + + @override + String get directUsbFormatNotice => + 'Se detectó un DAC USB directo. La conexión USB directa omite el mezclador y el volumen del sistema Android. El formato mostrado es el formato de contenido solicitado, no una medición de la frecuencia de salida del DAC.'; + + @override + String get usbVolumeSafetyPaused => + 'No se pudo confirmar el volumen del DAC. Pulsa Reproducir para volver a intentarlo con un nivel bajo. Si vuelve a fallar, reconecta el DAC.'; + + @override + String get usbHardwareVolumeUnavailable => + 'Flick no puede controlar el volumen del hardware USB. Durante el paso directo bit perfecto, usa los controles físicos del dispositivo. Para ajustar el volumen por software, reproduce PCM con el modo bit perfecto desactivado.'; + + @override + String usbHardwareVolumeError(String reason) { + return 'Volumen del hardware USB: $reason'; + } + + @override + String wAgo(Object arg1) { + return 'hace $arg1 sem'; + } + + @override + String get waitingForBrowserAuthorization => + 'Esperando la autorización del navegador…'; + + @override + String get waitingForPlayback => 'Esperando la reproducción'; + + @override + String was(Object arg1) { + return 'era: $arg1'; + } + + @override + String get wave => 'Onda'; + + @override + String get waveform => 'Forma de onda'; + + @override + String get waveformHeight => 'Altura de la forma de onda'; + + @override + String get waveformHeightDescription => + 'Ajusta la altura de las barras de la forma de onda.'; + + @override + String get waveformSeekbar => 'Barra de reproducción con forma de onda'; + + @override + String weLlKeepTheBestQuality(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count copias', + one: '$count copia', + ); + return 'Conservaremos la versión de mejor calidad de cada grupo (se prefiere la portada del álbum y luego la tasa de bits más alta) y quitaremos $_temp0. Los archivos del disco no se eliminarán.'; + } + + @override + String weLlKeepYourCheckedVersion(int kept, int removed) { + String _temp0 = intl.Intl.pluralLogic( + kept, + locale: localeName, + other: '$kept versiones que marcaste', + one: '$kept versión que marcaste', + ); + String _temp1 = intl.Intl.pluralLogic( + removed, + locale: localeName, + other: '$removed copias restantes', + one: '$removed copia restante', + ); + return 'Conservaremos $_temp0 y quitaremos de la biblioteca $_temp1. Los archivos de audio del disco no se eliminarán.'; + } + + @override + String get webdav => 'WebDAV'; + + @override + String get weekly => 'Semanal'; + + @override + String get welcomeBackLetSStartA => + '¡Qué bueno tenerte de vuelta! Empecemos una racha.'; + + @override + String get welcomeToFlick => '¡Te damos la bienvenida a Flick!'; + + @override + String get whatItShows => 'Qué muestra'; + + @override + String get whatSNew => 'Novedades'; + + @override + String get whenBitPerfectOutputIs => + 'Cuando la salida bit perfecta está activa, una cápsula muestra la frecuencia de muestreo y la profundidad de bits que se envían al DAC.'; + + @override + String get whenYouPlayOverBluetoothAndroid => + 'Al reproducir por Bluetooth, Android negocia el códec con tus audífonos o bocina.'; + + @override + String get whereShouldTheLrcFileBe => + '¿Dónde quieres guardar el archivo .lrc?'; + + @override + String get whereTheFocalSongSitsVertically => + 'Posición vertical de la canción destacada'; + + @override + String get whereYourMoneyGoes => 'A dónde va tu dinero'; + + @override + String get whisperWorld => 'Mundo susurrante'; + + @override + String get whisperedSecrets => 'Secretos susurrados'; + + @override + String get white => 'Blanco'; + + @override + String get wholeAlbum => 'Álbum completo'; + + @override + String get whyDonate => '¿Por qué donar?'; + + @override + String wide(Object amount) { + return '$amount% de ancho'; + } + + @override + String get widgets => 'Widgets'; + + @override + String get width => 'Ancho'; + + @override + String get wildWeather => 'Clima salvaje'; + + @override + String get willBeRemoved => 'Se quitará'; + + @override + String get willKeep => 'Se conservará'; + + @override + String get wiredOutput => 'Salida por cable'; + + @override + String word(Object arg1, Object arg2) { + return 'Palabra $arg1 · «$arg2»'; + } + + @override + String word2(Object arg1, Object token) { + return 'Palabra $arg1 · «$token»'; + } + + @override + String get wordSync => 'Sincronizar palabras'; + + @override + String get wordSyncModeKaraoke => 'Modo Sincronizar palabras (karaoke)'; + + @override + String wordTimelineLine(Object arg1) { + return 'Línea de tiempo de palabras · Línea $arg1'; + } + + @override + String get wrapAroundAndQueueBehavior => + 'Repetición y comportamiento de la cola'; + + @override + String get wrapAroundQueue => 'Cola con repetición'; + + @override + String get writeADescription => 'Escribe una descripción'; + + @override + String x(Object min) { + return '${min}x'; + } + + @override + String x2(Object max) { + return '${max}x'; + } + + @override + String x3(Object currentSpeed) { + return '${currentSpeed}x'; + } + + @override + String yAgo(Object arg1) { + return 'hace $arg1 años'; + } + + @override + String get year => 'Año'; + + @override + String get yearly => 'Anual'; + + @override + String get yesterday => 'Ayer'; + + @override + String get youAlreadyHaveTheLatestFlick => + 'Ya tienes la versión más reciente de Flick'; + + @override + String get youAlreadyHaveTheLatestPlay => + 'Ya tienes la versión más reciente de Play Store'; + + @override + String get youCanAlsoChangeTheCodec => + 'También puedes cambiar el códec en Opciones para desarrolladores de Android, en «Códec de audio Bluetooth».'; + + @override + String get youCustomizedWhichVersionsToKeep => + 'Personalizaste cuáles versiones conservar. Bien: tú decides.'; + + @override + String get youHaveUnsavedChangesAreYou => + 'Tienes cambios sin guardar. ¿Seguro que quieres descartarlos?'; + + @override + String get youHaveUnsavedLyricEditsLeave => + 'Tienes cambios sin guardar en las letras. ¿Quieres salir del Estudio de sincronización sin guardarlos?'; + + @override + String get youReOffline => 'No tienes conexión'; + + @override + String get youReOfflineSomeOnlineFeatures => + 'No tienes conexión. Es posible que algunas funciones en línea no estén disponibles.'; + + @override + String get youVeHitTheThresholdKeep => 'Llegaste al umbral: ¡sigue así!'; + + @override + String get yourCollectionAtAGlance => 'Tu colección de un vistazo'; + + @override + String get yourCustomCollections => 'Tus colecciones personalizadas'; + + @override + String get yourHeaviestRotationRightNow => 'Lo que más escuchas ahora'; + + @override + String get yourLatestLibraryScans => + 'Tus análisis de biblioteca más recientes'; + + @override + String get yourLibrary => 'Tu biblioteca'; + + @override + String get yourLibraryAtAGlance => 'Tu biblioteca de un vistazo'; + + @override + String get yourLibraryIsTidyWeLl => + 'Tu biblioteca está ordenada. Te avisaremos si aparecen nuevos duplicados después del próximo análisis.'; + + @override + String get yourListeningHistoryIsStillYours => + 'Tu historial de escucha sigue siendo tuyo. Intenta cargarlo de nuevo.'; + + @override + String get yourListensWillRemainOnListenbrainz => + 'Tus reproducciones seguirán en ListenBrainz, pero Flick dejará de enviarlas.'; + + @override + String get yourLogsAreUploadedToDpaste => + 'Tus registros se suben a dpaste.com como un enlace no listado que vence en 30 días. Cualquier persona con el enlace podrá leerlos; los registros pueden incluir rutas de archivos y detalles del dispositivo.'; + + @override + String get yourMonthlyRecapNeedsABit => + 'Tu resumen mensual necesita un poco más de tiempo de escucha este mes.'; + + @override + String get yourMostReplayedTrack => 'La pista que más repetiste'; + + @override + String get yourMusicIsBeingScrobbled => + 'Se están registrando tus reproducciones'; + + @override + String get yourMusicIsBeingSubmitted => + 'Se están enviando tus reproducciones'; + + @override + String get yourMusicOnRepeat => 'Tu música. Una y otra vez.'; + + @override + String get yourNewAudioEngineIsReady => + 'Tu nuevo motor de audio está listo. Reinicia Flick para aplicarlo.'; + + @override + String get yourNextFavoriteIsWaiting => 'Tu próximo favorito te espera.'; + + @override + String get yourNextFavoriteNisWaiting => 'Tu próximo favorito\nte espera.'; + + @override + String get yourPlaylists => 'Tus listas de reproducción'; + + @override + String get yourScrobblingHistoryWillRemainOn => + 'Tu historial de reproducciones seguirá en Last.fm, pero Flick dejará de enviar los registros.'; + + @override + String get yourSessionHistory => 'Tu historial de sesiones'; + + @override + String get yourWeeklyRecapAppearsOnceYou => + 'Tu resumen semanal aparecerá cuando empieces a escuchar música esta semana.'; + + @override + String get yourYearlyRecapFillsInAs => + 'Tu resumen anual se completa a medida que escuchas música durante el año.'; +} diff --git a/lib/l10n/generated/app_localizations_tl.dart b/lib/l10n/generated/app_localizations_tl.dart index 913a33f7..c5ced6a9 100644 --- a/lib/l10n/generated/app_localizations_tl.dart +++ b/lib/l10n/generated/app_localizations_tl.dart @@ -5625,6 +5625,14 @@ class AppLocalizationsTl extends AppLocalizations { @override String get orbital => 'Orbital'; + @override + String get orbitHeaderBoundaryBody => + 'Ang mga orbital card at orbit path ay nananatili sa ilalim ng Your Library heading at search bar. Kapag itinaas ang orbit, napuputol ito sa hangganang ito.'; + + @override + String get orbitHeaderBoundaryTitle => + 'Humihinto ang orbit sa library header'; + @override String get orbitLandscapeHint => 'Ginagamit kapag mas malapad kaysa matangkad ang window ng app.'; @@ -5636,6 +5644,16 @@ class AppLocalizationsTl extends AppLocalizations { String get orbitPortraitHint => 'Ginagamit kapag mas matangkad kaysa lapad ang window ng app.'; + @override + String get orbitPreviewHide => 'Itago ang preview'; + + @override + String get orbitPreviewHint => + 'Mag-swipe upang mag-browse. Walang tumutugtog, naidadagdag sa queue, o nababago sa mga paborito.'; + + @override + String get orbitPreviewShow => 'Ipakita ang preview'; + @override String get orbitSharedVisuals => 'Mga shared na visual'; @@ -7794,6 +7812,10 @@ class AppLocalizationsTl extends AppLocalizations { @override String get spaceOdyssey => 'Paglalakbay sa kalawakan'; + @override + String get spanishDraftDescription => + 'Latin American Spanish. Draft copy para sa review ng native speaker.'; + @override String get spatialTime => 'Espasyo at oras'; diff --git a/lib/l10n/generated/app_localizations_zh.dart b/lib/l10n/generated/app_localizations_zh.dart index 1b357334..7fc55335 100644 --- a/lib/l10n/generated/app_localizations_zh.dart +++ b/lib/l10n/generated/app_localizations_zh.dart @@ -5204,6 +5204,13 @@ class AppLocalizationsZh extends AppLocalizations { @override String get orbital => 'Orbital'; + @override + String get orbitHeaderBoundaryBody => + '轨道卡片和轨道路径始终位于媒体库标题与搜索栏下方。向上移动轨道时，会在此边界处被裁切。'; + + @override + String get orbitHeaderBoundaryTitle => '轨道止于媒体库顶栏'; + @override String get orbitLandscapeHint => '当应用窗口宽大于高时使用。'; @@ -5213,6 +5220,15 @@ class AppLocalizationsZh extends AppLocalizations { @override String get orbitPortraitHint => '当应用窗口高大于宽时使用。'; + @override + String get orbitPreviewHide => '隐藏预览'; + + @override + String get orbitPreviewHint => '滑动即可浏览。不会播放、加入队列或更改收藏。'; + + @override + String get orbitPreviewShow => '显示预览'; + @override String get orbitSharedVisuals => '共享视觉效果'; @@ -7145,6 +7161,9 @@ class AppLocalizationsZh extends AppLocalizations { @override String get spaceOdyssey => '太空漫游'; + @override + String get spanishDraftDescription => '拉丁美洲西班牙语，翻译草稿待母语使用者审核。'; + @override String get spatialTime => '空间与时间'; diff --git a/lib/l10n/l10n.dart b/lib/l10n/l10n.dart index 60b1e078..4c73ca7a 100644 --- a/lib/l10n/l10n.dart +++ b/lib/l10n/l10n.dart @@ -46,6 +46,7 @@ const Locale kBaybayinLocale = Locale.fromSubtags( const List kSupportedLocales = [ Locale('en'), Locale('zh', 'CN'), + Locale('es'), kFilipinoLocale, ]; diff --git a/lib/services/android_audio_device_service.dart b/lib/services/android_audio_device_service.dart index a8825756..cd769513 100644 --- a/lib/services/android_audio_device_service.dart +++ b/lib/services/android_audio_device_service.dart @@ -14,6 +14,11 @@ class AndroidPlaybackDeviceInfo { required this.model, this.routeType, this.routeLabel, + this.hasWiredAudioRoute = false, + this.physicalOutputType, + this.physicalOutputId, + this.physicalOutputConnectionId, + this.physicalOutputLabel, }); final bool hasUsbDac; @@ -22,12 +27,47 @@ class AndroidPlaybackDeviceInfo { final String model; final String? routeType; final String? routeLabel; + final bool hasWiredAudioRoute; + final String? physicalOutputType; + final String? physicalOutputId; + final String? physicalOutputConnectionId; + final String? physicalOutputLabel; bool get isUsbRoute => routeType == 'usb'; bool get isInternalRoute => routeType == 'internal'; bool get isWiredRoute => routeType == 'wired'; bool get isBluetoothRoute => routeType == 'bluetooth'; bool get isDockRoute => routeType == 'dock'; + + /// True whenever an external output exists, even if Android has not routed + /// audio to it yet or the app has no USB permission. + bool get hasPhysicalOutput => + hasUsbDac || + hasAttachedUac2Device || + hasWiredAudioRoute || + isUsbRoute || + isWiredRoute || + isDockRoute; + + /// Stable identity for one physical connection. Repeated AudioDeviceCallback + /// events for the same output must not re-apply the safety ceiling. + String? get physicalOutputKey { + if (!hasPhysicalOutput) return null; + final kind = + hasUsbDac || + hasAttachedUac2Device || + physicalOutputType == 'usb' || + isUsbRoute + ? 'usb' + : physicalOutputType ?? routeType ?? 'physical'; + final id = + physicalOutputConnectionId ?? + physicalOutputId ?? + physicalOutputLabel ?? + routeLabel; + return id == null || id.isEmpty ? kind : '$kind:$id'; + } + bool get looksLikeUsbAudioRoute { final summary = routeSummary.toLowerCase(); return summary.contains('usb') || summary.contains('dac'); @@ -70,6 +110,11 @@ class AndroidPlaybackDeviceInfo { model: raw['model'] as String? ?? '', routeType: raw['routeType'] as String?, routeLabel: raw['routeLabel'] as String?, + hasWiredAudioRoute: raw['hasWiredAudioRoute'] == true, + physicalOutputType: raw['physicalOutputType']?.toString(), + physicalOutputId: raw['physicalOutputId']?.toString(), + physicalOutputConnectionId: raw['physicalOutputConnectionId']?.toString(), + physicalOutputLabel: raw['physicalOutputLabel']?.toString(), ); } diff --git a/lib/services/android_audio_engine.dart b/lib/services/android_audio_engine.dart index 66870986..aacedf2d 100644 --- a/lib/services/android_audio_engine.dart +++ b/lib/services/android_audio_engine.dart @@ -113,6 +113,7 @@ bool shouldExitSingleTrackMode({ class AndroidAudioEngine implements AudioEngine { AndroidAudioEngine({ required AndroidPlayerProvider playerProvider, + AndroidPlayerProvider? secondaryPlayerProvider, required AndroidAudioSourcesBuilder sourcesBuilder, required AndroidAudioSourceBuilder sourceBuilder, required AndroidPlaylistProvider playlistProvider, @@ -125,7 +126,10 @@ class AndroidAudioEngine implements AudioEngine { AndroidNextSongProvider? onNextSong, AndroidTrackAdvancedCallback? onTrackAdvanced, AndroidTrackErrorCallback? onTrackError, + ValueChanged? onActivePlayerChanged, }) : _playerProvider = playerProvider, + _secondaryPlayerProvider = secondaryPlayerProvider ?? + (() async => just_audio.AudioPlayer()), _sourcesBuilder = sourcesBuilder, _sourceBuilder = sourceBuilder, _playlistProvider = playlistProvider, @@ -138,9 +142,11 @@ class AndroidAudioEngine implements AudioEngine { (() => AndroidCrossfadeConfig.disabled), _onNextSong = onNextSong, _onTrackAdvanced = onTrackAdvanced, - _onTrackError = onTrackError; + _onTrackError = onTrackError, + _onActivePlayerChanged = onActivePlayerChanged; final AndroidPlayerProvider _playerProvider; + final AndroidPlayerProvider _secondaryPlayerProvider; final AndroidAudioSourcesBuilder _sourcesBuilder; final AndroidAudioSourceBuilder _sourceBuilder; final AndroidPlaylistProvider _playlistProvider; @@ -153,6 +159,7 @@ class AndroidAudioEngine implements AudioEngine { final AndroidNextSongProvider? _onNextSong; final AndroidTrackAdvancedCallback? _onTrackAdvanced; final AndroidTrackErrorCallback? _onTrackError; + final ValueChanged? _onActivePlayerChanged; final StreamController _controller = StreamController.broadcast(); @@ -171,6 +178,8 @@ class AndroidAudioEngine implements AudioEngine { just_audio.AudioPlayer? _secondary; Timer? _crossfadeTimer; bool _crossfadeArmed = false; + int _crossfadeGeneration = 0; + bool _rampActive = false; double _rampUserVolume = 1.0; Duration _rampElapsed = Duration.zero; Duration _rampTotal = Duration.zero; @@ -184,19 +193,46 @@ class AndroidAudioEngine implements AudioEngine { @override Stream get playbackStateStream => _controller.stream; + /// Change the shared gain, not just one of the ping-pong player slots. A + /// connection safety ceiling must survive the next fade tick and player swap. + Future setVolume(double volume) async { + _rampUserVolume = volume.clamp(0.0, 1.0).toDouble(); + final active = _player; + if (active == null) return; + final outgoing = _secondary; + if (_rampActive && outgoing != null) { + final p = _rampProgress; + await Future.wait([ + active.setVolume(_rampUserVolume * crossfadeInVolume(_rampCurve, p)), + outgoing.setVolume( + _rampUserVolume * crossfadeInVolume(_rampCurve, 1 - p), + ), + ]); + } else { + await active.setVolume(_rampUserVolume); + } + } + + double get _rampProgress => _rampTotal.inMilliseconds <= 0 + ? 1.0 + : (_rampElapsed.inMilliseconds / _rampTotal.inMilliseconds) + .clamp(0.0, 1.0) + .toDouble(); + Future _ensurePlayer() async { final existing = _player; if (existing != null) return existing; final player = await _playerProvider(); _player = player; _attachListeners(player); + _onActivePlayerChanged?.call(player); return player; } Future _ensureSecondary() async { final existing = _secondary; if (existing != null) return existing; - final player = just_audio.AudioPlayer(); + final player = await _secondaryPlayerProvider(); _secondary = player; _attachListeners(player); await player.setVolume(0); @@ -477,11 +513,15 @@ class AndroidAudioEngine implements AudioEngine { rethrow; } // Resume a crossfade ramp that was frozen by pause(). - if (_crossfadeArmed) { + if (_rampActive) { final outgoing = _secondary; if (outgoing != null) { try { - await outgoing.play(); + unawaited( + outgoing.play().catchError((Object error) { + devLog('[crossfade] outgoing resume failed: $error'); + }), + ); } catch (_) {} _startRampTimer(outgoing, player); } @@ -555,6 +595,7 @@ class AndroidAudioEngine implements AudioEngine { void _armCrossfade(AndroidCrossfadeConfig cfg, int fadeMs) { // Set synchronously so the next position tick can't re-enter. _crossfadeArmed = true; + final generation = ++_crossfadeGeneration; unawaited(() async { final outgoing = _player; if (outgoing == null) { @@ -568,21 +609,29 @@ class AndroidAudioEngine implements AudioEngine { _crossfadeArmed = false; return; } + // Capture before any preparation can fail, including a muted outgoing + // player. Later shared-gain changes must remain authoritative. + _rampUserVolume = outgoing.volume; try { final incoming = await _ensureSecondary(); final source = await _sourceBuilder(next); - _rampUserVolume = outgoing.volume <= 0 ? 1.0 : outgoing.volume; await incoming.setAudioSource(source, preload: true); await incoming.seek(Duration.zero); await incoming.setVolume(0); await incoming.setSpeed(outgoing.speed); await incoming.setLoopMode(just_audio.LoopMode.off); - unawaited( - incoming.play().catchError((Object error, StackTrace stackTrace) { - devLog('[crossfade] incoming play() failed: $error'); - debugPrintStack(stackTrace: stackTrace); - }), - ); + if (generation != _crossfadeGeneration) return; + // A safety pause while the source was preparing must not be undone + // when preparation completes. Resume will start both slots explicitly. + final shouldPlay = outgoing.playing; + if (shouldPlay) { + unawaited( + incoming.play().catchError((Object error, StackTrace stackTrace) { + devLog('[crossfade] incoming play() failed: $error'); + debugPrintStack(stackTrace: stackTrace); + }), + ); + } _loadedTrack = next; _loadedSingleTrackOnly = true; _playlistSignature = const []; @@ -593,7 +642,9 @@ class AndroidAudioEngine implements AudioEngine { // idle slot and is faded out by the ramp. _player = incoming; _secondary = outgoing; - _startRampTimer(outgoing, incoming); + _rampActive = true; + _onActivePlayerChanged?.call(incoming); + if (shouldPlay) _startRampTimer(outgoing, incoming); // The emitted state drives PlayerService's track-change bookkeeping // (index sync, notification, replay tracking, position save). _emit( @@ -608,9 +659,13 @@ class AndroidAudioEngine implements AudioEngine { // playback-state subscription, so the service does them here. _onTrackAdvanced?.call(next); } catch (error, stackTrace) { + if (generation != _crossfadeGeneration) return; devLog('[crossfade] arm failed: $error'); debugPrintStack(stackTrace: stackTrace); _crossfadeArmed = false; + _rampActive = false; + _crossfadeTimer?.cancel(); + _crossfadeTimer = null; final active = _player; if (active != null) { try { @@ -630,11 +685,7 @@ class AndroidAudioEngine implements AudioEngine { // Hold the ramp while paused; play() restarts it from [_rampElapsed]. if (!incoming.playing) return; _rampElapsed += _rampTick; - final p = _rampTotal.inMilliseconds <= 0 - ? 1.0 - : (_rampElapsed.inMilliseconds / _rampTotal.inMilliseconds) - .clamp(0.0, 1.0) - .toDouble(); + final p = _rampProgress; final inVol = _rampUserVolume * crossfadeInVolume(_rampCurve, p); final outVol = _rampUserVolume * crossfadeInVolume(_rampCurve, 1 - p); incoming.setVolume(inVol); @@ -642,6 +693,7 @@ class AndroidAudioEngine implements AudioEngine { if (p >= 1.0) { timer.cancel(); _crossfadeTimer = null; + _rampActive = false; unawaited(_finishCrossfade(outgoing)); } }); @@ -661,8 +713,10 @@ class AndroidAudioEngine implements AudioEngine { } Future _cancelCrossfade() async { + _crossfadeGeneration++; _crossfadeTimer?.cancel(); _crossfadeTimer = null; + _rampActive = false; final wasArmed = _crossfadeArmed; _crossfadeArmed = false; final secondary = _secondary; @@ -691,9 +745,11 @@ class AndroidAudioEngine implements AudioEngine { @override Future dispose() async { + _crossfadeGeneration++; _crossfadeTimer?.cancel(); _crossfadeTimer = null; _crossfadeArmed = false; + _rampActive = false; for (final subscription in _subscriptions) { await subscription.cancel(); } diff --git a/lib/services/player_service.dart b/lib/services/player_service.dart index 07058937..1bfaf31e 100644 --- a/lib/services/player_service.dart +++ b/lib/services/player_service.dart @@ -469,6 +469,7 @@ class PlayerService { required AudioSessionManager sessionManager, required Uac2Service uac2Service, RustAudioService? rustAudioService, + AndroidAudioEngine? androidAudioEngine, bool directUsb = false, }) : _uac2Service = uac2Service, _rustAudioService = rustAudioService ?? RustAudioService(), @@ -476,9 +477,11 @@ class PlayerService { _sessionManager = sessionManager; _playbackManager = AudioEngineManager(); _audioInitialized = true; + _androidEngine = androidAudioEngine; } just_audio.AudioPlayer? _justAudioPlayer; + AndroidAudioEngine? _androidEngine; // Cached crossfade curve index (0..3) for synchronous reads inside the // just_audio engine's config provider; refreshed from prefs on load/change. int _crossfadeCurveIndex = 0; @@ -595,11 +598,23 @@ class PlayerService { int _usbHardwareVolumeRevision = 0; Future? _usbVolumeSafetyPause; final ValueNotifier usbVolumeSafetyBlockedNotifier = ValueNotifier(false); + String? _physicalOutputGuardKey; + bool _physicalOutputGuardApplied = false; + AudioEngineType? _physicalOutputGuardMode; + int _physicalOutputGuardGeneration = 0; + Future? _physicalOutputGuardInFlight; + int _physicalOutputGuardInFlightGeneration = 0; + bool _physicalOutputVolumeSafetyBlocked = false; + bool _physicalOutputSoftwareVolumeActive = false; /// Default volume for bit-perfect mode (25 %, safety level). /// Mapped to ~0.01 linear gain by Rust's volume_to_gain curve. static const double _bitPerfectDefaultVolume = 0.25; + /// One-shot ceiling for every newly connected headphone/DAC on the normal + /// (non-direct-USB) paths. + static const double _physicalOutputSafetyVolume = _bitPerfectDefaultVolume; + double get currentVolume => _currentVolume; /// Extended-volume boost (up to 200 %) toggle. Only the software (Rust) @@ -780,7 +795,9 @@ class PlayerService { ); }); AndroidAudioDeviceService.instance.deviceInfoNotifier.addListener(() { + final info = AndroidAudioDeviceService.instance.deviceInfoNotifier.value; unawaited(_refreshAudioOutputDiagnostics(reason: 'audio route changed')); + unawaited(_maybeApplyPhysicalOutputGuard(info)); }); _uac2Service.bitPerfectEnabledNotifier.addListener(() { unawaited(_handleBitPerfectPreferenceChanged()); @@ -854,6 +871,13 @@ class PlayerService { _, ) async { _usbDacVolumeRestore.reset(); + if (_audioInitialized && _isDirectUsbPath) { + try { + await _restoreUsbDacVolumeBeforePlayback(currentEngineType); + } catch (error) { + _debugLog('[VolFlow] USB attach volume restore failed: $error'); + } + } if (!isPlayingNotifier.value) return; final enabled = await _appPreferencesService.getPauseOnUsbDacConnect(); if (enabled) pause(); @@ -981,6 +1005,7 @@ class PlayerService { } Future _handleBitPerfectPreferenceChanged() async { + await _waitForPhysicalOutputVolumeGuard(); // When USB DAC bit-perfect is turned off, also turn off DAP bit-perfect // so the DAC receives non-bit-perfect data. if (!_uac2Service.isBitPerfectEnabledSync && @@ -1008,7 +1033,7 @@ class PlayerService { } else { final player = _justAudioPlayer; if (player != null) { - await player.setVolume(_currentVolume); + await _setAndroidPlayerVolume(_currentVolume); await player.setSpeed(playbackSpeedNotifier.value); } } @@ -1901,6 +1926,10 @@ class PlayerService { _playbackManager.publishIdleState(_sessionManager.selectedMode); _audioInitialized = true; await _refreshAudioOutputDiagnostics(reason: 'audio initialized'); + if (Platform.isAndroid) { + final info = await AndroidAudioDeviceService.instance.refresh(); + await _maybeApplyPhysicalOutputGuard(info, force: true); + } } finally { _audioInitInFlight = null; } @@ -2031,6 +2060,7 @@ class PlayerService { static const double _duckVolumeScale = 0.2; Future _setDucked(bool ducked) async { + await _waitForPhysicalOutputVolumeGuard(); if (_isDucked == ducked) return; _isDucked = ducked; try { @@ -2038,7 +2068,7 @@ class PlayerService { await _reconcileVolumeForTier(_determineCurrentTier()); } else { final volume = _currentVolume * (ducked ? _duckVolumeScale : 1.0); - await _justAudioPlayer?.setVolume(volume); + await _setAndroidPlayerVolume(volume); } } catch (e) { _debugLog('[AudioFocus] Failed to ${ducked ? 'apply' : 'lift'} duck: $e'); @@ -2088,6 +2118,16 @@ class PlayerService { return player; } + Future _setAndroidPlayerVolume(double volume) async { + final engine = _androidEngine; + if (engine != null) { + // The engine owns both crossfade slots and their shared ramp gain. + await engine.setVolume(volume); + } else { + await _justAudioPlayer?.setVolume(volume); + } + } + Future _configureAndroidPlayer(just_audio.AudioPlayer player) async { if (_justAudioPlayer != player) { _justAudioPlayer = player; @@ -2114,6 +2154,7 @@ class PlayerService { sourceBuilder: _buildAudioSourceForSong, playlistProvider: () => List.unmodifiable(_playlist), configurePlayer: _configureAndroidPlayer, + onActivePlayerChanged: (player) => _justAudioPlayer = player, disposeEngine: _disposeAndroidEngine, shouldSuppressTrackSync: () => _suppressSequenceStateUpdates || _isRebuildingPlaylist, @@ -2139,6 +2180,7 @@ class PlayerService { if (_usingRustBackend) return; unawaited(_onSongFinished()); }; + _androidEngine = engine; return engine; } @@ -2354,6 +2396,7 @@ class PlayerService { _usbHardwareVolumeReadyFor = _uac2Service.currentDeviceStatus?.device; _usbHardwareVolumeRevision++; _usbSoftwareVolumeUsed = false; + _physicalOutputSoftwareVolumeActive = false; usbVolumeSafetyBlockedNotifier.value = false; _usbVolumeSafetyPause = null; _usbDacVolumeRestore.reset(); @@ -2605,6 +2648,8 @@ class PlayerService { AudioEngineType? playbackMode, bool? passthroughActive, }) async { + await _waitForPhysicalOutputVolumeGuard(); + if (_physicalOutputVolumeSafetyBlocked) return; volumeTierNotifier.value = tier; final directUsb = (Platform.isAndroid || _testDirectUsb) && (playbackMode ?? currentEngineType) == AudioEngineType.usbDacExperimental; @@ -2716,25 +2761,43 @@ class PlayerService { if (usbVolumeSafetyBlockedNotifier.value) { throw UsbDacVolumeRestoreError('DAC hardware volume is unavailable'); } - _currentVolume = settings.software; + // A normal-route connection guard (or existing USB software gain) + // remains authoritative across a permission/engine handoff. Restoring + // a remembered higher software level must not undo that attenuation. + final preserveSoftwareVolume = + _usbSoftwareVolumeUsed || + _physicalOutputSoftwareVolumeActive || + _currentVolume == 0.0; + _currentVolume = preserveSoftwareVolume + ? math.min(_currentVolume, settings.software) + : settings.software; return; } final authorityHandoff = _usbSoftwareVolumeUsed || + _physicalOutputSoftwareVolumeActive || (_usbHardwareVolumeReadyFor != device && isPlayingNotifier.value); + final preserveSoftwareMute = + _currentVolume == 0.0 && + (_usbSoftwareVolumeUsed || + _physicalOutputSoftwareVolumeActive || + _usbHardwareVolumeReadyFor != device); final useLowDefault = settings.hardware == null || authorityHandoff || usbVolumeSafetyBlockedNotifier.value; - if (authorityHandoff) { + if (authorityHandoff || preserveSoftwareMute) { // An authority change must not remove software attenuation live. A // low, verified restore replaces the old mandatory slider gesture. await _blockUsbVolumeForSafety(); ensureCurrent(); } - var targetVolume = - settings.hardware ?? Uac2PreferencesService.defaultUsbDacVolume; + // Only exact mute transfers between software and hardware authority; + // the same nonzero percentage need not mean the same acoustic level. + var targetVolume = _currentVolume == 0.0 + ? 0.0 + : settings.hardware ?? Uac2PreferencesService.defaultUsbDacVolume; if (useLowDefault) { targetVolume = math.min( targetVolume, @@ -2792,6 +2855,21 @@ class PlayerService { await _blockUsbVolumeForSafety(); throw UsbDacVolumeRestoreError('DAC volume readback is unavailable'); } + // Normalized hardware 0% is only the bottom of the DAC's attenuation + // range, not necessarily silence. Preserve an app mute using a verified + // hardware mute, or keep the transport paused (also safe for DSD/DoP). + if (preserveSoftwareMute && appliedStatus.muted != true) { + final muted = await _uac2Service.setMute(true); + ensureCurrent(); + final mutedStatus = _uac2Service.currentDeviceStatus; + if (!muted || + mutedStatus?.device != device || + mutedStatus?.volumeMode != Uac2VolumeMode.hardware || + mutedStatus?.muted != true) { + await _blockUsbVolumeForSafety(); + throw UsbDacVolumeRestoreError('could not preserve the app mute'); + } + } await _preferencesService.setUsbVolumeForDevice( device, appliedVolume, @@ -2811,6 +2889,10 @@ class PlayerService { await _blockUsbVolumeForSafety(); throw UsbDacVolumeRestoreError('DAC volume authority changed'); } + if (preserveSoftwareMute && finalStatus?.muted != true) { + await _blockUsbVolumeForSafety(); + throw UsbDacVolumeRestoreError('DAC mute changed during handoff'); + } _debugLog( '[VolFlow] Hardware restore verified: $appliedVolume, ' 'lowDefault=$useLowDefault', @@ -2819,6 +2901,7 @@ class PlayerService { _usbHardwareVolumeReadyFor = device; _usbHardwareVolumeRevision++; _usbSoftwareVolumeUsed = false; + _physicalOutputSoftwareVolumeActive = false; _hwVolumeFailed = false; usbVolumeSafetyBlockedNotifier.value = false; _usbVolumeSafetyPause = null; @@ -2844,6 +2927,200 @@ class PlayerService { } } + @visibleForTesting + Future handlePlaybackDeviceInfoForTesting( + AndroidPlaybackDeviceInfo info, { + bool force = false, + }) => _maybeApplyPhysicalOutputGuard(info, force: force); + + /// Apply the low-volume ceiling once per physical connection. [force] is for + /// the initial launch probe. Only a successful application consumes the guard; + /// Play/resume and duplicate callbacks wait for the same in-flight write. + Future _maybeApplyPhysicalOutputGuard( + AndroidPlaybackDeviceInfo info, { + bool force = false, + }) async { + if (!info.hasPhysicalOutput) { + // AndroidAudioDeviceService emits the [unknown] placeholder when a + // platform refresh fails. Keep the key so that transient failure cannot + // re-lower a volume the user raised on the same connection. + if (!identical(info, AndroidPlaybackDeviceInfo.unknown)) { + _physicalOutputGuardKey = null; + _physicalOutputGuardGeneration++; + _physicalOutputGuardApplied = false; + _physicalOutputSoftwareVolumeActive = false; + _physicalOutputVolumeSafetyBlocked = false; + } + return; + } + final key = info.physicalOutputKey; + if (key == null) return; + if (key != _physicalOutputGuardKey) { + _physicalOutputGuardKey = key; + _physicalOutputGuardGeneration++; + _physicalOutputGuardApplied = false; + _physicalOutputSoftwareVolumeActive = false; + } + final inFlight = _physicalOutputGuardInFlight; + if (inFlight != null) { + final inFlightGeneration = _physicalOutputGuardInFlightGeneration; + await inFlight; + // A replacement output must wait for the previous device's write, then + // apply its own guard rather than accepting the stale completion. + if (inFlightGeneration != _physicalOutputGuardGeneration && + key == _physicalOutputGuardKey) { + await _maybeApplyPhysicalOutputGuard(info, force: force); + } + return; + } + if (!force && + _physicalOutputGuardApplied && + _physicalOutputGuardMode == currentEngineType) { + return; + } + final future = _runPhysicalOutputGuard(_physicalOutputGuardGeneration); + _physicalOutputGuardInFlight = future; + _physicalOutputGuardInFlightGeneration = _physicalOutputGuardGeneration; + try { + await future; + } finally { + if (identical(_physicalOutputGuardInFlight, future)) { + _physicalOutputGuardInFlight = null; + } + } + } + + Future _runPhysicalOutputGuard(int generation) async { + final mode = currentEngineType; + try { + final applied = await _applyPhysicalOutputSafetyVolume( + generation: generation, + ); + if (generation != _physicalOutputGuardGeneration) return; + _physicalOutputGuardApplied = applied; + _physicalOutputGuardMode = mode; + if (applied) _physicalOutputVolumeSafetyBlocked = false; + } catch (error) { + if (generation != _physicalOutputGuardGeneration) return; + _physicalOutputGuardApplied = false; + _physicalOutputVolumeSafetyBlocked = true; + _debugLog('[VolFlow] Physical output volume guard failed: $error'); + // Do not keep playing at the previous gain, or queue behind the Play + // request that is waiting for this guard. Stop the live transport now. + _wasPlayingBeforeAudioInterruption = false; + try { + if (_usingRustBackend) { + await _rustAudioService.pause(); + } else if (_androidEngine != null) { + await _androidEngine!.pause(); + } else { + await _justAudioPlayer?.pause(); + } + } catch (pauseError) { + _debugLog('[VolFlow] Physical output safety pause failed: $pauseError'); + try { + if (_usingRustBackend) { + await _rustAudioService.stop(); + } else if (_androidEngine != null) { + await _androidEngine!.stop(); + } else { + await _justAudioPlayer?.stop(); + } + } catch (stopError) { + _debugLog('[VolFlow] Physical output safety stop failed: $stopError'); + } + } + isPlayingNotifier.value = false; + _updatePriorityAnchor(); + } + } + + @visibleForTesting + Future ensurePhysicalOutputVolumeForTesting( + AndroidPlaybackDeviceInfo info, + ) => _ensurePhysicalOutputVolumeBeforePlayback(info: info); + + Future _waitForPhysicalOutputVolumeGuard() async { + while (_physicalOutputGuardInFlight != null) { + await _physicalOutputGuardInFlight; + } + } + + Future _ensurePhysicalOutputVolumeBeforePlayback({ + AndroidPlaybackDeviceInfo? info, + }) async { + await _maybeApplyPhysicalOutputGuard( + info ?? AndroidAudioDeviceService.instance.deviceInfoNotifier.value, + ); + if (_physicalOutputVolumeSafetyBlocked) { + throw StateError('Could not apply the physical output safety volume'); + } + } + + Future _applyPhysicalOutputSafetyVolume({int? generation}) async { + if (!_audioInitialized || _castingService.isActive) return false; + if (_isDirectUsbPath) { + // Direct USB has its own verified hardware-volume restore; a software + // ceiling would double-attenuate or silently corrupt the stream. + await _restoreUsbDacVolumeBeforePlayback(currentEngineType); + return true; + } + + final tier = _determineCurrentTier(); + if (tier == VolumeTier.unavailable || _isPassthroughActive) { + _debugLog( + '[VolFlow] Physical output guard skipped: bit-perfect volume unavailable', + ); + return false; + } + if (tier == VolumeTier.hardware) { + // The direct USB path was handled above. Other hardware authorities + // (DAP internal hi-res) keep their existing restore path. + _debugLog( + '[VolFlow] Physical output guard skipped: hardware volume authority', + ); + return false; + } + + final target = math.min(_currentVolume, _physicalOutputSafetyVolume); + // If this physical output later becomes a direct-USB session, the restore + // must treat the app attenuation as an authority handoff and use the low + // verified hardware default instead of a remembered higher DAC level. + volumeTierNotifier.value = tier; + switch (tier) { + case VolumeTier.software: + if (_usingRustBackend && _rustAudioService.isInitialized) { + await _rustAudioService.setVolume( + _isDucked + ? attenuateSoftwareVolume(target, _duckVolumeScale) + : target, + ); + } + await _reconcileSystemVolumeBoost(0.0); + break; + case VolumeTier.system: + final effective = math.min(target, 1.0) * _replayGainState.linear; + await _setAndroidPlayerVolume( + math.min(effective, 1.0) * (_isDucked ? _duckVolumeScale : 1.0), + ); + await _reconcileSystemVolumeBoost(effective); + break; + case VolumeTier.hardware: + case VolumeTier.unavailable: + break; + } + if (generation != null && generation != _physicalOutputGuardGeneration) { + return false; + } + _currentVolume = target; + _usbSoftwareVolumeUsed = true; + _physicalOutputSoftwareVolumeActive = true; + // Deliberately do not persist this safety level: it belongs to this + // physical connection only, and the user may raise it immediately. + _debugLog('[VolFlow] Physical output safety volume applied: $target'); + return true; + } + /// Prefer [primary], then the current-song notifier, then the last engine /// playback snapshot so USB focus stays latched when Rust is ahead of or /// behind the notifier during gapless / crossfade / buffering. @@ -4909,6 +5186,7 @@ class PlayerService { } Future _disposeAndroidEngine() async { + _androidEngine = null; final player = _justAudioPlayer; if (player == null) return; @@ -5402,6 +5680,7 @@ class PlayerService { Future _playInternal(Song song, {List? playlist}) async { await initAudio(); + await _ensurePhysicalOutputVolumeBeforePlayback(); final loadingGen = ++_networkLoadingGen; try { _debugLog( @@ -5478,6 +5757,9 @@ class PlayerService { // spawned source is stamped with this track's gain. await _refreshReplayGainForSong(song, pushSpawnDefault: true); } + // Engine preparation can change volume authority after the first + // preflight (including a direct-USB fallback). + await _ensurePhysicalOutputVolumeBeforePlayback(); await _runWithSuppressedSequenceStateUpdates(() async { await _playbackManager.playTrack(song); }); @@ -5833,6 +6115,7 @@ class PlayerService { return; } await initAudio(); + await _ensurePhysicalOutputVolumeBeforePlayback(); final song = currentSongNotifier.value ?? _songAtCurrentIndex(); if (song == null || song.filePath == null) { @@ -5852,6 +6135,7 @@ class PlayerService { // A matching prepared engine may be reused without re-running its policy. // Retry a low DAC level if a previous control failure held playback. await _restoreUsbVolumeForResume(activeEngine, song: song); + await _ensurePhysicalOutputVolumeBeforePlayback(); final latestState = _playbackManager.latestState; final canResumeDirectly = @@ -6043,6 +6327,9 @@ class PlayerService { initializeNewEngine: true, reason: 'direct USB startup refused', ); + // The failed direct engine may have held full-scale output. Enforce the + // physical-output ceiling before the fallback route starts playing. + await _applyPhysicalOutputSafetyVolume(); if (song != null) { await _prepareImmediatePlaybackAsset(song); @@ -6153,6 +6440,7 @@ class PlayerService { initializeNewEngine: true, reason: 'rust audio engine command channel dead', ); + await _applyPhysicalOutputSafetyVolume(); } if (song != null) { @@ -6565,6 +6853,8 @@ class PlayerService { // ==================== Volume ==================== Future setVolume(double volume) async { + // A user adjustment follows (rather than racing) the one-shot safety write. + await _waitForPhysicalOutputVolumeGuard(); if (!volume.isFinite || _switchingDsdForVolume) return; final tier = _determineCurrentTier(); final tierSupportsBoost = _extendedVolumeEnabled && @@ -6625,16 +6915,13 @@ class PlayerService { await _reconcileSystemVolumeBoost(0.0); break; case VolumeTier.system: - final player = _justAudioPlayer; final effective = math.min(clampedVolume, 1.0) * _replayGainState.linear; - if (player != null) { - // ExoPlayer clamps at 1.0; the boost portion (>1.0, from extended - // volume and/or ReplayGain) is applied via Android LoudnessEnhancer. - await player.setVolume( - math.min(effective, 1.0) * (_isDucked ? _duckVolumeScale : 1.0), - ); - } + // ExoPlayer clamps at 1.0; the boost portion (>1.0, from extended + // volume and/or ReplayGain) is applied via Android LoudnessEnhancer. + await _setAndroidPlayerVolume( + math.min(effective, 1.0) * (_isDucked ? _duckVolumeScale : 1.0), + ); _rememberSoftwareVolume(clampedVolume); await _reconcileSystemVolumeBoost(effective); break; @@ -6727,6 +7014,7 @@ class PlayerService { /// Fold [_replayGainState] into the just_audio (system tier) volume and /// LoudnessEnhancer boost for [song]. Future _applyReplayGainForSystemTier(Song? song) async { + await _waitForPhysicalOutputVolumeGuard(); await _refreshReplayGainForSong(song); if (_determineCurrentTier() != VolumeTier.system) return; final player = _justAudioPlayer; @@ -6734,7 +7022,9 @@ class PlayerService { final effective = math.min(_currentVolume.clamp(0.0, 1.0), 1.0) * _replayGainState.linear; try { - await player.setVolume(math.min(effective, 1.0)); + await _setAndroidPlayerVolume( + math.min(effective, 1.0) * (_isDucked ? _duckVolumeScale : 1.0), + ); } catch (e) { _debugLog('[RG] system-volume fold failed: $e'); } diff --git a/lib/widgets/common/detail_header.dart b/lib/widgets/common/detail_header.dart index cfe1a46b..a7f7883d 100644 --- a/lib/widgets/common/detail_header.dart +++ b/lib/widgets/common/detail_header.dart @@ -174,10 +174,12 @@ class DetailHeader extends StatelessWidget { color: context.adaptiveTextSecondary, ), const SizedBox(width: AppConstants.spacingXxs), - Text( - losslessLabel ?? context.l10n.lossless, - style: Theme.of(context).textTheme.bodySmall - ?.copyWith(color: context.adaptiveTextTertiary), + Flexible( + child: Text( + losslessLabel ?? context.l10n.lossless, + style: Theme.of(context).textTheme.bodySmall + ?.copyWith(color: context.adaptiveTextTertiary), + ), ), const SizedBox(width: AppConstants.spacingSm), ], diff --git a/test/features/settings/orbit_settings_screen_test.dart b/test/features/settings/orbit_settings_screen_test.dart index 248c59a3..ee698124 100644 --- a/test/features/settings/orbit_settings_screen_test.dart +++ b/test/features/settings/orbit_settings_screen_test.dart @@ -5,19 +5,66 @@ import 'package:shared_preferences/shared_preferences.dart'; import 'package:flick/core/theme/app_theme.dart'; import 'package:flick/features/settings/screens/orbit_settings_screen.dart'; +import 'package:flick/features/songs/widgets/orbit_scroll.dart'; +import 'package:flick/features/songs/widgets/song_card.dart'; import 'package:flick/l10n/l10n.dart'; +import 'package:flick/models/song.dart'; import 'package:flick/providers/providers.dart'; +import 'package:flick/services/app_preferences_service.dart'; -Widget _host() => ProviderScope( - overrides: [currentSongProvider.overrideWithValue(null)], - child: MaterialApp( - theme: AppTheme.darkTheme, - locale: kFallbackLocale, - supportedLocales: kSupportedLocales, - localizationsDelegates: kAppLocalizationsDelegates, - home: const OrbitSettingsScreen(), - ), -); +class _PreviewSongs extends SongsNotifier { + _PreviewSongs(this.songs); + + final List songs; + + @override + Future build() async => SongsState(songs: songs); +} + +class _PreviewPreferences extends AppPreferencesNotifier { + @override + AppPreferences build() => const AppPreferences(); + + void setRadius(double value) { + state = state.copyWith(orbitRadiusRatio: value); + } +} + +Widget _host({double textScale = 1, List songs = const []}) => + ProviderScope( + overrides: [ + currentSongProvider.overrideWithValue(null), + songsProvider.overrideWith(() => _PreviewSongs(songs)), + appPreferencesProvider.overrideWith(_PreviewPreferences.new), + ], + child: MaterialApp( + theme: AppTheme.darkTheme, + locale: kFallbackLocale, + supportedLocales: kSupportedLocales, + localizationsDelegates: kAppLocalizationsDelegates, + builder: (context, child) => MediaQuery( + data: MediaQuery.of( + context, + ).copyWith(textScaler: TextScaler.linear(textScale)), + child: child!, + ), + home: const OrbitSettingsScreen(), + ), + ); + +Future _pumpScreen( + WidgetTester tester, { + Size size = const Size(411, 900), + double textScale = 1, + List songs = const [], +}) async { + tester.view.devicePixelRatio = 1; + tester.view.physicalSize = size; + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + await tester.pumpWidget(_host(textScale: textScale, songs: songs)); + await tester.pumpAndSettle(); +} void main() { setUp(() => SharedPreferences.setMockInitialValues({})); @@ -25,14 +72,18 @@ void main() { testWidgets('profile selector switches without rotating the window', ( tester, ) async { - tester.view.devicePixelRatio = 1; - tester.view.physicalSize = const Size(411, 900); - addTearDown(tester.view.resetPhysicalSize); - addTearDown(tester.view.resetDevicePixelRatio); - await tester.pumpWidget(_host()); - await tester.pumpAndSettle(); + await _pumpScreen(tester); final copy = lookupFlickLocalizations(kFallbackLocale); + expect(find.text(copy.orbitHeaderBoundaryTitle), findsOneWidget); + expect(find.text(copy.orbitHeaderBoundaryBody), findsOneWidget); + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); + expect(find.byType(SongCard), findsWidgets); + expect( + tester.widget(find.byType(OrbitScroll)).scrollDirection, + Axis.vertical, + ); + expect(find.text(copy.portrait), findsOneWidget); expect(find.text(copy.landscape), findsOneWidget); expect(find.text(copy.horizontalReach), findsOneWidget); @@ -44,6 +95,182 @@ void main() { expect(find.text(copy.horizontalReach), findsNothing); expect(find.text(copy.cardSize), findsNothing); expect(find.text(copy.cardWidth), findsOneWidget); + expect( + tester.widget(find.byType(OrbitScroll)).scrollDirection, + Axis.horizontal, + ); + expect(tester.takeException(), isNull); + }); + + testWidgets('preview updates with preferences and can collapse', ( + tester, + ) async { + await _pumpScreen(tester); + + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); + expect( + tester.widget(find.byType(OrbitScroll)).radiusRatio, + 1.0, + ); + + final container = ProviderScope.containerOf( + tester.element(find.byType(OrbitSettingsScreen)), + ); + (container.read(appPreferencesProvider.notifier) as _PreviewPreferences) + .setRadius(1.6); + await tester.pump(); + + expect( + tester.widget(find.byType(OrbitScroll)).radiusRatio, + 1.6, + ); + + await tester.tap(find.byKey(const Key('orbit_preview_toggle'))); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('orbit_preview')), findsNothing); + expect(find.byType(OrbitScroll), findsNothing); + + await tester.tap(find.byKey(const Key('orbit_preview_toggle'))); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); + expect(find.byType(OrbitScroll), findsOneWidget); + expect(tester.takeException(), isNull); + }); + + testWidgets('preview browsing never leaves settings or starts playback', ( + tester, + ) async { + await _pumpScreen(tester); + + final cards = tester + .widgetList(find.byType(SongCard)) + .toList(growable: false); + expect(cards, isNotEmpty); + expect(cards.every((card) => !card.swipeActionsEnabled), isTrue); + + final selected = cards.firstWhere((card) => card.isSelected); + await tester.tap(find.text(selected.song.title)); + await tester.pumpAndSettle(); + + expect(find.byType(OrbitSettingsScreen), findsOneWidget); + final container = ProviderScope.containerOf( + tester.element(find.byType(OrbitSettingsScreen)), + ); + expect(container.read(currentSongProvider), isNull); + expect(tester.takeException(), isNull); + }); + + testWidgets('full-screen preview uses the real screen and can be closed', ( + tester, + ) async { + await _pumpScreen(tester); + + await tester.tap(find.byKey(const Key('orbit_preview_fullscreen_button'))); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('orbit_preview_fullscreen')), findsOneWidget); + final size = tester.getSize( + find.byKey(const Key('orbit_preview_fullscreen')), + ); + expect(size.width, 411); + expect(size.height, greaterThan(300)); + expect( + tester + .widget( + find.descendant( + of: find.byKey(const Key('orbit_preview_fullscreen')), + matching: find.byType(OrbitScroll), + ), + ) + .scrollDirection, + Axis.vertical, + ); + + await tester.tap(find.byKey(const Key('orbit_preview_close'))); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('orbit_preview_fullscreen')), findsNothing); + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); + expect(tester.takeException(), isNull); + }); + + testWidgets('full-screen preview follows the landscape profile', ( + tester, + ) async { + await _pumpScreen(tester); + final copy = lookupFlickLocalizations(kFallbackLocale); + + await tester.tap(find.text(copy.landscape)); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(const Key('orbit_preview_fullscreen_button'))); + await tester.pumpAndSettle(); + + expect( + tester + .widget( + find.descendant( + of: find.byKey(const Key('orbit_preview_fullscreen')), + matching: find.byType(OrbitScroll), + ), + ) + .scrollDirection, + Axis.horizontal, + ); + expect(find.text(copy.landscape), findsOneWidget); + expect(tester.takeException(), isNull); + }); + + testWidgets('preview uses a real library when enough songs are available', ( + tester, + ) async { + final songs = List.generate( + 5, + (index) => Song( + id: 'library-$index', + title: 'Library track $index', + artist: 'Library artist', + duration: const Duration(minutes: 3), + fileType: 'FLAC', + ), + ); + + await _pumpScreen(tester, songs: songs); + + final cards = tester.widgetList(find.byType(SongCard)); + expect(cards, isNotEmpty); + expect(cards.every((card) => card.song.id.startsWith('library-')), isTrue); + expect(find.textContaining('Library track'), findsWidgets); + expect(tester.takeException(), isNull); + }); + + for (final size in const [Size(900, 411), Size(1280, 800)]) { + testWidgets( + 'preview fits a ${size.width.toInt()}x${size.height.toInt()} window', + (tester) async { + await _pumpScreen(tester, size: size); + + if (size.height < 620) { + expect(find.byKey(const Key('orbit_preview')), findsNothing); + } else { + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); + expect( + tester + .widget(find.byType(OrbitScroll)) + .scrollDirection, + Axis.horizontal, + ); + } + expect(tester.takeException(), isNull); + }, + ); + } + + testWidgets('preview remains usable with enlarged text', (tester) async { + await _pumpScreen(tester, textScale: 1.5); + + expect(find.byKey(const Key('orbit_preview')), findsOneWidget); expect(tester.takeException(), isNull); }); } diff --git a/test/features/settings/settings_search_catalog_test.dart b/test/features/settings/settings_search_catalog_test.dart index a322ebd6..2e3dc679 100644 --- a/test/features/settings/settings_search_catalog_test.dart +++ b/test/features/settings/settings_search_catalog_test.dart @@ -165,6 +165,25 @@ void main() { }, ); + test('Spanish language names find the language setting in every locale', () { + for (final locale in kSupportedLocales) { + LocaleController.instance.bindLocale(locale); + final pages = buildSettingsSearchCatalog(); + for (final query in ['spanish', 'español', 'espanol', 'latinoamérica']) { + final results = searchSettings(query, pages); + expect( + results.any( + (result) => + result.page.id == 'interface_settings' && + result.matches.any((match) => match.section.id == 'language'), + ), + isTrue, + reason: '$locale: $query', + ); + } + } + }); + test( 'localized titles are rebuilt while navigation IDs remain unchanged', () { diff --git a/test/l10n/baybayin_layout_test.dart b/test/l10n/baybayin_layout_test.dart index bb51e7bb..14a3a372 100644 --- a/test/l10n/baybayin_layout_test.dart +++ b/test/l10n/baybayin_layout_test.dart @@ -238,6 +238,13 @@ void main() { ); expect(_option('Taglish'), findsOneWidget); expect(_option('English'), findsOneWidget); + expect(_option('Español (Latinoamérica)'), findsOneWidget); + expect( + tester + .widget(_option('Español (Latinoamérica)')) + .subtitle, + l10n.englishForFilipino.spanishDraftDescription, + ); expect( find.byType(ToggleSetting), locale == kFilipinoLocale ? findsOneWidget : findsNothing, @@ -258,6 +265,64 @@ void main() { } }); + testWidgets( + 'Spanish draft selection persists and keeps English and system reachable', + (tester) async { + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + final dispatcher = tester.binding.platformDispatcher; + dispatcher.localesTestValue = [const Locale('es', 'MX')]; + addTearDown(dispatcher.clearLocalesTestValue); + _setSize(tester, 320); + await LocaleController.instance.select(const Locale('en')); + await tester.pumpWidget(_app(_languagePage(), scale: 2)); + await tester.pumpAndSettle(); + final spanishOption = _option('Español (Latinoamérica)'); + expect( + tester.widget(spanishOption).subtitle, + 'Latin American Spanish. Draft translation pending native-speaker review.', + ); + + await tester.ensureVisible(spanishOption); + await tester.tap(spanishOption); + await tester.pumpAndSettle(); + expect(LocaleController.instance.value, const Locale('es')); + expect(l10n.language, 'Idioma'); + expect(tester.widget(spanishOption).selected, isTrue); + expect( + tester.widget(spanishOption).subtitle, + 'Español latinoamericano. Traducción preliminar pendiente de revisión ' + 'por hablantes nativos.', + ); + expect(find.byType(ToggleSetting), findsNothing); + LocaleController.instance.value = null; + await LocaleController.instance.load(); + await tester.pumpAndSettle(); + expect(LocaleController.instance.value, const Locale('es')); + expect(l10n.language, 'Idioma'); + + await tester.ensureVisible(_option('English')); + await tester.tap(_option('English')); + await tester.pumpAndSettle(); + expect(l10n.language, 'Language'); + expect(tester.widget(spanishOption).selected, isFalse); + + await tester.ensureVisible(_option('System default')); + await tester.tap(_option('System default')); + await tester.pumpAndSettle(); + expect(LocaleController.instance.followsSystem, isTrue); + expect(l10n.language, 'Idioma'); + expect(tester.widget(spanishOption).selected, isFalse); + expect( + tester + .widget(_option('Predeterminado del sistema')) + .selected, + isTrue, + ); + expect(tester.takeException(), isNull); + }, + ); + testWidgets( 'Taglish selector and independent script switch retain the English escape', (tester) async { diff --git a/test/l10n/locale_switch_test.dart b/test/l10n/locale_switch_test.dart index 22b495d6..794a8ffc 100644 --- a/test/l10n/locale_switch_test.dart +++ b/test/l10n/locale_switch_test.dart @@ -96,6 +96,67 @@ void main() { expect(find.text('Flick Replay'), findsOneWidget); }); + testWidgets('Spanish switches widgets, global copy and built-in controls', ( + tester, + ) async { + await LocaleController.instance.select(const Locale('en')); + await tester.pumpWidget(_app()); + expect(find.text('Language'), findsOneWidget); + + await LocaleController.instance.select(const Locale('es')); + await tester.pumpAndSettle(); + expect(l10n.localeName, 'es'); + expect(l10n.language, 'Idioma'); + expect(l10n.englishForFilipino.language, 'Idioma'); + expect(find.text('Idioma'), findsOneWidget); + expect(find.text('Language'), findsNothing); + final context = tester.element(find.text('Idioma')); + expect(Localizations.localeOf(context), const Locale('es')); + expect(MaterialLocalizations.of(context).cancelButtonLabel, 'Cancelar'); + + await LocaleController.instance.select(const Locale('en')); + await tester.pumpAndSettle(); + expect(l10n.language, 'Language'); + expect(find.text('Language'), findsOneWidget); + expect(find.text('Idioma'), findsNothing); + }); + + test('Spanish regional locales use the Latin American Spanish resource', () { + for (final requested in const [ + Locale('es'), + Locale('es', 'MX'), + Locale('es', '419'), + Locale('es', 'ES'), + Locale.fromSubtags(languageCode: 'es', scriptCode: 'Latn'), + ]) { + expect(resolveSupportedLocale(requested), const Locale('es')); + expect( + resolveAppLocale(requested, kSupportedLocales), + const Locale('es'), + ); + expect(lookupFlickLocalizations(requested).language, 'Idioma'); + } + expect(kSupportedLocales, contains(const Locale('es'))); + }); + + test( + 'Spanish selection persists and restores without enabling Baybayin', + () async { + final controller = LocaleController.instance; + final preferences = AppPreferencesService(); + await controller.select(const Locale('es', 'MX')); + expect(controller.value, const Locale('es')); + expect(await preferences.getAppLocale(), 'es'); + + controller.value = null; + await controller.load(); + expect(controller.value, const Locale('es')); + expect(controller.baybayinHeadings, isFalse); + controller.bindLocale(controller.effectiveLocale); + expect(l10n.language, 'Idioma'); + }, + ); + test( 'Filipino aliases resolve to the Latin UI, never the script resource', () { @@ -117,7 +178,7 @@ void main() { ), kFilipinoLocale, ), - (Locale('es'), kFallbackLocale), + (Locale('fr'), kFallbackLocale), ]; for (final (requested, expected) in cases) { expect(resolveSupportedLocale(requested), expected); @@ -190,6 +251,10 @@ void main() { 'en_US': Locale('en'), 'zh_CN': Locale('zh', 'CN'), 'zh_TW': Locale('zh', 'CN'), + 'es': Locale('es'), + 'es_MX': Locale('es'), + 'es-419': Locale('es'), + 'ES_latn_mx': Locale('es'), 'tl_Tglg': kFilipinoLocale, 'tl-Tglg-PH': kFilipinoLocale, 'TL_tglg_ph': kFilipinoLocale, @@ -240,6 +305,35 @@ void main() { } }); + testWidgets('system Spanish regional locales reach startup and widgets', ( + tester, + ) async { + final dispatcher = tester.binding.platformDispatcher; + addTearDown(dispatcher.clearLocalesTestValue); + for (final deviceLocale in const [ + Locale('es'), + Locale('es', 'MX'), + Locale('es', '419'), + ]) { + dispatcher.localesTestValue = [deviceLocale]; + LocaleController.instance.value = null; + LocaleController.instance.bindLocale( + LocaleController.instance.effectiveLocale, + ); + expect(l10n.language, 'Idioma'); + await tester.pumpWidget(_app()); + await tester.pumpAndSettle(); + expect(l10n.localeName, 'es'); + expect(find.text('Idioma'), findsOneWidget); + expect( + Localizations.localeOf(tester.element(find.text('Idioma'))), + const Locale('es'), + ); + expect(LocaleController.instance.followsSystem, isTrue); + expect(LocaleController.instance.baybayinHeadings, isFalse); + } + }); + testWidgets( 'Filipino and its visual switch reach widgets without changing services', (tester) async { diff --git a/test/l10n/spanish_arb_test.dart b/test/l10n/spanish_arb_test.dart new file mode 100644 index 00000000..8c7642ef --- /dev/null +++ b/test/l10n/spanish_arb_test.dart @@ -0,0 +1,177 @@ +// Technical checks do not certify the Spanish wording or native-speaker review. +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter/widgets.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'package:flick/l10n/generated/app_localizations.dart'; + +Map _loadArb(String locale) => + json.decode(File('lib/l10n/app_$locale.arb').readAsStringSync()) + as Map; + +void main() { + final en = _loadArb('en'); + final es = _loadArb('es'); + final messageKeys = en.keys.where((key) => !key.startsWith('@')).toSet(); + final spanish = lookupAppLocalizations(const Locale('es')); + + test('Spanish has every current message and no obsolete keys', () { + expect(es['@@locale'], 'es'); + expect(es.keys.where((key) => !key.startsWith('@')).toSet(), messageKeys); + for (final key in messageKeys) { + expect(es[key], isA(), reason: key); + expect((es[key] as String).trim(), isNotEmpty, reason: key); + } + }); + + test('Spanish preserves source metadata and every declared argument', () { + Set metadataKeys(Map arb) => arb.keys + .where((key) => key.startsWith('@') && !key.startsWith('@@')) + .toSet(); + + expect(metadataKeys(es), metadataKeys(en)); + for (final key in messageKeys) { + expect(es['@$key'], en['@$key'], reason: key); + final metadata = en['@$key'] as Map?; + final placeholders = metadata?['placeholders'] as Map?; + for (final name in placeholders?.keys ?? []) { + final argument = RegExp(r'\{' + RegExp.escape(name) + r'\s*[,}]'); + expect( + argument.hasMatch(es[key] as String), + isTrue, + reason: '$key lost the {$name} argument', + ); + } + } + }); + + test('new tutorial and artist information strings are translated', () { + final newKeys = { + ...messageKeys.where((key) => key.startsWith('tour')), + 'onlineArtistAlbumInformation', + 'showAppleMusicBiographiesRecommendationsAnd', + }; + for (final key in newKeys) { + expect(es[key], isNot(en[key]), reason: key); + } + expect(spanish.tourStart, 'Iniciar recorrido'); + expect(spanish.tourOutputBody, contains('no activa ningún modo')); + expect( + spanish.tourOutputBody, + contains('ni garantiza una salida bit-perfect'), + ); + expect(spanish.tourDspBody, contains('modifica la señal')); + expect(spanish.tourDspBody, contains('sin activar nada')); + }); + + test('Spanish remains visibly marked as awaiting native-speaker review', () { + expect(spanish.spanishDraftDescription, contains('Traducción preliminar')); + expect( + spanish.spanishDraftDescription, + contains('pendiente de revisión por hablantes nativos'), + ); + }); + + test('audio terms and action labels retain their meaning', () { + expect( + spanish.addSongsToPlaylist(2), + 'Agregar 2 canciones a la lista de reproducción', + ); + expect(spanish.pcmFrames, 'Tramas PCM'); + expect(spanish.release, 'Liberación'); + expect( + spanish.experimentalDownTunePlaybackBy432, + contains('por 432/440 para bajar la afinación de 440 a 432 Hz'), + ); + expect( + spanish.experimentalDownTunePlaybackBy432, + contains('desactiva el paso directo bit-perfect y usa la ruta DSP'), + ); + expect( + spanish.matchByArtistAlbumAndTrack(1), + 'Identificar 1 archivo por artista, álbum y duración de la pista', + ); + expect( + spanish.matchByArtistAlbumAndTrack(2), + 'Identificar 2 archivos por artista, álbum y duración de la pista', + ); + }); + + test('identification agrees with zero, one and multiple songs', () { + expect(spanish.identified(0, ''), 'Se identificaron 0 canciones.'); + expect(spanish.identified(1, ''), 'Se identificó 1 canción.'); + expect(spanish.identified(2, ''), 'Se identificaron 2 canciones.'); + expect( + spanish.identified(1, ' · portada actualizada'), + 'Se identificó 1 canción · portada actualizada.', + ); + }); + + test('DAC messages agree with zero, one and multiple devices', () { + expect(spanish.dacWillBeOfferedAgain(0), 'Se volverán a ofrecer 0 DAC.'); + expect(spanish.dacWillBeOfferedAgain(1), 'Se volverá a ofrecer 1 DAC.'); + expect(spanish.dacWillBeOfferedAgain(2), 'Se volverán a ofrecer 2 DAC.'); + }); + + test('playlist sync and skipped entries agree and preserve spacing', () { + expect( + spanish.syncedPlaylistFromServers(0), + 'Se sincronizaron 0 listas de reproducción desde los servidores', + ); + expect( + spanish.syncedPlaylistFromServers(1), + 'Se sincronizó 1 lista de reproducción desde los servidores', + ); + expect( + spanish.syncedPlaylistFromServers(2), + 'Se sincronizaron 2 listas de reproducción desde los servidores', + ); + expect( + spanish.skippedUnmatchedEntr(0), + ' Se omitieron 0 entradas sin coincidencia.', + ); + expect( + spanish.skippedUnmatchedEntr(1), + ' Se omitió 1 entrada sin coincidencia.', + ); + expect( + spanish.skippedUnmatchedEntr(2), + ' Se omitieron 2 entradas sin coincidencia.', + ); + }); + + test('queue selection avoids agreement on an Object placeholder', () { + expect(spanish.selectedOfSong(0, 0), 'Selección: 0 de 0 canciones'); + expect(spanish.selectedOfSong(1, 1), 'Selección: 1 de 1 canción'); + expect(spanish.selectedOfSong(1, 2), 'Selección: 1 de 2 canciones'); + expect(spanish.selectedOfSong(2, 2), 'Selección: 2 de 2 canciones'); + expect( + spanish.readyToRemoveSongKeepingIn(1, 1), + 'Todo listo para quitar 1 canción. Total a conservar: 1.', + ); + expect( + spanish.readyToRemoveSongKeepingIn(2, 2), + 'Todo listo para quitar 2 canciones. Total a conservar: 2.', + ); + }); + + test( + 'duplicate cleanup pluralizes both counts without promising deletion', + () { + for (final kept in [0, 1, 2]) { + for (final removed in [0, 1, 2]) { + final versions = kept == 1 ? 'versión' : 'versiones'; + final copies = removed == 1 ? 'copia restante' : 'copias restantes'; + expect( + spanish.weLlKeepYourCheckedVersion(kept, removed), + 'Conservaremos $kept $versions que marcaste y quitaremos de la ' + 'biblioteca $removed $copies. Los archivos de audio del disco no ' + 'se eliminarán.', + ); + } + } + }, + ); +} diff --git a/test/services/android_audio_device_service_test.dart b/test/services/android_audio_device_service_test.dart new file mode 100644 index 00000000..d8b562f0 --- /dev/null +++ b/test/services/android_audio_device_service_test.dart @@ -0,0 +1,88 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:flick/services/android_audio_device_service.dart'; + +void main() { + test('parses wired physical output fields', () { + final info = AndroidPlaybackDeviceInfo.fromMap({ + 'hasUsbDac': false, + 'hasAttachedUac2Device': false, + 'hasWiredAudioRoute': true, + 'hasPhysicalOutput': true, + 'physicalOutputType': 'wired', + 'physicalOutputId': 42, + 'physicalOutputLabel': 'USB-C Earphones', + 'manufacturer': 'Test', + 'model': 'Phone', + 'routeType': 'wired', + 'routeLabel': 'USB-C Earphones', + }); + + expect(info.hasPhysicalOutput, isTrue); + expect(info.hasWiredAudioRoute, isTrue); + expect(info.physicalOutputId, '42'); + expect(info.physicalOutputKey, 'wired:42'); + }); + + test('USB identity wins over a wired route label', () { + final info = AndroidPlaybackDeviceInfo.fromMap({ + 'hasUsbDac': true, + 'hasAttachedUac2Device': true, + 'hasWiredAudioRoute': true, + 'physicalOutputType': 'usb', + 'physicalOutputId': 'usb-1', + 'manufacturer': 'Test', + 'model': 'Phone', + 'routeType': 'internal', + 'routeLabel': 'Built-in output', + }); + + expect(info.physicalOutputKey, 'usb:usb-1'); + }); + + test('no physical output has no guard key', () { + const info = AndroidPlaybackDeviceInfo( + hasUsbDac: false, + hasAttachedUac2Device: false, + manufacturer: 'Test', + model: 'Phone', + routeType: 'internal', + routeLabel: 'Built-in output', + ); + + expect(info.hasPhysicalOutput, isFalse); + expect(info.physicalOutputKey, isNull); + }); + + test('USB connection identity does not depend on the managed route id', () { + const connectionId = '/dev/bus/usb/001/002'; + AndroidPlaybackDeviceInfo info(Object id, String routeType) => + AndroidPlaybackDeviceInfo.fromMap({ + 'hasUsbDac': true, + 'hasAttachedUac2Device': true, + 'physicalOutputId': id, + 'physicalOutputConnectionId': connectionId, + 'routeType': routeType, + }); + + expect( + info(connectionId, 'internal').physicalOutputKey, + 'usb:$connectionId', + ); + expect(info(42, 'usb').physicalOutputKey, 'usb:$connectionId'); + }); + + test('attached UAC2 device is a physical output without a route', () { + final info = AndroidPlaybackDeviceInfo.fromMap({ + 'hasUsbDac': true, + 'hasAttachedUac2Device': true, + 'manufacturer': 'Test', + 'model': 'Phone', + 'routeType': 'internal', + 'routeLabel': 'Built-in output', + 'physicalOutputLabel': 'Test DAC', + }); + + expect(info.hasPhysicalOutput, isTrue); + expect(info.physicalOutputKey, 'usb:Test DAC'); + }); +} diff --git a/test/services/android_audio_engine_volume_test.dart b/test/services/android_audio_engine_volume_test.dart new file mode 100644 index 00000000..ed44f2ec --- /dev/null +++ b/test/services/android_audio_engine_volume_test.dart @@ -0,0 +1,321 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:flick/models/song.dart'; +import 'package:flick/services/android_audio_engine.dart'; +import 'package:just_audio/just_audio.dart' as just_audio; + +class _Player extends Fake implements just_audio.AudioPlayer { + final positions = StreamController.broadcast(sync: true); + final volumes = []; + Completer? playCompletion; + Completer? sourcePreparation; + bool failSourcePreparation = false; + double _volume = 1.0; + bool _playing = false; + + @override + double get volume => _volume; + @override + bool get playing => _playing; + @override + double get speed => 1.0; + @override + Duration get position => Duration.zero; + @override + Duration get bufferedPosition => Duration.zero; + @override + Duration get duration => const Duration(seconds: 3); + @override + int get currentIndex => 0; + @override + List get sequence => const []; + + @override + Stream get positionStream => positions.stream; + @override + Stream get bufferedPositionStream => const Stream.empty(); + @override + Stream get durationStream => const Stream.empty(); + @override + Stream get playerStateStream => const Stream.empty(); + @override + Stream get playbackEventStream => + const Stream.empty(); + @override + Stream get sequenceStateStream => + const Stream.empty(); + @override + Stream get currentIndexStream => const Stream.empty(); + @override + Stream get processingStateStream => + const Stream.empty(); + @override + Stream get errorStream => const Stream.empty(); + + @override + Future setVolume(double volume) async { + volumes.add(volume); + _volume = volume; + } + + @override + Future setAudioSource( + just_audio.AudioSource source, { + bool preload = true, + int? initialIndex, + Duration? initialPosition, + }) async { + await sourcePreparation?.future; + if (failSourcePreparation) throw StateError('source preparation failed'); + return duration; + } + + @override + Future seek(Duration? position, {int? index}) async {} + @override + Future setSpeed(double speed) async {} + @override + Future setLoopMode(just_audio.LoopMode mode) async {} + @override + Future play() { + _playing = true; + return playCompletion?.future ?? Future.value(); + } + + @override + Future pause() async => _playing = false; + @override + Future stop() async => _playing = false; + @override + Future dispose() async { + if (!positions.isClosed) await positions.close(); + } +} + +const _firstSong = Song( + id: 'first', + title: 'First', + artist: 'Test', + duration: Duration(seconds: 3), + filePath: '/first.flac', + fileType: 'FLAC', +); +const _secondSong = Song( + id: 'second', + title: 'Second', + artist: 'Test', + duration: Duration(seconds: 3), + filePath: '/second.flac', + fileType: 'FLAC', +); + +({ + AndroidAudioEngine engine, + _Player first, + _Player second, + List active, +}) +_fixture({double initialVolume = 0.8}) { + final first = _Player(); + final second = _Player(); + final active = []; + final engine = AndroidAudioEngine( + playerProvider: () async => first, + secondaryPlayerProvider: () async => second, + sourcesBuilder: () async => + just_audio.AudioSource.uri(Uri.file('/first.flac')), + sourceBuilder: (song) async => + just_audio.AudioSource.uri(Uri.file(song.filePath!)), + playlistProvider: () => const [_firstSong, _secondSong], + configurePlayer: (player) => player.setVolume(initialVolume), + disposeEngine: () async { + await first.dispose(); + await second.dispose(); + }, + shouldSuppressTrackSync: () => false, + shouldIgnoreTrack: (_) => false, + shouldFastStartCurrentTrackOnly: () => false, + crossfadeConfigProvider: () => const AndroidCrossfadeConfig( + enabled: true, + durationSecs: 1.0, + curve: AndroidCrossfadeCurve.equalPower, + ), + onNextSong: () => _secondSong, + onActivePlayerChanged: active.add, + ); + return (engine: engine, first: first, second: second, active: active); +} + +void main() { + testWidgets('safety gain controls both slots and survives every ramp tick', ( + tester, + ) async { + final f = _fixture(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + expect(f.active.last, same(f.second)); + + await f.engine.setVolume(0.25); + for (var tick = 0; tick < 50; tick++) { + await tester.pump(const Duration(milliseconds: 20)); + expect(f.first.volume, lessThanOrEqualTo(0.25)); + expect(f.second.volume, lessThanOrEqualTo(0.25)); + } + expect(f.second.volume, closeTo(0.25, 1e-9)); + expect(f.first.playing, isFalse); + + // After the fade, only the new active slot should receive user gain. + await f.engine.setVolume(0.1); + expect(f.second.volume, 0.1); + expect(f.active, [f.first, f.second]); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('muted playback never becomes full-scale when a fade starts', ( + tester, + ) async { + final f = _fixture(initialVolume: 0.0); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); + expect(f.first.volume, 0.0); + expect(f.second.volume, 0.0); + await tester.pump(const Duration(milliseconds: 500)); + expect(f.second.volume, 0.0); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('muting a paused fade survives resume and cancellation', ( + tester, + ) async { + final f = _fixture(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 200)); + await f.engine.pause(); + await f.engine.setVolume(0.0); + await f.engine.play(); + await tester.pump(const Duration(milliseconds: 200)); + expect(f.first.volume, 0.0); + expect(f.second.volume, 0.0); + await f.engine.seek(Duration.zero); + expect(f.second.volume, 0.0); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('resume does not wait for either player to finish playback', ( + tester, + ) async { + final f = _fixture(); + f.first.playCompletion = Completer(); + f.second.playCompletion = Completer(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 200)); + await f.engine.pause(); + await f.engine.setVolume(0.25); + + var resumed = false; + final resume = f.engine.play().then((_) => resumed = true); + await tester.pump(); + expect(resumed, isTrue); + await resume; + await tester.pump(const Duration(milliseconds: 800)); + expect(f.second.volume, 0.25); + expect(f.first.playing, isFalse); + f.first.playCompletion!.complete(); + f.second.playCompletion!.complete(); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('a safety pause during source preparation is not undone', ( + tester, + ) async { + final f = _fixture(); + f.second.sourcePreparation = Completer(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + expect(f.active.last, same(f.first)); + await f.engine.pause(); + await f.engine.setVolume(0.0); + f.second.sourcePreparation!.complete(); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 200)); + expect(f.first.playing, isFalse); + expect(f.second.playing, isFalse); + + await f.engine.play(); + await tester.pump(const Duration(seconds: 1)); + expect(f.second.volume, 0.0); + expect(f.first.volume, 0.0); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('cancelling a preparing fade cannot restart its incoming slot', ( + tester, + ) async { + final f = _fixture(); + f.second.sourcePreparation = Completer(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + await f.engine.seek(Duration.zero); + f.second.sourcePreparation!.complete(); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 200)); + expect(f.active.last, same(f.first)); + expect(f.second.playing, isFalse); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('resuming during preparation does not ramp the wrong slots', ( + tester, + ) async { + final f = _fixture(); + f.second.sourcePreparation = Completer(); + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + await f.engine.pause(); + await f.engine.setVolume(0.25); + await f.engine.play(); + await tester.pump(const Duration(milliseconds: 200)); + expect(f.second.playing, isFalse); + expect(f.first.volume, 0.25); + + f.second.sourcePreparation!.complete(); + await tester.pump(); + await tester.pump(const Duration(seconds: 1)); + expect(f.second.volume, 0.25); + expect(f.first.playing, isFalse); + await tester.runAsync(f.engine.dispose); + }); + + testWidgets('a failed fade preparation cannot restore unity over mute', ( + tester, + ) async { + final f = _fixture(initialVolume: 0.0); + f.second.failSourcePreparation = true; + await f.engine.load(_firstSong); + await f.engine.play(); + f.first.positions.add(const Duration(milliseconds: 2400)); + await tester.pump(); + expect(f.active.last, same(f.first)); + expect(f.first.volume, 0.0); + expect(f.second.playing, isFalse); + await tester.runAsync(f.engine.dispose); + }); +} diff --git a/test/services/player_service_physical_output_guard_test.dart b/test/services/player_service_physical_output_guard_test.dart new file mode 100644 index 00000000..c16c71f4 --- /dev/null +++ b/test/services/player_service_physical_output_guard_test.dart @@ -0,0 +1,644 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:ffi'; +import 'dart:io'; + +import 'package:flutter/foundation.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:flick/data/database.dart'; +import 'package:flick/models/audio_engine_type.dart'; +import 'package:flick/services/android_audio_device_service.dart'; +import 'package:flick/services/android_audio_engine.dart'; +import 'package:flick/services/audio_session_manager.dart'; +import 'package:flick/services/player_service.dart'; +import 'package:flick/services/rust_audio_service.dart'; +import 'package:flick/services/uac2_preferences_service.dart'; +import 'package:flick/services/uac2_service.dart'; +import 'package:isar_community/isar.dart'; +import 'package:path/path.dart' as p; +import 'package:shared_preferences/shared_preferences.dart'; + +String? _isarCorePath() { + final override = Platform.environment['ISAR_CORE_LIB']; + if (override != null && File(override).existsSync()) return override; + + final fileName = switch (Abi.current()) { + Abi.linuxX64 || Abi.linuxArm || Abi.linuxArm64 => 'libisar.so', + Abi.macosX64 || Abi.macosArm64 => 'libisar.dylib', + Abi.windowsX64 => 'isar.dll', + _ => null, + }; + if (fileName == null) return null; + + final packageConfig = File( + p.join(Directory.current.path, '.dart_tool', 'package_config.json'), + ); + if (!packageConfig.existsSync()) return null; + + final config = + jsonDecode(packageConfig.readAsStringSync()) as Map; + final packages = config['packages']; + if (packages is! List) return null; + for (final package in packages) { + if (package is! Map || + package['name'] != 'isar_community_flutter_libs') { + continue; + } + final rootUri = package['rootUri']; + if (rootUri is! String) return null; + final root = Directory.fromUri(packageConfig.uri.resolve(rootUri)); + final path = p.join(root.path, Platform.operatingSystem, fileName); + return File(path).existsSync() ? path : null; + } + return null; +} + +const _authorizedDevice = Uac2DeviceInfo( + vendorId: 0x1234, + productId: 0x5678, + productName: 'Test DAC', + manufacturer: 'Test Audio', + serial: 'AUTHORIZED-SERIAL', + deviceName: '/dev/bus/usb/001/002', +); + +Uac2DeviceStatus _status(Uac2DeviceInfo device, {bool hardware = false}) => + Uac2DeviceStatus( + device: device, + state: Uac2State.connected, + routeType: Uac2RouteType.externalUsb, + isExternalRoute: true, + directUsbRegistered: device.serial != null, + volumeMode: hardware ? Uac2VolumeMode.hardware : Uac2VolumeMode.software, + hasVolumeControl: true, + volume: 1.0, + ); + +AndroidPlaybackDeviceInfo _wiredOutput([String id = 'wired-1']) => + AndroidPlaybackDeviceInfo( + hasUsbDac: false, + hasAttachedUac2Device: false, + manufacturer: 'Test', + model: 'Phone', + routeType: 'wired', + routeLabel: 'USB-C Earphones', + hasWiredAudioRoute: true, + physicalOutputType: 'wired', + physicalOutputId: id, + physicalOutputLabel: 'USB-C Earphones', + ); + +class _Session extends Fake implements AudioSessionManager { + _Session(AudioEngineType initial) + : selectedModeNotifier = ValueNotifier(initial), + initializedModeNotifier = ValueNotifier(initial); + + @override + final ValueNotifier selectedModeNotifier; + @override + final ValueNotifier initializedModeNotifier; + @override + AudioEngineType get selectedMode => selectedModeNotifier.value; + @override + AudioEngineType? get initializedMode => initializedModeNotifier.value; +} + +class _Usb extends Fake implements Uac2Service { + _Usb({bool hardware = false}) + : status = _status(_authorizedDevice, hardware: hardware); + + Uac2DeviceStatus status; + bool volumeWriteSucceeds = true; + bool muteWriteSucceeds = true; + bool ignoreMuteWrite = false; + final writes = []; + final muteWrites = []; + + @override + bool isBitPerfectEnabledSync = false; + @override + Uac2DeviceStatus get currentDeviceStatus => status; + + @override + Future refreshAndroidRouteStatus({ + Uac2AudioFormat? formatOverride, + bool? isPlaying, + bool? hasActiveSong, + }) async {} + + @override + Future setVolume(double volume, {bool persist = true}) async { + writes.add(volume); + if (!volumeWriteSucceeds) return false; + status = status.copyWith(volume: volume); + return true; + } + + @override + Future setMute(bool muted) async { + muteWrites.add(muted); + if (!muteWriteSucceeds) return false; + if (!ignoreMuteWrite) status = status.copyWith(muted: muted); + return true; + } +} + +class _Rust extends Fake implements RustAudioService { + final commands = []; + bool failVolumeWrite = false; + bool failPause = false; + Completer? volumeWrite; + double appliedVolume = 1.0; + + @override + bool get isInitialized => true; + + @override + Future setVolume(double volume) async { + commands.add(volume); + await volumeWrite?.future; + if (failVolumeWrite) throw StateError('volume write failed'); + appliedVolume = volume; + } + + @override + Future pause() async { + commands.add('pause'); + if (failPause) throw StateError('pause failed'); + } + + @override + Future stop() async => commands.add('stop'); +} + +class _Android extends Fake implements AndroidAudioEngine { + final volumes = []; + + @override + Future setVolume(double volume) async => volumes.add(volume); +} + +PlayerService _player( + AudioEngineType initial, + _Usb usb, { + _Rust? rust, + _Android? android, + bool directUsb = false, + _Session? sessionOverride, +}) { + final session = sessionOverride ?? _Session(initial); + final player = PlayerService.forTesting( + sessionManager: session, + uac2Service: usb, + rustAudioService: rust, + androidAudioEngine: android, + directUsb: directUsb, + ); + player.usingRustBackendNotifier.value = rust != null; + addTearDown(session.selectedModeNotifier.dispose); + addTearDown(session.initializedModeNotifier.dispose); + addTearDown(player.currentVolumeNotifier.dispose); + addTearDown(player.volumeTierNotifier.dispose); + addTearDown(player.usbVolumeSafetyBlockedNotifier.dispose); + addTearDown(player.usingRustBackendNotifier.dispose); + addTearDown(() async { + session.initializedModeNotifier.value = AudioEngineType.normalAndroid; + await player.reconcileVolumeForTesting(); + }); + return player; +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + late Directory databaseDir; + + setUpAll(() async { + databaseDir = await Directory.systemTemp.createTemp( + 'flick_physical_output', + ); + final corePath = _isarCorePath(); + if (corePath == null) { + fail('isar core library not found; set ISAR_CORE_LIB'); + } + Isar.initializeIsarCore(libraries: {Abi.current(): corePath}); + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger + .setMockMethodCallHandler( + const MethodChannel('plugins.flutter.io/path_provider'), + (call) async => databaseDir.path, + ); + await Database.init(); + }); + + tearDownAll(() async { + await Database.close(); + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger + .setMockMethodCallHandler( + const MethodChannel('plugins.flutter.io/path_provider'), + null, + ); + await databaseDir.delete(recursive: true); + }); + + setUp(() => SharedPreferences.setMockInitialValues({})); + + test('wired output lowers the system tier once and never raises', () async { + final player = _player(AudioEngineType.normalAndroid, _Usb()); + expect(player.currentVolume, 1.0); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 0.25); + expect(player.volumeTierNotifier.value, VolumeTier.system); + + await player.setVolume(0.8); + expect(player.currentVolume, 0.8); + + // A repeated AudioDeviceCallback for the same connection must not undo + // the user's adjustment. + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(player.currentVolume, 0.8); + }); + + test('a different physical output applies the ceiling again', () async { + final player = _player(AudioEngineType.normalAndroid, _Usb()); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + await player.setVolume(0.9); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput('wired-2')); + + expect(player.currentVolume, 0.25); + }); + + test('physical output removal lets the same connection re-apply', () async { + final player = _player(AudioEngineType.normalAndroid, _Usb()); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + await player.setVolume(0.7); + + await player.handlePlaybackDeviceInfoForTesting( + const AndroidPlaybackDeviceInfo( + hasUsbDac: false, + hasAttachedUac2Device: false, + manufacturer: 'Test', + model: 'Phone', + routeType: 'internal', + routeLabel: 'Built-in output', + ), + ); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 0.25); + }); + + test('unknown refresh does not re-lower the current connection', () async { + final player = _player(AudioEngineType.normalAndroid, _Usb()); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + await player.setVolume(0.7); + + await player.handlePlaybackDeviceInfoForTesting( + AndroidPlaybackDeviceInfo.unknown, + ); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 0.7); + }); + + test('muted or already-lower volume is never raised', () async { + final player = _player(AudioEngineType.normalAndroid, _Usb()); + await player.setVolume(0.0); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 0.0); + }); + + test('Rust software tier receives the safety ceiling exactly once', () async { + final rust = _Rust(); + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 0.25); + expect(player.volumeTierNotifier.value, VolumeTier.software); + expect(rust.commands, [0.25]); + + await player.setVolume(0.9); + expect(player.currentVolume, 0.9); + expect(rust.commands, [0.25, 0.9]); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(rust.commands, [0.25, 0.9]); + }); + + test( + 'direct USB keeps its verified hardware restore, not a software cap', + () async { + final usb = _Usb(hardware: true); + final rust = _Rust(); + final player = _player( + AudioEngineType.usbDacExperimental, + usb, + rust: rust, + directUsb: true, + ); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(usb.writes, [0.4]); + expect(player.currentVolume, 0.4); + expect(rust.commands, isEmpty); + }, + ); + + test('direct USB handoff keeps the software safety attenuation', () async { + await Uac2PreferencesService().setUsbVolumeForDevice( + _authorizedDevice, + 0.8, + authority: UsbVolumeAuthority.hardware, + ); + final session = _Session(AudioEngineType.normalAndroid); + final usb = _Usb(hardware: true); + final player = _player( + AudioEngineType.normalAndroid, + usb, + sessionOverride: session, + directUsb: true, + ); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(player.currentVolume, 0.25); + + // The user grants USB access on the same physical connection. + session.selectedModeNotifier.value = AudioEngineType.usbDacExperimental; + session.initializedModeNotifier.value = AudioEngineType.usbDacExperimental; + await player.restoreUsbVolumeForTesting(); + + // A remembered 80% DAC level must not undo the 25% app attenuation; + // the verified hardware restore takes the low 40% first-use ceiling. + expect(usb.writes, [0.4]); + expect(player.currentVolume, 0.4); + }); + + for (final volume in [0.0, 0.1, 1.0]) { + test('software USB handoff preserves guarded volume $volume', () async { + await Uac2PreferencesService().setUsbVolumeForDevice( + _authorizedDevice, + 0.8, + authority: UsbVolumeAuthority.software, + ); + final session = _Session(AudioEngineType.rustOboe); + final rust = _Rust(); + final player = _player( + AudioEngineType.rustOboe, + _Usb(), + rust: rust, + sessionOverride: session, + directUsb: true, + ); + await player.setVolume(volume); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + final guarded = player.currentVolume; + + session.selectedModeNotifier.value = AudioEngineType.usbDacExperimental; + session.initializedModeNotifier.value = + AudioEngineType.usbDacExperimental; + await player.restoreUsbVolumeForTesting(); + + expect(player.currentVolume, guarded); + expect(rust.appliedVolume, guarded); + final saved = await Uac2PreferencesService() + .getUsbVolumeSettingsForDevice(_authorizedDevice); + expect(saved.software, 0.8); // The one-shot ceiling is not a preference. + }); + } + + test('hardware USB handoff preserves the app mute', () async { + final session = _Session(AudioEngineType.rustOboe); + final usb = _Usb(hardware: true); + final rust = _Rust(); + final player = _player( + AudioEngineType.rustOboe, + usb, + rust: rust, + sessionOverride: session, + directUsb: true, + ); + await player.setVolume(0.0); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + session.selectedModeNotifier.value = AudioEngineType.usbDacExperimental; + session.initializedModeNotifier.value = AudioEngineType.usbDacExperimental; + await player.restoreUsbVolumeForTesting(); + + expect(usb.writes, [0.0]); + expect(usb.status.volume, 0.0); + expect(usb.muteWrites, [true]); + expect(usb.status.muted, isTrue); + expect(player.currentVolume, 0.0); + // Hardware mute is verified before releasing software attenuation. + expect(rust.commands, contains('pause')); + expect(rust.appliedVolume, 1.0); + }); + + for (final ignored in [false, true]) { + test('unverified hardware mute stays paused (ignored=$ignored)', () async { + final session = _Session(AudioEngineType.rustOboe); + final usb = _Usb(hardware: true) + ..muteWriteSucceeds = ignored + ..ignoreMuteWrite = ignored; + final rust = _Rust(); + final player = _player( + AudioEngineType.rustOboe, + usb, + rust: rust, + sessionOverride: session, + directUsb: true, + ); + await player.setVolume(0.0); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + session.selectedModeNotifier.value = AudioEngineType.usbDacExperimental; + session.initializedModeNotifier.value = + AudioEngineType.usbDacExperimental; + + await expectLater(player.restoreUsbVolumeForTesting(), throwsStateError); + expect(player.usbVolumeSafetyBlockedNotifier.value, isTrue); + expect(rust.commands, contains('pause')); + expect(rust.commands, isNot(contains(1.0))); + + usb.muteWriteSucceeds = true; + usb.ignoreMuteWrite = false; + await player.restoreUsbVolumeForTesting(); + expect(usb.status.muted, isTrue); + expect(player.usbVolumeSafetyBlockedNotifier.value, isFalse); + expect(rust.appliedVolume, 1.0); + }); + } + + test('system guard writes through the crossfade-owning engine', () async { + final android = _Android(); + final player = _player( + AudioEngineType.normalAndroid, + _Usb(), + android: android, + ); + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(android.volumes, [0.25]); + await player.setVolume(0.8); + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(android.volumes, [0.25, 0.8]); + }); + + test('failed safety write pauses and retries the same connection', () async { + final rust = _Rust()..failVolumeWrite = true; + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + player.isPlayingNotifier.value = true; + + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + + expect(player.currentVolume, 1.0); // Do not advertise an unapplied gain. + expect(rust.appliedVolume, 1.0); + expect(rust.commands, [0.25, 'pause']); + expect(player.isPlayingNotifier.value, isFalse); + rust.failVolumeWrite = false; + await player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + expect(rust.commands, [0.25, 'pause', 0.25]); + expect(player.currentVolume, 0.25); + expect(rust.appliedVolume, 0.25); + }); + + test('duplicate notifications await the in-flight safety write', () async { + final rust = _Rust()..volumeWrite = Completer(); + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + var secondCompleted = false; + final first = player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + final second = player + .handlePlaybackDeviceInfoForTesting(_wiredOutput()) + .then((_) => secondCompleted = true); + await Future.delayed(Duration.zero); + expect(secondCompleted, isFalse); + expect(rust.commands, [0.25]); + + rust.volumeWrite!.complete(); + await Future.wait([first, second]); + expect(player.currentVolume, 0.25); + }); + + test( + 'background reconciliation cannot undo a pending safety write', + () async { + final rust = _Rust()..volumeWrite = Completer(); + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + final guard = player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + final reconcile = player.reconcileVolumeForTesting(); + await Future.delayed(Duration.zero); + expect(rust.commands, [0.25]); + + rust.volumeWrite!.complete(); + await Future.wait([guard, reconcile]); + expect(rust.commands, [0.25, 0.25]); + expect(rust.appliedVolume, 0.25); + expect(player.currentVolume, 0.25); + }, + ); + + test('Play stays blocked on failure and retries before continuing', () async { + final rust = _Rust() + ..failVolumeWrite = true + ..failPause = true; + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + + await expectLater( + player.ensurePhysicalOutputVolumeForTesting(_wiredOutput()), + throwsStateError, + ); + expect(rust.commands, [0.25, 'pause', 'stop']); + expect(player.currentVolume, 1.0); + + rust.failVolumeWrite = false; + await player.ensurePhysicalOutputVolumeForTesting(_wiredOutput()); + expect(rust.commands, [0.25, 'pause', 'stop', 0.25]); + expect(rust.appliedVolume, 0.25); + expect(player.isPlayingNotifier.value, isFalse); + }); + + test('a hardware-to-normal engine change rechecks the output', () async { + final session = _Session(AudioEngineType.usbDacExperimental); + final android = _Android(); + final usb = _Usb(hardware: true); + final player = _player( + AudioEngineType.usbDacExperimental, + usb, + android: android, + directUsb: true, + sessionOverride: session, + ); + await player.ensurePhysicalOutputVolumeForTesting(_wiredOutput()); + expect(usb.writes, [0.4]); + expect(android.volumes, isEmpty); + + session.selectedModeNotifier.value = AudioEngineType.normalAndroid; + session.initializedModeNotifier.value = AudioEngineType.normalAndroid; + await player.ensurePhysicalOutputVolumeForTesting(_wiredOutput()); + expect(android.volumes, [0.25]); + expect(player.currentVolume, 0.25); + }); + + test('user mute follows rather than races the safety write', () async { + final rust = _Rust()..volumeWrite = Completer(); + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + final guard = player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + final mute = player.setVolume(0.0); + await Future.delayed(Duration.zero); + expect(rust.commands, [0.25]); + + rust.volumeWrite!.complete(); + await Future.wait([guard, mute]); + expect(rust.commands, [0.25, 0.0]); + expect(player.currentVolume, 0.0); + expect(rust.appliedVolume, 0.0); + }); + + test('replacement output and mute wait for the previous write', () async { + final rust = _Rust()..volumeWrite = Completer(); + final player = _player(AudioEngineType.rustOboe, _Usb(), rust: rust); + final first = player.handlePlaybackDeviceInfoForTesting(_wiredOutput()); + final second = player.handlePlaybackDeviceInfoForTesting( + _wiredOutput('wired-2'), + ); + final mute = player.setVolume(0.0); + await Future.delayed(Duration.zero); + expect(rust.commands, [0.25]); + + rust.volumeWrite!.complete(); + await Future.wait([first, second, mute]); + expect(rust.commands, [0.25, 0.25, 0.0]); + expect(player.currentVolume, 0.0); + expect(rust.appliedVolume, 0.0); + }); + + test('one USB connection survives Android route-id changes', () async { + const connectionId = '/dev/bus/usb/001/002'; + AndroidPlaybackDeviceInfo output(String routeId, String routeType) => + AndroidPlaybackDeviceInfo.fromMap({ + 'hasUsbDac': true, + 'hasAttachedUac2Device': true, + 'physicalOutputType': 'usb', + 'physicalOutputId': routeId, + 'physicalOutputConnectionId': connectionId, + 'physicalOutputLabel': 'Test DAC', + 'routeType': routeType, + }); + final player = _player(AudioEngineType.normalAndroid, _Usb()); + await player.handlePlaybackDeviceInfoForTesting( + output(connectionId, 'internal'), + ); + await player.setVolume(0.8); + await player.handlePlaybackDeviceInfoForTesting(output('42', 'usb')); + expect(player.currentVolume, 0.8); + await player.handlePlaybackDeviceInfoForTesting( + output(connectionId, 'internal'), + ); + expect(player.currentVolume, 0.8); + }); +}