Android基于网络媒体库编程的音乐播放器（实训）

基于网络媒体库编程的音乐播放器（实训）

1. 第一阶段功能要求
   加上程序启动引导页！
   [1] 数据源来自扫描存储卡MP3音乐获得的列表
   [2] 播放列表显示音乐文件(音乐名)
   [3] 利用自定义Service类来实现音乐的播放与暂停以及进度的更新
   [4] 界面类(Activity)与服务类(Service)之间通过广播接收者进行通信
   [5] 主界面包括播放列表、可设置播放模式、显示当前音乐名、拖拽条显示和设置播放进度、显示播放进度值和播放时长、包含上一首按钮、下一首按钮、播放|暂停按钮

2. 第二阶段功能要求
   [1] 数据源来自媒体库音频
   [2] 列表显示音乐文件(专辑封面图片、音乐名、演唱者、播放时长)
   [3] 音乐列表可按音乐标识符、标题或播放时长排序
   [4] 利用自定义Service类来实现音乐的播放与暂停以及进度的更新
   [5] 界面类(Activity)与服务类(Service) 之间通过广播接收者进行通信
   [6] 主界面包含播放播放列表、可设置播放模式、显示当前音乐名、拖拽条显示和设置播放进度、显示播放进度值和播放时长、包含上一首按钮、下一首按钮、播放 | 暂停按钮

3. 第三阶段功能要求
   [6] 数据源来自服务器音乐库(数据库保存专辑图片与音乐路径)
   [7] 列表显示音乐文件(专辑封面图片、音乐名、演唱者、播放时长)
   [8] 音乐列表可按音乐标识符、标题或播放时长排序
   [9] 利用自定义Service类来实现音乐的播放与暂停以及进度的更新
   [10] 界面类(Activity)与服务类(Service)之间通过广播接收者进行通信
   [11] 主界面包含播放列表、了设置播放模式、显示当前音乐名、拖拽条、显示和设置播放进度、显示播放进度值和播放时长、包含上一首按钮、下一首按钮、播放|暂停按钮
   前台客户端： 基于网络乐库音乐播放器V0.7(安卓)
   后台服务器端：MusicServier(Web)

4. 所需运行硬件环境：
   安卓系统2.2以上 3.5寸以上移动设备
   IntelliJ IDEA 社区版 2017.2
   软件开发环境的配置：
   （1） 配置Java程序开发环境
   （2） 安装并Android Studio
   （3） Android SDK的安装
   （4） ADT的安装及配置
   （5） Android夜神模拟器的配置
   （6） Tomcat 7.0 配置
   （7） 新建数据库创建表
   （7） 运用Android Studio完成项目代码的编写，启动Java服务，模拟器运行与调试；

---

代码片段：

public class MainActivity extends Activity implements AppConstants {
    /**
     * 音乐列表控件
     */
    private ListView lvMusic;
    /**
     * 媒体播放器
     */
    private MediaPlayer mp;
    /**
     * 音乐网址字符串
     */
    private String strMusicUrl;
    /**
     * 访问网络乐库应用程序
     */
    private AccessWebMusicStoreApplication app;
    /**
     * 音乐文件名
     */
    private String musicName;
    /**
     * 显示音乐名的标签
     */
    private TextView tvMusicName;
    /**
     * 播放|暂停按钮
     */
    private Button btnPlayOrPause;
    /**
     * 显示当前播放位置的标签
     */
    private TextView tvCurrentPosition;
    /**
     * 显示音乐播放时长的标签
     */
    private TextView tvDuration;
    /**
     * 音乐播放拖拽条
     */
    private SeekBar sbMusicProgress;
    /**
     * 音乐名列表控件
     */
    private ListView lvMusicList;
    /**
     * 音乐列表（数据源）
     */
    private List<Music> musicList;
    /**
     * 音乐适配器
     */
    private MusicAdapter adapter;
    /**
     * 播放模式单选按钮组
     */
    private RadioGroup rgPlayMode;
    /**
     * 音乐广播接收器
     */
    private MusicReceiver receiver;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 利用布局资源文件设置用户界面
        setContentView(R.layout.activity_main);

        // 获取访问网络乐库应用程序
        app = (AccessWebMusicStoreApplication) getApplication();

