Pilote audio personnalisé (Android)

Vue d'ensemble

Le SDK Android d'OpenTok vous permet de configurer un pilote audio personnalisé pour les émetteurs et les abonnés. Vous pouvez utiliser un pilote audio personnalisé pour personnaliser le son envoyé vers le flux d'un émetteur. Vous pouvez également personnaliser la lecture du son des flux auxquels vous êtes abonné.

Configuration de votre projet

Le code correspondant à cette section est disponible dans le projet « Basic-Audio-Driver-Java » de la opentok-android-sdk-samples repo. Si vous ne l'avez pas encore fait, vous devrez cloner le repo dans un répertoire local. Sur la ligne de commande, exécutez :

git clone git@github.com:Vonage/vonage-video-android-sdk-samples.git

Ouvrir le Java - Notions de base sur l'audio dans Android Studio.

Remarque : Ce tutoriel traite de la version Java de l'application exemple Android. Pour une version Kotlin accompagnée d'une documentation, consultez la page Exemples d'applications Android.

Étape 1 : Ajout d'un pilote audio personnalisé

Cet exemple d'application utilise le pilote audio personnalisé pour publier du bruit blanc (un signal audio aléatoire) dans son flux audio. Elle utilise également le pilote audio personnalisé pour capturer l'audio des flux souscrits et l'enregistrer dans un fichier.

Configuration du périphérique audio et du bus audio

En utilisant un pilote audio personnalisé, vous définissez un pilote audio personnalisé et un bus audio à utiliser par l'application.

Les NoiseAudioDevice définit une interface audio de base à utiliser par l'application. Elle étend la classe BaseAudioDevice classe, définie par le SDK Android d'OpenTok. Pour utiliser un pilote audio personnalisé, appelez la méthode AudioDeviceManager.setAudioDevice() méthode. Cet exemple définit le périphérique audio comme une instance de la méthode NoiseAudioDevice classe :

AudioDeviceManager.setAudioDevice(noiseAudioDevice);

Utiliser le AudioSettings classe, définie dans le SDK Android d'OpenTok, pour définir le format audio utilisé par le pilote audio personnalisé. La NoiseAudioDevice() instancie deux AudioSettings une pour le capteur audio personnalisé et une pour le moteur de rendu audio personnalisé. Il définit la fréquence d'échantillonnage et le nombre de canaux pour chacune d'entre elles :

public NoiseAudioDevice(Context context) {
    this.context = context;

    captureSettings = new AudioSettings(SAMPLING_RATE, NUM_CHANNELS_CAPTURING);
    rendererSettings = new AudioSettings(SAMPLING_RATE, NUM_CHANNELS_RENDERING);

    capturerStarted = false;
    rendererStarted = false;

    audioDriverPaused = false;

    capturerHandler = new Handler();
    rendererHandler = new Handler();
}

Le constructeur définit également quelques propriétés locales qui indiquent si le dispositif est en train de capturer ou d'effectuer un rendu. Il définit également une instance de Handler pour traiter la requête capturer Objet exécutable.

Les NoiseAudioDevice.getAudioBus() obtient la méthode AudioBus que ce périphérique audio utilise, définie par l'instance NoiseAudioDevice.AudioBus classe. Utiliser le AudioBus pour envoyer et recevoir des échantillons audio depuis et vers une session. L'éditeur accède à l'instance AudioBus pour obtenir les échantillons audio. Les abonnés envoient des échantillons audio (provenant des flux souscrits) à l'objet AudioBus.

Capturer l'audio pour l'utiliser par un éditeur

Les BaseAudioDevice.startCapturer() est appelée lorsque l'appareil audio doit commencer à capturer les données audio à publier. La méthode NoiseAudioDevice de cette méthode démarre le capturer thread à exécuter dans la file d'attente après 1 seconde :

public boolean startCapturer() {
    capturerStarted = true;
    capturerHandler.postDelayed(capturer, capturerIntervalMillis);
    return true;
}

