NoHttp est un cadre réseau pour Android qui implémente les protocoles HTTP standard. Il se distingue par sa gession avancée du cache et sa capacité à basculer dynamiquement entre des moteurs sous-jacents comme OkHttp et URLConnection. L'analyse de son code source révèle une architecture modulaire allant du point d'entrée principal jusqu'à la couche d'exécution réseau.

Le Point d'Entrée Principal et l'Initialisation

L'orchestrateur central du framework est la classe NoHttp. Conçue selon le pattern Singleton, elle centralise la configuration initiale, la fabrique de requêtes et la gestion des files d'attente.

L'initialisation doit être effectuée au démarrage de l'application, généralement dans la classe Application, pour préparer l'environnement d'exécution :

public class MonApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // Configuration de l'environnement réseau global
        NoHttp.init(this);
    }
}

Cette étape instancie les configurations globales nécessaires pour que le moteur puisse traiter les requêtes ultérieures.

Fabrique de Requêtes et Files d'Attente

La classe principale expose des méthodes de fabrique pour générer des objets Request typés (String, JSON, Bitmap, etc.). Une fois la requête configurée, elle est soumise à une file d'attente.

Le framework distingue deux types de files d'atttente : une pour les requêtes API standard et une autre dédiée aux téléchargements de fichiers. La taille du pool de threads est configurable lors de l'instanciation.

Mécanisme d'Ordonnancement (RequestQueue)

La classe RequestQueue agit comme le distributeur de tâches. Lors de sa création, elle alloue un tableau de distributeurs en fonction du nombre de threads spécifié.

public RequestQueue(int nombreThreads) {
    this.distributeurs = new DistributeurRequete[nombreThreads];
    this.fileTaches = new PriorityBlockingQueue<>();
}

Lorsqu'une requête est ajoutée via la méthode de soumission, elle est encapsulée dans un objet de travail et insérée dans une file bloquante prioritaire :

public <Reponse> void soumettre(int id, Request<Reponse> requete, EcouteurReponse<Reponse> ecouteur) {
    TacheReseau tache = new TacheReseau(id, requete, ecouteur);
    this.fileTaches.put(tache);
}

L'appel à la méthode de démarrage active les distributeurs. Chaque distributeur s'exécute dans son propre thread, consommant les tâches de la file de manière concurrente :

public void demarrer() {
    arreter(); // Nettoyer les anciens threads
    for (int index = 0; index < this.distributeurs.length; index++) {
        DistributeurRequete worker = new DistributeurRequete(this.fileTaches);
        this.distributeurs[index] = worker;
        worker.start();
    }
}

Abstraction de la Couche Réseau

L'exécution réelle des appels HTTP est déléguée à l'interface Network. Cette abstraction permet de découpler la logique métier du framework de l'implémentation HTTP sous-jacente.

L'interface définit les opérations fondamentales telles que l'obtention du flux de sortie pour l'envoi de données, la lecture du code de statut HTTP, l'extraction des en-têtes de réponse et la récupération du flux d'entrée du serveur.

Le framework fournit des implémentations concrètes comme URLConnectionNetwork (basée sur l'API native Java) et OkHttpNetwork (intégrée avec la bibliothèque OkHttp). Cette conception permet aux développeurs de changer de moteur HTTP sans modifier la logique de construction des requêtes, assurant ainsi une grande flexibilité au niveau de la couche transport.