Android Audio

Le système d’exploitation Android offre une prise en charge étendue du multimédia, comprenant à la fois l’audio et la vidéo. Ce guide se concentre sur l’audio dans Android et couvre la lecture et l’enregistrement audio à l’aide des classes de lecteur audio et d’enregistreur intégrées, ainsi que de l’API audio de bas niveau. Il couvre également l’utilisation d’événements audio diffusés par d’autres applications, afin que les développeurs puissent créer des applications bien comportementées.

Vue d’ensemble

Les appareils mobiles modernes ont adopté des fonctionnalités qui auparavant nécessitaient des équipements dédiés : caméras, lecteurs de musique et magnétoscopes. Pour cette raison, les frameworks multimédias sont devenus une fonctionnalité de première classe dans les API mobiles.

Android fournit une prise en charge étendue du multimédia. Cet article examine l’utilisation de l’audio dans Android et aborde les rubriques suivantes

1. Lecture audio avec MediaPlayer : utilisation de la classe intégrée MediaPlayer pour lire l’audio, y compris les fichiers audio locaux et les fichiers audio diffusés en continu avec la AudioTrack classe.

2. Enregistrement audio : utilisation de la classe intégrée MediaRecorder pour enregistrer l’audio.

3. Utilisation des notifications audio : utilisation de notifications audio pour créer des applications qui répondent correctement aux événements (tels que les appels téléphoniques entrants) en suspendant ou annulant leurs sorties audio.

4. Utilisation de Low-Level audio : lecture de l’audio à l’aide de la AudioTrack classe en écrivant directement dans les mémoires tampons. Enregistrement audio à l’aide de la AudioRecord classe et lecture directe à partir des mémoires tampons.

Spécifications

Ce guide nécessite Android 2.0 (niveau d’API 5) ou version ultérieure. Notez que le débogage audio sur Android doit être effectué sur un appareil.

Il est nécessaire de demander les RECORD_AUDIO autorisations dans AndroidManifest.XML:

Lecture de l’audio avec la classe MediaPlayer

La façon la plus simple de lire de l’audio dans Android consiste à utiliser la classe MediaPlayer intégrée. MediaPlayer peut lire des fichiers locaux ou distants en passant le chemin d’accès du fichier. Toutefois, MediaPlayer est très sensible à l’état et l’appel de l’une de ses méthodes dans un état incorrect entraîne la levée d’une exception. Il est important d’interagir avec MediaPlayer dans l’ordre décrit ci-dessous pour éviter les erreurs.

Initialisation et lecture

La lecture de l’audio avec MediaPlayer nécessite la séquence suivante :

1. Instanciez un nouvel objet MediaPlayer .

2. Configurez le fichier à lire via la méthode SetDataSource .

3. Appelez la méthode Prepare pour initialiser le lecteur.

4. Appelez la méthode Start pour démarrer la lecture audio.

L’exemple de code ci-dessous illustre cette utilisation :

protected MediaPlayer player;
public void StartPlayer(String  filePath)
{
  if (player == null) {
    player = new MediaPlayer();
  } else {
    player.Reset();
    player.SetDataSource(filePath);
    player.Prepare();
    player.Start();
  }
}

Suspension et reprise de la lecture

La lecture peut être suspendue en appelant la méthode Pause :

player.Pause();

Pour reprendre la lecture suspendue, appelez la méthode Start . Cette opération reprend à partir de l’emplacement suspendu dans la lecture :

player.Start();

L’appel de la méthode Stop sur le lecteur met fin à une lecture en cours :

player.Stop();

Lorsque le lecteur n’est plus nécessaire, les ressources doivent être libérées en appelant la méthode Release :

player.Release();

Utilisation de la classe MediaRecorder pour enregistrer l’audio

Le corollaire de pour l’enregistrement MediaPlayer audio dans Android est la classe MediaRecorder . Comme le MediaPlayer, il est sensible à l’état et passe à travers plusieurs états pour atteindre le point où il peut commencer l’enregistrement. Pour enregistrer l’audio, l’autorisation RECORD_AUDIO doit être définie. Pour obtenir des instructions sur la définition des autorisations d’application, consultez Utilisation de AndroidManifest.xml.