Les capturer produit un tampon contenant des échantillons de données aléatoires (bruit blanc). Il appelle ensuite la fonction writeCaptureData() de la méthode AudioBus qui envoie les échantillons au bus audio. L'éditeur de l'application utilise les échantillons envoyés au bus audio pour les transmettre en tant qu'audio dans le flux publié. Ensuite, si une capture est toujours en cours (si l'application est en cours de publication), l'objet capturer est relancé après une seconde :

private Runnable capturer = new Runnable() {
    @Override
    public void run() {
        capturerBuffer.rewind();

        Random rand = new Random();
        rand.nextBytes(capturerBuffer.array());

        getAudioBus().writeCaptureData(capturerBuffer, SAMPLING_RATE);

        if(capturerStarted && !audioDriverPaused) {
            capturerHandler.postDelayed(capturer, capturerIntervalMillis);
        }
    }
};

La classe `AudioDevice` comprend d'autres méthodes qui sont implémentées par la classe `NoiseAudioDevice`. Cependant, cet exemple ne fait rien d'intéressant avec ces méthodes ; elles ne sont donc pas abordées ici.

Étape 2 : Ajout d'un moteur de rendu audio personnalisé

Vous mettrez en œuvre un moteur de rendu audio simple pour les flux audio souscrits.

Les NoiseAudioDevice() La méthode constructeur configure un fichier afin d'y enregistrer le flux audio entrant. Cette opération a pour seul but d'illustrer l'utilisation du moteur de rendu audio du pilote audio personnalisé. L'application nécessite les autorisations suivantes, définies dans le fichier AndroidManifest.xml fichier :

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

Les BaseAudioDevice.initRenderer() est appelée lorsque l'application initialise le moteur de rendu audio. La méthode NoiseAudioDevice de cette méthode instancie un nouvel objet File, dans lequel l'application écrira les données audio :

@Override
public boolean initRenderer() {
    rendererBuffer = ByteBuffer.allocateDirect(SAMPLING_RATE * 2); // Each sample has 2 bytes
    File documentsDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS);
    rendererFile = new File(documentsDirectory, "output.raw");

    if (!rendererFile.exists()) {
        try {
            rendererFile.getParentFile().mkdirs();
            rendererFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    return true;
}

Les BaseAudioDevice.startRendering() est appelée lorsque l'appareil audio doit commencer à restituer (lire) l'audio des flux souscrits. La méthode NoiseAudioDevice de cette méthode démarre le capturer thread à exécuter dans la file d'attente après 1 seconde :

 @Override
 public boolean startRenderer() {
     rendererStarted = true;
     rendererHandler.postDelayed(renderer, rendererIntervalMillis);
     return true;
 }

Les renderer obtient une seconde d'audio à partir du bus audio en appelant la fonction readRenderData() de la méthode AudioBus objet. Il écrit ensuite les données audio dans le fichier (à des fins d'échantillonnage). Et, si le périphérique audio est toujours utilisé pour restituer des échantillons audio, il met en place un minuteur pour exécuter l'objet rendererHandler après 0,1 seconde :

private Handler rendererHandler;

private Runnable renderer = new Runnable() {
    @Override
    public void run() {
        rendererBuffer.clear();
        getAudioBus().readRenderData(rendererBuffer, SAMPLING_RATE);

        try {
            FileOutputStream stream = new FileOutputStream(rendererFile);
            stream.write(rendererBuffer.array());
            stream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (rendererStarted && !audioDriverPaused) {
            rendererHandler.postDelayed(renderer, rendererIntervalMillis);
        }
    }
};

Cet exemple est volontairement simple à des fins pédagogiques : il se contente d'enregistrer les données audio dans un fichier. Dans le cadre d'une utilisation plus concrète d'un pilote audio personnalisé, vous pourriez l'utiliser pour diffuser du son vers un appareil Bluetooth ou pour traiter le signal audio avant sa diffusion.

Félicitations ! Vous venez de terminer le tutoriel sur les pilotes audio personnalisés pour Android.
Vous pouvez continuer à tester et à modifier le code que vous avez développé ici, ou consulter le Prochaines étapes ci-dessous.

Prochaines étapes

Une fois que vous aurez terminé cette étape, poursuivez le développement et l'amélioration de votre application OpenTok à l'aide des ressources utiles suivantes :