在Android应用的所有活动中播放背景音乐

Question

我花了大约20个小时，但我的问题仍然存在。我正在创建一个具有多个活动（mainMenu，aboutUs，setting）的Android应用程序。我按照下面链接中最佳答案的方法进行操作，效果不错。 Music played using asyncTask isn't stopping by using cancel 当我运行我的应用程序时（我的代码在mainActivity中），音乐开始播放，并且在导航到其他活动时不会停止。这很好。但是，我在setting_activity活动中放置了一个ToggleButton，希望该按钮可以启动和停止这首音乐。现在我的问题是如何从setting_activity停止和/或重新启动音乐？

在另一个解决方案中： 我创建了一个名为MusicManager的类，并调用其start和stop方法。 但这也存在一些问题：

1. Music started in mainMenu_activity but only play for about 15 seconds and then stopped.

2. I could not stop the music from another activities.At this time i play music in mainMenua_ctivity as this line codes :

   MusicManager mm = new MusicManager(this, R.raw.background_sound);
   mm.play();
   

我该如何停止播放音乐？ 3. 当我切换到其他活动时，音乐停止了。

public class MusicManager implements OnPreparedListener {

    static MediaPlayer mPlayer;
    Context context;
    private int mySoundId;

    public MusicManager(Context ctx, int musicID) {
        context = ctx;
        mySoundId = musicID;
        mPlayer = MediaPlayer.create(context, mySoundId);
        mPlayer.setOnPreparedListener(this);
    }

    public void play() {
        mPlayer = MediaPlayer.create(context, mySoundId);

    }

    public void stop() {
        mPlayer.stop();
        mPlayer.release();
    }

    @Override
    public void onPrepared(MediaPlayer player) {
        player.start();
        mPlayer.setLooping(true);
        mPlayer.setVolume(25, 25);

    }

}

最后，我希望在所有活动中播放背景音乐而不停止/开始音乐。 我该怎么做？

- Mojtaba

Answer 1

你可以将音乐播放器放在一个服务中。这样就使它与活动无关，你仍然可以通过意图来控制播放。

以下是一些关于此的代码示例：https://dev59.com/3msy5IYBdhLWcg3w8Slc#8209975 下面的代码由Synxmax在StackOverflow上编写，并在上面的链接中介绍：

public class BackgroundSoundService extends Service {
    private static final String TAG = null;
    MediaPlayer player;
    public IBinder onBind(Intent arg0) {

        return null;
    }
    @Override
    public void onCreate() {
        super.onCreate();
        player = MediaPlayer.create(this, R.raw.idil);
        player.setLooping(true); // Set looping
        player.setVolume(100,100);

    }
    public int onStartCommand(Intent intent, int flags, int startId) {
        player.start();
        return 1;
    }

    public void onStart(Intent intent, int startId) {
        // TO DO
    }
    public IBinder onUnBind(Intent arg0) {
        // TO DO Auto-generated method
        return null;
    }

    public void onStop() {

    }
    public void onPause() {

    }
    @Override
    public void onDestroy() {
        player.stop();
        player.release();
    }

    @Override
    public void onLowMemory() {

    }
}

- Simon Cedergren Malmqvist

---

我创建了一个与上述类相同的类，并在main_activity类的onCreate()中编写了Intent svc = new Intent(this, BackgroundSoundService.class); startService(svc);，但我的音乐没有播放。 - Mojtaba

真的被卡住了！难以置信一个服务不能从其他活动中控制。 - Araib karim

看看Jake Wharton所开发的Otto。如果你非常需要，你可以利用它来控制服务，但更好的做法是重新考虑你的设计。 - Simon Cedergren Malmqvist

@anand 为什么你想从活动中访问服务方法？这是不可能的。我想你是想从活动中启动/停止歌曲。在这种情况下，你应该使用意图并处理它们。 - Sourav Kannantha B

