MainPlayerGestureListener.kt

The two codes you present have similar functionalities — they manage gestures to adjust brightness and volume based on the portion of the screen where the gesture occurs (left or right) — but they differ in their logic for controlling and handling the gestures.

1. First code:

val isBrightnessGestureEnabled = PlayerHelper.isBrightnessGestureEnabled(player.context)
val isVolumeGestureEnabled = PlayerHelper.isVolumeGestureEnabled(player.context)
if (isBrightnessGestureEnabled && isVolumeGestureEnabled) {
    if (getDisplayHalfPortion(initialEvent) === DisplayPortion.LEFT_HALF) {
        onScrollBrightness(distanceY)
    } else /* DisplayPortion.RIGHT_HALF */ {
        onScrollVolume(distanceY)
    }
} else if (isBrightnessGestureEnabled) {
    onScrollBrightness(distanceY)
} else if (isVolumeGestureEnabled) {
    onScrollVolume(distanceY)
}

Explanation:

  • Gesture availability control: The code first checks if the brightness and volume gestures are enabled (via isBrightnessGestureEnabled and isVolumeGestureEnabled).
  • Screen portion management: Then, it checks if both gestures are enabled. If they are, it checks which portion of the screen was touched (left or right) and applies the corresponding gesture (brightness for the left, volume for the right).
  • Individual gesture handling: If only one gesture is enabled (brightness or volume), the corresponding action is executed regardless of where the gesture occurred.

Key points:

  • It first checks if the brightness and volume gestures are enabled before taking action.
  • It applies the action based on the screen portion and the gesture enablement status.
  • The logic is somewhat more "binary": it acts only if the gestures are enabled.

2. Second code:

if (getDisplayHalfPortion(initialEvent) == DisplayPortion.RIGHT_HALF) {
    when (PlayerHelper.getActionForRightGestureSide(player.context)) {
        player.context.getString(R.string.volume_control_key) ->
            onScrollVolume(distanceY)
        player.context.getString(R.string.brightness_control_key) ->
            onScrollBrightness(distanceY)
    }
} else {
    when (PlayerHelper.getActionForLeftGestureSide(player.context)) {
        player.context.getString(R.string.volume_control_key) ->
            onScrollVolume(distanceY)
        player.context.getString(R.string.brightness_control_key) ->
            onScrollBrightness(distanceY)
    }
}

Explanation:

  • Screen portion control: Like the first code, this code begins by determining whether the event occurs in the right or left portion of the screen.
  • Action detection by screen portion: Then, it uses a method (getActionForRightGestureSide or getActionForLeftGestureSide) to retrieve the action associated with the corresponding portion. This action could be either volume control or brightness control.
  • Executing the action: Once the action is identified (based on the control key), it executes the appropriate volume or brightness gesture.

Key points:

  • The code uses a when to check the action to be performed, which could allow for greater flexibility if more gesture actions are added.
  • It checks the specific action based on the screen portion, using string keys (getString(R.string.volume_control_key) and getString(R.string.brightness_control_key)).
  • This logic is a bit more modular and depends on the specific action assigned to each screen portion, which could be useful if the logic needs to evolve or if other actions need to be added.

Main differences:

  • Gesture activation:

    • The first code simply checks if the brightness and volume gestures are globally enabled before acting.
    • The second code, on the other hand, works based on a specific action associated with each screen portion (left or right), and the action depends on the context configuration.

  • Control by action or gesture:

    • The first code is more direct: it performs simple checks to see if a gesture is enabled and adjusts the action accordingly.
    • The second code is more flexible, as it allows linking specific actions (brightness, volume, etc.) to each screen portion using string keys. This can make it easier to add new actions or change the configuration.

  • Readability and scalability:

    • The first code is simpler and more direct, but less modular.
    • The second code is more extensible, as it uses when and dynamic configuration values (string keys), allowing for more detailed management of gestures and their corresponding actions.

In summary, the first code is better suited for simple logic where gesture detection is basic, while the second code allows for more fine-grained management of actions associated with screen portions, with greater flexibility to handle gestures and their respective actions.

Les deux codes que vous présentez ont des fonctionnalités similaires — elles gèrent des gestes pour ajuster la luminosité et le volume en fonction de la portion de l'écran où se situe le geste (gauche ou droite) — mais ils diffèrent dans leur logique de contrôle et de gestion des gestes.

1. Premier code :

