多媒体——音频——利用MediaPlayer播放音频

我会带着你远行 2024-04-03 09:15 94阅读 0赞

**利用MediaPlayer播放音频**

若要在App内部自己播音，可使用媒体播放器MediaPlayer，具体的实现步骤如下：

(1)声明音频类型的实体对象；

(2)通过内容解析器查询系统的音频库，把符合条件的音频记录依次添加到音频列表；

(3)找到若干音频文件之后，再利用MediaPlayer来播音；

![42a1b19aeb0e202aa331ab225ee61acc.png][]

![6f8609324cfcb72353c5d8ffb3bcb773.png][]

布局：

![5e0e91d8ed4b982a2d80359a3bc4416d.png][]

AudioRecyclerAdapter

package com.example.myapplication.adapter;
    
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.LinearLayout;
    import android.widget.ProgressBar;
    import android.widget.TextView;
    
    import androidx.recyclerview.widget.RecyclerView;
    
    import com.example.myapplication.R;
    import com.example.myapplication.bean.MediaInfo;
    import com.example.myapplication.util.MediaUtil;
    import com.example.myapplication.widget.RecyclerExtras;
    
    import java.util.List;
    
    public class AudioRecyclerAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
        private Context mContext; // 声明一个上下文对象
        private List<MediaInfo> mAudioList; // 声明一个音频信息列表
    
        public AudioRecyclerAdapter(Context context, List<MediaInfo> audio_list) {
            mContext = context;
            mAudioList = audio_list;
        }
    
        // 获取列表项的个数
        public int getItemCount() {
            return mAudioList.size();
        }
    
        // 创建列表项的视图持有者
        public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup vg, int viewType) {
            // 根据布局文件item_audio.xml生成视图对象
            View v = LayoutInflater.from(mContext).inflate(R.layout.item_audio, vg, false);
            return new ItemHolder(v);
        }
    
        // 绑定列表项的视图持有者
        public void onBindViewHolder(RecyclerView.ViewHolder vh, @SuppressLint("RecyclerView") final int position) {
            ItemHolder holder = (ItemHolder) vh;
            MediaInfo audio = mAudioList.get(position);
            holder.tv_name.setText(audio.getTitle()); // 显示音频名称
            holder.tv_duration.setText(MediaUtil.formatDuration(audio.getDuration())); // 显示音频时长
            if (audio.getProgress() >= 0) { // 正在播放
                holder.ll_progress.setVisibility(View.VISIBLE);
                holder.pb_audio.setMax(audio.getDuration()); // 设置进度条的最大值，也就是媒体的播放时长
                holder.pb_audio.setProgress(audio.getProgress()); // 设置进度条的播放进度，也就是已播放的进度
                holder.tv_progress.setText(MediaUtil.formatDuration(audio.getProgress())); // 显示已播放时长
            } else { // 没在播放
                holder.ll_progress.setVisibility(View.GONE);
            }
            // 列表项的点击事件需要自己实现
            holder.ll_audio.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (mOnItemClickListener != null) {
                        mOnItemClickListener.onItemClick(v, position);
                    }
                }
            });
        }
    
        // 获取列表项的类型
        public int getItemViewType(int position) {
            return 0;
        }
    
        // 获取列表项的编号
        public long getItemId(int position) {
            return position;
        }
    
        // 定义列表项的视图持有者
        public class ItemHolder extends RecyclerView.ViewHolder {
            public LinearLayout ll_audio; // 声明音频列表的线性布局对象
            public TextView tv_name; // 声明音频名称的文本视图对象
            public TextView tv_duration; // 声明总时长的文本视图对象
            public LinearLayout ll_progress; // 声明进度区域的线性布局对象
            public ProgressBar pb_audio; // 声明音频播放的进度条对象
            public TextView tv_progress; // 声明已播放时长的文本视图对象
    
            public ItemHolder(View v) {
                super(v);
                ll_audio = v.findViewById(R.id.ll_audio);
                tv_name = v.findViewById(R.id.tv_name);
                tv_duration = v.findViewById(R.id.tv_duration);
                ll_progress = v.findViewById(R.id.ll_progress);
                pb_audio = v.findViewById(R.id.pb_audio);
                tv_progress = v.findViewById(R.id.tv_progress);
            }
    
        }
    
        // 声明列表项的点击监听器对象
        private RecyclerExtras.OnItemClickListener mOnItemClickListener;
        public void setOnItemClickListener(RecyclerExtras.OnItemClickListener listener) {
            this.mOnItemClickListener = listener;
        }
    
    }

