Music Notification and SoundLoader for Audio playback management

[Fector101]

Usage sample

from kivy.app import App
from kivy.uix.label import Label
from kivy.clock import Clock
import traceback
from android_notify.media.music.helper import requestAllFilesAccess,SoundLoader
from android_notify.media.music import MusicNotification


class MusicApp(App):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.sound = None
        self.music_path = None
        self.notification = None

    def build(self):
        self.music_path = "/storage/emulated/0/Music/test.mp3"
        self.notification = MusicNotification(
            play_music=self.play_music,
            pause_music=self.pause_music,
            seek_music=self.seek_music,
            next_music=self.next_music,
            prev_music=self.prev_music,
        )

        try:
            requestAllFilesAccess()
        except Exception as e:
            print("Error requestAllFilesAccess --> ", e)
            traceback.print_exc()

        # Initialize Android MediaPlayer asynchronously
        self.sound = SoundLoader.load(self.music_path, self.on_audio_ready)
        self.sound.loop = True
        # Schedule periodic position updates (every 1 second)
        Clock.schedule_interval(self.update_notification, 1)
        return Label(text="Music Notification Active")


    def update_notification(self, _):  # type: ignore
        """Periodic callback (every ~1s) - lightweight position update only."""
        pos = self.sound.get_pos()
        self.notification.updateProgressBar(int(pos * 1000), self.sound.state == 'play')

    def on_audio_ready(self):
        """Start playback."""
        self.play_music()
        self._push_notification(self.sound.get_pos())

    def _push_notification(self, pos):
        """Rebuild the full notification (heavy operation)."""
        length = self.sound.length
        print(f"notif: pos={pos:.1f}s  playing={self.sound.state == 'play'}")
        self.notification.build_notification(
            title="My Song",
            artist="Kivy Artist",
            is_playing=self.sound.state == 'play',
            current_ms=int(pos * 1000),
            duration_ms=int(length * 1000)
        )
        self.notification.setLargeIcon(music_path=self.music_path)

    def play_music(self):
        """Resume playback."""
        self.sound.play()

    def pause_music(self):
        """Pause playback."""
        self.sound.pause()

    def seek_music(self, sec):
        """Seek to a position (sec = seconds from start)."""
        self.sound.seek(sec)
        pos = self.sound.get_pos()
        self._push_notification(pos)

    def on_stop(self):
        """Clean up when the app closes."""
        self.notification.release()
        self.sound.stop()
        self.sound.unload()

    @staticmethod
    def next_music():
        print("Next track (stub)")

    @staticmethod
    def prev_music():
        print("Previous track (stub)")


if __name__ == "__main__":
    MusicApp().run()

point to java file folder

# buildozer.spec
package.name = myapp
package.domain = org.test
android.add_src = ./src

paste as-is in java directory

• only change first line to your package.domain.package.name

// Place inside: ./src/MyMediaCallback.java

package org.test.myapp;

import android.media.session.MediaSession;

public class MyMediaCallback extends MediaSession.Callback {

    public interface Listener {
        void onPlay();
        void onPause();
        void onSeekTo(long pos);
        void onSkipToNext();
        void onSkipToPrevious();
    }

    private Listener listener;

    public MyMediaCallback(Listener listener) {
        this.listener = listener;
    }

    @Override
    public void onPlay() {
        if (listener != null) {
            listener.onPlay();
        }
    }

    @Override
    public void onPause() {
        if (listener != null) {
            listener.onPause();
        }
    }

    @Override
    public void onSeekTo(long pos) {
        if (listener != null) {
            listener.onSeekTo(pos);
        }
    }

    @Override
    public void onSkipToNext() {
        if (listener != null) {
            listener.onSkipToNext();
        }
    }

    @Override
    public void onSkipToPrevious() {
        if (listener != null) {
            listener.onSkipToPrevious();
        }
    }
}

[Fector101]

Need better APIs and handle seek updates internally

self.notification = MusicNotification(
            on_play=self.play_music,
            on_pause=self.pause_music,
            on_seek=self.seek_music,       # receives seconds (float)
            on_next=self.next_music,
            on_prev=self.prev_music,
            auto_update_interval=1.0,      # drives the Clock internally
        )

[Fector101]

AudioManager and MusicNotification should be independent, methods like when music time stamp changes should cover from AudioManager

[Fector101]

