devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

科大讯飞 新版AIkit 离线语音听写 Java 版本_java 集成科大讯飞离线语言识别

作者：小小林熬夜学编程 | 2024-04-07 11:29:27

赞

踩

java 集成科大讯飞离线语言识别

前言：科大讯飞的新版离线语音听写，由于官网demo是kt语言开发的，咱也看不懂kt，搜遍了全网也没看到一个java版的新版离线语音demo，现记录下，留给有缘人参考！！！！！毕竟咱在这上面遇到了不少的坑。如果能留言指正，那就更好了。

实测一点问题都没

一、先把官网Demo中resource下的文件放到sdk目录下，示例如下

一、Activity简单布局 加几个语音听写的监听回调

  1. package com.mhzk.xunfeitest;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import androidx.core.app.ActivityCompat;
  5. import androidx.core.content.ContextCompat;
  6.  
  7. import android.Manifest;
  8. import android.content.Context;
  9. import android.content.pm.PackageManager;
  10. import android.os.Bundle;
  11.  
  12. import android.util.Log;
  13. import android.view.View;
  14. import android.widget.TextView;
  15. import android.widget.Toast;
  16.  
  17.  
  18. import com.iflytek.aikit.core.AiHandle;
  19.  
  20. import com.iflytek.aikit.core.AiStatus;
  21.  
  22.  
  23. public class MainActivity extends AppCompatActivity implements AbilityCallback{
  24.     private String TAG = "内容初始化";
  25.     private AiStatus state;
  26.     private AiHandle handle;
  27.     private int REQUEST_STORAGE_PERMISSION = 100;
  28.     private TextView start;
  29.     private TextView content;
  30.     private AudioRecordUtil instance;
  31.     private StringBuffer strBuffer;
  32.  
  33.     @Override
  34.     protected void onCreate(Bundle savedInstanceState) {
  35.         super.onCreate(savedInstanceState);
  36.         setContentView(R.layout.activity_main);
  37.         start = findViewById(R.id.one);
  38.  
  39.         content = findViewById(R.id.three);
  40.         instance = AudioRecordUtil.getInstance();
  41.         instance.initSDK(this);
  42.         AudioRecordUtil.setCallBack(this);
  43.         start.setOnClickListener(new View.OnClickListener() {
  44.             @Override
  45.             public void onClick(View view) {
  46.                 if(start.getText().toString().equals("开始录音")){
  47.                     instance.start(MainActivity.this);
  48.                 }else {
  49.                     instance.stop();
  50.                 }
  51.  
  52.             }
  53.         });
  54.  
  55.         
  56.         requestStoragePermission(this);
  57.  
  58.     }
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.     /**
  66.      * 查看当前设备是否有存储权限：
  67.      *      没有：请求获取权限
  68.      *      有：复制当前项目assets下的xtts文件夹到设备根目录下（语音合成所必须的文件）
  69.      * @param context
  70.      */
  71.     private void requestStoragePermission(Context context) {
  72.         if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)
  73.                 != PackageManager.PERMISSION_GRANTED) {
  74.             ActivityCompat.requestPermissions(this,
  75.                     new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
  76.                     REQUEST_STORAGE_PERMISSION);
  77.         }
  78.     }
  79.  
  80.     /**
  81.      * 请求获取存储权限
  82.      * @param requestCode
  83.      * @param permissions
  84.      * @param grantResults
  85.      */
  86.     @Override
  87.     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
  88.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  89.         if (requestCode == REQUEST_STORAGE_PERMISSION) {
  90.             if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  91.                 Log.i(TAG, "onRequestPermissionsResult: permission granted");
  92.                 //再次判断存储权限是否已授予
  93.                 boolean permission = FileUtils.hasStoragePermission(getApplicationContext());
  94.                 if (!permission) {
  95.                     Toast.makeText(getApplicationContext(), "没有存储权限，请重新获取!", Toast.LENGTH_SHORT).show();
  96.                     return;
  97.                 }
  98.                 // 应用具有存储权限
  99.                 Log.i(TAG,"成功获取存储权限!");
  100.                 //判断xtts文件是否存在，不存在则复制，存在则忽略
  101.                 FileUtils.createXttsDirAndCopyFile(getApplicationContext());
  102.             } else {
  103.                 Log.i(TAG, "onRequestPermissionsResult: permission denied");
  104.                 Toast.makeText(this, "You Denied Permission", Toast.LENGTH_SHORT).show();
  105.             }
  106.         }
  107.     }
  108.  
  109.  
  110.     /**
  111.      * 开始
  112.      */
  113.     @Override
  114.     public void onAbilityBegin() {
  115.         start.setText("暂停录音");
  116.         content.setText("内容展示");
  117.     }
  118.  
  119.     /**
  120.      *能力结果输出
  121.      * @param result 结果
  122.      */
  123.     @Override
  124.     public void onAbilityResult(String result) {
  125.         String s = content.getText().toString();
  126.         strBuffer = new StringBuffer(s);
  127.         strBuffer.append("\n"+result );
  128.         String value = strBuffer.toString();
  129.  
  130.         runOnUiThread(new Runnable() {
  131.             @Override
  132.             public void run() {
  133.                 content.setText(value);
  134.             }
  135.         });
  136.     }
  137.  
  138.     /**
  139.      *结束
  140.      * @param code
  141.      * @param error
  142.      */
  143.     @Override
  144.     public void onAbilityError(int code, Throwable error) {
  145.         runOnUiThread(new Runnable() {
  146.             @Override
  147.             public void run() {
  148.                 start.setText("开始录音");
  149.             }
  150.         });
  151.  
  152.         instance.stop();
  153.     }
  154.  
  155.     /**
  156.      * 能力结束
  157.      */
  158.     @Override
  159.     public void onAbilityEnd() {
  160.         runOnUiThread(new Runnable() {
  161.             @Override
  162.             public void run() {
  163.                 start.setText("开始录音");
  164.             }
  165.         });
  166.     }
  167. }