Initialisation et enregistrement

L’enregistrement audio avec nécessite MediaRecorder les étapes suivantes :

1. Instanciez un nouvel objet MediaRecorder .

2. Spécifiez le périphérique matériel à utiliser pour capturer l’entrée audio via la méthode SetAudioSource .

3. Définissez le format audio du fichier de sortie à l’aide de la méthode SetOutputFormat . Pour obtenir la liste des types audio pris en charge, consultez Formats multimédias android pris en charge.

4. Appelez la méthode SetAudioEncoder pour définir le type d’encodage audio.

5. Appelez la méthode SetOutputFile pour spécifier le nom du fichier de sortie dans lequel les données audio sont écrites.

6. Appelez la méthode Prepare pour initialiser l’enregistreur.

7. Appelez la méthode Start pour démarrer l’enregistrement.

L’exemple de code suivant illustre cette séquence :

protected MediaRecorder recorder;
void RecordAudio (String filePath)
{
  try {
    if (File.Exists (filePath)) {
      File.Delete (filePath);
    }
    if (recorder == null) {
      recorder = new MediaRecorder (); // Initial state.
    } else {
      recorder.Reset ();
      recorder.SetAudioSource (AudioSource.Mic);
      recorder.SetOutputFormat (OutputFormat.ThreeGpp);
      recorder.SetAudioEncoder (AudioEncoder.AmrNb);
      // Initialized state.
      recorder.SetOutputFile (filePath);
      // DataSourceConfigured state.
      recorder.Prepare (); // Prepared state
      recorder.Start (); // Recording state.
    }
  } catch (Exception ex) {
    Console.Out.WriteLine( ex.StackTrace);
  }
}

Arrêt de l’enregistrement

Pour arrêter l’enregistrement, appelez la Stop méthode sur le :MediaRecorder

recorder.Stop();

Nettoyage

Une fois le MediaRecorder a été arrêté, appelez la méthode Reset pour le remettre à l’état inactif :

recorder.Reset();

Lorsque le MediaRecorder n’est plus nécessaire, ses ressources doivent être libérées en appelant la méthode Release :

recorder.Release();

Gestion des notifications audio

Classe AudioManager

La classe AudioManager permet d’accéder aux notifications audio qui permettent aux applications de savoir quand des événements audio se produisent. Ce service permet également d’accéder à d’autres fonctionnalités audio, telles que le contrôle du volume et du mode de sonnerie. Permet à une application de gérer les notifications audio pour contrôler la AudioManager lecture audio.

Gestion du focus audio

Les ressources audio de l’appareil (lecteur et enregistreur intégrés) sont partagées par toutes les applications en cours d’exécution.

D’un point de vue conceptuel, cela est similaire aux applications sur un ordinateur de bureau où une seule application a le focus clavier : après avoir sélectionné l’une des applications en cours d’exécution en cliquant dessus, l’entrée du clavier va uniquement à cette application.

Le focus audio est une idée similaire et empêche plusieurs applications de lire ou d’enregistrer de l’audio en même temps. Il est plus compliqué que le focus clavier, car il est volontaire - l’application peut ignorer ce fait qu’elle n’a pas actuellement de focus et de lecture audio indépendamment - et parce qu’il existe différents types de focus audio qui peuvent être demandés. Par exemple, si le demandeur n’est censé lire l’audio que pendant une très courte période, il peut demander le focus temporaire.

Le focus audio peut être accordé immédiatement, ou initialement refusé et accordé ultérieurement. Par exemple, si une application demande le focus audio pendant un appel téléphonique, il est refusé, mais le focus peut être accordé une fois l’appel téléphonique terminé. Dans ce cas, un écouteur est enregistré afin de répondre en conséquence si le focus audio est retiré. La demande de focus audio est utilisée pour déterminer s’il est correct de lire ou d’enregistrer de l’audio.

Pour plus d’informations sur le focus audio, consultez Gestion du focus audio.

Inscription du rappel pour le focus audio

