Question

我正在尝试学习Android服务，但遇到一些麻烦。

我有一个简单的服务，MediaPlayer可以播放来自互联网的一些流。我将服务绑定到MainActivity，在服务上设置URL并开始播放流。这很好用。该服务立即成为带有通知的前台服务。我可以从MainActivity成功更改URL，然后开始新的流。但是，我想实现一些事情。

当MainActivity对用户可见时，我不想要通知，只有当用户按下主页按钮或后退按钮时，我希望服务开始在前台播放。当用户点击通知时，我希望MainActivity重新打开，并且流不会中断。这是否意味着我的MainActivity永远不会被销毁？

截至目前，当我按下主页按钮时，流继续播放并单击通知使MainActivity重新创建服务（流停止并再次开始播放）。我实际上希望服务永远不会停止播放，除非用户通过在多任务处理窗口中轻扫它来杀死应用程序（就像Spotify一样）。

我的服务代码如下：

public class StreamService extends Service implements
    MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener,
    MediaPlayer.OnCompletionListener {

    private MediaPlayer player;
    private final IBinder musicBind = new StreamBinder();
    private StreamInfo mCurrentStream;
    private static final int NOTIFY_ID = 1;

    public void onCreate() {
        super.onCreate();
        initMusicPlayer();
    }

    public void initMusicPlayer() {
        player = new MediaPlayer();
        player.setWakeMode(getApplicationContext(),
            PowerManager.PARTIAL_WAKE_LOCK);
        player.setAudioStreamType(AudioManager.STREAM_MUSIC);
        player.setOnPreparedListener(this);
        player.setOnCompletionListener(this);
        player.setOnErrorListener(this);
    }

    public class StreamBinder extends Binder {
        public StreamService getService() {
            return StreamService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return musicBind;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        player.stop();
        player.release();
        return false;
    }

    public void playStream() {
        player.reset();
        try {
            player.setDataSource(this, mCurrentStream.getUrl());
        } catch (Exception e) {
            Log.e("MUSIC SERVICE", "Error setting data source", e);
        }
        player.prepareAsync();
    }

    public void setStream(StreamInfo stream) {
        mCurrentStream = stream;
    }

    @Override
    public void onCompletion(MediaPlayer mp) {
    }

    @Override
    public boolean onError(MediaPlayer mp, int what, int extra) {
        mp.reset();
        return false;
    }

    @Override
    public void onPrepared(MediaPlayer mp) {
        mp.start();
        Intent notIntent = new Intent(this, MainActivity.class);
        notIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendInt = PendingIntent.getActivity(this, 0,
            notIntent, PendingIntent.FLAG_UPDATE_CURRENT);

        Notification.Builder builder = new Notification.Builder(this);

        builder.setContentIntent(pendInt)
            .setSmallIcon(R.drawable.ic_action_navigation_chevron_right)
            .setTicker(mCurrentStream.getTitle())
            .setOngoing(true)
            .setContentTitle("Playing")
            .setContentText(mCurrentStream.getTitle());
        Notification not = builder.build();
        startForeground(NOTIFY_ID, not);
    }

    @Override
    public void onDestroy() {
        stopForeground(true);
    }
}

我的MainActivity：

public class MainActivity extends AppCompatActivity implements ServiceConnection {

    private static final String TAG = MainActivity.class.getSimpleName();

    private StreamService mStreamService;
    private boolean musicBound = false;
    private Intent playIntent;

    @Override
    protected void onStart() {
        super.onStart();
        if (playIntent == null) {
            playIntent = new Intent(this, StreamService.class);
            bindService(playIntent, this, MainActivity.BIND_AUTO_CREATE);
            startService(playIntent);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startStreaming();
    }


    private void startStreaming() {
        mStreamService.setStream(getSelectedStream());
        mStreamService.playStream();
    }

    @Override
    protected void onDestroy() {
        stopService(playIntent);
        mStreamService = null;
        super.onDestroy();
    }

    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        StreamService.StreamBinder binder = (StreamService.StreamBinder) service;
        mStreamService = binder.getService();
        musicBound = true;
        startStreaming();
    }

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

    public StreamInfo getSelectedStream() {
        //Returns some stream from a widget
    }
}

当然，我的MainActivity中有一个带有监听器的小部件，当选择更改时，会调用startStreaming()方法。

有人能指出我正确的方向吗？

Answer 1

当MainActivity可见时，我不想要通知用户，只有当用户按下我想要的主页按钮或后退按钮时开始在前台播放的服务。

在您的服务中保留一个布尔标志，以指示是否绑定了某些内容。在显示通知之前检查标志。例如：

@Override
public IBinder onBind(Intent intent) {
    mBound = true;
    hideNotifications();
    return musicBind;
}

@Override
public void onRebind(Intent intent) {
    mBound = true;
    hideNotifications();
}

用户点击时在通知上我希望MainActivity重新打开和流不间断。这是否意味着我的MainActivity永远不会被销毁？

您需要取消绑定您的活动onStop()。

截至目前，当我按下主页按钮时，流继续播放单击通知使MainActivity重新创建服务（流停止并再次开始播放）。我其实想要的服务永不停止播放，除非用户通过滑动杀死应用程序它在多任务处理窗口中（就像Spotify一样）。

onStart()您的Activity检查服务是否正在运行并重新绑定到它而不是重新创建它。如果它没有运行 - 创建并绑定。

绑定服务的活动生命周期

1 个答案: