Android录音

最新推荐文章于 2023-08-18 09:59:52 发布
最新推荐文章于 2023-08-18 09:59:52 发布
阅读量987 收藏 2
点赞数 1
分类专栏： Android 文章标签： android录音
欢迎转载，转载附上链接
本文链接：https://blog.csdn.net/generallizhong/article/details/94631032
版权

许多时候我们会有这样的一个需求的就是app需要有录音功能，这里简单介绍录音，并在文章最后附上DEMO

先看两张图片

功能：

1.实现了录音，播放；

2.暂停录音开始录音，合并为同一个；

3.显示录音时间，录了多少秒，时分秒；
 

需要初始化：

VoiceManage mVoiceManage = new VoiceManage(mActivity, path);//初始化 

mVoiceManage.sessionRecord(true);// 开始录音 

mVoiceManage.sessionPlay(true, mFilePath);// 播放录音 

 

主界面代码： 

public class MainActivity extends ActionBarActivity {

    private LinearLayout mLayoutRecord;
    private RelativeLayout mLayoutPlay;
    private Button mBtRec;
    private Button mBtPlay;
    private VoiceManager voiceManager;
    private String mRecPath = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        mLayoutRecord = (LinearLayout) findViewById(R.id.layout_record);
        mLayoutPlay = (RelativeLayout) findViewById(R.id.layout_play);
        mBtRec = (Button) findViewById(R.id.button_rec);
        mBtPlay = (Button) findViewById(R.id.button_play);

        voiceManager = new VoiceManager(MainActivity.this, "/com.youmu.voicemanager/audio");

        voiceManager.setVoiceListener(new VoiceCallBack() {
            @Override
            public void voicePath(String path) {
                mRecPath = path;
            }

            @Override
            public void recFinish() {
                mBtPlay.setVisibility(View.VISIBLE);
            }
        });


        mBtRec.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                mLayoutRecord.setVisibility(View.VISIBLE);
                mLayoutPlay.setVisibility(View.GONE);
                mBtPlay.setVisibility(View.INVISIBLE);

                voiceManager.sessionRecord(true);
            }
        });

        mBtPlay.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mLayoutRecord.setVisibility(View.GONE);
                mLayoutPlay.setVisibility(View.VISIBLE);

                voiceManager.sessionPlay(true, mRecPath);
            }
        });
    }


录音类的代码：包括，开始，完成，回放等

public class VoiceManager {
    private ArrayList<File> mRecList = new ArrayList<File>();
    private Activity mActivity = null;
    private View mVRecRoot, mVPlaRoot, mVRecFinish;
    private ImageView mIVRecOperate, mIVPlaOperate, mIVPlaStop;
    private TextView mTVRecText, mTVRecTime, mTVPlaCurrent, mTVPlaTotal;
    private SeekBar mSBPlayProgress;
    private int mSavedState, mDeviceState = CommonDefine.MEDIA_STATE_UNDEFINE;
    private MediaRecorder mMediaRecorder = null;
    private MediaPlayer mMediaPlayer = null;
    private String mRecTimePrev, mPlaFilePath;
    private long mRecTimeSum = 0;
    private String filePath = "";// 录音所存放的位置  "/com.youmu.voicemanager/audio"
    private VoiceCallBack voiceCallBack;