二、AudioRecord进行音频录制并写入本地创建的pcm文件

        写入过程中把流数据复制一份传给sdk做文字转换

  1. package com.mhzk.xunfeitest;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.content.Context;
  5. import android.media.AudioFormat;
  6.  
  7. import android.media.AudioRecord;
  8. import android.media.MediaRecorder;
  9. import android.os.Environment;
  10. import android.util.Log;
  11.  
  12. import androidx.annotation.NonNull;
  13.  
  14. import com.iflytek.aikit.core.AiAudio;
  15. import com.iflytek.aikit.core.AiEvent;
  16. import com.iflytek.aikit.core.AiHandle;
  17. import com.iflytek.aikit.core.AiHelper;
  18. import com.iflytek.aikit.core.AiListener;
  19. import com.iflytek.aikit.core.AiRequest;
  20. import com.iflytek.aikit.core.AiResponse;
  21. import com.iflytek.aikit.core.AiStatus;
  22. import com.iflytek.aikit.core.AuthListener;
  23. import com.iflytek.aikit.core.DataStatus;
  24. import com.iflytek.aikit.core.ErrType;
  25.  
  26.  
  27.  
  28. import java.io.File;
  29.  
  30. import java.io.FileOutputStream;
  31.  
  32. import java.io.OutputStream;
  33. import java.io.UnsupportedEncodingException;
  34.  
  35. import java.util.List;
  36. import java.util.concurrent.atomic.AtomicBoolean;
  37.  
  38. public class AudioRecordUtil {
  39.     private static final String TAG = "AudioPlayByKeyUtils";
  40.     //设置音频采样率，44100是目前的标准，但是某些设备仍然支持22050，16000，11025
  41.     private final int sampleRateInHz = 16000;
  42.     //设置音频的录制的声道CHANNEL_IN_STEREO为双声道，CHANNEL_CONFIGURATION_MONO为单声道
  43.     private final int channelConfig = AudioFormat.CHANNEL_IN_MONO;
  44.     //音频数据格式:PCM 16位每个样本。保证设备支持。PCM 8位每个样本。不一定能得到设备支持。
  45.     private final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
  46.     //录制状态
  47.     private boolean recorderState = true;
  48.     private byte[] buffer;
  49.     private static AudioRecord audioRecord;
  50.     private static AudioRecordUtil audioRecordUtil = new AudioRecordUtil();
  51.  
  52.     private static AiHandle handle;
  53.     private File recordFile;
  54.     private AtomicBoolean atomicBoolean = new AtomicBoolean();
  55.     private byte[] lockArray = new byte[0];
  56.     private int recordMinBufferSize;
  57.  
  58.  
  59.     //SDK初始化
  60.     public   void initSDK(Context context) {
  61.         try {
  62.             //外部存储绝对路径
  63.             File externalStorageDirectory = Environment.getExternalStorageDirectory();
  64.             // 初始化参数构建
  65.             AiHelper.Params params = AiHelper.Params.builder()
  66.                     .appId(context.getString(R.string.appId))
  67.                     .apiKey(context.getString(R.string.apiKey))
  68.                     .apiSecret(context.getString(R.string.apiSecret))
  69.                     .workDir("/sdcard/iflytekAikit")//SDK工作路径，这里为绝对路径
  70.                     .authInterval(333) //授权更新间隔
  71.                     .build();
  72.             // 初始化
  73.             AiHelper.getInst().init(context, params);
  74.             // 注册SDK 初始化状态监听
  75.             AiHelper.getInst().registerListener(coreListener);
  76.             // 注册能力结果监听  R.string.enginID 为离线的语音听写ID，写死就好 ee62fa27c
  77.             AiHelper.getInst().registerListener(context.getString(R.string.enginID), aiRespListener);
  78.         } catch (Exception e) {
  79.             Log.e(TAG, "语音合成初始化出现异常" + e.getMessage());
  80.         }
  81.     }
  82.  
  83.  
  84.     public static AudioRecordUtil getInstance() {
  85.         return audioRecordUtil;
  86.     }
  87.  
  88.     private AudioRecordUtil() {
  89.         init();
  90.     }
  91.  
  92.     @SuppressLint("MissingPermission")
  93.     private void init() {
  94.         recordMinBufferSize = AudioRecord.getMinBufferSize(sampleRateInHz, channelConfig, audioFormat);
  95.         //指定 AudioRecord 缓冲区大小
  96.         buffer = new byte[recordMinBufferSize];
  97.         //根据录音参数构造AudioRecord实体对象
  98.         audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleRateInHz, channelConfig,
  99.                 audioFormat, recordMinBufferSize);
  100.     }
  101.  
  102.     /**
  103.      * 开始录制
  104.      */
  105.     public void start(Context context) {
  106.         //已初始化则略过
  107. //        initSDK(context);
  108.  
  109.         //能力逆初始化， 部分能力，比如语种切换的时候 需要逆初始化
  110.         AiHelper.getInst().engineUnInit(context.getString(R.string.enginID));
  111.         int ret = -1;
  112.         ret = AiHelper.getInst().engineInit(context.getString(R.string.enginID));
  113.         if (ret != 0) {
  114.                 abilityCallback.onAbilityError(ret, new Throwable("引擎初始化失败：$ret"));
  115.             return;
  116.         }
  117.         int[] indexs0 = {0};
  118.         int[] indexs1 = {1};
  119.         ret = AiHelper.getInst()
  120.                         .specifyDataSet(context.getString(R.string.enginID), "PPROC_NOT_REP", indexs0);
  121.         if (ret != 0) {
  122.             abilityCallback.onAbilityError(ret, new Throwable("open esr specifyDataSet 失败：$ret"));
  123.  
  124.             return;
  125.         }
  126.         ret = AiHelper.getInst()
  127.                 .specifyDataSet(context.getString(R.string.enginID), "PPROC_REPLACE",indexs1);
  128.         if (ret != 0) {
  129.             abilityCallback.onAbilityError(ret, new Throwable("open esr specifyDataSet 失败：$ret"));
  130.  
  131.             return;
  132.         }
  133.  
  134.         //音量及播报人等参数设置
  135.         AiRequest.Builder paramBuilder = audioParam();
  136.         handle = AiHelper.getInst().start(context.getString(R.string.enginID), paramBuilder.build(), null);
  137.         atomicBoolean.set(true);
  138.         if (!handle.isSuccess()) {
  139.             Log.e(TAG, "ERROR::START | handle code:" + handle.getCode());
  140.             return;
  141.         }
  142.         if (audioRecord.getState() == AudioRecord.RECORDSTATE_STOPPED) {
  143.             recorderState = true;
  144.             audioRecord.startRecording();
  145.             abilityCallback.onAbilityBegin();
  146.             String absolutePath = MyApp.mApplication.getExternalCacheDir().getAbsolutePath();
  147.             recordFile = new File(absolutePath + "/" + System.currentTimeMillis() + ".pcm");
  148.         }else {
  149.             init();
  150.             recorderState = true;
  151.             audioRecord.startRecording();
  152.             abilityCallback.onAbilityBegin();
  153.             String absolutePath = MyApp.mApplication.getExternalCacheDir().getAbsolutePath();
  154.             recordFile = new File(absolutePath + "/" + System.currentTimeMillis() + ".pcm");
  155.         }
  156.         new RecordThread().start();
  157.     }
  158.  
  159.  
  160.  
  161.  
  162.     /**
  163.      * 停止录制
  164.      */
  165.     public void stop() {
  166.         recorderState = false;
  167.         if (audioRecord.getState() == AudioRecord.RECORDSTATE_RECORDING) {
  168.             audioRecord.stop();
  169.         }
  170.         audioRecord.release();
  171.         int ret = AiHelper.getInst().end(handle);
  172.         if (ret != 0) {
  173.             String error = "end failed" + ret;
  174.             Log.e(TAG, error);
  175.         }
  176.     }
  177.  
  178.  
  179.     private class RecordThread extends Thread {
  180.  
  181.         @Override
  182.         public void run() {
  183.             //输出流
  184.             OutputStream os = null;
  185.             try {
  186.                 os = new FileOutputStream(recordFile);
  187. //                BufferedOutputStream bos = new BufferedOutputStream(os);
  188. //                DataOutputStream dos = new DataOutputStream(bos);
  189.                 while (recorderState) {
  190.                     int read = audioRecord.read(buffer, 0, buffer.length);
  191.                     for (int i = 0; i < read; i++) {
  192. //                        dos.writeShort(buffer[i]);
  193.                     }
  194.                     if (read == recordMinBufferSize) {
  195.                         AiStatus status = AiStatus.CONTINUE;
  196.                         if (atomicBoolean.get()) {
  197.                             status = AiStatus.BEGIN;
  198.                             atomicBoolean.set(false);
  199.                         }
  200.                         writeData(buffer, status);
  201.                     } else {
  202.                         byte[] copy = new byte[read];
  203.                         System.arraycopy(buffer, 0, copy, 0, read);
  204.  
  205.                         AiStatus status = AiStatus.CONTINUE;
  206.                         if (atomicBoolean.get()) {
  207.                             status = AiStatus.BEGIN;
  208.                             atomicBoolean.set(false);
  209.                         }
  210.                         writeData(copy, status);
  211.                     }
  212.                     os.write(buffer);
  213.  
  214.                 }
  215.                 os.flush();
  216.                 os.close();
  217.             } catch (Exception e) {
  218.                 e.printStackTrace();
  219.             }
  220.         }
  221.     }
  222.  
  223.  
  224.     /**
  225.      * 写入音频数据
  226.      *
  227.      * @param status 送入的数据的状态，告诉引擎送入的首帧数据、中间数据、还是尾帧
  228.      */
  229.     private void writeData(byte[] audio, AiStatus status) {
  230.         if (handle == null) {
  231.             return;
  232.         }
  233.         synchronized (lockArray) {
  234.             AiRequest.Builder dataBuilder = AiRequest.builder();
  235.             AiAudio.Holder holder = AiAudio.get("PCM").data(audio);
  236.             holder.status(status);
  237.             dataBuilder.payload(holder.valid());
  238.             int ret = AiHelper.getInst().write(dataBuilder.build(), handle);
  239.             if (ret != 0) {
  240.                 destory();
  241.                 Log.w(TAG, "writeData is error => $ret");
  242.             } else {
  243.                 ret = AiHelper.getInst().read("ee62fa27c", handle);
  244.                 if (ret != 0) {
  245.                     Log.w(TAG, "read error code => $ret");
  246.                     destory();
  247.                 } else {
  248.                     Log.w(TAG, "read success code => $ret");
  249.                 }
  250.             }
  251.         }
  252.     }
  253.  
  254.  
  255.     /**
  256.      * SDK监听回调
  257.      */
  258.     private static AuthListener coreListener = new AuthListener() {
  259.         @Override
  260.         public void onAuthStateChange(final ErrType type, final int code) {
  261.             Log.i(TAG, "core listener code:" + code);
  262.             switch (type) {
  263.                 case AUTH:
  264.                     Log.i(TAG, "SDK状态：授权结果码" + code);
  265.                     break;
  266.                 case HTTP:
  267.                     Log.i(TAG, "SDK状态：HTTP认证结果" + code);
  268.                     break;
  269.                 default:
  270.                     Log.i(TAG, "SDK状态：其他错误");
  271.             }
  272.         }
  273.     };
  274.  
  275.  
  276.     /**
  277.      * 能力监听回调
  278.      */
  279.     private static AiListener aiRespListener = new AiListener() {
  280.         //获取合成结果，封装到缓存数组中
  281.         @Override
  282.         public void onResult(int handleID, List<AiResponse> outputData, Object usrContext) {
  283.             if (outputData == null || outputData.isEmpty()) {
  284.                 return;
  285.             }
  286.             if (null != outputData && outputData.size() > 0) {
  287.                 for (int i = 0; i < outputData.size(); i++) {
  288.                     byte[] bytes = outputData.get(i).getValue();
  289.                     String key = outputData.get(i).getKey();
  290.  
  291.                     if (key.contains("plain") || key.contains("pgs")) {
  292.                         try {
  293.                             String s = new String(bytes, "GBK");
  294.                             Log.e(TAG, key + "      " + s);
  295.                             abilityCallback.onAbilityResult(key+ "  "+s);
  296.                         } catch (UnsupportedEncodingException e) {
  297.                             e.printStackTrace();
  298.                         }
  299.                         if (key.contains("plain")) {
  300.                             stopAsr();
  301.                         }
  302.                     }
  303.                 }
  304.                 if (outputData.get(0).getStatus() == DataStatus.END.getValue()) {
  305.                     stopAsr();
  306.                 }
  307.             }
  308.         }
  309.  
  310.         @Override
  311.         public void onEvent(int handleID, int event, List<AiResponse> eventData, Object usrContext) {
  312.             if (event == AiEvent.EVENT_UNKNOWN.getValue()) {
  313.             }
  314.             if (event == AiEvent.EVENT_START.getValue()) {
  315.             }
  316.             if (event == AiEvent.EVENT_END.getValue()) {
  317.                 if (handle != null) {
  318.                     int rets = AiHelper.getInst().end(handle);
  319.                     if (rets != 0) {
  320.                         String error = "end failed" + rets;
  321.                         Log.e(TAG, error);
  322.                     }
  323.                 }
  324.  
  325.             }
  326.             if (event == AiEvent.EVENT_PROGRESS.getValue()) {
  327.  
  328.             }
  329.         }
  330.  
  331.         @Override
  332.         public void onError(int handleID, int err, String msg, Object usrContext) {
  333.             if (handle != null) {
  334.                 int rets = AiHelper.getInst().end(handle);
  335.                 if (rets != 0) {
  336.                     String error = "end failed" + rets;
  337.                     Log.e(TAG, error);
  338.                 }
  339.             }
  340.         }
  341.     };
  342.  
  343.  
  344.     /**
  345.      * 音量及播报人等参数设置
  346.      */
  347.     @NonNull
  348.     private static AiRequest.Builder audioParam() {
  349.         AiRequest.Builder paramBuilder = AiRequest.builder();
  350.         paramBuilder.param("lmLoad", true);
  351.         paramBuilder.param("vadLoad", true);
  352.         paramBuilder.param("puncLoad", true);
  353.         paramBuilder.param("numLoad", true);
  354.         paramBuilder.param("postprocOn", true);
  355.         paramBuilder.param("lmOn", true);
  356.         paramBuilder.param("vadOn", true);
  357.         paramBuilder.param("vadLinkOn", false);
  358.         paramBuilder.param("vadNeed", true);
  359.         paramBuilder.param("vadThreshold", 0.1332);
  360.         paramBuilder.param("vadEnergyThreshold", 9);
  361.         return paramBuilder;
  362.     }
  363.  
  364.     /**
  365.      * 释放资源
  366.      */
  367.     public static void destory() {
  368.         stopAsr();
  369.     }
  370.  
  371.     /**
  372.      * 停止语音识别
  373.      */
  374.     private static void stopAsr() {
  375.         if (audioRecord != null) {
  376.             if (audioRecord.getState() == AudioRecord.STATE_INITIALIZED) {
  377.                 audioRecord.stop();
  378.             }
  379.         }
  380.         audioRecord.release();
  381.         int ret = AiHelper.getInst().end(handle);
  382.         if (ret == 0) {
  383.             abilityCallback.onAbilityEnd();
  384.         } else {
  385.             abilityCallback.onAbilityError(ret, new Throwable("aiHandle end error"));
  386.         }
  387.     }
  388.  
  389.  
  390.  
  391.  
  392.     private static AbilityCallback abilityCallback;
  393.  
  394.     public static void setCallBack(AbilityCallback callBack) {
  395.         abilityCallback = callBack;
  396.     }
  397.  
  398.  
  399.  
  400.  
  401. }

