Partager via

Android Audio

  • Article

Le système d’exploitation Android offre une prise en charge étendue du multimédia, englobant à 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 intégrées du lecteur audio et de l’enregistreur, ainsi que 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 auraient auparavant requis des pièces d’équipement dédiées : caméras, lecteurs de musique et enregistreurs vidéo. En raison de cela, les infrastructures multimédias sont devenues une fonctionnalité de première classe dans les API mobiles.

Android offre 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 bien comportementées qui répondent correctement aux événements (tels que les appels téléphoniques entrants) en suspendant ou en annulant leurs sorties audio.

  4. Utilisation d’audio de bas niveau : lecture audio à l’aide de la AudioTrack classe en écrivant directement dans des mémoires tampons. Enregistrement audio à l’aide de la AudioRecord classe et lecture directement à partir de 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 :

Section Autorisations requises du manifeste Android avec RECORD_AUDIO activé

Lecture audio avec la classe MediaPlayer

La façon la plus simple de lire l’audio dans Android est avec la classe MediaPlayer intégrée. MediaPlayer peut lire les fichiers locaux ou distants en transmettant le chemin d’accès au fichier. Toutefois, MediaPlayer il est très sensible à l’état et appelle 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 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 continue :

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 à MediaPlayer l’enregistrement audio dans Android est la classe MediaRecorder . Comme le MediaPlayer, il est sensible à l’état et passe par 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 les MediaRecorder étapes suivantes est nécessaire :

  1. Instanciez un nouvel objet MediaRecorder .

  2. Spécifiez l’appareil 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 Les formats multimédias pris en charge par Android.

  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 :MediaRecorder

recorder.Stop();

Nettoyage

Une fois l’arrêt MediaRecorder terminé, appelez la méthode Reset pour la remettre dans son état d’inactivité :

recorder.Reset();

Lorsque l’élément 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

La classe AudioManager

La classe AudioManager fournit un accès aux notifications audio qui indiquent aux applications quand des événements audio se produisent. Ce service permet également d’accéder à d’autres fonctionnalités audio, telles que le contrôle en mode volume et sonnerie. L’application AudioManager permet à une application de gérer les notifications audio pour contrôler la 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.

Conceptuellement, 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 sur celle-ci, l’entrée du clavier ne s’affiche qu’à cette application.

Le focus audio est une idée similaire et empêche plusieurs applications de lire ou d’enregistrer du contenu audio en même temps. Il est plus compliqué que le focus clavier parce qu’il est volontaire – l’application peut ignorer ce fait qu’elle n’a pas actuellement le focus audio et la lecture indépendamment – et parce qu’il existe différents types de focus audio qui peuvent être demandés. Par exemple, si le demandeur est censé lire l’audio pendant un temps très court, 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 bien être accordé une fois l’appel téléphonique terminé. Dans ce cas, un écouteur est inscrit pour 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 ok ou non de lire ou d’enregistrer du contenu audio.

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

Inscription du rappel pour le focus audio

L’inscription du FocusChangeListener rappel à partir de celui-ci IOnAudioChangeListener est une partie importante de l’obtention et de la 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 de 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 il s’agit de cet appel qui inscrit le rappel. Si le focus audio est initialement refusé mais accordé ultérieurement, l’application est informée en appelant OnAudioFocusChange le rappel. La même méthode est utilisée pour indiquer à l’application que le focus audio est retiré.

Une fois l’application terminée à l’aide des ressources audio, elle appelle la AbandonFocus méthode du AudioManagerrappel, puis passe à nouveau dans le rappel. Cette opération annule le 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 une 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 pendant une période indéfinie, par exemple).

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

  5. Si la demande est refusée, aucune autre action n’est prise. 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);
}

Libération du focus audio

Une fois la lecture de la piste terminée, la AbandonFocus méthode activée 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 s’ils 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.

AudioTrack, classe

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 : diffusion en continu ou statique.

Après la construction, la méthode Play d’est AudioTrack appelée pour la configurer pour commencer à jouer. L’écriture de la mémoire tampon audio dans le AudioTrack démarrage de 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 termine définitivement la lecture :

audioTrack.Stop();

Nettoyage

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

audioTrack.Release();

La classe AudioRecord

La classe AudioRecord est l’équivalent du AudioTrack côté enregistrement. Comme AudioTrack, il utilise des mémoires tampons directement, à la place de fichiers et d’URI. L’autorisation RECORD_AUDIO doit être définie dans le manifeste.

Initialisation et enregistrement

La première étape consiste à construire un nouvel objet AudioRecord . La liste d’arguments passée dans le constructeur fournit toutes les informations requises pour l’enregistrement. Contrairement à , AudioTrackoù les arguments sont en grande partie des énumérations, les arguments équivalents sont des entiers AudioRecord . 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 des mémoires tampons en octets

Une fois la AudioRecord construction construite, sa méthode StartRecording est appelée. Il est maintenant prêt à commencer l’enregistrement. Le AudioRecord tampon audio lit 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 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 a abordé la lecture et l’enregistrement audio à l’aide des classes et MediaRecorder des niveaux MediaPlayer supérieurs. Ensuite, il a exploré comment utiliser des notifications audio pour partager les ressources audio de l’appareil entre différentes applications. Enfin, il traite de la lecture et de l’enregistrement audio à l’aide des API de bas niveau, qui interface directement avec des mémoires tampons.