MediaInfo

package com.example.myapplication.bean;
    
    public class MediaInfo {
        private long id; // 编号
        private String title; // 标题
        private int duration; // 播放时长
        private long size; // 文件大小
        private String path; // 文件路径
        private int progress=-1; // 播放进度
    
        public long getId() {
            return id;
        }
    
        public void setId(long id) {
            this.id = id;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public int getDuration() {
            return duration;
        }
    
        public void setDuration(int duration) {
            this.duration = duration;
        }
    
        public long getSize() {
            return size;
        }
    
        public void setSize(long size) {
            this.size = size;
        }
    
        public String getPath() {
            return path;
        }
    
        public void setPath(String path) {
            this.path = path;
        }
    
        public int getProgress() {
            return progress;
        }
    
        public void setProgress(int progress) {
            this.progress = progress;
        }
    
    }

MediaUtil

package com.example.myapplication.util;
    
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.graphics.Bitmap;
    import android.media.MediaMetadataRetriever;
    import android.net.Uri;
    import android.os.Environment;
    import android.util.Log;
    
    import java.io.File;
    
    @SuppressLint("DefaultLocale")
    public class MediaUtil {
        private final static String TAG = "MediaUtil";
    
        // 格式化播放时长(mm:ss)
        public static String formatDuration(int milliseconds) {
            int seconds = milliseconds / 1000;
            int hour = seconds / 3600;
            int minute = seconds / 60;
            int second = seconds % 60;
            String str;
            if (hour > 0) {
                str = String.format("%02d:%02d:%02d", hour, minute, second);
            } else {
                str = String.format("%02d:%02d", minute, second);
            }
            return str;
        }
    
        // 获得音视频文件的缓存路径
        public static String getRecordFilePath(Context context, String dir_name, String extend_name) {
            String path = "";
            File recordDir = new File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS).toString() + "/" + dir_name + "/");
            if (!recordDir.exists()) {
                recordDir.mkdirs();
            }
            try {
                File recordFile = File.createTempFile(DateUtil.getNowDateTime(), extend_name, recordDir);
                path = recordFile.getAbsolutePath();
                Log.d(TAG, "dir_name=" + dir_name + ", extend_name=" + extend_name + ", path=" + path);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return path;
        }
    
        // 获取视频文件中的某帧图片
        public static Bitmap getOneFrame(Context ctx, Uri uri) {
            MediaMetadataRetriever retriever = new MediaMetadataRetriever();
            retriever.setDataSource(ctx, uri);
            // 获得视频的播放时长，大于1秒的取第1秒处的帧图，不足1秒的取第0秒处的帧图
            String duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
            Log.d(TAG, "duration="+duration);
            int pos = (Integer.parseInt(duration)/1000)>1 ? 1 : 0;
            // 获取指定时间的帧图，注意getFrameAtTime方法的时间单位是微秒
            return retriever.getFrameAtTime(pos * 1000 * 1000);
        }
    }

RecyclerExtras

package com.example.myapplication.widget;
    
    import android.view.View;
    
    public class RecyclerExtras
    {
    
    
        // 定义一个循环视图列表项的点击监听器接口
        public interface OnItemClickListener
        {
    
            void onItemClick(View view, int position);
        }
    
        // 定义一个循环视图列表项的长按监听器接口
        public interface OnItemLongClickListener
        {
    
            void onItemLongClick(View view, int position);
        }
    
        // 定义一个循环视图列表项的删除监听器接口
        public interface OnItemDeleteClickListener
        {
    
            void onItemDeleteClick(View view, int position);
        }
    
    }