Android文档建议不要为此场景创建服务：“如果您必须在主线程之外执行工作，但仅在用户与您的应用程序交互时执行，请改为在另一个应用程序组件的上下文中创建新线程。例如，如果您想播放一些音乐，但仅在您的活动正在运行时，请在onCreate()中创建一个线程，在onStart()中开始运行它，并在onStop()中停止它。” https://developer.android.com/guide/components/services#Choosing-service-thread - Florian Wicher

Answer 2

 @Override
    public void onCreate (){
      super.onCreate();

       Player = MediaPlayer.create(this, R.raw.jingle);
       mPlayer.setOnErrorListener(this);

       if(mPlayer!= null)
        {
            mPlayer.setLooping(true);
            mPlayer.setVolume(100,100);
        }


        mPlayer.setOnErrorListener(new OnErrorListener() {

      public boolean onError(MediaPlayer mp, int what, int
          extra){

            onError(mPlayer, what, extra);
            return true;
        }
          });
    }

- mahesh talaviya

---

虽然这段代码可能回答了问题，但您仍然可以考虑添加一些解释性的句子，因为这会增加其他用户对您答案的价值。 - MBT

Answer 3

public class serv extends Service{

    MediaPlayer mp;
    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return null;
    }
    public void onCreate()
    {   
        mp = MediaPlayer.create(this, R.raw.b);
        mp.setLooping(false);
    }
    public void onDestroy()
    {       
        mp.stop();
    }
    public void onStart(Intent intent,int startid){

        Log.d(tag, "On start");
        mp.start();
    }
}

- mahesh talaviya

Answer 4

这是我的解决方案：

1- 首先在raw文件夹中添加一个音乐文件（在我的情况下是coffee.mp3）。

2- 创建一个名为BackgroundSoundService的类，它扩展了Service：

public class BackgroundSoundService extends Service {

MediaPlayer mediaPlayer;

@Nullable
@Override
public IBinder onBind(Intent intent) {
    return null;
}
@Override
public void onCreate() {
    super.onCreate();
    mediaPlayer = MediaPlayer.create(this, R.raw.coffee);
    mediaPlayer.setLooping(true); // Set looping
    mediaPlayer.setVolume(100, 100);
}
public int onStartCommand(Intent intent, int flags, int startId) {

    if (intent.getAction().equals("PLAY")) {
        if(mediaPlayer.isPlaying() == false) {
            mediaPlayer.start();
            Toast.makeText(getApplicationContext(), "Music Is Playing", Toast.LENGTH_SHORT).show();
           
        }
    }
    if (intent.getAction().equals("STOP")) {
        this.stopService(intent);
        Toast.makeText(getApplicationContext(), "Music Stopped",    Toast.LENGTH_SHORT).show();

    }
    
    return startId;
}
@Override
public void onDestroy() {
    mediaPlayer.stop();
    mediaPlayer.release();
}
@Override
public void onLowMemory() {
}
}

不要忘记在 Android manifest.xml 文件的应用程序标签中定义此服务：

<service android:name=".BackgroundSoundService" />

3- 对于您的活动中的播放按钮，请使用以下代码：

btnPlay.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            String action = "PLAY";
            Intent myService = new Intent(MainActivity.this, BackgroundSoundService.class);
            myService.setAction(action);
            startService(myService);
        }
    });

3- 对于您的活动中的停止按钮，请使用以下代码：

btnStop.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            String action = "STOP";
            Intent myService = new Intent(MainActivity.this, BackgroundSoundService.class);
            myService.setAction(action);
            startService(myService);
        }
    });

我创建了一个简单的安卓应用，包含两个活动和后台服务播放音乐。如果应用程序对用户不可见（例如用户按下主页按钮），该应用程序将暂停播放音乐。 您可以在我的 github 上查看更多详细信息。

- farhad.kargaran

Answer 5

前面的回答是正确的，不过你还需要在清单文件中添加该服务。

 <service android:enabled="true" android:name="BackgroundSoundService" />