接口类

  1. package com.mhzk.xunfeitest;
  2.  
  3. public interface AbilityCallback {
  4.  
  5.         /**
  6.          * 开始
  7.          */
  8.         void onAbilityBegin();
  9.  
  10.         /**
  11.          * 能力结果输出
  12.          *
  13.          * @param result 结果
  14.          */
  15.         void onAbilityResult(String result);
  16.  
  17.         /**
  18.          * 结束
  19.          *
  20.          * @param code
  21.          * @param error
  22.          */
  23.         void onAbilityError(int code, Throwable error);
  24.  
  25.         /**
  26.          * 能力结束
  27.          */
  28.         void onAbilityEnd();
  29.  
  30. }

Activity中权限使用类，用不用都行，看自己

  1. package com.mhzk.xunfeitest;
  2.  
  3.  
  4. import android.Manifest;
  5. import android.content.Context;
  6. import android.content.pm.PackageManager;
  7. import android.content.res.AssetManager;
  8. import android.os.Build;
  9. import android.os.Environment;
  10. import android.util.Log;
  11.  
  12.  
  13.  
  14. import java.io.File;
  15. import java.io.FileOutputStream;
  16. import java.io.IOException;
  17. import java.io.InputStream;
  18. import java.io.OutputStream;
  19.  
  20. /**
  21.  * 讯飞语音合成文件复制公共功能
  22.  *	以下五个文件：
  23.  *		e3fe94474_1.0.0_xTTS_CnCn_xiaoyan_2018_arm.irf
  24.  *		e4b08c6f3_1.0.0_xTTS_CnCn_xiaofeng_2018_fix_arm.dat
  25.  *		e4caee636_1.0.2_xTTS_CnCn_front_Emb_arm_2017.irf
  26.  *		e05d571cc_1.0.0_xTTS_CnCn_xiaoyan_2018_fix_arm.dat
  27.  *		ebdbd61ae_1.0.0_xTTS_CnCn_xiaofeng_2018_arm.irf
  28.  */
  29. public class FileUtils {
  30.     private static final String TAG = "FileUtils";
  31.     // 获取外部存储路径
  32.     public static String getExternalStoragePath() {
  33.         return Environment.getExternalStorageDirectory().getAbsolutePath();
  34.     }
  35.  
  36.     // 创建xtts目录
  37.     public static void createDirectory(String directoryPath) {
  38.         File directory = new File(directoryPath);
  39.         if (!directory.exists()) {
  40.             if (directory.mkdirs()) {
  41.                 Log.d(TAG, "Directory created: " + directoryPath);
  42.             } else {
  43.                 Log.e(TAG, "Failed to create directory: " + directoryPath);
  44.             }
  45.         } else {
  46.             Log.d(TAG, "Directory already exists: " + directoryPath);
  47.         }
  48.     }
  49.  
  50.     // 判断目录是否为空
  51.     public static boolean isDirectoryEmpty(String directoryPath) {
  52.         File directory = new File(directoryPath);
  53.         if (directory.exists() && directory.isDirectory()) {
  54.             File[] files = directory.listFiles();
  55.             return files == null || files.length == 0;
  56.         }
  57.         return true;
  58.     }
  59.  
  60.     // 递归复制文件
  61.     public static void copyFiles(Context context, String sourceDir, String destinationDir) throws IOException {
  62.         AssetManager assetManager = context.getAssets();
  63.         String[] files = assetManager.list(sourceDir);
  64.         if (files != null && files.length > 0) {
  65.             createDirectory(destinationDir);
  66.             for (String fileName : files) {
  67.                 String sourcePath = sourceDir + File.separator + fileName;
  68.                 String destinationPath = destinationDir + File.separator + fileName;
  69.  
  70.                 if (assetManager.list(sourcePath).length > 0) {
  71.                     // 如果是目录，递归复制目录
  72.                     copyFiles(context, sourcePath, destinationPath);
  73.                 } else {
  74.                     // 如果是文件，复制文件
  75.                     copyFile(context, sourcePath, destinationPath);
  76.                 }
  77.             }
  78.         }
  79.     }
  80.  
  81.     // 复制文件
  82.     public static void copyFile(Context context, String sourcePath, String destinationPath) throws IOException {
  83.         InputStream inputStream = null;
  84.         OutputStream outputStream = null;
  85.  
  86.         try {
  87.             inputStream = context.getAssets().open(sourcePath);
  88.             outputStream = new FileOutputStream(destinationPath);
  89.             byte[] buffer = new byte[4096];
  90.             int length;
  91.             while ((length = inputStream.read(buffer)) > 0) {
  92.                 outputStream.write(buffer, 0, length);
  93.             }
  94.             Log.d(TAG, "File copied: " + destinationPath);
  95.         } finally {
  96.             if (inputStream != null) {
  97.                 try {
  98.                     inputStream.close();
  99.                 } catch (IOException e) {
  100.                     Log.e(TAG, "Failed to close input stream", e);
  101.                 }
  102.             }
  103.             if (outputStream != null) {
  104.                 try {
  105.                     outputStream.close();
  106.                 } catch (IOException e) {
  107.                     Log.e(TAG, "Failed to close output stream", e);
  108.                 }
  109.             }
  110.         }
  111.     }
  112.  
  113.     /**
  114.      * 创建讯飞语音合成所必须的目录：xtts并复制音频文件
  115.      * @param context
  116.      */
  117.     public static void createXttsDirAndCopyFile(Context context){
  118.         // 获取外部存储路径
  119.         String externalStoragePath = FileUtils.getExternalStoragePath();
  120.  
  121.         String xttsFolderPath = externalStoragePath + File.separator + context.getString(R.string.dir);
  122.         // 创建xtts文件夹
  123.         FileUtils.createDirectory(xttsFolderPath);
  124.         // 判断xtts文件夹是否为空
  125.         if (FileUtils.isDirectoryEmpty(xttsFolderPath)) {
  126.             // 复制assets目录下的xtts文件夹中的所有文件到外部存储的xtts文件夹中
  127.             try {
  128.                 FileUtils.copyFiles(context, context.getString(R.string.dir), xttsFolderPath);
  129.             } catch (IOException e) {
  130.                 Log.e(TAG, "文件复制失败"+e.getMessage());
  131.             }
  132.         } else {
  133.             // xtts文件夹不为空
  134.             Log.d(TAG, "xtts folder is not empty. Skipping the operation.");
  135.         }
  136.     }
  137.  
  138.     public static boolean hasStoragePermission(Context context) {
  139.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  140.             int permissionResult = context.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE);
  141.             return permissionResult == PackageManager.PERMISSION_GRANTED;
  142.         }
  143.         return true;
  144.     }
  145.  
  146. }
  147.