    private MediaPlayer.OnCompletionListener mPlayCompetedListener = new MediaPlayer.OnCompletionListener() {
        @Override
        public void onCompletion(MediaPlayer mp) {
            mDeviceState = CommonDefine.MEDIA_STATE_PLAY_STOP;
            mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);

            mMediaPlayer.stop();
            mMediaPlayer.release();

            mSBPlayProgress.setProgress(0);
            mTVPlaCurrent.setText("00:00:00");
            mIVPlaOperate.setImageResource(R.mipmap.voice_play);
        }
    };

    @SuppressLint("HandlerLeak")
    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            TimeMethod ts;
            int current;
            try {
                switch (msg.what) {
                    case CommonDefine.MSG_TIME_INTERVAL:
                        if (mDeviceState == CommonDefine.MEDIA_STATE_RECORD_DOING) {
                            ts = TimeMethod.timeSpanToNow(mRecTimePrev);
                            mRecTimeSum += ts.mDiffSecond;
                            mRecTimePrev = TimeMethod.getTimeStrFromMillis(ts.mNowTime);

                            ts = TimeMethod.timeSpanSecond(mRecTimeSum);
                            mTVRecTime.setText(String.format("%02d:%02d:%02d",
                                    ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));

                            mHandler.sendEmptyMessageDelayed(CommonDefine.MSG_TIME_INTERVAL, 1000);

                        } else if (mDeviceState == CommonDefine.MEDIA_STATE_PLAY_DOING) {
                            current = mMediaPlayer.getCurrentPosition();
                            mSBPlayProgress.setProgress(current);

                            ts = TimeMethod.timeSpanSecond(current / 1000);
                            mTVPlaCurrent.setText(String.format("%02d:%02d:%02d",
                                    ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));

                            mHandler.sendEmptyMessageDelayed(CommonDefine.MSG_TIME_INTERVAL, 1000);
                        }
                        break;
                    default:
                        break;
                }
            } catch (Exception e) {
            }
        }
    };

    public void setVoiceListener (VoiceCallBack callBack) {
        voiceCallBack = callBack;
    }

    public VoiceManager(Activity act, String filePath) {
        this.mActivity = act;
        this.filePath = filePath;

        mVRecRoot = mActivity.findViewById(R.id.unit_voice_record_root);
        mIVRecOperate = (ImageView) mActivity.findViewById(R.id.unit_voice_record_operate);
        mTVRecText = (TextView) mActivity.findViewById(R.id.unit_voice_record_text);
        mTVRecTime = (TextView) mActivity.findViewById(R.id.unit_voice_record_time);
        mVRecFinish = mActivity.findViewById(R.id.unit_voice_record_finish);

        mVPlaRoot = mActivity.findViewById(R.id.unit_voice_play_root);
        mIVPlaOperate = (ImageView) mActivity.findViewById(R.id.unit_voice_play_operate);
        mIVPlaStop = (ImageView) mActivity.findViewById(R.id.unit_voice_play_stop);
        mSBPlayProgress = (SeekBar) mActivity.findViewById(R.id.unit_voice_play_progress);
        mTVPlaCurrent = (TextView) mActivity.findViewById(R.id.unit_voice_play_current);
        mTVPlaTotal = (TextView) mActivity.findViewById(R.id.unit_voice_play_total);

        if (mIVRecOperate != null) {
            mIVRecOperate.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {

                    if (mDeviceState == CommonDefine.MEDIA_STATE_RECORD_DOING) {
                        mDeviceState = CommonDefine.MEDIA_STATE_RECORD_PAUSE;
                        stopRecorder(mMediaRecorder, true);
                        mMediaRecorder = null;

                        mTVRecText.setText("已暂停");
                        mIVRecOperate.setImageResource(R.mipmap.voice_pause);
                    } else {
                        sessionRecord(false);
                    }
                }
            });
        }

        if (mVRecFinish != null) {
            mVRecFinish.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    clickRecordFinish();
                }
            });
        }

        if (mIVPlaOperate != null) {
            mIVPlaOperate.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {

                    if (mDeviceState == CommonDefine.MEDIA_STATE_PLAY_DOING) {
                        mDeviceState = CommonDefine.MEDIA_STATE_PLAY_PAUSE;
                        pauseMedia(mMediaPlayer);
                        mIVPlaOperate.setImageResource(R.mipmap.voice_play);

                    } else if (mDeviceState == CommonDefine.MEDIA_STATE_PLAY_PAUSE) {
                        mDeviceState = CommonDefine.MEDIA_STATE_PLAY_DOING;
                        playMedia(mMediaPlayer);

                        mIVPlaOperate.setImageResource(R.mipmap.voice_pause);
                        mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
                        mHandler.sendEmptyMessage(CommonDefine.MSG_TIME_INTERVAL);

                    } else if (mDeviceState == CommonDefine.MEDIA_STATE_PLAY_STOP) {
                        if (!TextUtils.isEmpty(mPlaFilePath)) {
                            sessionPlay(false, mPlaFilePath);
                        }
                    }
                }
            });
        }

        if (mIVPlaStop != null) {
            mIVPlaStop.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    try {
                        mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
                        mDeviceState = CommonDefine.MEDIA_STATE_PLAY_STOP;

                        mIVPlaOperate.setImageResource(R.mipmap.voice_play);
                        mTVPlaCurrent.setText("00:00:00");

                        stopMedia(mMediaPlayer, true);
                        mMediaPlayer = null;

                    } catch (Exception e) {

                    } finally {
                        mVPlaRoot.setVisibility(View.GONE);
                    }
                }
            });
        }

        if (mSBPlayProgress != null) {
            mSBPlayProgress.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                @Override
                public void onStartTrackingTouch(SeekBar seekBar) {
                    mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
                    mSavedState = mDeviceState;
                    if (mSavedState == CommonDefine.MEDIA_STATE_PLAY_DOING) {
                        pauseMedia(mMediaPlayer);
                    }
                }

                @Override
                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                    mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);

                    TimeMethod ts = TimeMethod.timeSpanSecond(progress / 1000);
                    mTVPlaCurrent.setText(String.format("%02d:%02d:%02d",
                            ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));
                }

                @Override
                public void onStopTrackingTouch(SeekBar seekBar) {
                    seektoMedia(mMediaPlayer, mSBPlayProgress.getProgress());

                    if (mSavedState == CommonDefine.MEDIA_STATE_PLAY_DOING) {
                        playMedia(mMediaPlayer);
                        mHandler.sendEmptyMessage(CommonDefine.MSG_TIME_INTERVAL);
                    }
                }
            });
        }
    }

    public void sessionRecord(boolean init) {
        if (!FileUtils.isSDCardAvailable()) return;
        if (init) {
            mRecTimeSum = 0;
            cleanFieArrayList(mRecList);
        }

        stopRecorder(mMediaRecorder, true);
        mMediaRecorder = null;

        stopMedia(mMediaPlayer, true);
        mMediaPlayer = null;

        if (mVPlaRoot != null) {
            mVPlaRoot.setVisibility(View.GONE);
        }
        mVRecRoot.setVisibility(View.VISIBLE);
        mIVRecOperate.setImageResource(R.mipmap.voice_record);

        mMediaRecorder = new MediaRecorder();
        File file = prepareRecorder(mMediaRecorder, true);
        if (file != null) {
            mTVRecText.setText("正在录音");
            mDeviceState = CommonDefine.MEDIA_STATE_RECORD_DOING;
            mRecTimePrev = TimeMethod.getTimeStrFromMillis(System.currentTimeMillis());
            mRecList.add(file);

            mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
            mHandler.sendEmptyMessage(CommonDefine.MSG_TIME_INTERVAL);
        }
    }

    public void sessionRecordEx(boolean init, int resTimeTextId) {
        if (!FileUtils.isSDCardAvailable()) return;
        if (init) {
            mRecTimeSum = 0;
            cleanFieArrayList(mRecList);
        }

        mTVRecTime = (TextView) mActivity.findViewById(resTimeTextId);

        stopRecorder(mMediaRecorder, true);
        mMediaRecorder = null;

        stopMedia(mMediaPlayer, true);
        mMediaPlayer = null;

        if (mVPlaRoot != null) {
            mVPlaRoot.setVisibility(View.GONE);
        }

        mMediaRecorder = new MediaRecorder();
        File file = prepareRecorder(mMediaRecorder, true);
        if (file != null) {
            mDeviceState = CommonDefine.MEDIA_STATE_RECORD_DOING;
            mRecTimePrev = TimeMethod.getTimeStrFromMillis(System.currentTimeMillis());
            mRecList.add(file);

            mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
            mHandler.sendEmptyMessage(CommonDefine.MSG_TIME_INTERVAL);
        }
    }

    /**
     * 完成录音
     */
    public void clickRecordFinish() {
        try {
            mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
            mDeviceState = CommonDefine.MEDIA_STATE_RECORD_STOP;
            stopRecorder(mMediaRecorder, true);
            mMediaRecorder = null;

            if (mVRecRoot != null) {
                mVRecRoot.setVisibility(View.GONE);
            }
            if (TimeMethod.timeSpanSecond(mRecTimeSum).mSpanSecond == 0) {
                Toast.makeText(mActivity, "时间过短", Toast.LENGTH_SHORT).show();
            } else {

                File file = getOutputVoiceFile(mRecList);
                if (file != null && file.length() > 0) {
                    cleanFieArrayList(mRecList);
                    //TODO 这里可以返回数据 setResult
                    voiceCallBack.recFinish();
                    voiceCallBack.voicePath(file.getAbsolutePath());
                }
            }

        } catch (Exception e) {
        }
    }

    /**
     * 录音播放
     *
     * @param init
     * @param path
     */
    public void sessionPlay(boolean init, String path) {
        if (TextUtils.isEmpty(path)) return;
        mPlaFilePath = path;

        try {
            mVPlaRoot.setVisibility(View.VISIBLE);
            if (mVRecRoot != null) {
                mVRecRoot.setVisibility(View.GONE);
            }

            mIVPlaOperate.setImageResource(R.mipmap.voice_pause);
            mTVPlaCurrent.setText("00:00:00");

            stopRecorder(mMediaRecorder, true);
            mMediaRecorder = null;

            stopMedia(mMediaPlayer, true);
            mMediaPlayer = null;

            mMediaPlayer = new MediaPlayer();
            mMediaPlayer.setOnCompletionListener(mPlayCompetedListener);

            if (prepareMedia(mMediaPlayer, path)) {
                mDeviceState = CommonDefine.MEDIA_STATE_PLAY_DOING;

                TimeMethod ts = TimeMethod.timeSpanSecond(mMediaPlayer.getDuration() / 1000);
                mTVPlaTotal.setText(String.format("%02d:%02d:%02d",
                        ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));

                mSBPlayProgress.setMax(Math.max(1, mMediaPlayer.getDuration()));

                if (init) {
                    mSBPlayProgress.setProgress(0);
                    seektoMedia(mMediaPlayer, 0);
                } else {
                    seektoMedia(mMediaPlayer, mSBPlayProgress.getProgress());
                }

                if (playMedia(mMediaPlayer)) {
                    mHandler.removeMessages(CommonDefine.MSG_TIME_INTERVAL);
                    mHandler.sendEmptyMessage(CommonDefine.MSG_TIME_INTERVAL);
                }
            }
        } catch (Exception e) {
        }
    }

    /**
     * 合并录音
     *
     * @param list
     * @return
     */
    private File getOutputVoiceFile(ArrayList<File> list) {
        String mMinute1 = TimeMethod.getTime();
        String recFilePath = FileUtils.recAudioPath(filePath);
        File recDirFile = FileUtils.recAudioDir(recFilePath);

        // 创建音频文件,合并的文件放这里
        File resFile = new File(recDirFile, mMinute1 + ".amr");
        FileOutputStream fileOutputStream = null;

        if (!resFile.exists()) {
            try {
                resFile.createNewFile();
            } catch (IOException e) {
            }
        }
        try {
            fileOutputStream = new FileOutputStream(resFile);
        } catch (IOException e) {
        }
        // list里面为暂停录音 所产生的 几段录音文件的名字，中间几段文件的减去前面的6个字节头文件
        for (int i = 0; i < list.size(); i++) {
            File file = list.get(i);
            try {
                FileInputStream fileInputStream = new FileInputStream(file);
                byte[] myByte = new byte[fileInputStream.available()];
                // 文件长度
                int length = myByte.length;
                // 头文件
                if (i == 0) {
                    while (fileInputStream.read(myByte) != -1) {
                        fileOutputStream.write(myByte, 0, length);
                    }
                }
                // 之后的文件，去掉头文件就可以了
                else {
                    while (fileInputStream.read(myByte) != -1) {
                        fileOutputStream.write(myByte, 6, length - 6);
                    }
                }
                fileOutputStream.flush();
                fileInputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 结束后关闭流
        try {
            fileOutputStream.close();
        } catch (IOException e) {
        }

        return resFile;
    }

    private void cleanFieArrayList(ArrayList<File> list) {
        for (File file : list) {
            file.delete();
        }
        list.clear();
    }

    /**
     * 播放录音准备工作
     *
     * @param mp
     * @param file
     * @return
     */
    private boolean prepareMedia(MediaPlayer mp, String file) {
        boolean result = false;

        try {
            mp.setDataSource(file);
            mp.prepare();
            result = true;
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 播放录音开始
     *
     * @param mp
     * @return
     */
    private boolean playMedia(MediaPlayer mp) {
        boolean result = false;

        try {
            if (mp != null) {
                mp.start();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 拖动播放进度条
     *
     * @param mp
     * @param pos
     * @return
     */
    private boolean seektoMedia(MediaPlayer mp, int pos) {
        boolean result = false;

        try {
            if (mp != null && pos >= 0) {
                mp.seekTo(pos);
                result = true;
            }
        } catch (Exception e) {
        }
        return result;
    }

    /**
     * 停止播放
     *
     * @param mp
     * @param release
     * @return
     */
    private boolean stopMedia(MediaPlayer mp, boolean release) {
        boolean result = false;

        try {
            if (mp != null) {
                mp.stop();

                if (release) {
                    mp.release();
                }
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 暂停播放
     *
     * @param mp
     * @return
     */
    private boolean pauseMedia(MediaPlayer mp) {
        boolean result = false;

        try {
            if (mp != null) {
                mp.pause();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 停止录音
     *
     * @param mr
     * @param release
     * @return
     */
    private boolean stopRecorder(MediaRecorder mr, boolean release) {
        boolean result = false;

        try {
            if (mr != null) {
                mr.stop();
                if (release) {
                    mr.release();
                }
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 录音准备工作 ，开始录音
     *
     * @param mr
     * @param start
     * @return
     */
    @SuppressWarnings("deprecation")
    private File prepareRecorder(MediaRecorder mr, boolean start) {
        File recFile = null;
        if (mr == null) return null;

        try {
            String path = FileUtils.recAudioPath(filePath);
            recFile = new File(path, TimeMethod.getTime() + ".amr");

            mr.setAudioSource(MediaRecorder.AudioSource.MIC);
            mr.setOutputFormat(MediaRecorder.OutputFormat.RAW_AMR);
            mr.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
            mr.setOutputFile(recFile.getAbsolutePath());
            mr.prepare();

            if (start) {
                mr.start();
            }
        } catch (Exception e) {
        }
        return recFile;
    }
}

代码比较简单。

需要下载Demo的：

百度网盘：戳这里     提取码：pjep

CSDN:下载

 

 


 

 

generallizhong
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Android代码-Android 高质量录音库。
08-06
SimpleRecorder 这是用AudioRecord来封装的录音代码，如果对音频数据源有需求的话，推荐使用。如果仅仅使用录音文件的话，最好使用MediaRecord相关 用法 在module/build.gradle里添加 compile 'com.mass.audio.library:library:0.1.2' 需要自己申请权限，别忘了在AndroidManifest.xml添加 使用的时候传入采样率、声道格式、位宽度、音源和每次处理的采样数，监听需要的话可以添加，不需要的话可以填null mRecorder = new Recorder(44100/*采样率*/, AudioFormat.CHANNEL_IN_MONO/*单双声道*/, AudioFormat.ENCODING_PCM_16BIT/*格式*/, MediaRecorder.AudioSource.MIC/*AudioSource*/, 512/*每次多少个采样*/,
android录音功能的实现
chaozhung的专栏
06-20 9209
这个录音实现是我在Bus上看到并下载的，他那个源码不完整，再次把我整理完整的代码贴出，源码地址在这：http://download.csdn.net/detail/chaozhung/5618649 Bus上的那个网址找不到了，见谅！！！ 下为核心代码： 核心代码1.. package com.lv.reco; import java.io.File; public class S
Android 实现录音功能
最新发布
Steve_XiaoHai的博客
08-18 3187
实现android音频录制功能，适配高低版本
Android录音实现
weixin_55522643的博客
09-26 1346
1 Android录音需要声明录音权限 <uses-permission android:name="android.permission.RECORD_AUDIO" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /
Android 录音程序源码.zip
12-04
这个“Android录音程序源码.zip”文件提供了一个完整的Android应用项目，旨在帮助开发者学习如何在自己的应用中实现录音功能。源码通常包含了项目结构、布局文件、Java代码以及必要的资源配置，为深入理解Android...
android录音功能实现
07-18
"RecordDemo"项目可能包含了实现以上功能的示例代码，你可以通过查看该项目来更深入地了解Android录音和播放的细节。记住，调试和测试在不同设备和Android版本上的表现，因为录音功能可能因设备差异而有所不同。 ...
android 录音播放
06-11
<uses-permission android:name="android.permission.RECORD_AUDIO"/> 本人用于cocos creator，使用时需要添加权限，简单实用，适合android小白
android录音代码
01-30
`android录音代码`这个主题涉及到如何在Android应用中集成录音功能。下面将详细解释这个过程，并给出关键代码片段。 首先，我们需要在AndroidManifest.xml文件中添加麦克风使用的权限： ```xml <uses-permission ...
Android 录音
03-09
主要有，上滑取消录音，限制录音时长，录音动画和仿we微信播放效果，并解决开启权限发生来语音错误
android录音Demo
07-17
android录音Demo，分别用AudioRecorde类和MediaRecorder类实现，测试可用，因为是网上搜集的程序，就不要资源分了，整理出来方便大家使用。
Android调用手机系统自带录音功能实现语音录制与播放
12-20
Android调用手机系统自带录音功能实现语音录制与播放
android下的录音APP，实用。
11-22
android下如何调用系统自身的录音设备进行录音实例，实用。
Android 录音机的实现
02-21
大体思路:暂停一次,便保存一次生成一个文件,点击停止时候,将所有生生成文件合并,除第一个生成文件的其他文件前六个字节删除
Android 录音实现
weixin_33890526的博客
06-11 51
2019独角兽企业重金招聘Python工程师标准>>> ...
Android 录音实现（AudioRecord）
Liuqz2009的专栏
01-02 1409
上一篇文章介绍了使用 MediaRecorder 实现录音功能 Android录音实现(MediaRecorder) ，下面我们继续看看使用 AudioRecord 实现录音功能。 AudioRecord 首先看看Android帮助文档中对该类的简单概述: AndioRecord 类的主要功能是让各种 Java 应用能够管理音频资源，以便它们通过此类能够录制平台的声音输入硬件所收集的声音。此功...
android 录音
07-28
你想了解关于 Android 录音的内容吗？我可以为您提供一些基本信息。Android 提供了一些 API 和功能，可以帮助您在应用程序中实现录音功能。您可以使用 MediaRecorder 类来录制音频，并使用 AudioManager 类来管理...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

generallizhong

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值