L’enregistrement du FocusChangeListener rappel à partir du est une partie importante de l’obtention et de la IOnAudioChangeListener libération du focus audio. Cela est dû au fait que l’octroi du focus audio peut être différé jusqu’à une date ultérieure. Par exemple, une application peut demander à lire de la musique pendant qu’un appel téléphonique est en cours. Le focus audio ne sera pas accordé tant que l’appel téléphonique n’est pas terminé.

Pour cette raison, l’objet de rappel est passé en tant que paramètre dans la GetAudioFocus méthode du AudioManager, et c’est cet appel qui inscrit le rappel. Si le focus audio est initialement refusé mais accordé par la suite, l’application est informée en appelant OnAudioFocusChange sur le rappel. La même méthode est utilisée pour indiquer à l’application que le focus audio est retiré.

Lorsque l’application a fini d’utiliser les ressources audio, elle appelle la AbandonFocus méthode du AudioManager, puis transmet à nouveau le rappel. Cette opération annule l’inscription du rappel et libère les ressources audio, afin que d’autres applications puissent obtenir le focus audio.

Demande de focus audio

Les étapes requises pour demander les ressources audio de l’appareil sont les suivantes :

1. Obtenez un handle pour le AudioManager service système.

2. Créez un instance de la classe de rappel.

3. Demandez les ressources audio de l’appareil en appelant la RequestAudioFocus méthode sur le AudioManager . Les paramètres sont l’objet de rappel, le type de flux (musique, appel vocal, sonnerie, etc.) et le type du droit d’accès demandé (les ressources audio peuvent être demandées momentanément ou pour une période indéterminée, par exemple).

4. Si la demande est accordée, la playMusic méthode est appelée immédiatement et l’audio commence à être lu.

5. Si la demande est refusée, aucune autre action n’est effectuée. Dans ce cas, l’audio ne sera lu que si la demande est accordée ultérieurement.

L’exemple de code ci-dessous montre les étapes suivantes :

Boolean RequestAudioResources(INotificationReceiver parent)
{
  AudioManager audioMan = (AudioManager) GetSystemService(Context.AudioService);
  AudioManager.IOnAudioFocusChangeListener listener  = new MyAudioListener(this);
  var ret = audioMan.RequestAudioFocus (listener, Stream.Music, AudioFocus.Gain );
  if (ret == AudioFocusRequest.Granted) {
    playMusic();
    return (true);
  } else if (ret == AudioFocusRequest.Failed) {
    return (false);
  }
  return (false);
}

Publication du focus audio

Une fois la lecture de la piste terminée, la AbandonFocus méthode on AudioManager est appelée. Cela permet à une autre application d’obtenir les ressources audio de l’appareil. D’autres applications recevront une notification de ce changement de focus audio si elles ont inscrit leurs propres écouteurs.

API Audio de bas niveau

Les API audio de bas niveau offrent un meilleur contrôle sur la lecture et l’enregistrement audio, car elles interagissent directement avec les mémoires tampons au lieu d’utiliser des URI de fichier. Il existe certains scénarios où cette approche est préférable. Il s’agit entre autres des scénarios suivants :

1. Lors de la lecture à partir de fichiers audio chiffrés.

2. Lors de la lecture d’une succession de courts clips.

3. Streaming audio.

Classe AudioTrack

La classe AudioTrack utilise les API audio de bas niveau pour l’enregistrement et est l’équivalent de bas niveau de la MediaPlayer classe.

Initialisation et lecture

Pour lire l’audio, une nouvelle instance de AudioTrack doit être instanciée. La liste d’arguments passée dans le constructeur spécifie comment lire l’exemple audio contenu dans la mémoire tampon. Les arguments sont :

1. Type de flux : voix, sonnerie, musique, système ou alarme.

2. Fréquence : taux d’échantillonnage exprimé en Hz.

3. Configuration du canal : mono ou stéréo.

4. Format audio : encodage 8 bits ou 16 bits.

5. Taille de la mémoire tampon : en octets.

6. Mode mémoire tampon : streaming ou statique.

