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

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

利用MediaPlayer播放音频

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

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

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

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

42a1b19aeb0e202aa331ab225ee61acc.png

6f8609324cfcb72353c5d8ffb3bcb773.png

布局：

  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     android:layout_width="match_parent"
  3.     android:layout_height="match_parent"
  4.     android:orientation="vertical"
  5.     android:padding="5dp">
  7.     <TextView
  8.         android:layout_width="match_parent"
  9.         android:layout_height="wrap_content"
  10.         android:gravity="center"
  11.         android:text="点击音频列表开始播放"
  12.         android:textColor="@color/black"
  13.         android:textSize="17sp" />
  15.     <LinearLayout
  16.         android:layout_width="match_parent"
  17.         android:layout_height="40dp"
  18.         android:layout_margin="2dp"
  19.         android:orientation="horizontal">
  21.         <TextView
  22.             android:layout_width="0dp"
  23.             android:layout_height="match_parent"
  24.             android:layout_weight="3"
  25.             android:gravity="left|center"
  26.             android:text="音频名称"
  27.             android:textColor="@color/black"
  28.             android:textSize="15sp" />
  30.         <TextView
  31.             android:layout_width="0dp"
  32.             android:layout_height="match_parent"
  33.             android:layout_weight="1"
  34.             android:gravity="right|center"
  35.             android:text="总时长"
  36.             android:textColor="@color/black"
  37.             android:textSize="15sp" />
  39.     </LinearLayout>
  41.     <androidx.recyclerview.widget.RecyclerView
  42.         android:id="@+id/rv_audio"
  43.         android:layout_width="match_parent"
  44.         android:layout_height="0dp"
  45.         android:layout_weight="1" />
  47. </LinearLayout>

