diff --git a/.env b/.env
index ce76ab54d..8d82675d4 100755
Binary files a/.env and b/.env differ
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index 6345b2d47..1907b9165 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -7,30 +7,27 @@
     <!-- playing radio in background permissions -->
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <application
         android:label="ToPWR"
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher">
 
-        <!-- playing radio in background permissions -->
-        <service 
-                android:name="com.ryanheise.audioservice.AudioService"
-                android:foregroundServiceType="mediaPlayback"
-                android:enabled="true"
-                android:exported="true" 
-                tools:ignore="Instantiatable" 
-                android:stopWithTask="true" >
+        <!-- Audio Service -->
+        <service android:name="com.ryanheise.audioservice.AudioService"
+            android:foregroundServiceType="mediaPlayback"
+            android:exported="true" tools:ignore="Instantiatable">
             <intent-filter>
                 <action android:name="android.media.browse.MediaBrowserService" />
             </intent-filter>
         </service>
 
-         <!-- playing radio in background permissions -->
         <receiver android:name="com.ryanheise.audioservice.MediaButtonReceiver"
             android:exported="true" tools:ignore="Instantiatable">
-        <intent-filter>
-            <action android:name="android.intent.action.MEDIA_BUTTON" />
-        </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
         </receiver> 
 
         <meta-data android:name="com.google.android.geo.API_KEY"
@@ -41,7 +38,6 @@
         <!-- name attribute has to be change to play radio in foreground -->
         <activity
             android:name="com.ryanheise.audioservice.AudioServiceActivity"
-            android:enableOnBackInvokedCallback="true"
             android:exported="true"
             android:launchMode="singleTask"
             android:theme="@style/LaunchTheme"
@@ -80,6 +76,10 @@
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />
+        <!-- Android Auto Definition -->
+        <meta-data
+            android:name="com.google.android.gms.car.application"
+            android:resource="@xml/automotive_app_desc"/>
     </application>
     <!-- Required to query activities that can process text, see:
          https://developer.android.com/training/package-visibility?hl=en and
diff --git a/android/app/src/main/res/xml/automotive_app_desc.xml b/android/app/src/main/res/xml/automotive_app_desc.xml
new file mode 100644
index 000000000..e64f44258
--- /dev/null
+++ b/android/app/src/main/res/xml/automotive_app_desc.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<automotiveApp>
+    <uses name="media" />
+</automotiveApp>
diff --git a/lib/features/digital_guide/tabs/micronavigation/presentation/widgets/my_audio_player.dart b/lib/features/digital_guide/tabs/micronavigation/presentation/widgets/my_audio_player.dart
index 7b4ddb5d5..94820a63a 100644
--- a/lib/features/digital_guide/tabs/micronavigation/presentation/widgets/my_audio_player.dart
+++ b/lib/features/digital_guide/tabs/micronavigation/presentation/widgets/my_audio_player.dart
@@ -1,8 +1,8 @@
 import "dart:async";
 
-import "package:audioplayers/audioplayers.dart";
 import "package:flutter/material.dart";
 import "package:flutter_hooks/flutter_hooks.dart";
+import "package:just_audio/just_audio.dart";
 
 import "../../../../../../config/ui_config.dart";
 import "../../../../../../theme/app_theme.dart";