- MNadi Grant

Answer 6

Simon的回答是正确的。我遇到了类似的问题，我的片段中有音乐播放器，我需要在单击按钮时返回到该UI。您的情况类似，但是您想控制回放而不是返回UI。以下是我为我的应用程序所做的。这会处理包括洗牌和重复功能在内的音频列表的回放。这也会在通知栏中显示媒体控件。

1. 使用以下代码创建服务MusicPlayerService：

public class MediaPlayerService extends Service implements MediaPlayer.OnCompletionListener,
            MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener, MediaPlayer.OnSeekCompleteListener,
            MediaPlayer.OnInfoListener, MediaPlayer.OnBufferingUpdateListener,
    
            AudioManager.OnAudioFocusChangeListener {
            
            
        public static final String ACTION_PLAY = "pkg_name.ACTION_PLAY";
        public static final String ACTION_PAUSE = "pkg_name.ACTION_PAUSE";
        public static final String ACTION_PREVIOUS = "pkg_name.ACTION_PREVIOUS";
        public static final String ACTION_NEXT = "pkg_name.ACTION_NEXT";
        public static final String ACTION_STOP = "pkg_name.ACTION_STOP";
    
        private MediaPlayer mediaPlayer;
    
        //MediaSession
        private MediaSessionManager mediaSessionManager;
        private MediaSessionCompat mediaSession;
        private MediaControllerCompat.TransportControls transportControls;
    
        //AudioPlayer notification ID
        private static final int NOTIFICATION_ID = 101;
    
        //Used to pause/resume MediaPlayer
        private int resumePosition;
    
        // Binder given to clients
        private final IBinder iBinder = new LocalBinder();
    
        //List of available Audio files
        private ArrayList<PlayableTrack> audioList;
        private int audioIndex = -1;
    
    
        //Handle incoming phone calls
        private boolean ongoingCall = false;
        private PhoneStateListener phoneStateListener;
        private TelephonyManager telephonyManager;
        private Bitmap albumArtBitmap;
        private boolean shuffle = false;
        private boolean repeat = false;
        private Random rand;
    
        /**
         * Service lifecycle methods
         */
        @Override
        public IBinder onBind(Intent intent) {
            return iBinder;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            // Perform one-time setup procedures
    
            // Manage incoming phone calls during playback.
            // Pause MediaPlayer on incoming call,
            // Resume on hangup.
            callStateListener();
            //ACTION_AUDIO_BECOMING_NOISY -- change in audio outputs -- BroadcastReceiver
            registerBecomingNoisyReceiver();
            //Listen for new Audio to play -- BroadcastReceiver
            register_playNewAudio();
            rand = new Random();
            StorageUtil storage = new StorageUtil(getApplicationContext());
            shuffle = storage.loadShuffleRepeat("Shuffle");
            repeat = storage.loadShuffleRepeat("Repeat");
        }
    
        //The system calls this method when an activity, requests the service be started
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            try {
    
                //Load data from SharedPreferences
                StorageUtil storage = new StorageUtil(getApplicationContext());
                audioList = storage.loadAudio();
                audioIndex = storage.loadAudioIndex();
    
                if (audioIndex != -1 && audioIndex < audioList.size()) {
                    //index is in a valid range
                    activeAudio = audioList.get(audioIndex);
                } else {
                    stopSelf();
                }
            } catch (NullPointerException e) {
                stopSelf();
            }
    
            if (mediaSessionManager == null) {
                try {
                    initMediaSession();
                    initMediaPlayer();
                } catch (RemoteException e) {
                    e.printStackTrace();
                    stopSelf();
                }
                buildNotification(PlaybackStatus.PLAYING);
            }
    
            //Handle Intent action from MediaSession.TransportControls
            handleIncomingActions(intent);
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Override
        public boolean onUnbind(Intent intent) {
            mediaSession.release();
            removeNotification();
            return super.onUnbind(intent);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            if (mediaPlayer != null) {
                stopMedia();
                mediaPlayer.reset();
            }
            //Disable the PhoneStateListener
            if (phoneStateListener != null) {
                telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE);
            }
    
            removeNotification();
    
            //unregister BroadcastReceivers
            unregisterReceiver(becomingNoisyReceiver);
            unregisterReceiver(playNewAudio);
    
            Picasso.get().cancelRequest(target);
        }
    
        /**
         * Service Binder
         */
        public class LocalBinder extends Binder {
            public MediaPlayerService getService() {
                // Return this instance of LocalService so clients can call public methods
                return MediaPlayerService.this;
            }
        }
    
    
        /**
         * MediaPlayer callback methods
         */
        @Override
        public void onBufferingUpdate(MediaPlayer mp, int percent) {
            //Invoked indicating buffering status of
            //a media resource being streamed over the network.
        }
    
        @Override
        public void onCompletion(MediaPlayer mp) {
            //Invoked when playback of a media source has completed.
            stopMedia();
        }
    
        @Override
        public boolean onError(MediaPlayer mp, int what, int extra) {
            //Invoked when there has been an error during an asynchronous operation
            switch (what) {
                case MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
                    Log.d("MediaPlayer Error", "MEDIA ERROR NOT VALID FOR PROGRESSIVE PLAYBACK " + extra);
                    break;
                case MediaPlayer.MEDIA_ERROR_SERVER_DIED:
                    Log.d("MediaPlayer Error", "MEDIA ERROR SERVER DIED " + extra);
                    break;
                case MediaPlayer.MEDIA_ERROR_UNKNOWN:
                    Log.d("MediaPlayer Error", "MEDIA ERROR UNKNOWN " + extra);
                    break;
            }
            return false;
        }
    
        @Override
        public void onPrepared(MediaPlayer mp) {
            //Invoked when the media source is ready for playback.
            playMedia();
        }
    
        @Override
        public void onAudioFocusChange(int focusState) {
    
            //Invoked when the audio focus of the system is updated.
            switch (focusState) {
                case AudioManager.AUDIOFOCUS_GAIN:
                    // resume playback
                    if (mediaPlayer == null) initMediaPlayer();
                    else if (!mediaPlayer.isPlaying()) mediaPlayer.start();
                    mediaPlayer.setVolume(1.0f, 1.0f);
                    break;
                case AudioManager.AUDIOFOCUS_LOSS:
                    // Lost focus for an unbounded amount of time: stop playback and release media player
                    if (mediaPlayer.isPlaying()) mediaPlayer.stop();
                    mediaPlayer.reset();
                    mediaPlayer = null;
                    break;
                case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
                    // Lost focus for a short time, but we have to stop
                    // playback. We don't release the media player because playback
                    // is likely to resume
                    if (mediaPlayer.isPlaying()) mediaPlayer.pause();
                    break;
                case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK:
                    // Lost focus for a short time, but it's ok to keep playing
                    // at an attenuated level
                    if (mediaPlayer.isPlaying()) mediaPlayer.setVolume(0.1f, 0.1f);
                    break;
            }
        }
    
        /**
         * MediaPlayer actions
         */
        private void initMediaPlayer() {
            if (mediaPlayer == null)
                mediaPlayer = new MediaPlayer();//new MediaPlayer instance
    
            //Set up MediaPlayer event listeners
            mediaPlayer.setOnCompletionListener(this);
            mediaPlayer.setOnErrorListener(this);
            mediaPlayer.setOnPreparedListener(this);
            mediaPlayer.setOnBufferingUpdateListener(this);
            mediaPlayer.setOnSeekCompleteListener(this);
            mediaPlayer.setOnInfoListener(this);
            //Reset so that the MediaPlayer is not pointing to another data source
            mediaPlayer.reset();
    
            mediaPlayer.setAudioAttributes(new AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_MEDIA)
                    .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                    .build());
            try {
                // Set the data source to the mediaFile location
                mediaPlayer.setDataSource(activeAudio.getFileLocation());
            } catch (IOException e) {
                e.printStackTrace();
                stopSelf();
            }
            mediaPlayer.prepareAsync();
        }
    
        public void playMedia() {
            if (!mediaPlayer.isPlaying()) {
                mediaPlayer.start();
            }
            buildNotification(PlaybackStatus.PLAYING);
            Intent intent = new Intent("PLAYBACK_STARTED");
            LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
        }
    
        private void stopMedia() {
            if (mediaPlayer == null) return;
            if (mediaPlayer.isPlaying()) {
                mediaPlayer.stop();
            }
        }
    
        public void pauseMedia() {
            if (mediaPlayer.isPlaying()) {
                mediaPlayer.pause();
                resumePosition = mediaPlayer.getCurrentPosition();
            }
            buildNotification(PlaybackStatus.PAUSED);
            Intent intent = new Intent("PLAYBACK_PAUSED");
            LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
        }
    
        private void resumeMedia() {
            if (!mediaPlayer.isPlaying()) {
                mediaPlayer.seekTo(resumePosition);
                mediaPlayer.start();
                buildNotification(PlaybackStatus.PLAYING);
                Intent intent = new Intent("PLAYBACK_STARTED");
                LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
            }
        }
    
        /**
         * ACTION_AUDIO_BECOMING_NOISY -- change in audio outputs
         */
        private BroadcastReceiver becomingNoisyReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                //pause audio on ACTION_AUDIO_BECOMING_NOISY
                pauseMedia();
                buildNotification(PlaybackStatus.PAUSED);
            }
        };
    
        private void registerBecomingNoisyReceiver() {
            //register after getting audio focus
            IntentFilter intentFilter = new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
            registerReceiver(becomingNoisyReceiver, intentFilter);
        }
    
        /**
         * Handle PhoneState changes
         */
        private void callStateListener() {
            // Get the telephony manager
            telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
            //Starting listening for PhoneState changes
            phoneStateListener = new PhoneStateListener() {
                @Override
                public void onCallStateChanged(int state, String incomingNumber) {
                    switch (state) {
                        //if at least one call exists or the phone is ringing
                        //pause the MediaPlayer
                        case TelephonyManager.CALL_STATE_OFFHOOK:
                        case TelephonyManager.CALL_STATE_RINGING:
                            if (mediaPlayer != null) {
                                pauseMedia();
                                ongoingCall = true;
                            }
                            break;
                        case TelephonyManager.CALL_STATE_IDLE:
                            // Phone idle. Start playing.
                            if (mediaPlayer != null) {
                                if (ongoingCall) {
                                    ongoingCall = false;
                                    resumeMedia();
                                }
                            }
                            break;
                    }
                }
            };
            // Register the listener with the telephony manager
            // Listen for changes to the device call state.
            telephonyManager.listen(phoneStateListener,
                    PhoneStateListener.LISTEN_CALL_STATE);
        }
            
        /**
         * MediaSession and Notification actions
         */
        private void initMediaSession() throws RemoteException {
            if (mediaSessionManager != null) return; //mediaSessionManager exists
    
            mediaSessionManager = (MediaSessionManager) getSystemService(Context.MEDIA_SESSION_SERVICE);
            // Create a new MediaSession
            mediaSession = new MediaSessionCompat(getApplicationContext(), "AudioPlayer");
            //Get MediaSessions transport controls
            transportControls = mediaSession.getController().getTransportControls();
            //set MediaSession -> ready to receive media commands
            mediaSession.setActive(true);
            //indicate that the MediaSession handles transport control commands
            // through its MediaSessionCompat.Callback.
            mediaSession.setFlags(MediaSessionCompat.FLAG_HANDLES_TRANSPORT_CONTROLS);
    
            //Set mediaSession's MetaData
            updateMetaData();
    
            // Attach Callback to receive MediaSession updates
            mediaSession.setCallback(new MediaSessionCompat.Callback() {
                // Implement callbacks
                @Override
                public void onPlay() {
                    super.onPlay();
                    resumeMedia();
                }
    
                @Override
                public void onPause() {
                    super.onPause();
                    pauseMedia();
                }
            });
        }
            
        private void updateMetaData() {
            fetchBitmapOfAlbum();
            // Update the current metadata
            mediaSession.setMetadata(new MediaMetadataCompat.Builder()
                    .putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, albumArtBitmap)
                    .putString(MediaMetadataCompat.METADATA_KEY_ARTIST, "")
                    .putString(MediaMetadataCompat.METADATA_KEY_ALBUM, activeAudio.getAlbumName())
                    .putString(MediaMetadataCompat.METADATA_KEY_TITLE, activeAudio.getTrackName())
                    .build());
        }
    
        private Target target = new Target() {
            @Override
            public void onBitmapLoaded(Bitmap bitmap, Picasso.LoadedFrom from) {
                albumArtBitmap = bitmap;
            }
    
            @Override
            public void onBitmapFailed(Exception e, Drawable errorDrawable) {
    
            }
    
            @Override
            public void onPrepareLoad(Drawable placeHolderDrawable) {
            }
        };
    
        private void fetchBitmapOfAlbum() {
            Picasso.get().load(activeAudio.getAlbumArt())
                    .placeholder(R.drawable.rotate_animation)
                    .error(R.drawable.ic_blank)
                    .into(target);
        }
        
        private void buildNotification(PlaybackStatus playbackStatus) {
           
            int notificationAction = android.R.drawable.ic_media_pause;//needs to be initialized
            PendingIntent play_pauseAction = null;
    
            //Build a new notification according to the current state of the MediaPlayer
            if (playbackStatus == PlaybackStatus.PLAYING) {
                notificationAction = android.R.drawable.ic_media_pause;
                //create the pause action
                play_pauseAction = playbackAction(1);
            } else if (playbackStatus == PlaybackStatus.PAUSED) {
                notificationAction = android.R.drawable.ic_media_play;
                //create the play action
                play_pauseAction = playbackAction(0);
            }
    
                fetchBitmapOfAlbum(); //replace with your own image
                String channelId = "";
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    channelId = "APP_MUSIC";
                }
                // Create a new Notification
                NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this, channelId)
                        // Hide the timestamp
                        .setShowWhen(false)
                        // Set the Notification style
                        .setStyle(new androidx.media.app.NotificationCompat.MediaStyle()
                                // Attach our MediaSession token
                                .setMediaSession(mediaSession.getSessionToken())
                                // Show our playback controls in the compat view
                                .setShowActionsInCompactView(0, 1, 2))
                        // Set the Notification color
                        .setColor(ContextCompat.getColor(this.getApplicationContext(), R.color.colorAccent))
                        // Set the large and small icons
                        .setLargeIcon(albumArtBitmap)
                        .setSmallIcon(R.drawable.ic_stat_notifications)
                        // Set Notification content information
                        .setContentText(activeAudio.getTrackName())
                        .setTicker(activeAudio.getAlbumName() + "-" + activeAudio.getTrackName())
                        .setOngoing(true)
                        .setContentTitle(activeAudio.getAlbumName())
                        .setContentInfo(activeAudio.getTrackName())
                        // Add playback actions
                        .addAction(notificationAction, "pause", play_pauseAction)
        
                ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE)).notify(NOTIFICATION_ID, notificationBuilder.build());
        }
            
            
        private PendingIntent playbackAction(int actionNumber) {
            Intent playbackAction = new Intent(this, MediaPlayerService.class);
            switch (actionNumber) {
                case 0:
                    // Play
                    playbackAction.setAction(ACTION_PLAY);
                    return PendingIntent.getService(this, actionNumber, playbackAction, 0);
                case 1:
                    // Pause
                    playbackAction.setAction(ACTION_PAUSE);
                    return PendingIntent.getService(this, actionNumber, playbackAction, 0);
                default:
                    break;
            }
            return null;
        }
    
        private void removeNotification() {
            NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            notificationManager.cancel(NOTIFICATION_ID);
        }
    
        private void handleIncomingActions(Intent playbackAction) {
            if (playbackAction == null || playbackAction.getAction() == null) return;
    
            String actionString = playbackAction.getAction();
            if (actionString.equalsIgnoreCase(ACTION_PLAY)) {
                transportControls.play();
            } else if (actionString.equalsIgnoreCase(ACTION_PAUSE)) {
                transportControls.pause();
            } 
        }        
        /**
         * Play new Audio
         */
        private BroadcastReceiver playNewAudio = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
    
                //Get the new media index form SharedPreferences
                audioIndex = new StorageUtil(getApplicationContext()).loadAudioIndex();
                if (audioIndex != -1 && audioIndex < audioList.size()) {
                    //index is in a valid range
                    activeAudio = audioList.get(audioIndex);
                } else {
                    stopSelf();
                }
    
                //A PLAY_NEW_AUDIO action received
                //reset mediaPlayer to play the new Audio
                stopMedia();
                mediaPlayer.reset();
                initMediaPlayer();
                updateMetaData();
                buildNotification(PlaybackStatus.PLAYING);
            }
        };
    
        private void register_playNewAudio() {
            //Register playNewMedia receiver
            IntentFilter filter = new IntentFilter(MainActivity.Broadcast_PLAY_NEW_AUDIO);
            registerReceiver(playNewAudio, filter);
        }
        
        public boolean isPlaying(){
            return mediaPlayer.isPlaying();
        }
    
        public void setShuffle(){
            if(shuffle) shuffle=false;
            else shuffle=true;
            StorageUtil storage = new StorageUtil(getApplicationContext());
            storage.storeShuffleRepeat("Shuffle", shuffle);
        }
    
        public void setRepeat(){
            if(repeat) repeat=false;
            else repeat=true;
            StorageUtil storage = new StorageUtil(getApplicationContext());
            storage.storeShuffleRepeat("Repeat", repeat);
        }
    }

