Service端
public class MyMusicService extends Service {
private MyBinder binder=new MyBinder();
private String orderPath=null;
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
@Override
public IBinder onBind(Intent intent) {
return binder;
}
@Override
public void onDestroy() {
super.onDestroy();
}
public class MyBinder extends Binder{
private MediaPlayer player;
/**
* 通过资源路径播放资源
* @param uri
*/
public void play(String uri){
if (player==null){
player=new MediaPlayer();
// over();
try {
player.reset();
player.setDataSource(uri);//设置播放资源路径
player.prepare();//同步准备播放
} catch (IOException e) {
e.printStackTrace();
}
player.start();//播放
orderPath=uri;
player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mediaPlayer) {
Log.d("","over==========="+mediaPlayer.getCurrentPosition());
Intent intent=new Intent();
intent.setAction(MainActivity.SERVICE_ACTIVITY);
sendBroadcast(intent);
}
});
}else if (!player.isPlaying()){//没有正在播放
if (uri.equals(orderPath)){//判断是否是新地址还是刚暂停的
player.start();
}else {
try {
player.reset();//复位(reset)MediaPlayer至未初始化状态
player.setDataSource(uri);//设置播放资源路径
player.prepare();//同步准备播放
} catch (IOException e) {
e.printStackTrace();
}
player.start();//播放
orderPath=uri;
}
}
// if (player!=null){
// while (player.isPlaying()){
// setSeekBar();
// try {
// Thread.sleep(1000);
//
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
// }
}
/**
* 暂停播放
*/
public void paus(){
if (player!=null&&player.isPlaying()){
player.pause();//暂停
}
}
/**
* 停止播放
*/
public void stop(){
if (player!=null&&player.isPlaying()){
// player.stop();
player.seekTo(0);//切换到初始播放位置0
}
}
/**
* 获取当前播放时长
*/
public int getCurrentPosition(){
return player.getCurrentPosition();
}
/**
* 获取当前播放的总时长
*/
public int getDuration(){
return player.getDuration();
}
/**
* 切换到具体的播放位置
*/
public void seekTo(int l){
player.seekTo(l);
}
/**
* 发送实时进度
*/
public void setSeekBar(){
Intent intent=new Intent();
intent.setAction(MainActivity.SEEKBAR_ACTIVITY);
Log.d("","getCurrentPosition=========="+getCurrentPosition());
intent.putExtra("seekbar",getCurrentPosition());//获取当前的时长
sendBroadcast(intent);
}
}
}activity端
public static final String MUSIC_INDEX="music_index";//intent的key
public static final String SERVICE_HANDLER="handler";//bunder的key
public static final int REQUEST_READ_EXTERNAL=1;//请求码
public static final String SERVICE_ACTIVITY="com.hfzy.mymusic.activity.service";//service的广播activity
public static final String LIST_ACTIVITY="com.hfzy.mymusic.activity.listitem";//list发送的广播activity
public static final String SEEKBAR_ACTIVITY="com.hfzy.mymusic.activity.seekbar";//service发送的进度条广播
private ImageView PlaySet,LastOne,NextOne,List,Status,musicPhoto;
private ImageView isMusicPhoto;
private boolean IS_MUSIC_PLAY_PHOTO=false;//设置当前旋转图片是被创建过
private TextView musicNowTime,musicDuration;//音乐当前播放时长，音乐总时长
private TextView musicPlayTitle,musicPlayArtist;//音乐播放时的音乐名和歌手
private DBHelper helper;
private Thread thread;
private ObjectAnimator mAnimator;//图片动画
private ServiceConnection connection;
private MyMusicService.MyBinder binder;
private SeekBar seekBar;
private int PLAY_MODE=0;//播放模式0单曲循环，1列表循环，2随机
private boolean IS_PLAY=false;//是否播放
private boolean f=false;
private int MUSIC_SERIALNUMBER=0;//歌曲list位置，默认为0
private int presentIndex=0,lastIndex,nextIndex;//当前播放歌曲的，上一首歌曲，下一首歌曲的序列号
private Music music;
// private MyThread thread;//线程去设置进度条
private List<Music> musicList=new ArrayList<>();//用来提取数据库中的所有数据
private MyReceiver receiver;//广播接受着
private LocalBroadcastManager localBroadcastManager;//本地
private Handler handler=new Handler(Looper.myLooper()){
@Override
public void handleMessage(@NonNull Message msg) {
switch (msg.what){
case 1:
seekBar.setProgress(msg.arg1);//设置进度条已完成进度
musicNowTime.setText(formatTime(msg.arg1));//更新已播放的时间
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
seekBar=findViewById(R.id.seekBar);//拖动进度条
musicPhoto=findViewById(R.id.musicPhoto);//播放界面音乐图片
PlaySet=findViewById(R.id.PlaySet);//状态设置
LastOne=findViewById(R.id.LastOne);//上一首
NextOne=findViewById(R.id.NextOne);//下一首
List=findViewById(R.id.List);//音乐列表
Status=findViewById(R.id.Status);//播放状态
musicNowTime=findViewById(R.id.musictime1);//音乐当前时长
musicDuration=findViewById(R.id.musictime2);//音乐总时长
musicPlayTitle=findViewById(R.id.musicPlayTitle);//音乐播放时标题
musicPlayArtist=findViewById(R.id.musicPlayArtist);//音乐播放时歌手
PlaySet.setOnClickListener(this);//点击转换播放格式
LastOne.setOnClickListener(this);//点击播放上一首
NextOne.setOnClickListener(this);//点击播放上一首
List.setOnClickListener(this);//点击音乐列表
Status.setOnClickListener(this);//点击播放或者暂停
helper=new DBHelper(this,2);
onBind();//绑定服务
lookUpFromDatabase();//从数据库加载数据到list中
// requestPermission();//权限请求
registrationReceiver();//注册广播
}
/**
*drawable转Bitmap
* @param drawable
* @return
*/
private Bitmap drawableToBitmap(Drawable drawable) {
if (drawable instanceof BitmapDrawable) {
BitmapDrawable bd = (BitmapDrawable) drawable;
return bd.getBitmap();
}
int w = drawable.getIntrinsicWidth();
int h = drawable.getIntrinsicHeight();
Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
drawable.setBounds(0, 0, w, h);
drawable.draw(canvas);
return bitmap;
}
/**
* 初始播放所选择的音乐
* 此方法在此程序中只会走一次
*/
private void getDataFromIntent() {
Intent intent=getIntent();
MUSIC_SERIALNUMBER=intent.getIntExtra(MUSIC_INDEX,0);
nextIndex=MUSIC_SERIALNUMBER;
Log.d("","MUSIC_SERIALNUMBER2========="+MUSIC_SERIALNUMBER);
playMusic(IS_PLAY,MUSIC_SERIALNUMBER);
}
/**
* 设置广播接收器
*/
private void registrationReceiver() {
localBroadcastManager=LocalBroadcastManager.getInstance(this);
receiver=new MyReceiver();
IntentFilter filter=new IntentFilter();
filter.addAction(LIST_ACTIVITY);
filter.addAction(SERVICE_ACTIVITY);
filter.addAction(SEEKBAR_ACTIVITY);
localBroadcastManager.registerReceiver(receiver,filter);
registerReceiver(receiver,filter);
}
/**
* 通过设置最大长度来设置进度条
* 进度条的滑动出发事件处理
* @param maxLong
*/
private void setSeekBar(int maxLong) {
seekBar.setMax(maxLong);//设置最大的长度
seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
@Override
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
if (b){
binder.seekTo(i);//根据拖动，设置歌曲播放位置
}
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
}
});
}
/**
* 绑定服务
*/
private void onBind() {
Intent intent=new Intent(this, MyMusicService.class);
connection=new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
binder=(MyMusicService.MyBinder) iBinder;
getDataFromIntent();
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
}
};
boolean f=bindService(intent,connection,BIND_AUTO_CREATE);//绑定
}
// /**
// * 判断是否有权限
// */
// private void requestPermission() {
// if(ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
// == PackageManager.PERMISSION_GRANTED){
// //有权限
// getMusicFromSDCard();//从SD卡获得音频文件
// lookUpFromDatabase();//从数据库获得数据，放在list中
// musicPlayTitle.setText(musicList.get(MUSIC_SERIALNUMBER).getTitle());//默认设置第一首歌曲名
// musicPlayArtist.setText(musicList.get(MUSIC_SERIALNUMBER).getArtist());//默认设置第一首歌曲歌手
// musicPhoto.setImageBitmap(createCircleImage(musicList.get(MUSIC_SERIALNUMBER).getBitmap()));//默认显示第一首歌曲的图片
// }else {
// //没有权限，进行权限申请
// ActivityCompat.requestPermissions(this,
// new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
// REQUEST_READ_EXTERNAL);
// }
// }
// /**
// * 权限请求返回处理
// * @param requestCode
// * @param permissions
// * @param grantResults
// */
// @Override
// public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
// super.onRequestPermissionsResult(requestCode, permissions, grantResults);
// if (requestCode==REQUEST_READ_EXTERNAL
// &&Manifest.permission.READ_EXTERNAL_STORAGE.equals(permissions[0])
// &&grantResults[0]==PackageManager.PERMISSION_GRANTED){
// getMusicFromSDCard();//从SD卡获得音频文件
// lookUpFromDatabase();//从数据库获得数据，放在list中
//
// musicPlayTitle.setText(musicList.get(MUSIC_SERIALNUMBER).getTitle());//默认设置第一首歌曲名
// musicPlayArtist.setText(musicList.get(MUSIC_SERIALNUMBER).getArtist());//默认设置第一首歌曲歌手
// musicPhoto.setImageBitmap(createCircleImage(musicList.get(MUSIC_SERIALNUMBER).getBitmap()));//默认显示第一首歌曲的图片
// }else {
// Toast.makeText(this, "您拒绝了读取SD卡的权限", Toast.LENGTH_LONG).show();
// }
// }
// /**
// * 从SD卡获得音频文件
// */
// private void getMusicFromSDCard() {
// ContentResolver resolver=getContentResolver();//实例化ContentResolver
// Uri uri= MediaStore.Audio.Media.getContentUri(MediaStore.VOLUME_EXTERNAL);//实例化uri对象
// SQLiteDatabase db=helper.getWritableDatabase();
//
// Cursor cursor=resolver.query(uri//指定某个应用程序下的一张表
// ,null//指定查询的列名
// ,null//指定where的约束条件
// ,null//为where的占位符提供具体的值
// ,null);//指定查询结果的排序方式
// while (cursor.moveToNext()){
// String sql="insert OR IGNORE into mp3 (_id,duration,title,url,artist,photoaddress) values(?,?,?,?,?,?)";
// int id =cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID));//歌曲id
// int duration=cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DURATION));//获取歌曲时长
// String title=cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE));//获得歌曲名称
// String uri1=cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DATA));//获得作品数据地址
// String artist=cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST));//获得作者名字
// String photoaddress=cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM_ID));//获得图片的地址
//
// db.execSQL(sql,new Object[]{id,duration,title,uri1,artist,photoaddress});//存入数据库
//
// }
// cursor.close();
// db.close();
// /**
// * insert or replace：如果不存在就插入，存在就更新
// * insert or ignore：如果不存在就插入，存在就忽略
// * 只对UNIQUE（列名）设定的列有效
// */
// }
/**
* 点击事件
* @param view
*/
@Override
public void onClick(View view) {
switch (view.getId()){
case R.id.PlaySet:
//点击转换播放状态，默认为单曲循环
switchFor();
break;
case R.id.LastOne:
//点击播放上一首
playMsiLastone(lastIndex);
break;
case R.id.NextOne:
//点击播放下一首
playMusicNext(nextIndex);
break;
case R.id.List:
//点击音乐列表
lodingMusicListView();
break;
case R.id.Status:
//点击播放或暂停
playMusic(IS_PLAY,MUSIC_SERIALNUMBER);//播放音乐
break;
}
}
/**
* 选择循环模式
*/
private void switchFor() {
switch (PLAY_MODE){
case 0:
//从单曲循环变成列表循环
listFor();
PlaySet.setImageResource(R.drawable.listplay);
PLAY_MODE=1;
break;
case 1:
//从列表循环到随机播放
randomPlay();
PlaySet.setImageResource(R.drawable.numplay);
PLAY_MODE=2;
break;
case 2:
//从随机播放到单曲循环
oneFor();
PlaySet.setImageResource(R.drawable.one);
PLAY_MODE=0;
break;
}
}
/**
* 列表循环
*/
private void listFor() {
if (presentIndex==0){
lastIndex=musicList.size()-1;
nextIndex=presentIndex+1;
}else if (presentIndex==musicList.size()-1){
lastIndex=presentIndex-1;
nextIndex=0;
}else {
lastIndex=presentIndex-1;
nextIndex=presentIndex+1;
}
}
/**
* 随机播放
*/
private void randomPlay() {
if (presentIndex==nextIndex){//判断是点击下一首触发
nextIndex=(int) (Math.random()*(musicList.size()));
}else if (presentIndex==lastIndex){//判断是点击上一首触发
lastIndex=(int) (Math.random()*(musicList.size()));
}
}
/**
* 单曲循环时上下首歌都是本首歌
*/
private void oneFor() {
lastIndex=presentIndex;
presentIndex=nextIndex;
}
/**
* 根据下标播放下一首歌
* 下标由播放模式改变
* @param nextIndex
*/
private void playMusicNext(int nextIndex) {
binder.stop();//结束当前音乐
// thread.stop();
IS_PLAY=false;
lastIndex=presentIndex;
presentIndex=nextIndex;
accordingForDometoPlay();
}
/**
* 加载音乐列表
*/
private void lodingMusicListView() {
Intent intent=new Intent(MainActivity.this,MusicListActivity.class);
startActivity(intent);
}
/**
* 根据下标播放上一首歌
* 下标由播放模式改变
* @param lastIndex
*/
private void playMsiLastone(int lastIndex) {
// binder.stop();//结束当前音乐
// thread.stop();
IS_PLAY=false;
nextIndex=presentIndex;
presentIndex=lastIndex;
accordingForDometoPlay();
}
/**
* 通过输入的参数判断播放还是暂停，false则开始播放，true则去暂停
* @param is_play
*/
private void playMusic(boolean is_play,int index) {
if (is_play){//判断当前是否是播放状态
binder.paus();//暂停播放
mAnimator.pause();//停止图片旋转
if (index==presentIndex){//判断是否是当前播放的序列号
IS_PLAY=false;
Status.setImageResource(R.drawable.pasu);//暂停播放
}else {//不是则继续播放新的歌曲
play(index);
presentIndex=index;
}
}else {//没有播放则调用方法，进行播放
play(index);
IS_PLAY=true;
Status.setImageResource(R.drawable.start);//正在播放图片
presentIndex=index;
}
}
/**
* 播放
* @param index
*/
private void play(int index) {
Log.d("AF2205","");
MUSIC_SERIALNUMBER=index;
String uri=musicList.get(index).getUrl();//从全局对象中获得本地音乐地址
int musicTime=musicList.get(index).getDuration();//音乐时长
Bitmap bitmap=musicList.get(index).getBitmap();//获得当前音乐的图片的bitmap
String title=musicList.get(index).getTitle();//当前音乐的作者
String artist=musicList.get(index).getArtist();//当前音乐的歌手
binder.play(uri);//播放
musicPhoto.setImageBitmap(createCircleImage(bitmap));//设置播放界面音乐图片
rotateImage(musicPhoto);
// int Minutes=musicTime/1000/60;
// int Seconds=musicTime/1000%60;
musicDuration.setText(formatTime(musicTime));//设置歌曲的总时间
musicPlayTitle.setText(title);//设置播放歌曲的名称
musicPlayArtist.setText(artist);//设置播放歌曲的歌手
setSeekBar(musicTime);//设置滑动条长度
// String str=readLRC(uri);//解析歌词
setPlayBar(musicTime);//设置播放时滑动条的长度
// binder.over();//音乐结束回调
}
//使用formatTime方法对时间格式化
private String formatTime(int length){
Date date=new Date(length);
//时间格式化工具
SimpleDateFormat sdf=new SimpleDateFormat("mm:ss");
String totalTime=sdf.format(date);
return totalTime;
}
/**
* 设置播放的进度条
* 输入最大的进度
* @param musicTime
*/
private void setPlayBar(int musicTime) {
thread=new Thread(new Runnable() {
@Override
public void run() {
try {
for (int i=0;i<=musicTime;){
Thread.sleep(100);//0.1s
i=binder.getCurrentPosition();//获取当前的播放时长
Message message=handler.obtainMessage();
message.what=1;
message.arg1=i;
handler.sendMessage(message);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
}
/**
* 一首歌结束，发送结束消息，然后切换歌曲
*/
private void sendOkMessage() {
Message message=handler.obtainMessage();
message.what=2;
handler.sendMessage(message);
}
/**
* 从数据库中查询当前所存在的信息，实例化List
*/
private void lookUpFromDatabase() {
String sql="select distinct * from mp3";
SQLiteDatabase db=helper.getReadableDatabase();//建立SQLiteDatabase对象
Cursor cursor = db.rawQuery(sql, null);//执行查询语句
while (cursor.moveToNext()){
int id=cursor.getInt(0);//歌曲id
int duration=cursor.getInt(1);//歌曲时长
String title=cursor.getString(2);//歌曲名称
String uri=cursor.getString(3);//歌曲地址
String artist=cursor.getString(4);//歌曲作者
// String photoaddress=cursor.getString(5);//歌曲图片
Bitmap bitmap=getAlbumPicture(uri);//歌曲图片
music=new Music(id,duration,title,uri,artist,bitmap);//实例化全局music对象
musicList.add(music);
}
cursor.close();
db.close();
}
/**
* 广播
*/
class MyReceiver extends BroadcastReceiver{
/**
* 接受信号，然后播放对应的音乐
* @param context
* @param intent
*/
@Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(LIST_ACTIVITY)){
MUSIC_SERIALNUMBER=intent.getIntExtra(MusicListActivity.REVICER_KEY,0);
playMusic(IS_PLAY,MUSIC_SERIALNUMBER);
}else if (intent.getAction().equals(SERVICE_ACTIVITY)){
//自动播放下一首事件
f=true;
playMusicNext(nextIndex);
}else if (intent.getAction().equals(SEEKBAR_ACTIVITY)){
//进度条变化事件
int i=intent.getIntExtra("seekbar",0);
Message message=handler.obtainMessage();
message.what=1;
message.arg1=i;
handler.sendMessage(message);
}
}
}
/**
* 根据模式播放下一首
*/
private void accordingForDometoPlay() {
switch (PLAY_MODE) {
case 0:
//单曲
oneFor();
playMusic(IS_PLAY, presentIndex);
break;
case 1:
//列表
listFor();
playMusic(IS_PLAY, presentIndex);
break;
case 2:
//随机
randomPlay();
playMusic(IS_PLAY, presentIndex);
break;
}
}
/**
* 通过音乐文件地址
* 获取歌曲专辑图片
* @param dataPath
* @return
*/
public Bitmap getAlbumPicture(String dataPath) {
android.media.MediaMetadataRetriever mmr = new MediaMetadataRetriever();
mmr.setDataSource(dataPath);
byte[] data = mmr.getEmbeddedPicture();
Bitmap albumPicture = null;
if (data != null) {
//获取bitmap对象
albumPicture = BitmapFactory.decodeByteArray(data, 0, data.length);
//获取宽高
int width = albumPicture.getWidth();
int height = albumPicture.getHeight();
//Log.w("DisplayActivity","width = "+width+" height = "+height);
// 创建操作图片用的Matrix对象
Matrix matrix = new Matrix();
// 计算缩放比例
float sx = ((float) 120 / width);
float sy = ((float) 120 / height);
// 设置缩放比例
matrix.postScale(sx, sy);
// 建立新的bitmap，其内容是对原bitmap的缩放后的图
albumPicture = Bitmap.createBitmap(albumPicture, 0, 0, width, height, matrix, false);
return albumPicture;
} else {
albumPicture = BitmapFactory.decodeResource(getResources(), R.drawable.music1);
//music1是从歌曲文件读取不出来专辑图片时用来代替的默认专辑图片
int width = albumPicture.getWidth();
int height = albumPicture.getHeight();
//Log.w("DisplayActivity","width = "+width+" height = "+height);
// 创建操作图片用的Matrix对象
Matrix matrix = new Matrix();
// 计算缩放比例
float sx = ((float) 120 / width);
float sy = ((float) 120 / height);
// 设置缩放比例
matrix.postScale(sx, sy);
// 建立新的bitmap，其内容是对原bitmap的缩放后的图
albumPicture = Bitmap.createBitmap(albumPicture, 0, 0, width, height, matrix, false);
return albumPicture;
}
}
private LrcContent mLrcContent;
private List<LrcContent> LrcList;
/**
* 解析歌词
*/
public String readLRC(String song_path) {
// public void Read(String file){
StringBuilder stringBuilder = new StringBuilder();
File f = new File(song_path.substring(0, song_path.lastIndexOf("."))
+ ".lrc");
try {
FileInputStream fis = new FileInputStream(f);
InputStreamReader isr = new InputStreamReader(fis, "GB2312");
BufferedReader br = new BufferedReader(isr);
String s = "";
while ((s = br.readLine()) != null) {
s += " "; // 处理只有时间没有内容的行
if ((s.indexOf("[ar:") != -1) || (s.indexOf("[ti:") != -1)
|| (s.indexOf("[by:") != -1)
|| (s.indexOf("[al:") != -1) || s.equals(" ")) {
continue;
}
s = s.replace("[", "");
//关键代码，歌词用的时候需要对时间进行排序
String splitLrc_data[] = s.split("]");
for (int i = 0; i < splitLrc_data.length - 1; i++) {
//System.out.println(splitLrc_data[i]);
mLrcContent.setLrc_time(TimeStr(splitLrc_data[i]));
mLrcContent.setLrc(splitLrc_data[splitLrc_data.length - 1]);
LrcList.add(mLrcContent);
mLrcContent = new LrcContent();
}
//关键代码
}
br.close();
isr.close();
fis.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
stringBuilder.append("没有找到歌词文件！");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
stringBuilder.append("无法读取歌词文件！");
}
return stringBuilder.toString();
}
/**
* 处理时间
* 时间转换为毫秒millisecond
*/
public int TimeStr(String timeStr) {
timeStr = timeStr.replace(":", ".");
timeStr = timeStr.replace(".", "@");
String timeData[] = timeStr.split("@");
int currentTime = 0;
// 分离出分、秒并转换为整型
try {
int minute = Integer.parseInt(timeData[0]);
int second = Integer.parseInt(timeData[1]);
int millisecond = Integer.parseInt(timeData[2]);
currentTime = (minute * 60 + second) * 1000 + millisecond * 10;
} catch (Exception ex) {
ex.printStackTrace();
}
return currentTime;
}
/**
* 旋转图片
* ObjectAnimator
* private boolean IS_MUSIC_PLAY_PHOTO=false;//设置当前旋转图片是被创建过
* private ImageView isMusicPhoto;
*/
private void rotateImage(ImageView musicPhoto) {
if (IS_MUSIC_PLAY_PHOTO){//判断当前旋转图片是被创建过
if (musicPhoto!=isMusicPhoto){
mAnimator = ObjectAnimator.ofFloat(musicPhoto, "rotation", 0.0f, 360.0f);
isMusicPhoto=musicPhoto;
}
}else {
//旋转动画
mAnimator = ObjectAnimator.ofFloat(musicPhoto, "rotation", 0.0f, 360.0f);
isMusicPhoto=musicPhoto;
IS_MUSIC_PLAY_PHOTO=true;
}
//设定转一圈的时间
mAnimator.setDuration(20000);
//设定无限循环
mAnimator.setRepeatCount(Animation.INFINITE);
// 循环模式
mAnimator.setRepeatMode(ObjectAnimator.RESTART);
// 匀速
mAnimator.setInterpolator(new LinearInterpolator());
if (mAnimator.isPaused()){//判断是否暂停
mAnimator.resume();//继续
}else {
//开始动画
mAnimator.start();
}
// mAnimator.reverse();
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(connection);
}
/**
* 歌词类
* 需要排序的话，要用Integer替代int
*/
public class LrcContent {
private String Lrc;
private Integer Lrc_time;
public String getLrc() {
return Lrc;
}
public void setLrc(String lrc) {
Lrc = lrc;
}
public Integer getLrc_time() {
return Lrc_time;
}
public void setLrc_time(int lrc_time) {
Lrc_time = lrc_time;
}
}
//图片剪辑
public static Bitmap createCircleImage(Bitmap source) {
int length = source.getWidth() < source.getHeight() ? source.getWidth() : source.getHeight();
Paint paint = new Paint();
paint.setAntiAlias(true);
Bitmap target = Bitmap.createBitmap(length, length, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(target);
canvas.drawCircle(length / 2, length / 2, length / 2, paint);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawBitmap(source, 0, 0, paint);
return target;
}
}
147
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