5e0e91d8ed4b982a2d80359a3bc4416d.png

  1. AudioRecyclerAdapter
  3. package com.example.myapplication.adapter;
  5. import android.annotation.SuppressLint;
  6. import android.content.Context;
  7. import android.view.LayoutInflater;
  8. import android.view.View;
  9. import android.view.ViewGroup;
  10. import android.widget.LinearLayout;
  11. import android.widget.ProgressBar;
  12. import android.widget.TextView;
  14. import androidx.recyclerview.widget.RecyclerView;
  16. import com.example.myapplication.R;
  17. import com.example.myapplication.bean.MediaInfo;
  18. import com.example.myapplication.util.MediaUtil;
  19. import com.example.myapplication.widget.RecyclerExtras;
  21. import java.util.List;
  23. public class AudioRecyclerAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
  24.     private Context mContext; // 声明一个上下文对象
  25.     private List<MediaInfo> mAudioList; // 声明一个音频信息列表
  27.     public AudioRecyclerAdapter(Context context, List<MediaInfo> audio_list) {
  28.         mContext = context;
  29.         mAudioList = audio_list;
  30.     }
  32.     // 获取列表项的个数
  33.     public int getItemCount() {
  34.         return mAudioList.size();
  35.     }
  37.     // 创建列表项的视图持有者
  38.     public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup vg, int viewType) {
  39.         // 根据布局文件item_audio.xml生成视图对象
  40.         View v = LayoutInflater.from(mContext).inflate(R.layout.item_audio, vg, false);
  41.         return new ItemHolder(v);
  42.     }
  44.     // 绑定列表项的视图持有者
  45.     public void onBindViewHolder(RecyclerView.ViewHolder vh, @SuppressLint("RecyclerView") final int position) {
  46.         ItemHolder holder = (ItemHolder) vh;
  47.         MediaInfo audio = mAudioList.get(position);
  48.         holder.tv_name.setText(audio.getTitle()); // 显示音频名称
  49.         holder.tv_duration.setText(MediaUtil.formatDuration(audio.getDuration())); // 显示音频时长
  50.         if (audio.getProgress() >= 0) { // 正在播放
  51.             holder.ll_progress.setVisibility(View.VISIBLE);
  52.             holder.pb_audio.setMax(audio.getDuration()); // 设置进度条的最大值，也就是媒体的播放时长
  53.             holder.pb_audio.setProgress(audio.getProgress()); // 设置进度条的播放进度，也就是已播放的进度
  54.             holder.tv_progress.setText(MediaUtil.formatDuration(audio.getProgress())); // 显示已播放时长
  55.         } else { // 没在播放
  56.             holder.ll_progress.setVisibility(View.GONE);
  57.         }
  58.         // 列表项的点击事件需要自己实现
  59.         holder.ll_audio.setOnClickListener(new View.OnClickListener() {
  60.             @Override
  61.             public void onClick(View v) {
  62.                 if (mOnItemClickListener != null) {
  63.                     mOnItemClickListener.onItemClick(v, position);
  64.                 }
  65.             }
  66.         });
  67.     }
  69.     // 获取列表项的类型
  70.     public int getItemViewType(int position) {
  71.         return 0;
  72.     }
  74.     // 获取列表项的编号
  75.     public long getItemId(int position) {
  76.         return position;
  77.     }
  79.     // 定义列表项的视图持有者
  80.     public class ItemHolder extends RecyclerView.ViewHolder {
  81.         public LinearLayout ll_audio; // 声明音频列表的线性布局对象
  82.         public TextView tv_name; // 声明音频名称的文本视图对象
  83.         public TextView tv_duration; // 声明总时长的文本视图对象
  84.         public LinearLayout ll_progress; // 声明进度区域的线性布局对象
  85.         public ProgressBar pb_audio; // 声明音频播放的进度条对象
  86.         public TextView tv_progress; // 声明已播放时长的文本视图对象
  88.         public ItemHolder(View v) {
  89.             super(v);
  90.             ll_audio = v.findViewById(R.id.ll_audio);
  91.             tv_name = v.findViewById(R.id.tv_name);
  92.             tv_duration = v.findViewById(R.id.tv_duration);
  93.             ll_progress = v.findViewById(R.id.ll_progress);
  94.             pb_audio = v.findViewById(R.id.pb_audio);
  95.             tv_progress = v.findViewById(R.id.tv_progress);
  96.         }
  98.     }
  100.     // 声明列表项的点击监听器对象
  101.     private RecyclerExtras.OnItemClickListener mOnItemClickListener;
  102.     public void setOnItemClickListener(RecyclerExtras.OnItemClickListener listener) {
  103.         this.mOnItemClickListener = listener;
  104.     }
  106. }
  108. MediaInfo
  110. package com.example.myapplication.bean;
  112. public class MediaInfo {
  113.     private long id; // 编号
  114.     private String title; // 标题
  115.     private int duration; // 播放时长
  116.     private long size; // 文件大小
  117.     private String path; // 文件路径
  118.     private int progress=-1; // 播放进度
  120.     public long getId() {
  121.         return id;
  122.     }
  124.     public void setId(long id) {
  125.         this.id = id;
  126.     }
  128.     public String getTitle() {
  129.         return title;
  130.     }
  132.     public void setTitle(String title) {
  133.         this.title = title;
  134.     }
  136.     public int getDuration() {
  137.         return duration;
  138.     }
  140.     public void setDuration(int duration) {
  141.         this.duration = duration;
  142.     }
  144.     public long getSize() {
  145.         return size;
  146.     }
  148.     public void setSize(long size) {
  149.         this.size = size;
  150.     }
  152.     public String getPath() {
  153.         return path;
  154.     }
  156.     public void setPath(String path) {
  157.         this.path = path;
  158.     }
  160.     public int getProgress() {
  161.         return progress;
  162.     }
  164.     public void setProgress(int progress) {
  165.         this.progress = progress;
  166.     }
  168. }
  170. MediaUtil
  172. package com.example.myapplication.util;
  174. import android.annotation.SuppressLint;
  175. import android.content.Context;
  176. import android.graphics.Bitmap;
  177. import android.media.MediaMetadataRetriever;
  178. import android.net.Uri;
  179. import android.os.Environment;
  180. import android.util.Log;
  182. import java.io.File;
  184. @SuppressLint("DefaultLocale")
  185. public class MediaUtil {
  186.     private final static String TAG = "MediaUtil";
  188.     // 格式化播放时长(mm:ss)
  189.     public static String formatDuration(int milliseconds) {
  190.         int seconds = milliseconds / 1000;
  191.         int hour = seconds / 3600;
  192.         int minute = seconds / 60;
  193.         int second = seconds % 60;
  194.         String str;
  195.         if (hour > 0) {
  196.             str = String.format("%02d:%02d:%02d", hour, minute, second);
  197.         } else {
  198.             str = String.format("%02d:%02d", minute, second);
  199.         }
  200.         return str;
  201.     }
  203.     // 获得音视频文件的缓存路径
  204.     public static String getRecordFilePath(Context context, String dir_name, String extend_name) {
  205.         String path = "";
  206.         File recordDir = new File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS).toString() + "/" + dir_name + "/");
  207.         if (!recordDir.exists()) {
  208.             recordDir.mkdirs();
  209.         }
  210.         try {
  211.             File recordFile = File.createTempFile(DateUtil.getNowDateTime(), extend_name, recordDir);
  212.             path = recordFile.getAbsolutePath();
  213.             Log.d(TAG, "dir_name=" + dir_name + ", extend_name=" + extend_name + ", path=" + path);
  214.         } catch (Exception e) {
  215.             e.printStackTrace();
  216.         }
  217.         return path;
  218.     }
  220.     // 获取视频文件中的某帧图片
  221.     public static Bitmap getOneFrame(Context ctx, Uri uri) {
  222.         MediaMetadataRetriever retriever = new MediaMetadataRetriever();
  223.         retriever.setDataSource(ctx, uri);
  224.         // 获得视频的播放时长，大于1秒的取第1秒处的帧图，不足1秒的取第0秒处的帧图
  225.         String duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
  226.         Log.d(TAG, "duration="+duration);
  227.         int pos = (Integer.parseInt(duration)/1000)>1 ? 1 : 0;
  228.         // 获取指定时间的帧图，注意getFrameAtTime方法的时间单位是微秒
  229.         return retriever.getFrameAtTime(pos * 1000 * 1000);
  230.     }
  231. }
  233. RecyclerExtras
  235. package com.example.myapplication.widget;
  237. import android.view.View;
  239. public class RecyclerExtras
  240. {
  243.     // 定义一个循环视图列表项的点击监听器接口
  244.     public interface OnItemClickListener
  245.     {
  247.         void onItemClick(View view, int position);
  248.     }
  250.     // 定义一个循环视图列表项的长按监听器接口
  251.     public interface OnItemLongClickListener
  252.     {
  254.         void onItemLongClick(View view, int position);
  255.     }
  257.     // 定义一个循环视图列表项的删除监听器接口
  258.     public interface OnItemDeleteClickListener
  259.     {
  261.         void onItemDeleteClick(View view, int position);
  262.     }
  264. }
  266. FileUtil
  268. package com.example.myapplication.util;
  270. import android.content.Context;
  271. import android.database.Cursor;
  272. import android.graphics.Bitmap;
  273. import android.graphics.BitmapFactory;
  274. import android.net.Uri;
  275. import android.os.Build;
  276. import android.provider.MediaStore;
  277. import android.util.Log;
  279. import androidx.core.content.FileProvider;
  281. import java.io.File;
  282. import java.io.FileInputStream;
  283. import java.io.FileOutputStream;
  284. import java.io.InputStream;
  285. import java.io.OutputStream;
  287. public class FileUtil {
  288.     private final static String TAG = "FileUtil";
  290.     // 把字符串保存到指定路径的文本文件
  291.     public static void saveText(String path, String txt) {
  292.         // 根据指定的文件路径构建文件输出流对象
  293.         try (FileOutputStream fos = new FileOutputStream(path)) {
  294.             fos.write(txt.getBytes()); // 把字符串写入文件输出流
  295.         } catch (Exception e) {
  296.             e.printStackTrace();
  297.         }
  298.     }
  300.     // 从指定路径的文本文件中读取内容字符串
  301.     public static String openText(String path) {
  302.         String readStr = "";
  303.         // 根据指定的文件路径构建文件输入流对象
  304.         try (FileInputStream fis = new FileInputStream(path)) {
  305.             byte[] b = new byte[fis.available()];
  306.             fis.read(b); // 从文件输入流读取字节数组
  307.             readStr = new String(b); // 把字节数组转换为字符串
  308.         } catch (Exception e) {
  309.             e.printStackTrace();
  310.         }
  311.         return readStr; // 返回文本文件中的文本字符串
  312.     }
  314.     // 把位图数据保存到指定路径的图片文件
  315.     public static void saveImage(String path, Bitmap bitmap) {
  316.         // 根据指定的文件路径构建文件输出流对象
  317.         try (FileOutputStream fos = new FileOutputStream(path)) {
  318.             // 把位图数据压缩到文件输出流中
  319.             bitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos);
  320.         } catch (Exception e) {
  321.             e.printStackTrace();
  322.         }
  323.     }
  325.     // 从指定路径的图片文件中读取位图数据
  326.     public static Bitmap openImage(String path) {
  327.         Bitmap bitmap = null; // 声明一个位图对象
  328.         // 根据指定的文件路径构建文件输入流对象
  329.         try (FileInputStream fis = new FileInputStream(path)) {
  330.             // 从文件输入流中解码位图数据
  331.             bitmap = BitmapFactory.decodeStream(fis);
  332.         } catch (Exception e) {
  333.             e.printStackTrace();
  334.         }
  335.         return bitmap; // 返回图片文件中的位图数据
  336.     }
  338.     // 检查文件是否存在，以及文件路径是否合法
  339.     public static boolean checkFileUri(Context ctx, String path) {
  340.         boolean result = true;
  341.         File file = new File(path);
  342.         if (!file.exists() || !file.isFile() || file.length() <= 0) {
  343.             result = false;
  344.         }
  345.         try
  346.         {
  347.             Uri uri = Uri.parse(path); // 根据指定路径创建一个Uri对象
  349.             // 兼容Android7.0，把访问文件的Uri方式改为FileProvider
  350.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
  351.             {
  353. //                // 通过FileProvider获得文件的Uri访问方式
  354. //                uri = FileProvider.getUriForFile(ctx,
  355. //                        ctx.getPackageName()+".fileProvider", new File(path));
  356.             }
  357.         }
  358.         catch (Exception e)   // 该路径可能不存在
  359.         {
  360.             e.printStackTrace();
  361.             result = false;
  362.         }
  363.         return result;
  364.     }
  366.     // 把指定uri保存为存储卡文件
  367.     public static void saveFileFromUri(Context ctx, Uri src, String dest) {
  368.         try (InputStream is = ctx.getContentResolver().openInputStream(src);
  369.              OutputStream os = new FileOutputStream(dest);) {
  370.             int byteCount = 0;
  371.             byte[] bytes = new byte[8096];
  372.             while ((byteCount = is.read(bytes)) != -1){
  373.                 os.write(bytes, 0, byteCount);
  374.             }
  375.         } catch (Exception e) {
  376.             e.printStackTrace();
  377.         }
  378.     }
  380.     // 从content://media/external/file/这样的Uri中获取文件路径
  381.     public static String getPathFromContentUri(Context context, Uri uri) {
  382.         String path = uri.toString();
  383.         if (path.startsWith("content://")) {
  384.             String[] proj = new String[]{ // 媒体库的字段名称数组
  385.                     MediaStore.Video.Media._ID, // 编号
  386.                     MediaStore.Video.Media.TITLE, // 标题
  387.                     MediaStore.Video.Media.SIZE, // 文件大小
  388.                     MediaStore.Video.Media.MIME_TYPE, // 文件类型
  389.                     MediaStore.Video.Media.DATA // 文件大小
  390.             };
  391.             try (Cursor cursor = context.getContentResolver().query(uri,
  392.                     proj, null, null, null)) {
  393.                 cursor.moveToFirst(); // 把游标移动到开头
  394.                 if (cursor.getString(4) != null) {
  395.                     path = cursor.getString(4);
  396.                 }
  397.                 Log.d(TAG, cursor.getLong(0) + " " + cursor.getString(1)
  398.                         + " " + cursor.getLong(2) + " " + cursor.getString(3)
  399.                         + " " + cursor.getString(4));
  400.             } catch (Exception e) {
  401.                 e.printStackTrace();
  402.             }
  403.         }
  404.         return path;
  405.     }
  407. }
  409. MainActivity
  411. package com.example.myapplication;
  413. import androidx.appcompat.app.AppCompatActivity;
  414. import androidx.recyclerview.widget.LinearLayoutManager;
  415. import androidx.recyclerview.widget.RecyclerView;
  417. import android.database.Cursor;
  418. import android.media.AudioManager;
  419. import android.media.MediaPlayer;
  420. import android.net.Uri;
  421. import android.os.Bundle;
  422. import android.os.Handler;
  423. import android.os.Looper;
  424. import android.os.Message;
  425. import android.provider.MediaStore;
  426. import android.util.Log;
  427. import android.view.View;
  428. import com.example.myapplication.adapter.AudioRecyclerAdapter;
  429. import com.example.myapplication.bean.MediaInfo;
  430. import com.example.myapplication.util.FileUtil;
  431. import com.example.myapplication.widget.RecyclerExtras;
  433. import java.util.ArrayList;
  434. import java.util.List;
  435. import java.util.Timer;
  436. import java.util.TimerTask;
  438. public class MainActivity extends AppCompatActivity implements RecyclerExtras.OnItemClickListener {
  439.     private final static String TAG = "AudioPlayActivity";
  440.     private RecyclerView rv_audio; // 音频列表的循环视图
  441.     private List<MediaInfo> mAudioList = new ArrayList<MediaInfo>(); // 音频列表
  442.     private Uri mAudioUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI; // 音频库的Uri
  443.     private String[] mAudioColumn = new String[]{ // 媒体库的字段名称数组
  444.             MediaStore.Audio.Media._ID, // 编号
  445.             MediaStore.Audio.Media.TITLE, // 标题
  446.             MediaStore.Audio.Media.DURATION, // 播放时长
  447.             MediaStore.Audio.Media.SIZE, // 文件大小
  448.             MediaStore.Audio.Media.DATA}; // 文件路径
  449.     private AudioRecyclerAdapter mAdapter; // 音频列表的适配器
  450.     private MediaPlayer mMediaPlayer = new MediaPlayer(); // 媒体播放器
  451.     private Timer mTimer = new Timer(); // 计时器
  452.     private int mLastPosition = -1; // 上次播放的音频序号
  454.     @Override
  455.     protected void onCreate(Bundle savedInstanceState) {
  456.         super.onCreate(savedInstanceState);
  457.         setContentView(R.layout.activity_main);
  458.         rv_audio = findViewById(R.id.rv_audio);
  459.         loadAudioList(); // 加载音频列表
  460.         showAudioList(); // 显示音频列表
  461.     }
  463.     // 加载音频列表
  464.     private void loadAudioList() {
  465.         mAudioList.clear(); // 清空音频列表
  466.         // 通过内容解析器查询音频库，并返回结果集的游标。记录结果按照修改时间降序返回
  467.         Cursor cursor = getContentResolver().query(mAudioUri, mAudioColumn,null, null, "date_modified desc");
  469.         if (cursor != null)
  470.         {
  472.             // 下面遍历结果集，并逐个添加到音频列表。简单起见只挑选前十个音频
  473.             for (int i=0; i<10 && cursor.moveToNext(); i++)
  474.             {
  476.                 MediaInfo audio = new MediaInfo(); // 创建一个音频信息对象
  477.                 audio.setId(cursor.getLong(0)); // 设置音频编号
  478.                 audio.setTitle(cursor.getString(1)); // 设置音频标题
  479.                 audio.setDuration(cursor.getInt(2)); // 设置音频时长
  480.                 audio.setSize(cursor.getLong(3)); // 设置音频大小
  481.                 audio.setPath(cursor.getString(4)); // 设置音频路径
  482.                 Log.d(TAG, audio.getTitle() + " " + audio.getDuration() + " " + audio.getSize() + " " + audio.getPath());
  484.                 if (!FileUtil.checkFileUri(this, audio.getPath()))
  485.                 {
  487.                     i--;
  488.                     continue;
  489.                 }
  490.                 mAudioList.add(audio); // 添加至音频列表
  491.             }
  492.             cursor.close(); // 关闭数据库游标
  493.         }
  494.     }
  496.     // 显示音频列表
  497.     private void showAudioList()
  498.     {
  500.         // 创建一个水平方向的线性布局管理器
  501.         LinearLayoutManager manager = new LinearLayoutManager(this, RecyclerView.VERTICAL, false);
  503.         rv_audio.setLayoutManager(manager); // 设置循环视图的布局管理器
  505.         mAdapter = new AudioRecyclerAdapter(this, mAudioList); // 创建音频列表的线性适配器
  507.         mAdapter.setOnItemClickListener(this); // 设置线性列表的点击监听器
  509.         rv_audio.setAdapter(mAdapter); // 设置循环视图的列表适配器
  510.     }
  512.     @Override
  513.     protected void onDestroy() {
  514.         super.onDestroy();
  515.         mTimer.cancel(); // 取消计时器
  516.         if (mMediaPlayer.isPlaying()) { // 是否正在播放
  517.             mMediaPlayer.stop(); // 结束播放
  518.         }
  519.         mMediaPlayer.release(); // 释放媒体播放器
  520.     }
  522.     @Override
  523.     public void onItemClick(View view, final int position) {
  524.         if (mLastPosition!=-1 && mLastPosition!=position) {
  525.             MediaInfo last_audio = mAudioList.get(mLastPosition);
  526.             last_audio.setProgress(-1); // 当前进度设为-1表示没在播放
  527.             mAudioList.set(mLastPosition, last_audio);
  528.             mAdapter.notifyItemChanged(mLastPosition); // 刷新此处的列表项
  529.         }
  530.         mLastPosition = position;
  531.         final MediaInfo audio = mAudioList.get(position);
  532.         Log.d(TAG, "onItemClick position="+position+",audio.getPath()="+audio.getPath());
  533.         mTimer.cancel(); // 取消计时器
  534.         mMediaPlayer.reset(); // 重置媒体播放器
  535.         // mMediaPlayer.setVolume(0.5f, 0.5f); // 设置音量，可选
  536.         mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); // 设置音频流的类型为音乐
  537.         try {
  538.             mMediaPlayer.setDataSource(audio.getPath()); // 设置媒体数据的文件路径
  539.             mMediaPlayer.prepare(); // 媒体播放器准备就绪
  540.             mMediaPlayer.start(); // 媒体播放器开始播放
  541.         } catch (Exception e) {
  542.             e.printStackTrace();
  543.         }
  544.         mTimer = new Timer(); // 创建一个计时器
  545.         mTimer.schedule(new TimerTask() {
  546.             @Override
  547.             public void run() {
  548.                 audio.setProgress(mMediaPlayer.getCurrentPosition()); // 设置进度条的当前进度
  549.                 mAudioList.set(position, audio);
  550.                 // 界面刷新操作需要在主线程执行，故而向处理器发送消息，由处理器在主线程更新界面
  551.                 mHandler.sendEmptyMessage(position);
  552.                 Log.d(TAG, "CurrentPosition="+mMediaPlayer.getCurrentPosition()+",position="+position);
  553.             }
  554.         }, 0, 1000); // 计时器每隔一秒就更新进度条上的播放进度
  555.     }
  557.     private Handler mHandler = new Handler(Looper.myLooper()) {
  558.         @Override
  559.         public void handleMessage(Message msg) {
  560.             super.handleMessage(msg);
  561.             mAdapter.notifyItemChanged(msg.what); // 刷新此处的列表项
  562.         }
  563.     };
  565. }

ff19f60bd94a5d0ed91aa540e1bb4c43.png

3fc516f3bacbf5a829dbcc204f39c312.png

c7acba08034cf606df4d8835dfac9d32.png

c03a2da036e0cb521813a1b9fb6fbbe4.png

5c12dbfef0e9653030e48d69425f7258.png

00ebbd63b5ca9780896d8db21c6440a4.png

75f3c73bedd21414fa6e21a313898d28.png

发表评论

表情：
评论列表 （有 0 条评论，220人围观）

还没有评论，来说两句吧...

相关阅读

    相关 多媒体（音频）

    播放放在项目中的音频，功能可以做到点击播放、点击暂停、拖动进度条决定音频的播放进度，下面先给大家介绍一下关于多媒体和它的方法： ![Center][] 效果图： !

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 350 阅读