将该服务添加到您的清单中。

<service android:name=".service.MediaPlayerService" />

在MainActivity中绑定服务并声明调用服务的方法。

public class MainActivity {
    private MediaPlayerService player;
    boolean serviceBound = false;
    public static final String Broadcast_PLAY_NEW_AUDIO = "pkg_name.PlayNewAudio";
    //Binding this Client to the AudioPlayer Service
    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance
            MediaPlayerService.LocalBinder binder = (MediaPlayerService.LocalBinder) service;
            player = binder.getService();
            serviceBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            serviceBound = false;
        }
    };

    // Call this method to play track
    public void playAudio(int audioIndex, ArrayList<PlayableTrack> updatedList) {
        //Check is service is active
        audioList = updatedList;
        if (!serviceBound) {    
            Intent playerIntent = new Intent(this, MediaPlayerService.class);
            startService(playerIntent);
            bindService(playerIntent, serviceConnection, Context.BIND_AUTO_CREATE);
        } else {   
            //Service is active
            //Send a broadcast to the service -> PLAY_NEW_AUDIO
            Intent broadcastIntent = new Intent(Broadcast_PLAY_NEW_AUDIO);
            sendBroadcast(broadcastIntent);
        }

    }
    // Additional methods for control
    public void start() {
        player.playMedia();
    }
    public void pause() {
        player.pauseMedia();
    }
    public boolean isPlaying() {
        if (player != null && serviceBound) {
            return player.isPlaying();
        }
        return false;
    }
}

- Deepak Dhamuria

Answer 7

您可以使用SharedPrefences保存一个Boolean，并在每次更改设置后重新启动应用程序，并检查您在设置中保存的Boolean。

If (your Boolean ==true) mediaplayer.start()

- KG-Amse