1. Fondements : Deux paradigmes distincts

1.1 Open-AutoGLM : L'approche par vision artificielle

Open-AutoGLM fonctionne comme un assistant virtuel doté de la vue. Son module central, AutoGLM-Phone, repose sur un modèle de langage visuel (VLM). Le processus se déroule en plusieurs étapes :

1. Capture visuelle : Le framework récupère une capture d'écran en temps réel via ADB (Android Debug Bridge).
2. Interprétation : L'image et la commande en langage naturel (par exemple, "Cherche un restaurent sur l'application X") sont transmises à un modèle multimodal.
3. Planification : L'IA identifie les éléments interactifs (icônes, champs) et détermine la séquence d'actions requise.
4. Exécution : Les instructions (taps, swipes, saisie de texte) sont envoyées à l'appareil via ADB.

Cette méthode excelle dans la manipulation d'interfaces non standard ou fréquemment modifiées, car elle ne dépend pas de la structure interne de l'application.

1.2 Selenium/Appium : Le contrôle par sélecteur

Selenium, étendu au mobile via Appium, repose sur l'interaction directe avec l'arborescence des composants UI. Le flux classique est le suivant :

1. Localisation : Le script cible explicitement un élément grâce à des attributs comme l'ID (ex: com.app:id/search_bar) ou XPath.
2. Action : Une méthode est invoquée sur cet élément, telle que .click() ou .send_keys().

Ce mécanisme offre une précision absolue et une reproductibilité totale, à condition que les attributs cibles restent inchangés d'une version à l'autre.

2. Configuration technique

2.1 Déploiement d'Open-AutoGLM

Le déploiement nécessite un appareil Android (version 7.0+), ADB, et Python 3.10+.

Installation d'ADB :

Sous Windows, il faut ajouter le chemin de platform-tools à la variable d'environnement Path. Sous macOS/Linux, une comande d'export suffit :

export PATH=$PATH:~/Telechargements/platform-tools

Préparation du smartphone :

• Activer le mode Développeur (7 taps sur le numéro de build).
• Activer le débogage USB dans les options développeur.
• Installer et définir ADBKeyboard.apk comme clavier par défaut pour stabiliser la saisie de texte par l'IA.

Installation du framework :

# Clonage du dépôt
git clone https://github.com/zai-org/Open-AutoGLM open_autoglm_repo
cd open_autoglm_repo

# Installation des dépendances
pip install -r requirements.txt
pip install -e .

Connexion et exécution :

La connexion peut s'établir par USB (adb devices) ou via Wi-Fi après avoir ouvert le port 5555 (adb tcpip 5555 puis adb connect IP_APPAREIL:5555).

Pour lancer une commande en ligne de commande :

python execute_agent.py \
  --target-device 192.168.1.100:5555 \
  --api-endpoint http://123.45.67.89:8800/v1 \
  --llm-name "autoglm-phone-9b" \
  "Ouvre TikTok, cherche le créateur X et abonne-toi !"

Alternativement, via l'API Python :

from mobile_agent.controller import DeviceManager, scan_connected_devices

manager = DeviceManager()
is_connected, status_msg = manager.establish_link("192.168.1.100:5555")
print(f"Statut de la connexion : {status_msg}")

available_devices = scan_connected_devices()
for dev in available_devices:
    print(f"Identifiant : {dev.identifier} - Mode : {dev.link_mode.value}")

manager.terminate_link("192.168.1.100:5555")

2.2 Mise en route de Selenium avec Appium

L'environnement nécessite Node.js pour le serveur Appium, ainsi que le client Python.

Installation du serveur :

npm install -g appium
npm install -g appium-doctor
pip install Appium-Python-Client

Script d'automatisation (Calculatrice) :

from appium import webdriver
from appium.webdriver.common.appiumby import AppiumBy

config_caps = {
    'platformName': 'Android',
    'platformVersion': '13',
    'deviceName': 'Emulateur_Pixel',
    'appPackage': 'com.android.calculator2',
    'appActivity': 'com.android.calculator2.Calculator',
    'automationName': 'UiAutomator2'
}

appium_session = webdriver.Remote('http://127.0.0.1:4723/wd/hub', config_caps)

# Opération 1 + 2
appium_session.find_element(AppiumBy.ID, 'com.android.calculator2:id/digit_1').click()
appium_session.find_element(AppiumBy.ACCESSIBILITY_ID, 'plus').click()
appium_session.find_element(AppiumBy.ID, 'com.android.calculator2:id/digit_2').click()
appium_session.find_element(AppiumBy.ACCESSIBILITY_ID, 'equals').click()

output_value = appium_session.find_element(AppiumBy.ID, 'com.android.calculator2:id/result').text
print(f"Valeur obtenue : {output_value}")

appium_session.quit()

3. Critères de choix et synergie

Privilégier Open-AutoGLM pour :

• Les scénarios multi-applications où la navigation fluide est requise.
• Les interfaces dont la structure DOM est inaccessible ou masquée (Canvas, jeux).
• Les instructions ouvertes nécessitant une interprétation sémantique.

Privilégier Selenium/Appium pour :

• L'automatisation de longs workflows où chaque étape doit être vérifiable et stable.
• La validation précise de données (assertions sur le texte d'un élément spécifique).
• L'intégration dans des pipelines CI/CD existants basés sur des tests unitaires et fonctionnels.

Plutôt que de s'opposer, ces outils se complètent : Open-AutoGLM peut gérer les étapes imprévisibles comme l'identification d'une fonctionnalité enfouie, tandis que Selenium/Appium assure l'exécution fiable des sous-tâches précises comme le remplissage methodique de formulaires complexes.