Activity的布局

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:orientation="vertical"
  7.     android:gravity="center_horizontal"
  8.     android:layout_height="match_parent"
  9.     tools:context=".MainActivity">
  10.  
  11.     <TextView
  12.         android:id="@+id/one"
  13.         android:layout_width="wrap_content"
  14.         android:layout_height="wrap_content"
  15.         android:text="开始录音"
  16.         android:textSize="20sp"
  17.         app:layout_constraintBottom_toBottomOf="parent"
  18.         app:layout_constraintEnd_toEndOf="parent"
  19.         app:layout_constraintStart_toStartOf="parent"
  20.         app:layout_constraintTop_toTopOf="parent" />
  21.  
  22.  
  23.  
  24.  
  25.     <TextView
  26.         android:layout_marginTop="20dp"
  27.         android:id="@+id/three"
  28.         android:layout_width="wrap_content"
  29.         android:layout_height="wrap_content"
  30.         android:text="内容展示"
  31.         android:textSize="20sp"
  32.         app:layout_constraintBottom_toBottomOf="parent"
  33.         app:layout_constraintEnd_toEndOf="parent"
  34.         app:layout_constraintStart_toStartOf="parent"
  35.         app:layout_constraintTop_toTopOf="parent" />
  36.  
  37.  
  38. </LinearLayout>

 要demo的可以私信

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/378311
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号