Après la construction, la méthode Play de AudioTrack est appelée pour la configurer pour commencer à jouer. L’écriture de la mémoire tampon audio dans démarre AudioTrack la lecture :

void PlayAudioTrack(byte[] audioBuffer)
{
  AudioTrack audioTrack = new AudioTrack(
    // Stream type
    Stream.Music,
    // Frequency
    11025,
    // Mono or stereo
    ChannelOut.Mono,
    // Audio encoding
    Android.Media.Encoding.Pcm16bit,
    // Length of the audio clip.
    audioBuffer.Length,
    // Mode. Stream or static.
    AudioTrackMode.Stream);

    audioTrack.Play();
    audioTrack.Write(audioBuffer, 0, audioBuffer.Length);
}

Suspension et arrêt de la lecture

Appelez la méthode Pause pour suspendre la lecture :

audioTrack.Pause();

L’appel de la méthode Stop met fin définitivement à la lecture :

audioTrack.Stop();

Nettoyage

Lorsque le AudioTrack n’est plus nécessaire, ses ressources doivent être libérées en appelant Release :

audioTrack.Release();

Classe AudioRecord

La classe AudioRecord est l’équivalent de AudioTrack sur le côté enregistrement. Comme AudioTrack, il utilise des mémoires tampons directement, à la place des fichiers et des URI. Il nécessite que l’autorisation RECORD_AUDIO soit définie dans le manifeste.

Initialisation et enregistrement

La première étape consiste à construire un nouvel objet AudioRecord . La liste d’arguments transmise au constructeur fournit toutes les informations requises pour l’enregistrement. Contrairement à dans AudioTrack, où les arguments sont en grande partie des énumérations, les arguments équivalents dans AudioRecord sont des entiers. Il s’agit notamment des paramètres suivants :

1. Source d’entrée audio matérielle telle que le microphone.

2. Type de flux : voix, sonnerie, musique, système ou alarme.

3. Fréquence : taux d’échantillonnage exprimé en Hz.

4. Configuration du canal : mono ou stéréo.

5. Format audio : encodage 8 bits ou 16 bits.

6. Taille de mémoire tampon en octets

Une fois le AudioRecord construit, sa méthode StartRecording est appelée. Il est maintenant prêt à commencer l’enregistrement. lit AudioRecord en continu la mémoire tampon audio pour l’entrée et écrit cette entrée dans un fichier audio.

void RecordAudio()
{
  byte[] audioBuffer = new byte[100000];
  var audRecorder = new AudioRecord(
    // Hardware source of recording.
    AudioSource.Mic,
    // Frequency
    11025,
    // Mono or stereo
    ChannelIn.Mono,
    // Audio encoding
    Android.Media.Encoding.Pcm16bit,
    // Length of the audio clip.
    audioBuffer.Length
  );
  audRecorder.StartRecording();
  while (true) {
    try
    {
      // Keep reading the buffer while there is audio input.
      audRecorder.Read(audioBuffer, 0, audioBuffer.Length);
      // Write out the audio file.
    } catch (Exception ex) {
      Console.Out.WriteLine(ex.Message);
      break;
    }
  }
}

Arrêt de l’enregistrement

L’appel de la méthode Stop met fin à l’enregistrement :

audRecorder.Stop();

Nettoyage

Lorsque l’objet AudioRecord n’est plus nécessaire, l’appel de sa méthode Release libère toutes les ressources qui lui sont associées :

audRecorder.Release();

Résumé

Le système d’exploitation Android fournit une infrastructure puissante pour la lecture, l’enregistrement et la gestion de l’audio. Cet article explique comment lire et enregistrer de l’audio à l’aide des classes et MediaRecorder de niveau MediaPlayer supérieur. Ensuite, il a exploré comment utiliser les notifications audio pour partager les ressources audio de l’appareil entre différentes applications. Enfin, il a traité de la lecture et de l’enregistrement audio à l’aide des API de bas niveau, qui s’interfacent directement avec les mémoires tampons.

Liens associés

• Utilisation de l’audio (exemple)
• Lecteur multimédia
• Enregistreur multimédia
• Gestionnaire audio
• Piste audio
• Enregistreur audio