Réduction de l'APK

La réduction de la taille de l'APK est un aspect important du développement d'une bonne application Android. Cela est particulièrement vrai lorsque vous ciblez des marchés en développement, ainsi que lors du développement d'une appli instantanée Android. Dans ce cas, il peut être souhaitable de réduire la taille de la bibliothèque ExoPlayer incluse dans l'APK. Cette page décrit quelques étapes simples qui peuvent vous aider à y parvenir.

Utiliser uniquement les dépendances requises

Dépendez uniquement des modules de bibliothèque dont vous avez réellement besoin. Par exemple, la commande suivante ajoute des dépendances aux modules d'ExoPlayer, de DASH et de bibliothèque d'UI, comme cela peut être nécessaire pour une application qui ne lit que le contenu DASH:

implementation("androidx.media3:media3-exoplayer:1.3.1")
implementation("androidx.media3:media3-exoplayer-dash:1.3.1")
implementation("androidx.media3:media3-ui:1.3.1")

implementation "androidx.media3:media3-exoplayer:1.3.1"
implementation "androidx.media3:media3-exoplayer-dash:1.3.1"
implementation "androidx.media3:media3-ui:1.3.1"

Activer la minification du code et des ressources

Vous devez activer la minification du code et des ressources pour les builds de votre application. ExoPlayer est structuré de manière à permettre la minification de code afin de supprimer efficacement les fonctionnalités inutilisées. Par exemple, pour une application qui lit du contenu DASH, la contribution d'ExoPlayer à la taille de l'APK peut être réduite d'environ 40% en activant la minification de code.

Consultez Réduire, obscurcir et optimiser votre application pour savoir comment activer la minification du code et des ressources.

Spécifiez les moteurs de rendu dont votre application a besoin

Par défaut, les moteurs de rendu du lecteur sont créés à l'aide de DefaultRenderersFactory. DefaultRenderersFactory dépend de toutes les implémentations Renderer fournies dans la bibliothèque ExoPlayer. Par conséquent, aucune d'entre elles ne sera supprimée par la minification du code. Si vous savez que votre application n'a besoin que d'un sous-ensemble de moteurs de rendu, vous pouvez spécifier votre propre RenderersFactory. Par exemple, une application qui ne lit que du contenu audio peut définir une fabrique comme celle-ci lors de l'instanciation d'instances ExoPlayer:

val audioOnlyRenderersFactory =
  RenderersFactory {
    handler: Handler,
    videoListener: VideoRendererEventListener,
    audioListener: AudioRendererEventListener,
    textOutput: TextOutput,
    metadataOutput: MetadataOutput,
    ->
    arrayOf<Renderer>(
      MediaCodecAudioRenderer(context, MediaCodecSelector.DEFAULT, handler, audioListener)
    )
}
val player = ExoPlayer.Builder(context, audioOnlyRenderersFactory).build()

RenderersFactory audioOnlyRenderersFactory =
    (handler, videoListener, audioListener, textOutput, metadataOutput) ->
        new Renderer[] {
            new MediaCodecAudioRenderer(
                context, MediaCodecSelector.DEFAULT, handler, audioListener)
        };
ExoPlayer player = new ExoPlayer.Builder(context, audioOnlyRenderersFactory).build();

Cela permettra de supprimer d'autres implémentations de Renderer par minification de code. Dans cet exemple, les moteurs de rendu de vidéo, de texte et de métadonnées sont supprimés (ce qui signifie que les sous-titres ou les métadonnées InStream (par exemple ICY) ne seront pas traités ni émis par le lecteur.

Spécifier les extracteurs dont votre application a besoin

Par défaut, le lecteur crée des instances Extractor pour lire les contenus multimédias progressifs à l'aide de DefaultExtractorsFactory. DefaultExtractorsFactory dépend de toutes les implémentations Extractor fournies dans la bibliothèque ExoPlayer. Par conséquent, aucune d'entre elles ne sera supprimée par la minification du code. Si vous savez que votre application n'a besoin de lire qu'un petit nombre de formats de conteneur ou qu'elle ne lit pas de contenu multimédia progressif, vous pouvez spécifier votre propre ExtractorsFactory à la place. Par exemple, une application qui ne doit lire que des fichiers MP4 peut fournir une fabrique comme suit:

val mp4ExtractorFactory = ExtractorsFactory {
  arrayOf<Extractor>(Mp4Extractor(DefaultSubtitleParserFactory()))
}
val player =
  ExoPlayer.Builder(context, DefaultMediaSourceFactory(context, mp4ExtractorFactory)).build()

ExtractorsFactory mp4ExtractorFactory =
    () -> new Extractor[] {new Mp4Extractor(new DefaultSubtitleParserFactory())};
ExoPlayer player =
    new ExoPlayer.Builder(context, new DefaultMediaSourceFactory(context, mp4ExtractorFactory))
        .build();

Cela permettra de supprimer les autres implémentations de Extractor par la minification du code, ce qui peut entraîner une réduction significative de la taille.

Si votre application ne lit pas du tout de contenu progressif, vous devez transmettre ExtractorsFactory.EMPTY au constructeur DefaultMediaSourceFactory, puis transmettre ce mediaSourceFactory au constructeur ExoPlayer.Builder.

val player =
  ExoPlayer.Builder(context, DefaultMediaSourceFactory(context, ExtractorsFactory.EMPTY)).build()

ExoPlayer player =
    new ExoPlayer.Builder(
            context, new DefaultMediaSourceFactory(context, ExtractorsFactory.EMPTY))
        .build();

Instanciation MediaSource personnalisée

Si votre application utilise un MediaSource.Factory personnalisé et que vous souhaitez que DefaultMediaSourceFactory soit supprimé par suppression de code, vous devez transmettre votre MediaSource.Factory directement au constructeur ExoPlayer.Builder.

val player = ExoPlayer.Builder(context, customMediaSourceFactory).build()

ExoPlayer player = new ExoPlayer.Builder(context, mediaSourceFactory).build();

Si votre application utilise directement MediaSource au lieu de MediaItem, vous devez transmettre MediaSource.Factory.UNSUPPORTED au constructeur ExoPlayer.Builder, pour vous assurer que DefaultMediaSourceFactory et DefaultExtractorsFactory peuvent être supprimés par la minification de code.

val player = ExoPlayer.Builder(context, MediaSource.Factory.UNSUPPORTED).build()
val mediaSource =
  ProgressiveMediaSource.Factory(dataSourceFactory, customExtractorsFactory)
    .createMediaSource(MediaItem.fromUri(uri))

ExoPlayer player = new ExoPlayer.Builder(context, MediaSource.Factory.UNSUPPORTED).build();
ProgressiveMediaSource mediaSource =
    new ProgressiveMediaSource.Factory(dataSourceFactory, customExtractorsFactory)
        .createMediaSource(MediaItem.fromUri(uri));