android 锁屏音乐控制

1.是否有音乐应用播放音乐的广播监听

// 注册音乐播放的广播
IntentFilter mFilter = new IntentFilter();
mFilter.addAction("com.android.music.playstatechanged");
mFilter.addAction("com.android.music.metachanged");
mFilter.addAction("com.android.music.queuechanged");
mFilter.addAction("com.android.music.playbackcomplete");
mContext.registerReceiver(mMusicBroadcastReceiver, mFilter);

* 音乐播放广播

获取音乐控制权需要权限
*/<uses-permission android:name="android.permission.MEDIA_CONTENT_CONTROL" />

public class MusicBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
LogUtil.d(TAG, "MusicBroadcastReceiver-->" + intent.getAction());
MusicInfo.setArtistName(intent.getStringExtra("artist"));
MusicInfo.setMusicName(intent.getStringExtra("track"));
MusicInfo.setPlaying(intent.getBooleanExtra("playing", false));

LogUtil.d(TAG, "artistName-->" + MusicInfo.getArtistName());
LogUtil.d(TAG, "musicName-->" + MusicInfo.getMusicName());
LogUtil.d(TAG, "playing-->" + MusicInfo.isPlaying());

Constant.MUSIC_PLAY = MusicInfo.isPlaying();
// 因为音乐后台服务发送的是粘性广播，所以接收后要删除，不然会保持
removeStickyBroadcast(intent);
}

2.音乐控制

import android.content.Context;

import android.graphics.Bitmap;

import android.media.AudioManager;

import android.media.MediaMetadataEditor;

import android.media.MediaMetadataRetriever;

import android.media.RemoteControlClient;

import android.media.RemoteController;

import android.media.RemoteController.MetadataEditor;

import android.util.AttributeSet;

import android.util.DisplayMetrics;

import android.view.KeyEvent;

import android.view.View;

import android.widget.FrameLayout;

import android.widget.ImageView;

import android.widget.SeekBar;

import android.widget.TextView;

@SuppressWarnings("deprecation")

public class MusicControlView extends FrameLayout {

private final static String TAG = MusicControlView.class.getName();
private Context mContext;
private AudioManager mAudioManager;
private RemoteController mRemoteController;
private RemoteController.OnClientUpdateListener mClientUpdateListener;
private Metadata mMetadata;
private int mCurrentPlayState;

private ImageView mImageIcon;

    private TextView mTitle;

    private TextView mArtist;

    private ImageView mBtnPrev;

    private ImageView mBtnPlay;

    private ImageView mBtnNext;

    private SeekBar mSeekBar;

public MusicControlView(Context context, AttributeSet attrs) {
super(context, attrs);
this.mContext = context;
init();
}

private void init() {
LogUtil.d(TAG,"------->init()");
mMetadata = new Metadata();
mAudioManager = ((AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE));
mCurrentPlayState = 0;
mClientUpdateListener = new RemoteController.OnClientUpdateListener() {

@Override
public void onClientTransportControlUpdate(int transportControlFlags) {
LogUtil.d(TAG,"------->onClientPlaybackStateUpdate  transportControlFlags = "
+ transportControlFlags);
}

@Override
public void onClientPlaybackStateUpdate(int state,
long stateChangeTimeMs, long currentPosMs, float speed) {
           updatePlayPauseState(state);
LogUtil.d(TAG, "------->onClientPlaybackStateUpdate(state=" + state
+ ", stateChangeTimeMs=" + stateChangeTimeMs
+ ", currentPosMs=" + currentPosMs + ", speed=" + speed
+ ")");
}

@Override
public void onClientPlaybackStateUpdate(int state) {
LogUtil.d(TAG, "------->onClientPlaybackStateUpdate  state = "
+ state);
updatePlayPauseState(state);

}

@Override
public void onClientMetadataUpdate(MetadataEditor metadataEditor) {
updateMetadata(metadataEditor);
}

@Override
public void onClientChange(boolean clearing) {
           if (clearing) {
               clearMetadata();
           }
}
};
mRemoteController = new RemoteController(mContext,mClientUpdateListener);

        final DisplayMetrics dm = mContext.getResources().getDisplayMetrics();

        final int dim = Math.max(dm.widthPixels, dm.heightPixels);

        mRemoteController.setArtworkConfiguration(dim, dim);
}

@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
mMetadata.clear();