Music Notifications — V1 Usage

V1 separates playback from the Android notification.

• AudioManager manages one audio file.
• MusicNotification represents and controls the currently bound audio.
• The application owns playlist or queue logic.
• The notification observes playback state instead of maintaining its own copy.

Basic Usage

from android_notify import AudioManager, MusicNotification

audio = AudioManager("music/song.mp3")

notification = MusicNotification(
    title="My Song",
    artist="Kivy Artist",
)

notification.bind(audio)

audio.play()

Once bound, the notification follows the audio manager's playback state.

AudioManager

AudioManager is responsible for a single audio file:

audio = AudioManager("music/song.mp3")

audio.play()
audio.pause()
audio.seek(30)
audio.stop()

It owns playback state such as:

audio.position
audio.duration

It does not manage playlists or decide what track comes next.

MusicNotification

Create the notification independently:

notification = MusicNotification(
    title="My Song",
    artist="Kivy Artist",
)

Then bind it to an audio manager:

notification.bind(audio)

The notification becomes the Android control surface for that audio.

Playback Controls

Application code controls playback through AudioManager:

audio.play()
audio.pause()
audio.seek(60)

Likewise, Android notification controls should ultimately operate on the bound
AudioManager.

The application should not need to manually synchronize the notification after
every play, pause, seek, or position change.

Next and Previous

AudioManager manages one file, so it does not provide next() or
previous().

Those actions belong to the application or playlist layer.

The notification can expose callbacks for these actions:

def play_next():
    # Application decides which track comes next.
    ...


def play_previous():
    # Application decides which track comes before the current track.
    ...


notification = MusicNotification(
    title="My Song",
    artist="Kivy Artist",
    on_next=play_next,
    on_previous=play_previous,
)

notification.bind(audio)

When the user presses Next:

Android notification
        ↓
MusicNotification
        ↓
on_next()
        ↓
Application / Playlist
        ↓
Create AudioManager for the next file
        ↓
notification.bind(new_audio)

For example:

def play_next():
    global audio

    audio.stop()
    audio = AudioManager("music/song2.mp3")

    notification.bind(audio)
    audio.play()

The same pattern applies to Previous.

This keeps responsibilities separate:

• AudioManager — manages one audio file and its playback state.
• MusicNotification — displays and controls the current media.
• Application / playlist — decides what Next and Previous mean.

Track Information

Track information belongs to the current media represented by the notification.

For example:

notification = MusicNotification(
    title="My Song",
    artist="Kivy Artist",
)

When the application changes tracks, it can create/bind a new AudioManager and
update the notification's track information.

The notification should not need to know how the application chooses its tracks.

Position and Progress

Playback position belongs to AudioManager.

The notification uses the audio manager's state to display progress.

Application code should not need to repeatedly do this:

notification.update_progress(audio.position)

Instead, the notification observes position/state updates from the bound audio
manager.

Keeping the Components Independent

AudioManager should not depend on MusicNotification.

This should work without a notification:

audio = AudioManager("music/song.mp3")
audio.play()

Likewise, a notification can exist before it is bound:

notification = MusicNotification(
    title="My Song",
    artist="Kivy Artist",
)

The connection is explicit:

notification.bind(audio)

This keeps the two components reusable and independent.

Recommended Application Structure

A simple application can look like:

from android_notify import AudioManager, MusicNotification


class Player:
    def __init__(self):
        self.audio = AudioManager("music/song.mp3")

        self.notification = MusicNotification(
            title="My Song",
            artist="Kivy Artist",
            on_next=self.play_next,
            on_previous=self.play_previous,
        )

        self.notification.bind(self.audio)

    def play(self):
        self.audio.play()

    def pause(self):
        self.audio.pause()

    def seek(self, position):
        self.audio.seek(position)

    def play_next(self):
        # Application / playlist chooses the next file.
        self.audio.stop()
        self.audio = AudioManager("music/song2.mp3")
        self.notification.bind(self.audio)
        self.audio.play()

    def play_previous(self):
        # Application / playlist chooses the previous file.
        ...

The important part is that playlist logic stays outside AudioManager.

V1 Design Principle

AudioManager owns one file and its playback state. MusicNotification
observes and controls the bound audio source. The application owns playlist
and track-selection logic.

Avoid duplicating playback state between AudioManager and
MusicNotification.