FileUtil

package com.example.myapplication.util;
    
    import android.content.Context;
    import android.database.Cursor;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.net.Uri;
    import android.os.Build;
    import android.provider.MediaStore;
    import android.util.Log;
    
    import androidx.core.content.FileProvider;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    public class FileUtil {
        private final static String TAG = "FileUtil";
    
        // 把字符串保存到指定路径的文本文件
        public static void saveText(String path, String txt) {
            // 根据指定的文件路径构建文件输出流对象
            try (FileOutputStream fos = new FileOutputStream(path)) {
                fos.write(txt.getBytes()); // 把字符串写入文件输出流
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 从指定路径的文本文件中读取内容字符串
        public static String openText(String path) {
            String readStr = "";
            // 根据指定的文件路径构建文件输入流对象
            try (FileInputStream fis = new FileInputStream(path)) {
                byte[] b = new byte[fis.available()];
                fis.read(b); // 从文件输入流读取字节数组
                readStr = new String(b); // 把字节数组转换为字符串
            } catch (Exception e) {
                e.printStackTrace();
            }
            return readStr; // 返回文本文件中的文本字符串
        }
    
        // 把位图数据保存到指定路径的图片文件
        public static void saveImage(String path, Bitmap bitmap) {
            // 根据指定的文件路径构建文件输出流对象
            try (FileOutputStream fos = new FileOutputStream(path)) {
                // 把位图数据压缩到文件输出流中
                bitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 从指定路径的图片文件中读取位图数据
        public static Bitmap openImage(String path) {
            Bitmap bitmap = null; // 声明一个位图对象
            // 根据指定的文件路径构建文件输入流对象
            try (FileInputStream fis = new FileInputStream(path)) {
                // 从文件输入流中解码位图数据
                bitmap = BitmapFactory.decodeStream(fis);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bitmap; // 返回图片文件中的位图数据
        }
    
        // 检查文件是否存在，以及文件路径是否合法
        public static boolean checkFileUri(Context ctx, String path) {
            boolean result = true;
            File file = new File(path);
            if (!file.exists() || !file.isFile() || file.length() <= 0) {
                result = false;
            }
            try
            {
                Uri uri = Uri.parse(path); // 根据指定路径创建一个Uri对象
    
                // 兼容Android7.0，把访问文件的Uri方式改为FileProvider
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
                {
    
    //                // 通过FileProvider获得文件的Uri访问方式
    //                uri = FileProvider.getUriForFile(ctx,
    //                        ctx.getPackageName()+".fileProvider", new File(path));
                }
            }
            catch (Exception e)   // 该路径可能不存在
            {
                e.printStackTrace();
                result = false;
            }
            return result;
        }
    
        // 把指定uri保存为存储卡文件
        public static void saveFileFromUri(Context ctx, Uri src, String dest) {
            try (InputStream is = ctx.getContentResolver().openInputStream(src);
                 OutputStream os = new FileOutputStream(dest);) {
                int byteCount = 0;
                byte[] bytes = new byte[8096];
                while ((byteCount = is.read(bytes)) != -1){
                    os.write(bytes, 0, byteCount);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 从content://media/external/file/这样的Uri中获取文件路径
        public static String getPathFromContentUri(Context context, Uri uri) {
            String path = uri.toString();
            if (path.startsWith("content://")) {
                String[] proj = new String[]{ // 媒体库的字段名称数组
                        MediaStore.Video.Media._ID, // 编号
                        MediaStore.Video.Media.TITLE, // 标题
                        MediaStore.Video.Media.SIZE, // 文件大小
                        MediaStore.Video.Media.MIME_TYPE, // 文件类型
                        MediaStore.Video.Media.DATA // 文件大小
                };
                try (Cursor cursor = context.getContentResolver().query(uri,
                        proj, null, null, null)) {
                    cursor.moveToFirst(); // 把游标移动到开头
                    if (cursor.getString(4) != null) {
                        path = cursor.getString(4);
                    }
                    Log.d(TAG, cursor.getLong(0) + " " + cursor.getString(1)
                            + " " + cursor.getLong(2) + " " + cursor.getString(3)
                            + " " + cursor.getString(4));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return path;
        }
    
    }

MainActivity

package com.example.myapplication;
    
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.recyclerview.widget.LinearLayoutManager;
    import androidx.recyclerview.widget.RecyclerView;
    
    import android.database.Cursor;
    import android.media.AudioManager;
    import android.media.MediaPlayer;
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.provider.MediaStore;
    import android.util.Log;
    import android.view.View;
    import com.example.myapplication.adapter.AudioRecyclerAdapter;
    import com.example.myapplication.bean.MediaInfo;
    import com.example.myapplication.util.FileUtil;
    import com.example.myapplication.widget.RecyclerExtras;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class MainActivity extends AppCompatActivity implements RecyclerExtras.OnItemClickListener {
        private final static String TAG = "AudioPlayActivity";
        private RecyclerView rv_audio; // 音频列表的循环视图
        private List<MediaInfo> mAudioList = new ArrayList<MediaInfo>(); // 音频列表
        private Uri mAudioUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI; // 音频库的Uri
        private String[] mAudioColumn = new String[]{ // 媒体库的字段名称数组
                MediaStore.Audio.Media._ID, // 编号
                MediaStore.Audio.Media.TITLE, // 标题
                MediaStore.Audio.Media.DURATION, // 播放时长
                MediaStore.Audio.Media.SIZE, // 文件大小
                MediaStore.Audio.Media.DATA}; // 文件路径
        private AudioRecyclerAdapter mAdapter; // 音频列表的适配器
        private MediaPlayer mMediaPlayer = new MediaPlayer(); // 媒体播放器
        private Timer mTimer = new Timer(); // 计时器
        private int mLastPosition = -1; // 上次播放的音频序号
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            rv_audio = findViewById(R.id.rv_audio);
            loadAudioList(); // 加载音频列表
            showAudioList(); // 显示音频列表
        }
    
        // 加载音频列表
        private void loadAudioList() {
            mAudioList.clear(); // 清空音频列表
            // 通过内容解析器查询音频库，并返回结果集的游标。记录结果按照修改时间降序返回
            Cursor cursor = getContentResolver().query(mAudioUri, mAudioColumn,null, null, "date_modified desc");
    
            if (cursor != null)
            {
    
                // 下面遍历结果集，并逐个添加到音频列表。简单起见只挑选前十个音频
                for (int i=0; i<10 && cursor.moveToNext(); i++)
                {
    
                    MediaInfo audio = new MediaInfo(); // 创建一个音频信息对象
                    audio.setId(cursor.getLong(0)); // 设置音频编号
                    audio.setTitle(cursor.getString(1)); // 设置音频标题
                    audio.setDuration(cursor.getInt(2)); // 设置音频时长
                    audio.setSize(cursor.getLong(3)); // 设置音频大小
                    audio.setPath(cursor.getString(4)); // 设置音频路径
                    Log.d(TAG, audio.getTitle() + " " + audio.getDuration() + " " + audio.getSize() + " " + audio.getPath());
    
                    if (!FileUtil.checkFileUri(this, audio.getPath()))
                    {
    
                        i--;
                        continue;
                    }
                    mAudioList.add(audio); // 添加至音频列表
                }
                cursor.close(); // 关闭数据库游标
            }
        }
    
        // 显示音频列表
        private void showAudioList()
        {
    
            // 创建一个水平方向的线性布局管理器
            LinearLayoutManager manager = new LinearLayoutManager(this, RecyclerView.VERTICAL, false);
    
            rv_audio.setLayoutManager(manager); // 设置循环视图的布局管理器
    
            mAdapter = new AudioRecyclerAdapter(this, mAudioList); // 创建音频列表的线性适配器
    
            mAdapter.setOnItemClickListener(this); // 设置线性列表的点击监听器
    
            rv_audio.setAdapter(mAdapter); // 设置循环视图的列表适配器
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            mTimer.cancel(); // 取消计时器
            if (mMediaPlayer.isPlaying()) { // 是否正在播放
                mMediaPlayer.stop(); // 结束播放
            }
            mMediaPlayer.release(); // 释放媒体播放器
        }
    
        @Override
        public void onItemClick(View view, final int position) {
            if (mLastPosition!=-1 && mLastPosition!=position) {
                MediaInfo last_audio = mAudioList.get(mLastPosition);
                last_audio.setProgress(-1); // 当前进度设为-1表示没在播放
                mAudioList.set(mLastPosition, last_audio);
                mAdapter.notifyItemChanged(mLastPosition); // 刷新此处的列表项
            }
            mLastPosition = position;
            final MediaInfo audio = mAudioList.get(position);
            Log.d(TAG, "onItemClick position="+position+",audio.getPath()="+audio.getPath());
            mTimer.cancel(); // 取消计时器
            mMediaPlayer.reset(); // 重置媒体播放器
            // mMediaPlayer.setVolume(0.5f, 0.5f); // 设置音量，可选
            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); // 设置音频流的类型为音乐
            try {
                mMediaPlayer.setDataSource(audio.getPath()); // 设置媒体数据的文件路径
                mMediaPlayer.prepare(); // 媒体播放器准备就绪
                mMediaPlayer.start(); // 媒体播放器开始播放
            } catch (Exception e) {
                e.printStackTrace();
            }
            mTimer = new Timer(); // 创建一个计时器
            mTimer.schedule(new TimerTask() {
                @Override
                public void run() {
                    audio.setProgress(mMediaPlayer.getCurrentPosition()); // 设置进度条的当前进度
                    mAudioList.set(position, audio);
                    // 界面刷新操作需要在主线程执行，故而向处理器发送消息，由处理器在主线程更新界面
                    mHandler.sendEmptyMessage(position);
                    Log.d(TAG, "CurrentPosition="+mMediaPlayer.getCurrentPosition()+",position="+position);
                }
            }, 0, 1000); // 计时器每隔一秒就更新进度条上的播放进度
        }
    
        private Handler mHandler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                mAdapter.notifyItemChanged(msg.what); // 刷新此处的列表项
            }
        };
    
    }

![ff19f60bd94a5d0ed91aa540e1bb4c43.png][]

![3fc516f3bacbf5a829dbcc204f39c312.png][]

![c7acba08034cf606df4d8835dfac9d32.png][]

![c03a2da036e0cb521813a1b9fb6fbbe4.png][]

![5c12dbfef0e9653030e48d69425f7258.png][]

![00ebbd63b5ca9780896d8db21c6440a4.png][]

![75f3c73bedd21414fa6e21a313898d28.png][]

[42a1b19aeb0e202aa331ab225ee61acc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3d39aabc1cd24196b9d09dc9feaac43e.png
[6f8609324cfcb72353c5d8ffb3bcb773.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/77c321242ea141cea32cc62eb63bae01.png
[5e0e91d8ed4b982a2d80359a3bc4416d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/51c32cfd648342019d2a99d1c836dcd1.png
[ff19f60bd94a5d0ed91aa540e1bb4c43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/0d50dbdcf57247209884018f1f450310.png
[3fc516f3bacbf5a829dbcc204f39c312.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7d757a42e466491ba291212c5af3479b.png
[c7acba08034cf606df4d8835dfac9d32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/eb32085b026d478dbdb6ac5f934cb926.png
[c03a2da036e0cb521813a1b9fb6fbbe4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ea54735bcf084a38b91829353e71040b.png
[5c12dbfef0e9653030e48d69425f7258.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/cb3cf142367442c294bf53716e99d678.png
[00ebbd63b5ca9780896d8db21c6440a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5e569bb9fc2b4ace844e0f08faa935e1.png
[75f3c73bedd21414fa6e21a313898d28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/8f2da4b70db648068f37966988487970.png