        mAudioManager.registerRemoteController(mRemoteController);
}

@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mAudioManager.unregisterRemoteController(mRemoteController);
   mMetadata.clear();
}

void updateMetadata(RemoteController.MetadataEditor data) {
mMetadata.artist = data.getString(
MediaMetadataRetriever.METADATA_KEY_ARTIST,
mMetadata.artist);
mMetadata.trackTitle = data
.getString(MediaMetadataRetriever.METADATA_KEY_TITLE,
mMetadata.trackTitle);
mMetadata.albumTitle = data
.getString(MediaMetadataRetriever.METADATA_KEY_ALBUM,
mMetadata.albumTitle);
mMetadata.duration = data.getLong(
MediaMetadataRetriever.METADATA_KEY_DURATION, -1);
mMetadata.bitmap = data.getBitmap(
MediaMetadataEditor.BITMAP_KEY_ARTWORK, mMetadata.bitmap);
populateMetadata();
}

    void clearMetadata() {

        mMetadata.clear();

        populateMetadata();

    }

    
private void populateMetadata() {
LogUtil.d(TAG, "----->mMetadata = "+mMetadata.toString());
mImageIcon.setImageBitmap(mMetadata.bitmap);
mTitle.setText(mMetadata.trackTitle);
mArtist.setText(mMetadata.artist);
}
private void updatePlayPauseState(int state) {
LogUtil.d(TAG, "------>updatePlayPauseState(), old = " + mCurrentPlayState + ", state = " + state);

        if (state == mCurrentPlayState) {

            return;

        }

        switch (state) {

            case RemoteControlClient.PLAYSTATE_ERROR:

                break;

            case RemoteControlClient.PLAYSTATE_PLAYING:

                break;

            case RemoteControlClient.PLAYSTATE_BUFFERING:

                break;

            case RemoteControlClient.PLAYSTATE_PAUSED:

            default:

                break;

        }

        mCurrentPlayState = state;
}

private class Metadata {
private String artist;
private String trackTitle;
private String albumTitle;
private Bitmap bitmap;
private long duration;

public void clear() {
artist = null;
trackTitle = null;
albumTitle = null;
bitmap = null;
duration = -1;
}

public String toString() {
return "Metadata[artist=" + artist + " trackTitle=" + trackTitle
+ " albumTitle=" + albumTitle + " duration=" + duration
+ "]";
}
}

@Override
public void onFinishInflate() {
super.onFinishInflate();
mImageIcon=(ImageView) findViewById(R.id.music_icon);
   mTitle=(TextView) findViewById(R.id.music_title);
   mArtist=(TextView) findViewById(R.id.music_artist);

        mBtnPrev = (ImageView) findViewById(R.id.btn_play_prev);

        mBtnPlay = (ImageView) findViewById(R.id.btn_play);

        mBtnNext = (ImageView) findViewById(R.id.btn_play_next);

        mSeekBar=(SeekBar) findViewById(R.id.music_seekBar);

        final View buttons[] = { mBtnPrev, mBtnPlay, mBtnNext };

        for (View view : buttons) {

            view.setOnClickListener(mTransportCommandListener);

        }
}

    private final OnClickListener mTransportCommandListener = new OnClickListener() {

        public void onClick(View v) {

            int keyCode = -1;

            if (v == mBtnPrev) {

                keyCode = KeyEvent.KEYCODE_MEDIA_PREVIOUS;

            } else if (v == mBtnNext) {

                keyCode = KeyEvent.KEYCODE_MEDIA_NEXT;

            } else if (v == mBtnPlay) {

                keyCode = KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE;
if (mCurrentPlayState == RemoteControlClient.PLAYSTATE_PAUSED) {
mBtnPlay.setBackground(mContext.getResources().getDrawable(R.drawable.btn_pause_selector));
} else if (mCurrentPlayState == RemoteControlClient.PLAYSTATE_PLAYING) {
mBtnPlay.setBackground(mContext.getResources().getDrawable(R.drawable.btn_play_selector));
}

            }

            if (keyCode != -1) {

                sendMediaButtonClick(keyCode);

            }

        }

    };

    private void sendMediaButtonClick(int keyCode) {

        mRemoteController.sendMediaKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, keyCode));

        mRemoteController.sendMediaKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, keyCode));

    }

    

}