val isBrightnessGestureEnabled = PlayerHelper.isBrightnessGestureEnabled(player.context)
val isVolumeGestureEnabled = PlayerHelper.isVolumeGestureEnabled(player.context)
if (isBrightnessGestureEnabled && isVolumeGestureEnabled) {
    if (getDisplayHalfPortion(initialEvent) === DisplayPortion.LEFT_HALF) {
        onScrollBrightness(distanceY)
    } else /* DisplayPortion.RIGHT_HALF */ {
        onScrollVolume(distanceY)
    }
} else if (isBrightnessGestureEnabled) {
    onScrollBrightness(distanceY)
} else if (isVolumeGestureEnabled) {
    onScrollVolume(distanceY)
}

Explication :

  • Contrôle de la disponibilité des gestes : Le code commence par vérifier si les gestes de luminosité et de volume sont activés (via isBrightnessGestureEnabled et isVolumeGestureEnabled).
  • Gestion des portions de l'écran : Ensuite, il vérifie si les deux gestes sont activés. Si c'est le cas, il vérifie quelle portion de l'écran a été touchée (gauche ou droite) et applique le geste correspondant (luminosité pour la gauche, volume pour la droite).
  • Gestion individuelle des gestes : Si un seul geste est activé (luminosité ou volume), l'action correspondante est exécutée, quel que soit l'endroit où le geste a été effectué.

Points clés :

  • Il vérifie d'abord si les gestes de luminosité et de volume sont activés avant d'agir.
  • Il applique l'action en fonction de la portion de l'écran et de l'état d'activation des gestes.
  • La logique est un peu plus "binaires" : il agit uniquement si les gestes sont activés.

2. Deuxième code :

if (getDisplayHalfPortion(initialEvent) == DisplayPortion.RIGHT_HALF) {
    when (PlayerHelper.getActionForRightGestureSide(player.context)) {
        player.context.getString(R.string.volume_control_key) ->
            onScrollVolume(distanceY)
        player.context.getString(R.string.brightness_control_key) ->
            onScrollBrightness(distanceY)
    }
} else {
    when (PlayerHelper.getActionForLeftGestureSide(player.context)) {
        player.context.getString(R.string.volume_control_key) ->
            onScrollVolume(distanceY)
        player.context.getString(R.string.brightness_control_key) ->
            onScrollBrightness(distanceY)
    }
}

Explication :

  • Contrôle des portions de l'écran : Comme le premier code, ce code commence par déterminer si l'événement se déroule dans la portion droite ou gauche de l'écran.
  • Détection d'action par portion d'écran : Ensuite, il utilise une méthode (getActionForRightGestureSide ou getActionForLeftGestureSide) pour récupérer l'action associée à la portion correspondante. Cette action pourrait être soit le contrôle du volume soit le contrôle de la luminosité.
  • Exécution de l'action : Une fois l'action identifiée (en fonction de la clé de contrôle), il exécute le geste de volume ou de luminosité approprié.

Points clés :

  • Le code utilise un when pour vérifier l'action à effectuer, ce qui peut permettre une plus grande flexibilité si d'autres actions de geste sont ajoutées.
  • Il vérifie l'action spécifique en fonction de la portion de l'écran, en utilisant des clés de chaîne (getString(R.string.volume_control_key) et getString(R.string.brightness_control_key)).
  • Cette logique est un peu plus modulaire et dépend de l'action spécifique assignée à chaque portion d'écran, ce qui peut être utile si la logique doit évoluer ou si d'autres actions doivent être ajoutées.

Différences principales :

  • Activation des gestes :

    • Le premier code vérifie simplement si les gestes de luminosité et de volume sont activés globalement avant d'agir.
    • Le deuxième code, lui, fonctionne sur la base d'une action spécifique associée à chaque portion d'écran (gauche ou droite) et l'action dépend de la configuration du contexte.

  • Contrôle par action ou geste :

    • Le premier code est plus direct : il fait des vérifications simples pour savoir si un geste est activé et ajuste l'action en conséquence.
    • Le deuxième code est plus flexible, car il permet de lier des actions spécifiques (luminosité, volume, etc.) à chaque portion de l'écran via des clés de chaîne. Cela peut faciliter l'ajout de nouvelles actions ou le changement de configuration.

  • Lisibilité et évolutivité :

    • Le premier code est plus simple et plus direct, mais moins modulaire.
    • Le deuxième code est plus extensible, car il utilise des when et des valeurs de configuration dynamiques (clés de chaîne), ce qui permet une gestion plus détaillée des gestes et des actions.

En résumé, le premier code est plus adapté pour une logique simple où la détection de gestes est suffisamment basique, tandis que le deuxième code permet une gestion plus fine des actions associées aux portions d'écran, avec une plus grande flexibilité pour gérer les gestes et leurs actions respectives.