Uniapp uses Baidu Voice to realize the function of converting recording to text

  <view class="popup-content" >  
                    <view>{{msg}}</view>  
                    <view>You are talking about {{voicetext}}</view>  
                    <button class="uni-btn" type="warn" @touchstart="startvoice" @touchend="endvoice">Press and release to stop</button>  
                    <button class="uni-btn" type="warn" @tap="playvoice" >Play recording</button>  
    </view>  
<script>  
import permission from "@/js_sdk/wa-permission/permission.js"  
    const recorderManager = uni.getRecorderManager();  
    const innerAudioContext = uni.createInnerAudioContext();  
export default {  
     data() {  
    return {  
            voicetext:"",  
        msg:"",  
        voicepath:""  
       }  
   },  
  onLoad() {  
      this.initaudio()  
 
   },  
methods: {  
   async initaudio(){  
                           //Note that this must be await because it will trigger an asynchronous event. The permission request dialog box will pop up on the phone and you can proceed to the next step of recording only after processing. let recordauth = await permision.requestAndroidPermission("android.permission.RECORD_AUDIO")  
                 console.log("Judge whether there is recording permission>>>>>"+recordauth)  
                  if(recordauth==1){  
                               recorderManager.onStart((res)=>{  
                                        console.log("Start recording>>>>>>>>...")  
                                    });  
                               recorderManager.onStop((res)=>{  
                                    console.log("recorderstop....res.tempFilePath>>>"+res.tempFilePath)  
                                    this.voicepath = res.tempFilePath  
                                    this.uploadvoicefile()  
                                    //Use uni.uploadFile to upload to the server, this time in mp3 format});  
 
                                recorderManager.onError( (res)=> {  
 
                                 console.log('onError'+JSON.stringify(res));  
                                });  
                  }   
            }, //initaudio method ends startvoice(){  
                console.log("Start recording")  
                recorderManager.start({  
                    format:"mp3",  
                    sampleRate: 16000 // This parameter must be set in the background, otherwise Baidu speech recognition will not work});  
         },  
        endvoice(){  
 
              console.log("End recording")  
              //Note that in order to avoid the API bug caused by too short a speaking time, some delays should be added setTimeout(()=>{  
                recorderManager.stop()  
             },1000)  
 
            },  
            playvoice(){  
                console.log("Click playvoice")  
                if (this.voicepath) {  
                    console.log("play sound")  
                    innerAudioContext.src = this.voicepath;  
                    innerAudioContext.play();  
                }  
            },  
            uploadvoicefile(){  
                // this.msg = "Call java service file path" + this.voicepath  
                 uni.uploadFile({  
                url: 'http://ip:port/uploadFile (java end receiving file interface name)',   
                filePath: this.voicepath, //The temporary path returned after the recording is completed,  
                name: 'file',  
                formData: {  
                   dev_id:1537 // Chinese with punctuation},  
                success: (uploadFileRes) => {  
                    let word = uploadFileRes.data  
                    console.log("Audio uploaded successfully"+word);  
                },  
                fail: (res) => {  
 
                    console.log("Failed to upload audio"+JSON.stringify(res));  
                }  
                });  
            }  
    }  
}  
</script> ```   
 //Note that the ip in the url attribute of uploadFile cannot be localhost or 127. If you start the java service on your own computer, it must be the real ip of the local computer, such as 192.xxx, or a domain name, and the java interface must support cross-domain. Many people are stuck on this ip, and it is difficult for me to find a post on the Internet to solve the problem. Note that the filePath path is the path starting with _doc obtained by the onStop event of recorderManager. There is no need to add any file:, not like some people on the Internet say to add this kind of thing

            <dependency>  
            <groupId>com.baidu.aip</groupId>  
            <artifactId>java-sdk</artifactId>  
            <version>4.16.3</version>  
        </dependency>  
 
        <dependency>  
            <groupId>com.googlecode.soundlibs</groupId>  
            <artifactId>mp3spi</artifactId>  
            <version>1.9.5.4</version>  
        </dependency>  
 
 ``` import com.baidu.aip.speech.AipSpeech;  
import javazoom.spi.mpeg.sampled.file.MpegAudioFileReader;  
import org.apache.commons.io.IOUtils;  
import org.json.JSONArray;  
import org.json.JSONObject;  
 
import org.springframework.web.bind.annotation.*;  
import org.springframework.web.multipart.MultipartFile;  
 
import javax.sound.sampled.AudioFormat;  
import javax.sound.sampled.AudioInputStream;  
import javax.sound.sampled.AudioSystem;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.HashMap;  
 
@RestController  
@CrossOrigin(origins = "*")  
public class BaiduSpeech {  
    //Set APPID/AK/SK  
    public static final String APP_ID = ""; //Go to Baidu voice service application public static final String API_KEY = ""; //Go to Baidu voice service application public static final String SECRET_KEY = ""; //Go to Baidu voice service application @RequestMapping(value = "/uploadFile")  
    public String uploadFile( @RequestParam("dev_id") int dev_id, @RequestParam("file") MultipartFile file) throws Exception {  
        byte[] pcmbytedata = mp3Convert2pcm(file.getInputStream());  
        HashMap<String,Object> options = new HashMap<String,Object>();  
        options.put("dev_pid",dev_id);//  
        JSONObject jsonfrombaidu = basicBydata(pcmbytedata,"pcm",options);  
        JSONArray jsonArray = jsonfrombaidu.getJSONArray("result");  
        String result = jsonArray.getString(0);  
        System.out.println(result); //The result of parsing return result;  
    }  
    // Get the AipSpeech object. It is recommended to use a single instance. public static AipSpeech getClient() {  
        AipSpeech client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);  
        // Optional: Set network connection parameters client.setConnectionTimeoutInMillis(2000);  
        client.setSocketTimeoutInMillis(60000);  
        return client;  
    }  
 
    // Speech recognition (from file)  
    public static JSONObject basicBydata(byte[] voicedata, String fileType,HashMap<String,Object> options) {  
        AipSpeech client = getClient();  
 
        return client.asr(voicedata, fileType, 16000, options);  
    }  
    /**  
     * Convert MP3 to PCM  
     * @param inputStream MP3 input stream * @throws Exception  
     */  
    public static byte[] mp3Convert2pcm(InputStream inputStream) throws Exception {  
        //Convert PCM audioInputStream data AudioInputStream audioInputStream = getPcmAudioInputStream(inputStream);  
        byte[] pcmBytes = IOUtils.toByteArray(audioInputStream);  
        return pcmBytes;  
    }  
 
    /**  
     * Get PCM AudioInputStream data * @param inputStream MP3 input stream * @return AudioInputStream PCM input stream */  
    private static AudioInputStream getPcmAudioInputStream(InputStream inputStream) {  
        AudioInputStream audioInputStream = null;  
        AudioFormat targetFormat = null;  
        try {  
            AudioInputStream in = null;  
            MpegAudioFileReader mp = new MpegAudioFileReader();  
            in = mp.getAudioInputStream(inputStream);  
            AudioFormat baseFormat = in.getFormat();  
            targetFormat = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16,  
                    baseFormat.getChannels(), baseFormat.getChannels() * 2, baseFormat.getSampleRate(), false);  
            audioInputStream = AudioSystem.getAudioInputStream(targetFormat, in);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return audioInputStream;  
    }  
 
} ```