@@ -22,15 +22,15 @@ class MyAudioPlayer extends HookWidget {
     final totalTime = useState(Duration.zero);
 
     useEffect(() {
-      final stateSubscription = audioPlayer.onPlayerStateChanged.listen((state) {
-        isPlaying.value = state == PlayerState.playing;
+      final stateSubscription = audioPlayer.playerStateStream.listen((state) {
+        isPlaying.value = state.playing;
       });
 
-      final durationSubscription = audioPlayer.onDurationChanged.listen((duration) {
-        totalTime.value = duration;
+      final durationSubscription = audioPlayer.durationStream.listen((duration) {
+        totalTime.value = duration ?? Duration.zero;
       });
 
-      final positionSubscription = audioPlayer.onPositionChanged.listen((position) {
+      final positionSubscription = audioPlayer.positionStream.listen((position) {
         currentTime.value = position;
       });
 
@@ -46,7 +46,8 @@ class MyAudioPlayer extends HookWidget {
       if (isPlaying.value) {
         await audioPlayer.pause();
       } else {
-        await audioPlayer.play(UrlSource(audioUrl));
+        await audioPlayer.setUrl(audioUrl);
+        await audioPlayer.play();
       }
     }, [audioUrl]);
 
diff --git a/lib/features/radio_luz/data/models/now_playing.dart b/lib/features/radio_luz/data/models/now_playing.dart
new file mode 100644
index 000000000..3d3ae500c
--- /dev/null
+++ b/lib/features/radio_luz/data/models/now_playing.dart
@@ -0,0 +1,11 @@
+import "package:freezed_annotation/freezed_annotation.dart";
+
+part "now_playing.freezed.dart";
+part "now_playing.g.dart";
+
+@freezed
+abstract class NowPlaying with _$NowPlaying {
+  const factory NowPlaying({required String? now, required String? next}) = _NowPlaying;
+
+  factory NowPlaying.fromJson(Map<String, dynamic> json) => _$NowPlayingFromJson(json);
+}
diff --git a/lib/features/radio_luz/presentation/radio_luz_view.dart b/lib/features/radio_luz/presentation/radio_luz_view.dart
index 5a421ba64..a96fae7f7 100644
--- a/lib/features/radio_luz/presentation/radio_luz_view.dart
+++ b/lib/features/radio_luz/presentation/radio_luz_view.dart
@@ -1,10 +1,15 @@
+import "dart:async";
+
 import "package:auto_route/auto_route.dart";
 import "package:flutter/material.dart";
+import "package:flutter_hooks/flutter_hooks.dart";
+import "package:hooks_riverpod/hooks_riverpod.dart";
 
 import "../../../config/ui_config.dart";
 import "../../../theme/app_theme.dart";
 import "../../../utils/context_extensions.dart";
 import "../../../widgets/horizontal_symmetric_safe_area.dart";
+import "../service/radio_player_controller.dart";
 import "audio_player_widget.dart";
 import "broadcasts_section.dart";
 import "now_playing_section.dart";
@@ -13,13 +18,21 @@ import "radio_luz_socials_section.dart";
 import "radio_luz_title.dart";
 
 @RoutePage()
-class RadioLuzView extends StatelessWidget {
+class RadioLuzView extends HookConsumerWidget {
   const RadioLuzView({super.key});
 
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
     final l10n = context.localize;
     final cappedTextScale = context.textScaler.clamp(maxScaleFactor: 1.7);
+
+    useEffect(() {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        unawaited(ref.read(radioControllerProvider.notifier).preload());
+      });
+      return null;
+    }, []);
+
     return MediaQuery(
       data: MediaQuery.of(context).copyWith(textScaler: cappedTextScale),
       child: HorizontalSymmetricSafeAreaScaffold(
diff --git a/lib/features/radio_luz/service/audio_player_streams.dart b/lib/features/radio_luz/service/audio_player_streams.dart
index 2bec7e86a..bff0fcfa7 100644
--- a/lib/features/radio_luz/service/audio_player_streams.dart
+++ b/lib/features/radio_luz/service/audio_player_streams.dart
@@ -7,12 +7,12 @@ part "audio_player_streams.g.dart";
 
 @riverpod
 Stream<PlayerState> audioPlayerState(Ref ref) {
-  final player = ref.watch(radioPlayerProvider);
-  return player.playerStateStream;
+  final handler = ref.watch(radioPlayerProvider);
+  return handler.playerState;
 }
 
 @riverpod
 Stream<double> audioPlayerVolume(Ref ref) {
-  final player = ref.watch(radioPlayerProvider);
-  return player.volumeStream;
+  final handler = ref.watch(radioPlayerProvider);
+  return handler.volume;
 }
diff --git a/lib/features/radio_luz/service/radio_audio_handler.dart b/lib/features/radio_luz/service/radio_audio_handler.dart
new file mode 100644
index 000000000..f3e48efe8
--- /dev/null
+++ b/lib/features/radio_luz/service/radio_audio_handler.dart
@@ -0,0 +1,357 @@
+import "dart:async";
+import "dart:convert";
+
+import "package:audio_service/audio_service.dart";
+import "package:audio_session/audio_session.dart";
+import "package:dio/dio.dart";
+import "package:flutter/widgets.dart";
+import "package:just_audio/just_audio.dart";
+
+import "../../../config/env.dart";
+import "../data/models/history_entry.dart";
+import "../data/models/now_playing.dart";
+import "../data/models/schedule.dart";
+
+//Here the audio player is defined. Its created at app startup and is used for playing live stream.
+//This whole class describes the audio player behavior, media items and metadata.
+//This class acts as a bridge between the audio player (just_audio) and the audio service (audio_service).
+//Thanks to that the audio player can talk to native APIs of audio services specific to the platform.
+//Specifically, it allows the app to be recognized as a media player, which allows integration with Android Auto, CarPlay, etc.
+
+const radioLuzArtwork = "https://api.topwr.solvro.pl/uploads/28ef1261-47d5-4324-9f1f-9ae594af1327.png";
+const refreshInterval = Duration(seconds: 15);
+const staleStreamThreshold = Duration(seconds: 30);
+
+//used for AA and CP to display folders and media items
+class _MediaIds {
+  static const liveRadioFolder = "radio_luz_folder";
+  static const liveRadioPlayable = "radio_luz_station";
+  static const recentlyPlayed = "recently_played_folder";
+  static const schedule = "schedule_folder";
+}
+
+class RadioAudioHandlerBridge extends BaseAudioHandler with SeekHandler, WidgetsBindingObserver {
+  final _player = AudioPlayer();
+
+  //used for fetching recently played and schedule
+  final _dio = Dio(
+    BaseOptions(
+      baseUrl: Env.radioLuzApiUrl,
+      connectTimeout: const Duration(seconds: 10),
+      receiveTimeout: const Duration(seconds: 10),
+      headers: {
+        "User-Agent": "RadioLuzApp/1.0 (Dart Dio)",
+        "Accept": "*/*",
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    ),
+  );
+
+  //main media item - live radio (information source)
+  var _radioLuzMediaItem = MediaItem(
+    id: _MediaIds.liveRadioPlayable,
+    title: "Radio LUZ",
+    album: "Studenckie Radio",
+    artUri: Uri.parse(radioLuzArtwork), //artwork cannot be local asset
+  );
+
+  List<MediaItem>? _recentlyPlayedCache;
+  DateTime? _recentlyPlayedLastFetch;
+  static const _recentlyPlayedTtl = Duration(minutes: 1);
+
+  List<MediaItem>? _scheduleCache;
+  DateTime? _scheduleLastFetch;
+  static const _scheduleTtl = Duration(minutes: 5);
+
+  var _isDisposed = false;
+
+  Timer? _refreshTimer;
+  StreamSubscription<PlaybackState>? _playbackEventSubscription;
+  StreamSubscription<SequenceState?>? _sequenceStateSubscription;
+
+  RadioAudioHandlerBridge() {
+    _initializeListeners();
+  }
+
+  void _initializeListeners() {
+    //connect 'just_audio' (Flutter) to 'audio_service' (native)
+    _playbackEventSubscription = _player.playbackEventStream.map(_transformEvent).listen(playbackState.add);
+
+    _sequenceStateSubscription = _player.sequenceStateStream.listen((state) {
+      mediaItem.add(_radioLuzMediaItem);
+    });
+
+    //periodically refresh now playing metadata
+    _refreshTimer?.cancel();
+    _refreshTimer = Timer.periodic(refreshInterval, (_) async {
+      await _fetchNowPlaying();
+    });
+
+    //pre-configure audio session for iOS to reduce playback startup latency
+    unawaited(_initAudioSession());
+
+    //register lifecycle observer to stop playback when app is killed
+    WidgetsBinding.instance.addObserver(this);
+  }
+
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    // Stop playback when app is detached (killed)
+    if (state == AppLifecycleState.detached) {
+      unawaited(stop());
+    }
+  }
+
+  /// iOS audio session
+  Future<void> _initAudioSession() async {
+    final session = await AudioSession.instance;
+    await session.configure(
+      const AudioSessionConfiguration(
+        avAudioSessionCategory: AVAudioSessionCategory.playback,
+        avAudioSessionCategoryOptions: AVAudioSessionCategoryOptions.allowBluetooth,
+        avAudioSessionMode: AVAudioSessionMode.defaultMode,
+        avAudioSessionRouteSharingPolicy: AVAudioSessionRouteSharingPolicy.defaultPolicy,
+        avAudioSessionSetActiveOptions: AVAudioSessionSetActiveOptions.none,
+        androidAudioAttributes: AndroidAudioAttributes(
+          contentType: AndroidAudioContentType.music,
+          usage: AndroidAudioUsage.media,
+        ),
+        androidWillPauseWhenDucked: false,
+      ),
+    );
+  }
+
+  //track when the stream was paused to detect stale buffers
+  DateTime? _lastPauseTime;
+
+  Future<void> _fetchNowPlaying() async {
+    try {
+      if (_isDisposed) return;
+      final formData = FormData.fromMap({"action": "nowPlaying"});
+      final response = await _dio.post<String>("admin-ajax.php", data: formData);
+
+      if (response.data == null) return;
+
+      final dynamic decoded = jsonDecode(response.data!);
+      if (decoded is! Map<String, dynamic>) return;
+
+      final nowPlaying = NowPlaying.fromJson(decoded);
+      if (nowPlaying.now == null || nowPlaying.now!.isEmpty) return;
+
+      _radioLuzMediaItem = _radioLuzMediaItem.copyWith(album: nowPlaying.now, artist: nowPlaying.now);
+
+      mediaItem.add(_radioLuzMediaItem);
+    } on Exception catch (_) {
+      //keep the old metadata
+    }
+  }
+
+  ///pre-loads the audio stream
+  Future<void> _loadStream() async {
+    await _player.setAudioSource(AudioSource.uri(Uri.parse(Env.radioLuzStreamUrl), tag: _radioLuzMediaItem));
+    mediaItem.add(_radioLuzMediaItem);
+  }
+
+  Future<void> preload() async {
+    if (_player.processingState == ProcessingState.idle) {
+      await _loadStream();
+    }
+  }
+
+  @override
+  Future<void> play() async {
+    final now = DateTime.now();
+    final isStale = _lastPauseTime != null && now.difference(_lastPauseTime!) > staleStreamThreshold;
+
+    _lastPauseTime = null;
+
+    //if stream is stale or player is idle, reload the audio source
+    if (isStale || _player.processingState == ProcessingState.idle) {
+      await _loadStream();
+    }
+
+    unawaited(_player.play());
+  }
+
+  @override
+  Future<void> pause() async {
+    _lastPauseTime = DateTime.now();
+    await _player.pause();
+  }
+
+  @override
+  Future<void> stop() async {
+    _isDisposed = true;
+    _refreshTimer?.cancel();
+    await _playbackEventSubscription?.cancel();
+    await _sequenceStateSubscription?.cancel();
+    WidgetsBinding.instance.removeObserver(this);
+    await _player.stop();
+    return super.stop();
+  }
+
+  //most crucial - defines the structure of the media library that is visible in AA and CP
+  @override
+  Future<List<MediaItem>> getChildren(String parentMediaId, [Map<String, dynamic>? options]) async {
+    switch (parentMediaId) {
+      case AudioService.browsableRootId:
+        return [
+          const MediaItem(
+            id: _MediaIds.liveRadioFolder,
+            title: "Radio LUZ",
+            album: "Studenckie Radio",
+            playable: false,
+          ),
+          const MediaItem(id: _MediaIds.recentlyPlayed, title: "Teraz gramy", playable: false),
+          const MediaItem(id: _MediaIds.schedule, title: "Audycje", playable: false),
+        ];
+
+      case _MediaIds.liveRadioFolder:
+        return [_radioLuzMediaItem];
+
+      case _MediaIds.recentlyPlayed:
+        return _fetchRecentlyPlayed();
+
+      case _MediaIds.schedule:
+        return _fetchSchedule();
+
+      default:
+        return [];
+    }
+  }
+
+  Future<List<MediaItem>> _fetchRecentlyPlayed() async {
+    final now = DateTime.now();
+    if (_recentlyPlayedCache != null &&
+        _recentlyPlayedLastFetch != null &&
+        now.difference(_recentlyPlayedLastFetch!) < _recentlyPlayedTtl) {
+      return _recentlyPlayedCache!;
+    }
+
+    try {
+      final formData = FormData.fromMap({"action": "histoprylog"});
+      final response = await _dio.post<String>("admin-ajax.php", data: formData);
+
+      if (_isDisposed) return [];
+
+      if (response.data == null) return _recentlyPlayedCache ?? [];
+
+      final dynamic decoded = jsonDecode(response.data!);
+      if (decoded is! List) return _recentlyPlayedCache ?? [];
+
+      final items = decoded.whereType<List<dynamic>>().map((e) {
+        final entry = HistoryEntry.fromList(e);
+        final timeStr = "${entry.time.hour.toString().padLeft(2, '0')}:${entry.time.minute.toString().padLeft(2, '0')}";
+        return MediaItem(
+          id: "history_${entry.date}_${entry.title}",
+          title: "$timeStr - ${entry.title}",
+          artist: entry.artist,
+          album: entry.album,
+        );
+      }).toList();
+
+      //because title is in format "HH:MM - Title", it is sorted by time from latest to oldest
+      items.sort((a, b) => b.title.compareTo(a.title));
+
+      _recentlyPlayedCache = items;
+      _recentlyPlayedLastFetch = now;
+
+      return items;
+    } on Exception catch (_) {
+      return _recentlyPlayedCache ?? [];
+    }
+  }
+
+  Future<List<MediaItem>> _fetchSchedule() async {
+    final now = DateTime.now();
+    if (_scheduleCache != null && _scheduleLastFetch != null && now.difference(_scheduleLastFetch!) < _scheduleTtl) {
+      return _scheduleCache!;
+    }
+
+    try {
+      final formData = FormData.fromMap({"action": "schedule"});
+      final response = await _dio.post<String>("admin-ajax.php", data: formData);
+
+      if (response.data == null) return _scheduleCache ?? [];
+
+      final dynamic jsonMap = jsonDecode(response.data!);
+      if (jsonMap is! Map<String, dynamic>) return _scheduleCache ?? [];
+
+      final schedule = Schedule.fromJson(jsonMap);
+
+      final items = <MediaItem>[];
+
+      for (final block in schedule.broadcasts) {
+        final isNow = block.isNow ?? false;
+
+        for (final broadcast in block.broadcasts) {
+          Uri? artUri;
+          if (broadcast.thumbnail != null && broadcast.thumbnail!.isNotEmpty) {
+            artUri = Uri.tryParse(broadcast.thumbnail!);
+          }
+
+          items.add(
+            MediaItem(
+              id: "schedule_${broadcast.id}",
+              title: isNow ? "▶ ${broadcast.title}" : broadcast.title,
+              album: broadcast.time,
+              artUri: artUri,
+            ),
+          );
+        }
+      }
+
+      _scheduleCache = items;
+      _scheduleLastFetch = now;
+
+      return items;
+    } on Exception catch (_) {
+      return _scheduleCache ?? [];
+    }
+  }
+
+  //start playing media item
+  @override
+  Future<void> playFromMediaId(String mediaId, [Map<String, dynamic>? extras]) async {
+    //...because anything you click on should play the radio
+    if (mediaId == _radioLuzMediaItem.id || mediaId.startsWith("history_") || mediaId.startsWith("schedule_")) {
+      await _loadStream();
+      unawaited(_player.play());
+    }
+    //this if might be useless but you never know...
+  }
+
+  Future<void> setVolume(double volume) => _player.setVolume(volume);
+
+  Future<void> setAudioSource(AudioSource source) async {
+    await _player.setAudioSource(source);
+    if (source is UriAudioSource && source.tag is MediaItem) {
+      mediaItem.add((source.tag as MediaItem).copyWith(playable: true));
+    }
+  }
+
+  //this is where the audio player (just_audio) and audio service (audio_service) connect
+  PlaybackState _transformEvent(PlaybackEvent event) {
+    return PlaybackState(
+      controls: [if (_player.playing) MediaControl.pause else MediaControl.play],
+      systemActions: const {MediaAction.seek},
+      androidCompactActionIndices: const [0],
+      processingState: switch (_player.processingState) {
+        ProcessingState.idle => AudioProcessingState.idle,
+        ProcessingState.loading => AudioProcessingState.loading,
+        ProcessingState.buffering => AudioProcessingState.buffering,
+        ProcessingState.ready => AudioProcessingState.ready,
+        ProcessingState.completed => AudioProcessingState.completed,
+      },
+      playing: _player.playing,
+      updatePosition: _player.position,
+      bufferedPosition: _player.bufferedPosition,
+      speed: _player.speed,
+      queueIndex: event.currentIndex,
+    );
+  }
+
+  Stream<double> get volume => _player.volumeStream;
+  Stream<PlayerState> get playerState => _player.playerStateStream;
+  Duration get bufferedPosition => _player.bufferedPosition;
+}
diff --git a/lib/features/radio_luz/service/radio_player_controller.dart b/lib/features/radio_luz/service/radio_player_controller.dart
index ece3eaae0..fea9b6b54 100644
--- a/lib/features/radio_luz/service/radio_player_controller.dart
+++ b/lib/features/radio_luz/service/radio_player_controller.dart
@@ -1,18 +1,15 @@
 import "dart:async";
 import "dart:io";
 
-import "package:flutter/material.dart";
 import "package:flutter/services.dart";
 import "package:just_audio/just_audio.dart";
-import "package:just_audio_background/just_audio_background.dart";
 import "package:path/path.dart" as p;
 import "package:path_provider/path_provider.dart";
 import "package:riverpod_annotation/riverpod_annotation.dart";
 
-import "../../../config/env.dart";
-import "../../../gen/assets.gen.dart";
 import "../data/models/audio_player_strings.dart";
 import "audio_player_streams.dart";
+import "radio_audio_handler.dart";
 import "radio_player_provider.dart";
 import "radio_state.dart";
 
@@ -20,17 +17,12 @@ part "radio_player_controller.g.dart";
 
 @Riverpod(keepAlive: true)
 class RadioController extends _$RadioController {
-  late final AudioPlayer _player = ref.watch(radioPlayerProvider);
-  late final AudioPlayerStrings _audioPlayerStrings;
-  _AppLifecycleStopper? _stopper;
+  late final RadioAudioHandlerBridge _handler = ref.watch(radioPlayerProvider);
 
   var _initialized = false;
 
   @override
   RadioState build() {
-    _stopper ??= _AppLifecycleStopper(_player);
-    ref.onDispose(() => _stopper?.dispose());
-
     final volumeProvider = ref.watch(audioPlayerVolumeProvider);
     final volume = volumeProvider.value ?? 1.0;
 
@@ -39,36 +31,13 @@ class RadioController extends _$RadioController {
     final processingState = playerStateProvider.value?.processingState;
 
     final isPlaying = (playerStateProvider.value?.playing ?? false) && processingState == ProcessingState.ready;
-    final isIdle = processingState == ProcessingState.idle;
-    final isLoading =
-        processingState == ProcessingState.loading || processingState == ProcessingState.buffering || isIdle;
-
-    if (isIdle) {
-      unawaited(_initPlayer());
-    }
+    final isLoading = processingState == ProcessingState.loading || processingState == ProcessingState.buffering;
 
     return RadioState(isPlaying: isPlaying, isLoading: isLoading, volume: volume);
   }
 
-  Future<void> _initPlayer() async {
-    final assetPath = Assets.png.radioLuz.radioLuzLogo.path;
-    final artUri = await assetToFileUri(assetPath);
-
-    final audioSource = AudioSource.uri(
-      Uri.parse(Env.radioLuzStreamUrl),
-      tag: MediaItem(id: "1", title: _audioPlayerStrings.title, album: _audioPlayerStrings.album, artUri: artUri),
-    );
-
-    await _player.setAudioSource(audioSource);
-    await _player.setCanUseNetworkResourcesForLiveStreamingWhilePaused(true);
-
-    final volume = ref.read(audioPlayerVolumeProvider).value ?? 1.0;
-    await _player.setVolume(volume);
-  }
-
   void init(AudioPlayerStrings audioPlayerStrings) {
     if (_initialized) return;
-    _audioPlayerStrings = audioPlayerStrings;
     _initialized = true;
   }
 
@@ -84,48 +53,24 @@ class RadioController extends _$RadioController {
     return file.uri;
   }
 
+  ///pre-loads the audio stream to reduce startup delay
+  Future<void> preload() async {
+    await _handler.preload();
+  }
+
   Future<void> play() async {
     const durationGuard = Duration(milliseconds: 200);
-    final duration = _player.bufferedPosition;
-    await _player.seek(duration > durationGuard ? duration - durationGuard : Duration.zero);
+    final duration = _handler.bufferedPosition;
+    await _handler.seek(duration > durationGuard ? duration - durationGuard : Duration.zero);
 
-    await _player.play();
+    await _handler.play();
   }
 
   Future<void> pause() async {
-    await _player.pause();
-  }
-
-  Future<void> stop() async {
-    await _player.stop();
+    await _handler.pause();
   }
 
   Future<void> setVolume(double newVolume) async {
-    await _player.setVolume(newVolume);
-  }
-}
-
-// responsible for stoping the player when the user swipes away the app (force kill) on Android
-// however, the app is still running altough its not visible to the user
-// when the user opens the app again it will have the same state as when it was closed
-// if the user does not use the app for some time, the android will kill the process
-class _AppLifecycleStopper with WidgetsBindingObserver {
-  final AudioPlayer player;
-
-  _AppLifecycleStopper(this.player) {
-    WidgetsBinding.instance.addObserver(this);
-  }
-
-  void dispose() {
-    WidgetsBinding.instance.removeObserver(this);
-  }
-
-  @override
-  Future<void> didChangeAppLifecycleState(AppLifecycleState state) async {
-    if (state == AppLifecycleState.detached) {
-      if (player.playing) {
-        await player.stop();
-      }
-    }
+    await _handler.setVolume(newVolume);
   }
 }
diff --git a/lib/features/radio_luz/service/radio_player_provider.dart b/lib/features/radio_luz/service/radio_player_provider.dart
index 1b5d5a17e..b1f5846a1 100644
--- a/lib/features/radio_luz/service/radio_player_provider.dart
+++ b/lib/features/radio_luz/service/radio_player_provider.dart
@@ -1,11 +1,14 @@
-import "package:just_audio/just_audio.dart";
 import "package:riverpod_annotation/riverpod_annotation.dart";
 
+import "radio_audio_handler.dart";
+
 part "radio_player_provider.g.dart";
 
+//we only need to define the provider here
+//the actual implementation is in radio_audio_handler.dart
+//the player is assigned in main.dart so it starts even before app is fully loaded
+
 @Riverpod(keepAlive: true)
-AudioPlayer radioPlayer(Ref ref) {
-  final player = AudioPlayer();
-  ref.onDispose(player.dispose);
-  return player;
+RadioAudioHandlerBridge radioPlayer(Ref ref) {
+  throw UnimplementedError("radioPlayer provider must be overridden in main.dart");
 }
diff --git a/lib/main.dart b/lib/main.dart
index 414b2e159..45c1ca289 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -1,12 +1,12 @@
 import "dart:async";
 import "dart:io";
 
+import "package:audio_service/audio_service.dart";
 import "package:clarity_flutter/clarity_flutter.dart";
 import "package:flutter/foundation.dart";
 import "package:flutter/material.dart";
 import "package:flutter/services.dart";
 import "package:hooks_riverpod/hooks_riverpod.dart";
-import "package:just_audio_background/just_audio_background.dart";
 import "package:sentry_flutter/sentry_flutter.dart";
 import "package:solvro_translator_core/solvro_translator_core.dart";
 import "package:wiredash/wiredash.dart";
@@ -19,6 +19,8 @@ import "features/in_app_review/presentation/in_app_review.dart";
 import "features/navigator/app_router.dart";
 import "features/navigator/hooks/use_deeplink_listener.dart";
 import "features/navigator/navigation_stack.dart";
+import "features/radio_luz/service/radio_audio_handler.dart";
+import "features/radio_luz/service/radio_player_provider.dart";
 import "features/parkings/parkings_view/repository/parkings_repository.dart";
 import "features/splash_screen/splash_screen.dart";
 import "features/splash_screen/splash_screen_controller.dart";
@@ -48,20 +50,17 @@ Future<void> main() async {
 Future<void> runToPWR() async {
   final data = await PlatformAssetBundle().load(Assets.certs.przewodnikPwrEduPl);
   SecurityContext.defaultContext.setTrustedCertificatesBytes(data.buffer.asUint8List());
-  try {
-    await JustAudioBackground.init(
+  // await setupParkingWidgetsWorkManager();
+
+  final config = ClarityConfig(projectId: Env.clarityConfigId, logLevel: LogLevel.None);
+
+  final audioHandler = await AudioService.init(
+    builder: RadioAudioHandlerBridge.new,
+    config: const AudioServiceConfig(
       androidNotificationChannelId: "com.solvro.topwr.audio",
       androidNotificationChannelName: "Audio playback",
       androidNotificationOngoing: true,
-      showStopAction: false,
-    );
-  } on PlatformException catch (e, st) {
-    await Sentry.captureException(e, stackTrace: st);
-  }
-
-  final config = ClarityConfig(
-    projectId: Env.clarityConfigId,
-    logLevel: LogLevel.None, // Note: Use "LogLevel.Verbose" value while testing to debug initialization issues.
+    ),
   );
 
   return runApp(
@@ -74,6 +73,7 @@ Future<void> runToPWR() async {
           if (retryCount > 5) return null;
           return Duration(seconds: retryCount * 2);
         },
+        overrides: [radioPlayerProvider.overrideWithValue(audioHandler)],
         child: const SplashScreen(child: MyApp()),
       ),
     ),
diff --git a/linux/flutter/generated_plugin_registrant.cc b/linux/flutter/generated_plugin_registrant.cc
index 964fa0378..6eaefceb3 100644
--- a/linux/flutter/generated_plugin_registrant.cc
+++ b/linux/flutter/generated_plugin_registrant.cc
@@ -6,16 +6,12 @@
 
 #include "generated_plugin_registrant.h"
 
-#include <audioplayers_linux/audioplayers_linux_plugin.h>
 #include <gtk/gtk_plugin.h>
 #include <sentry_flutter/sentry_flutter_plugin.h>
 #include <sqlite3_flutter_libs/sqlite3_flutter_libs_plugin.h>
 #include <url_launcher_linux/url_launcher_plugin.h>
 
 void fl_register_plugins(FlPluginRegistry* registry) {
-  g_autoptr(FlPluginRegistrar) audioplayers_linux_registrar =
-      fl_plugin_registry_get_registrar_for_plugin(registry, "AudioplayersLinuxPlugin");
-  audioplayers_linux_plugin_register_with_registrar(audioplayers_linux_registrar);
   g_autoptr(FlPluginRegistrar) gtk_registrar =
       fl_plugin_registry_get_registrar_for_plugin(registry, "GtkPlugin");
   gtk_plugin_register_with_registrar(gtk_registrar);
diff --git a/linux/flutter/generated_plugins.cmake b/linux/flutter/generated_plugins.cmake
index 4c84e8457..3b42d6dc3 100644
--- a/linux/flutter/generated_plugins.cmake
+++ b/linux/flutter/generated_plugins.cmake
@@ -3,7 +3,6 @@
 #
 
 list(APPEND FLUTTER_PLUGIN_LIST
-  audioplayers_linux
   gtk
   sentry_flutter
   sqlite3_flutter_libs
diff --git a/pubspec.yaml b/pubspec.yaml
index c3b4b33c0..80d9e03b0 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -118,12 +118,9 @@ dependencies:
   crypto: ^3.0.7
 
   #Audio
-  just_audio: ^0.10.5
-  just_audio_background:
-    git:
-      url: https://github.com/24bartixx/just_audio.git
-      path: just_audio_background
-      ref: a7cf5a2e2a1bcf5f1c7e37e7047d02e7a88e1453
+  just_audio: ^0.9.36
+  audio_service: ^0.18.18
+  audio_session: ^0.1.21
 
   #Other
   in_app_update: ^4.2.5
@@ -134,7 +131,6 @@ dependencies:
   separate: ^1.0.3
   wiredash: ^2.6.0
   flutter_hooks: ^0.21.3
-  audioplayers: ^6.5.1
   sentry_flutter: ^9.9.1
 
   #Solvro packages
diff --git a/windows/flutter/generated_plugin_registrant.cc b/windows/flutter/generated_plugin_registrant.cc
index 31ad26d07..5eb881f08 100644
--- a/windows/flutter/generated_plugin_registrant.cc
+++ b/windows/flutter/generated_plugin_registrant.cc
@@ -7,7 +7,6 @@
 #include "generated_plugin_registrant.h"
 
 #include <app_links/app_links_plugin_c_api.h>
-#include <audioplayers_windows/audioplayers_windows_plugin.h>
 #include <connectivity_plus/connectivity_plus_windows_plugin.h>
 #include <firebase_core/firebase_core_plugin_c_api.h>
 #include <geolocator_windows/geolocator_windows.h>
@@ -19,8 +18,6 @@
 void RegisterPlugins(flutter::PluginRegistry* registry) {
   AppLinksPluginCApiRegisterWithRegistrar(
       registry->GetRegistrarForPlugin("AppLinksPluginCApi"));
-  AudioplayersWindowsPluginRegisterWithRegistrar(
-      registry->GetRegistrarForPlugin("AudioplayersWindowsPlugin"));
   ConnectivityPlusWindowsPluginRegisterWithRegistrar(
       registry->GetRegistrarForPlugin("ConnectivityPlusWindowsPlugin"));
   FirebaseCorePluginCApiRegisterWithRegistrar(
diff --git a/windows/flutter/generated_plugins.cmake b/windows/flutter/generated_plugins.cmake
index a38bf6341..6b711de13 100644
--- a/windows/flutter/generated_plugins.cmake
+++ b/windows/flutter/generated_plugins.cmake
@@ -4,7 +4,6 @@
 
 list(APPEND FLUTTER_PLUGIN_LIST
   app_links
-  audioplayers_windows
   connectivity_plus
   firebase_core
   geolocator_windows