        // 通过资源标识获得控件实例
        lvMusicList = (ListView) findViewById(R.id.lv_music_name);
        tvMusicName = (TextView) findViewById(R.id.tv_music_name);
        btnPlayOrPause = (Button) findViewById(R.id.btn_play_pause);
        tvCurrentPosition = (TextView) findViewById(R.id.tv_current_position);
        tvDuration = (TextView) findViewById(R.id.tv_duration);
        sbMusicProgress = (SeekBar) findViewById(R.id.sb_music_progress);
        rgPlayMode = (RadioGroup) findViewById(R.id.rg_play_mode);




        // 获取音乐列表（数据源）
        musicList = app.getMusicList();
        // 判断音乐列表里是否有元素
        if (musicList.size() > 0) {
            // 创建音乐适配器
            adapter = new MusicAdapter(this, musicList);
            // 给音乐列表设置适配器
            lvMusicList.setAdapter(adapter);

            // 给播放模式单选按钮组注册监听器
            rgPlayMode.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
                @Override
                public void onCheckedChanged(RadioGroup radioGroup, int checkedId) {
                    // 判断用户选择何种播放模式
                    switch (checkedId) {
                        // 顺序播放模式
                        case R.id.rb_order:
                            app.setPlayMode(PLAY_MODE_ORDER);
                            break;
                        // 随机播放模式
                        case R.id.rb_random:
                            app.setPlayMode(PLAY_MODE_RANDOM);
                            break;
                        // 单曲循环模式
                        case R.id.rb_loop:
                            app.setPlayMode(PLAY_MODE_LOOP);
                            break;
                    }
                }
            });
            // 实例化媒体播放器
            mp = new MediaPlayer();

            // 给音乐列表控件注册监听器
            lvMusicList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                    // 获取音乐网址字符串
                    String strMusicUrl = MUSIC_SERVER_URL + musicList.get(position).getData();

                    if (mp.isPlaying()) {
                        mp.stop();
                    }
                    // 重置媒体播放器
                    mp.reset();
                    try {
                        // 设置播放源
                        mp.setDataSource(MainActivity.this, Uri.parse(strMusicUrl));
                        // 缓存播放源（从服务器端下载音乐文件到内存）
                        mp.prepare();
                        // 播放音乐
                        mp.start();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            // 给音乐播放拖拽条注册监听器
            sbMusicProgress.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    // 判断进度是否为用户修改
                    if (fromUser) {
                        // 设置用户修改的播放进度
                        app.setProgressChangedByUser(progress);
                        // 创建意图
                        Intent intent = new Intent();
                        // 设置广播频道：用户修改播放进度
                        intent.setAction(INTENT_ACTION_USER_CHANCG_PROGRESS);
                        // 按意图发送广播
                        sendBroadcast(intent);
                        //Toast.makeText(MainActivity.this,progress+"",Toast.LENGTH_LONG).show();
                    }
                }

                @Override
                public void onStartTrackingTouch(SeekBar seekBar) {
                }

                @Override
                public void onStopTrackingTouch(SeekBar seekBar) {
                }
            });

            // 启动音乐服务
            startService(new Intent(MainActivity.this, MusicPlayService.class));
            // 创建音乐广播接收器
            receiver = new MusicReceiver();
            // 创建意图过滤器
            IntentFilter filter = new IntentFilter();
            // 通过意图过滤器添加广播频道
            filter.addAction(INTENT_ACTION_UPDATE_PROGRESS);
            // 注册音乐广播接收器
            registerReceiver(receiver, filter);
            // 设置音乐名标签内容，去掉路径和扩展名
            String musicName = app.getMusicList().get(app.getCurrentMusicIndex()).getData();
            int duration = app.getMusicList().get(app.getCurrentMusicIndex()).getDuration();
            tvMusicName.setText("No. " + (app.getCurrentMusicIndex() + 1) + " " + musicName.substring(
                    musicName.lastIndexOf('/') + 1, musicName.lastIndexOf(".")));
            tvCurrentPosition.setText(app.getFormatTime(0));
            tvDuration.setText(app.getFormatTime(duration));
        } else {
            Toast.makeText(this, "网络乐库里没有音乐！", Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * 音乐广播接收者
     */
    private class MusicReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            // 获取广播频道
            String action = intent.getAction();
            // 判断广播频道是否为空
            if (action != null) {
                // 根据不同广播频道执行不同操作
                if (INTENT_ACTION_UPDATE_PROGRESS.equals(action)) {
                    // 获取播放时长
                    int duration = intent.getIntExtra(DURATION, 0);
                    // 获取播放控制图标
                    int controlIcon = intent.getIntExtra(CONTROL_ICON,
                            R.drawable.play_button_selector);
                    // 计算进度值
                    int progress = app.getCurrentPosition() * 100 / duration;
                    // 获取音乐名
                    musicName = app.getMusicList().get(app.getCurrentMusicIndex()).getMusicName();
                    // 设置正在播放的文件名（去掉扩展名）
                    tvMusicName.setText("No." + (app.getCurrentMusicIndex() + 1) + "  "
                            + musicName.substring(musicName.lastIndexOf("/") + 1, musicName.lastIndexOf(".")));
                    // 设置播放进度值标签
                    tvCurrentPosition.setText(app.getFormatTime(app.getCurrentPosition()));
                    // 设置播放时长标签
                    tvDuration.setText(app.getFormatTime(duration));
                    // 设置播放拖拽条的进度值
                    sbMusicProgress.setProgress(progress);
                    // 设置【播放|暂停】按钮显示的图标
                    btnPlayOrPause.setBackgroundResource(controlIcon);
                }
            }
        }
    }


    /**
     * 创建选项菜单
     * TODO
     * @param menu
     * @return
     */
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main,menu);
        return true;
    }

    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            // 默认排序
            case R.id.action_default_order:
                Collections.sort(app.getMusicList(), new Comparator<Music>() {
                    @Override
                    public int compare(Music lhs, Music rhs) {
                        return (lhs.getId() - rhs.getId());
                    }
                });
                // TODO
                savaDefaultOrderBy("default");
                break;
            // 按标题排序
            case R.id.action_title_order:
                Collections.sort(app.getMusicList(), new Comparator<Music>() {
                    @Override
                    public int compare(Music lhs, Music rhs) {
                        return lhs.getTitle().compareTo(rhs.getTitle());
                    }
                });

                //TODO
                savaDefaultOrderBy("title");
                break;
            // 按时长排序
            case R.id.action_duration_order:
                Collections.sort(app.getMusicList(), new Comparator<Music>() {
                    @Override
                    public int compare(Music lhs, Music rhs) {
                        return (lhs.getDuration() - rhs.getDuration());
                    }
                });
                //
                savaDefaultOrderBy("duration");
                break;
        }
        adapter.notifyDataSetInvalidated();
        return true;
    }


    private void savaDefaultOrderBy(String orderBy) {
        SharedPreferences sp = getSharedPreferences(USER_CONFIG,MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();
        editor.putString("order-by", orderBy);
        editor.commit();
    }


    /**
     * 播放|暂停按钮单击事件处理方法
     *
     * @param view
     */
    public void doPlayOrPause(View view) {
        // 创建意图
        Intent intent = new Intent();
        // 设置广播频道
        intent.setAction(INTENT_ACTION_PLAY_OR_PAUSE);
        // 按意图发送广播
        sendBroadcast(intent);
    }
    /**
     * 上一首音乐按钮单击事件处理方法
     *
     * @param view
     */
    public void doPrevious(View view) {
        // 创建意图
        Intent intent = new Intent();
        // 设置广播频道
        intent.setAction(INTENT_ACTION_PREVIOUS);
        // 按意图发送广播
        sendBroadcast(intent);
    }

    /**
     * 下一首音乐按钮单击事件处理方法
     *
     * @param view
     */
    public void doNext(View view) {
        // 创建意图
        Intent intent = new Intent();
        // 设置广播频道
        intent.setAction(INTENT_ACTION_NEXT);
        // 按意图发送广播
        sendBroadcast(intent);
    }


    /**
     * 销毁方法
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止音乐播放服务
        stopService(new Intent(MainActivity.this, MusicPlayService.class));
        // 注销广播接收者
        unregisterReceiver(receiver);
    }
}

---

/**
 * 功能：音乐播放服务类
 * Created by lenovo on 2018/1/19.
 */
public class MusicPlayService extends Service implements AppConstants {
    /**
     * 媒体播放器
     */
    private MediaPlayer mp;
    /**
     * 音乐列表（数据源）
     */
    private List<Music> musicList;
    /**
     * 音乐文件名
     */
    private String musicName;
    /**
     * 更新音乐播放进度的线程
     */
    private Thread thread;
    /**
     * 线程循环控制变量
     */
    private boolean isRunning;
    /**
     * 音乐播放器应用程序
     */
    private AccessWebMusicStoreApplication app;
    /**
     * 音乐广播接收器
     */
    private MusicReceiver receiver;

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

    @Override
    public void onCreate() {
        super.onCreate();
        // 获取获得音乐播放器应用程序对象
        app = (AccessWebMusicStoreApplication) getApplication();

        // 获取音乐列表（数据源）
        musicList = app.getMusicList();

        // 创建媒体播放器
        mp = new MediaPlayer();
        // 给媒体播放器起注册完成监听器
        mp.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
            @Override
            public void onCompletion(MediaPlayer mp) {
                // 切换到下一首音乐
                nextMusic();
            }
        });


        // 设置线程循环控制变量为真
        isRunning = true;
        // 创建线程更新播放进度
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (isRunning) {
                    // 判断音乐是否在播放
                    if (mp.isPlaying()) {
                        // 设置音乐当前播放位置
                        app.setCurrentPosition(mp.getCurrentPosition());
                        // 创建意图
                        Intent intent = new Intent();
                        // 设置广播频道：更新播放进度
                        intent.setAction(INTENT_ACTION_UPDATE_PROGRESS);
                        // 让意图携带播放时长
                        intent.putExtra(DURATION, mp.getDuration());
                        // 让意图携带控制图标（暂停图标）
                        intent.putExtra(CONTROL_ICON, R.drawable.pause_button_selector);
                        // 按意图发送广播
                        sendBroadcast(intent);
                    }
                    // 让线程睡眠500毫秒
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        // 启动线程
        thread.start();

        // 创建音乐广播接收者
        receiver = new MusicReceiver();
        // 创建意图过滤器
        IntentFilter filter = new IntentFilter();
        // 通过意图过滤器添加广播频道
        filter.addAction(INTENT_ACTION_PLAY_OR_PAUSE);
        filter.addAction(INTENT_ACTION_PLAY);
        filter.addAction(INTENT_ACTION_PREVIOUS);
        filter.addAction(INTENT_ACTION_NEXT);
        filter.addAction(INTENT_ACTION_USER_CHANCG_PROGRESS);
        // 注册广播接收者
        registerReceiver(receiver, filter);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        // 返回非粘性服务
        return Service.START_NOT_STICKY;
    }

    /**
     * 上一首音乐
     */
    private void previousMusic() {
        // 更新音乐索引
        if (app.getCurrentMusicIndex() > 0) {
            app.setCurrentMusicIndex(app.getCurrentMusicIndex() - 1);
        } else {
            app.setCurrentMusicIndex(musicList.size() - 1);
        }
        // 当前播放位置归零
        app.setCurrentPosition(0);
        // 调用播放方法
        play();
    }

    /**
     * 下一首音乐
     */
    private void nextMusic() {
        // 根据播放模式来更新音乐索引
        switch (app.getPlayMode()) {
            // 顺序播放模式
            case PLAY_MODE_ORDER:
                if (app.getCurrentMusicIndex() < musicList.size() - 1) {
                    app.setCurrentMusicIndex(app.getCurrentMusicIndex() + 1);
                } else {
                    app.setCurrentMusicIndex(0);
                }
                break;
            // 随机播放模式
            case PLAY_MODE_RANDOM:
                // 随机设置索引
                app.setCurrentMusicIndex(new Random().nextInt(app.getMusicList().size()));
                break;
            // 单曲循环模式
            case PLAY_MODE_LOOP:
                // 音乐索引保持不变
                break;
        }
        // 当前播放位置归零
        app.setCurrentPosition(0);
        // 调用播放方法
        play();
    }

    /**
     * 播放方法
     */
    private void play() {
        try {
            // 重置播放器
            mp.reset();
            // 获取当前播放的音乐名
            musicName = musicList.get(app.getCurrentMusicIndex()).getData();
            // 设置播放源
            mp.setDataSource(musicName);
            // 缓冲播放源，加载到内存
            mp.prepare();
            // 定位到暂停时的播放位置
            mp.seekTo(app.getCurrentPosition());
            // 启动音乐的播放
            mp.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 暂停方法
     */
    private void pause() {
        // 暂停播放
        mp.pause();
        // 保存当前音乐播放位置
        app.setCurrentPosition(mp.getCurrentPosition());
        /* 发送广播给前台MainActivity，更改图标、更改播放进度 */
        // 创建意图
        Intent intent = new Intent();
        // 设置广播频道：更新播放进度
        intent.setAction(INTENT_ACTION_UPDATE_PROGRESS);
        // 让意图携带播放时长
        intent.putExtra(DURATION, mp.getDuration());
        // 让意图携带控制图标（播放图标）
        intent.putExtra(CONTROL_ICON, R.drawable.play_button_selector);
        // 按意图发送广播
        sendBroadcast(intent);
    }

    /**
     * 音乐广播接收者
     */
    private class MusicReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 获取意图动作（广播频道）
            String action = intent.getAction();
            // 当广播频道非空时进行判断
            if (action != null) {
                // 根据不同广播频道执行不同的操作
                switch (action) {
                    case INTENT_ACTION_PLAY:
                        // 播放进度值归零
                        app.setCurrentPosition(0);
                        // 调用播放方法
                        play();
                        break;
                    case INTENT_ACTION_PLAY_OR_PAUSE:
                        // 判断音乐是否在播放
                        if (mp.isPlaying()) {
                            pause();
                        } else {
                            play();
                        }
                        break;
                    case INTENT_ACTION_PREVIOUS:
                        // 切换到上一首音乐
                        previousMusic();
                        break;
                    case INTENT_ACTION_NEXT:
                        // 切换到下一首音乐
                        nextMusic();
                        break;
                    case INTENT_ACTION_USER_CHANCG_PROGRESS:
                        // 根据拖拽条的进度值计算当前播放位置
                        app.setCurrentPosition(app.getProgressChangedByUser() * mp.getDuration() / 100);
                        // 根据音乐当前播放位置开始播放音乐
                        play();
                        break;
                }
            }
        }
    }

    /**
     * 销毁回调方法
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        // 释放媒体播放器
        if (mp != null) {
            mp.release();
            mp = null;
        }
        // 注销广播接收者
        unregisterReceiver(receiver);
        // 设置线程循环控制变量
        isRunning = false;
        // 销毁子线程
        thread = null;
    }
}

---

/**
 * 访问网络乐库应用程序类
 * Created by lenovo on 2018/1/24.
 */

public class AccessWebMusicStoreApplication extends Application implements AppConstants {
    /**
     * 简单日期格式
     */
    private SimpleDateFormat sdf;
    /**
     * 音乐列表
     */
    private List<Music> musicList;
    /**
     * 当前音乐索引
     */
    private int currentMusicIndex;
    /**
     * 播放模式
     */
    private int playMode;
    /**
     * 专辑图片数组
     */
    private Bitmap[] albums;
    /**
     * 专辑图片索引
     */
    private int albumIndex;

    public int getProgressChangedByUser() {
        return progressChangedByUser;
    }

    public void setProgressChangedByUser(int progressChangedByUser) {
        this.progressChangedByUser = progressChangedByUser;
    }

    /**
     * 用户修改的播放进度
     */
    private int progressChangedByUser;


    public int getCurrentPosition() {
        return currentPosition;
    }

    public void setCurrentPosition(int currentPosition) {
        this.currentPosition = currentPosition;
    }

    /**
     * 音乐播放进度值
     */
    private int currentPosition;

    @Override
    public void onCreate() {
        super.onCreate();
        // 创建简单日期格式对象
        sdf = new SimpleDateFormat("mm:ss");
        // 定义获取音乐列表的网址
        String strGetMusicListUrl = MUSIC_SERVER_URL + "/getMusicList";
        // 执行获取音乐列表异步任务，传入一个参数：获取音乐列表的网址
        new GetMusicListTask().execute(strGetMusicListUrl);
    }

    /**
     * 编码字符串  39
     */

    /**
     * 获取音乐列表异步任务类
     */
    private class GetMusicListTask extends AsyncTask<String, Void, String> {
        @Override
        protected String doInBackground(String... params) {
            // 定义结果字符串
            String result = "";
            // 创建get请求
            HttpGet request = new HttpGet(params[0]);
            // 创建http客户端
            HttpClient client = new DefaultHttpClient();
            try {
                // 执行get请求，返回响应对象
                HttpResponse response = client.execute(request);
                // 根据响应对象里的状态码判断是否请求成功
                if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                    // 获取响应数据实体
                    HttpEntity entity = response.getEntity();
                    // 将响应数据实体转换成字符串作为返回值
                    result = EntityUtils.toString(entity, "gbk");
                }

            } catch (IOException e) {
                e.printStackTrace();
            }

            // 返回结果字符串
            return result;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            // 判断结果是否为空
            if (!result.equals("")) {
                /* 将获取json字符串转换成数组列表 */
                // 创建音乐列表
                musicList = new ArrayList<>();
                try {
                    // 基于json字符串创建json数组
                    JSONArray array = new JSONArray(result);
                    // 创建专辑图片数组
                    albums = new Bitmap[array.length()];
                    // 创建json对象
                    JSONObject object;
                    // 遍历json数组
                    for (int i = 0; i < array.length(); i++) {
                        // 获取json数组元素
                        object = array.getJSONObject(i);
                        // 创建音乐实体
                        Music music = new Music();
                        // 设置音乐实体属性
                        music.setId(object.getInt("id"));
                        music.setData(object.getString("data"));
                        music.setTitle(object.getString("title"));
                        music.setArtist(object.getString("artist"));
                        music.setDuration(object.getInt("duration"));
                        music.setAlbum(object.getString("album"));
                        // 执行获取专辑图片异步任务，传入两个参数（专辑图片索引，专辑图片路径）
                        new GetAlbumTask().execute(String.valueOf(i), music.getAlbum());
                        // 将音乐实体添加到音乐列表
                        musicList.add(music);
                    }
                    //读取排序设置
                    SharedPreferences sp = getSharedPreferences(USER_CONFIG, MODE_PRIVATE);
                    String orderBy = sp.getString("order-by","default");
                    if (orderBy.equals("dedault")) {  //默认排序
                        Collections.sort(musicList, new Comparator<Music>() {
                            @Override
                            public int compare(Music lhs, Music rhs) {
                                return (int) (lhs.getId() - rhs.getId());
                            }
                        });
                    } else if (orderBy.equals("title")) { //按标题排序
                        Collections.sort(musicList, new Comparator<Music>() {
                            @Override
                            public int compare(Music lhs, Music rhs) {
                                return lhs.getTitle().compareTo(rhs.getTitle());
                            }
                        });
                    } else if (orderBy.equals("duration")) {  //按音乐时长排序
                        Collections.sort(musicList, new Comparator<Music>() {
                            @Override
                            public int compare(Music lhs, Music rhs) {
                                return lhs.getDuration() - rhs.getDuration();
                            }
                        });

                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 获取专辑图片异步任务
     */
    private class GetAlbumTask extends AsyncTask<String, Void, Void> {
        @Override
        protected Void doInBackground(String... params) {
            // 获取专辑图片索引
            albumIndex = Integer.parseInt(params[0]);
            // 获取专辑图片路径
            String albumPath = params[1];
            // 声明URL连接
            HttpURLConnection conn = null;
            // 声明位图对象
            Bitmap bitmap = null;
            try {
                // 定义URL对象
                URL url = new URL(MUSIC_SERVER_URL + albumPath);
                // 打开URL连接
                conn = (HttpURLConnection) url.openConnection();
                // 获取响应码
                int responseCode = conn.getResponseCode();
                // 根据响应码执行不同操作
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    // 由连接获取字节输入流
                    InputStream in = conn.getInputStream();
                    // 利用位图工厂生成位图对象
                    bitmap = BitmapFactory.decodeStream(in);
                } else {
                    Log.d(TAG, "没有得到响应数据。");
                }
                // 设置专辑图片数组元素值
                albums[albumIndex] = bitmap;

            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);
        }
    }

    /**
     * 获取格式化时间
     *
     * @param time
     * @return
     */
    public String getFormatTime(int time) {
        return sdf.format(time);
    }

    public List<Music> getMusicList() {
        return musicList;
    }

    public Bitmap[] getAlbums() {
        return albums;
    }

    public int getCurrentMusicIndex() {
        return currentMusicIndex;
    }

    public int getPlayMode() {
        return playMode;
    }

    public void setCurrentMusicIndex(int currentMusicIndex) {
        this.currentMusicIndex = currentMusicIndex;
    }

    public void setPlayMode(int playMode) {
        this.playMode = playMode;
    }
}

---

程序实现效果：

Android项目代码：https://liumce.github.io/Android/
Web服务器测试代码：链接：https://pan.baidu.com/s/1c3xeWu8 密码：qy31