Implementierung der Miniprogramm-Aufzeichnungsfunktion

const recorderManager = Taro.getRecorderManager();

useEffect(() => {
 // Auf Aufnahmestart warten recorderManager.onStart(() => {
   console.log('Aufzeichnung starten');
  });
 // Monitor-Aufnahmepause recorderManager.onPause(() => {
   console.log('Aufzeichnung pausieren');
  });
 // Warten Sie auf die Aufnahme, um fortzufahren recorderManager.onResume(() => {
   console.log('Aufzeichnung fortsetzen');
  });
 // Monitoraufzeichnung stoppen recorderManager.onStop((res) => {
   wenn (Res.Dauer < 1000) {
    Taro.showToast({
     Titel: 'Aufnahmezeit ist zu kurz',
     Dauer: 1000,
     Symbol: „keine“,
    });
   } anders {
    console.log('Aufzeichnung beenden');
    DateiUpload(res.tempFilePath);
   }
  });

  recorderManager.onError(() => {
   Taro.showToast({
    Titel: ,,Aufnahme fehlgeschlagen! ',
    Dauer: 1000,
    Symbol: „keine“,
   });
  });
 }, []);

const fileUpload = (tempFilePath) => {
  Taro.uploadDatei({
   url: 'http://127.0.0.1:7001/record', // Serveradresse Dateipfad: tempFilePath,
   Name: 'Datei', // Dies kann nach Belieben ausgefüllt werden Header: {
    'content-type': 'multipart/form-data', // Das Format muss dieses sein Autorisierung: Taro.getStorageSync('token'),
   },
   // formData wird verwendet, um andere Informationen als Dateien zu übertragen formData: {
    record_name: 'Rezitation Werke',
    Gedicht-ID: GedichtInfo.id,
    Kategorie: GedichtInfo.Kategorie,
   },
   Erfolg: (res) => {
    konsole.log(res);
    const url = res.data;
    playAudio(url); // Aufnahme abspielen},
   fehlgeschlagen: (Fehler) => {
    console.log('fehlgeschlagen!');
    konsole.fehler(fehler);
   },
  });
 };

const handleClick = () => {
  const curPause = pause;
  setPause(!aktuellePause);

  if (ersterDatensatz) {
   setzeErstenDatensatz(false);

   recorderManager.start({
    Dauer: 60000,
    Beispielrate: 44100,
    Anzahl der Kanäle: 1,
    encodeBitRate: 192000,
    Format: 'mp3',
    Rahmengröße: 50,
   });

   Taro.showToast({
    Titel: 'Aufnahme starten',
    Dauer: 1000,
    Symbol: „keine“,
   });

  } anders {
   if (aktuellePause) {
    recorderManager.pause(); // Aufnahme pausieren } else {
    recorderManager.resume(); //Aufnahme fortsetzen}
  }
 };

 const handleComplete = () => {
  recorderManager.stop(); // Aufnahme stoppen};

module.exports = (app) => {
 Konstantenkonfiguration = (Export = {});
 
 ...

 config.multipart = {
  Modus: "Datei",
  Dateigröße: „50 MB“,
 }
 ...

 zurückkehren {
  ...Konfiguration,
  ...Benutzerkonfiguration,
 };
};

// Aufnahme senden router.post('/record', auth, controller.record.postRecord);

Definieren Sie die Datei record.js im Controller-Verzeichnis und schreiben Sie den folgenden Inhalt:
const Controller = require('egg').Controller;

Klasse RecordController erweitert Controller {
 asynchroner PostRecord() {
  const { ctx } = dies;
  const Datei = ctx.request.files[0];
  const { Datensatzname, Gedicht-ID, Kategorie } = ctx.request.body;
  
  const res = warte auf ctx.service.record.postRecord(Datei, Datensatzname, Gedicht-ID, Kategorie);

  ctx.body = res;
 }
}

module.exports = DatensatzController;

const Service = erfordern('egg').Service;
Lassen Sie OSS = erfordern ('ali-oss');

lass aliInfo = {
 // https://help.aliyun.com/document_detail/31837.html
 Region: 'oss-cn-guangzhou',
 Eimer: 'Gedicht-Mini-Programm',
 accessKeyId: 'xxx', // Füllen Sie die accessKeyId von Alibaba Cloud aus
 accessKeySecret: 'xxx', // Füllen Sie Alibaba Clouds accessKeySecret aus
};

let client = neues OSS(aliInfo);

Klasse RecordService erweitert Service {
 async postRecord(Datei, Datensatzname, Gedicht-ID, Kategorie) {
  const url = warte auf dies.uploadOSS(Datei);
  warte auf Folgendes.updateRecord(URL, Datensatzname, Gedicht-ID, Kategorie);

  URL zurückgeben;
 }

 asynchroner UploadOSS(Datei) {
  const { ctx } = dies;

  lass resultieren;
  versuchen {
   // Dateien verarbeiten, beispielsweise in die Cloud hochladen result = await client.put(file.filename, file.filepath);
  Endlich
   // Temporäre Dateien müssen gelöscht werden. Warten Sie auf ctx.cleanupRequestFiles();
  }
  gib result.url zurück;
 }

 async updateRecord(url, Datensatzname, Gedicht-ID, Kategorie) {
  const { ctx } = dies;

  console.log('OpenID von ctx.locals abrufen');
  Konsole.log(ctx.locals.openid);
  const openid = ctx.locals.openid;

  // Benutzerinformationen in der Datenbank aufzeichnen const res = await ctx.model.Record.create({
   Datensatzname: Datensatzname,
   record_url: URL,
   Gedicht-ID: Gedicht-ID,
   Kategorie: Kategorie,
   OpenID: OpenID,
  });
 }
}
module.exports = Datensatzdienst;

const innerAudioText = Taro.createInnerAudioContext();

useEffect(() => {
  innerAudioText.onPlay(() => {
   console.log('Mit der Wiedergabe beginnen');
  });

  innerAudioText.onError((e) => {
   console.log('Wiedergabestörung');
   konsole.log(e);
  });
 }, []);

const playAudio = (URL) => {
 innerAudioText.autoplay = true;
 innerAudioText.src = URL;
};