Règles d'accessibilité du Web – Principes, lignes directrices, critères et techniques

Aspose.HTML for Java fournit le package com.aspose.html.accessibility, qui est destiné à toutes les manipulations et vérifications liées à l’accessibilité du Web. Dans cet article, vous apprendrez à utiliser la classe AccessibilityRules, qui est un référentiel d’exigences, de critères de réussite et de techniques WCAG 2.0.

Les règles d’accessibilité sont un ensemble de lignes directrices, de normes ou de meilleures pratiques qui définissent la manière de concevoir et de développer le contenu numérique, tel que les sites web, les applications et les médias, afin de s’assurer qu’ils sont utilisables par les personnes handicapées. Ces règles contribuent à rendre les expériences en ligne accessibles aux personnes souffrant d’un handicap visuel, auditif, moteur ou cognitif, ce qui favorise l’inclusion numérique et garantit l’égalité d’accès à l’information, aux services et à la technologie pour tous.

La structure de la référence rapide sur l’accessibilité du web peut être représentée sous la forme d’un diagramme, qui est illustré ci-dessous :

Règles d’accessibilité

La classe AccessibilityRules est un référentiel d’exigences, de critères de réussite et de techniques WCAG 2.0 et possède une structure qui correspond à la spécification WCAG (Quick Reference). Pour afficher la liste des règles, vous devez initialiser le conteneur WebAccessibility et utiliser la propriété Rules.

La propriété renvoie un objet de type AccessibilityRules, qui possède des méthodes d’accès aux règles :

Methods	Description
getPrinciple(string code)	Returns a Principle object by code from WCAG.
getPrinciples()	Returns a list of principles IList<Principle>.
getRules(params string[] codes)	Returns a list of rules IList< IRule> for given codes from WCAG.

Le répertoire contient des règles qui héritent de la classe abstraite Rule. Il existe plusieurs types de règles :

• principle
• guideline
• criterion
• technique

IRule

Toutes les règles mettent en œuvre l’interface IRule, une interface publique qui définit les propriétés de base des règles :

Property	Description
Code	Rule code from the quick reference WCAG.
Description	Description of Rule from the quick reference WCAG.

Rule

Classe abstraite de base pour toutes les règles, qui met en œuvre l’interface IRule. Pour obtenir une règle, vous pouvez utiliser la méthode getRules() :

// Retrieve and list accessibility rules by code with their descriptions from the rules repository

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// List of rule codes can contain both technique codes and principles,
// guidelines and criteria - all rules that implement the interface IRule
String[] rulesCodes = new String[]{"H2", "H37", "H30", "1.1", "1.2.1"};

// Get a list of IRule objects; if a rule with the specified code is not found,
// it will not be in the list
List<IRule> rules = webAccessibility.getRules().getRules(rulesCodes);

// Get code and description of rule
for (IRule rule : rules) {
    System.out.println(String.format("%s: %s",
            rule.getCode(),
            rule.getDescription()
    ));
}

Le programme affichera une sortie sur la console :

    H2:Combining adjacent image and text links for the same resource
    H37:Using alt attributes on img elements
    H30:Providing link text that describes the purpose of a link for anchor elements
    1.1:Text Alternatives
    1.2.1:Audio-only and Video-only (Prerecorded)

Principe

Au premier niveau de la liste des règles se trouvent les principes, qui indiquent l’orientation principale et l’objectif des règles contenues dans cette section. C’est donc par eux que commence le travail avec le répertoire.

La classe Principe a hérité de la classe Rule et contient également une liste de lignes directrices.

Method	Description
getGuideline(string code)	Get Guideline by code from WCAG, contained in principle. Return Guideline object.
getGuidelines()	Get a list of Guideline from Principle. Return IList< Guideline> object.

Exemple de récupération d’un objet Principe à partir d’une liste de règles :

// Get accessibility principle by code from WCAG rules in Aspose.HTML for Java

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Get the principle by code
Principle rule = webAccessibility.getRules().getPrinciple("1");

// Get code and description of principle
System.out.println(String.format("%s: %s",
        rule.getCode(),
        rule.getDescription()
));
// @output: 1:Perceivable

Guideline

La classe Guideline hérite de la classe Rule et contient une liste de critères. Les lignes directrices constituent le niveau suivant après les principes. Elles définissent des cadres et des objectifs généraux qui aident les auteurs à comprendre les critères de réussite et à mieux appliquer les techniques.

Method	Description
getCriterion(string code)	Get Guideline by code from WCAG, contained in current Guideline. Return Criterion object.
getCriterions()	Get a list of Criterion from current Guideline. Return IList< Criterion> object.

Exemple de récupération d’un objet Guideline à partir d’une liste de règles :

// Get accessibility guideline by code from WCAG principle in Aspose.HTML for Java

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Get the principle by code 
Principle principle = webAccessibility.getRules().getPrinciple("1");

// Get guideline 1.1
Guideline guideline = principle.getGuideline("1.1");
if (guideline != null) {
    System.out.println(String.format("%s: %s, %s",
            guideline.getCode(),
            guideline.getDescription(),
            guideline
    ));
    // @output: 1.1:Text Alternatives
}

Criterion

La classe Criterion décrit les critères de réussite WCAG, hérités de la classe abstraite Rule. Des informations détaillées sont disponibles ici – Understanding Techniques for WCAG Success Criteria. La base de la détermination de la conformité aux WCAG 2.0 est constituée par les critères de réussite de la norme. Le critère contient une liste de techniques permettant de respecter les lignes directrices des WCAG en matière d’accessibilité du contenu web. Si toutes les méthodes suffisantes pour un critère donné sont compatibles avec l’accessibilité, le critère de réussite est validé.

Utilisez la méthode getCriterion(code) pour accéder aux critères de la ligne directrice :

// Get accessibility criterion and its sufficient techniques in Java

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Get the principle by code 
Principle principle = webAccessibility.getRules().getPrinciple("1");

// Get guideline 
Guideline guideline = principle.getGuideline("1.1");

// Get criterion by code
Criterion criterion = guideline.getCriterion("1.1.1");
if (criterion != null) {
    System.out.println(String.format("%s: %s - %s",
            criterion.getCode(),
            criterion.getDescription(),
            criterion.getLevel()
    ));
    // @output: 1.1.1:Non-text Content - A

    // Get all Sufficient Techniques and write to console
    for (IRule technique : criterion.getSufficientTechniques())
        System.out.println(String.format("%s: %s",
                technique.getCode(),
                technique.getDescription()
        ));
}

Vérifier le code HTML par rapport à des règles spécifiques d’accessibilité du Web

Ce code montre comment valider un document HTML pour l’accessibilité du web en utilisant l’ensemble des règles spécifiées.

// Validate an HTML document using specific rule codes with Java

String htmlPath = "input.html";

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// List of necessary rules for checking (rule code according to the specification) 
String[] rulesCode = new String[]{"H2", "H37", "H67", "H86"};

// Get the required IList<Rule> rules from the rules reference
List<IRule> rules = webAccessibility.getRules().getRules(rulesCode);

// Create an accessibility validator, pass the found rules as parameters,
// and specify the full validation settings
AccessibilityValidator validator = webAccessibility.createValidator(
        rules, ValidationBuilder.getAll());

// Initialize an object of the HTMLDocument
final HTMLDocument document = new HTMLDocument(htmlPath);
// Check the document
ValidationResult validationResult = validator.validate(document);

// Return the result in string format
// SaveToString - return only errors and warnings
System.out.println(validationResult.saveToString());

• Utilisez le constructeur WebAccessibility() pour créer le conteneur webAccessibility, qui gère les règles d’accessibilité et la validation.
• Définissez une liste de codes de règles (par exemple, “H2”, “H37”, “H67”, “H86”) qui correspondent aux normes d’accessibilité que vous souhaitez valider.
• Appeler la méthode getRules(), en passant la liste des codes de règles en paramètre.
• Créer un validator en appelant la méthode createValidator() sur le conteneur webAccessibility et en lui passant les règles résultantes et le ValidationBuilder.getAll().
• Chargez un document HTML que vous souhaitez valider en utilisant l’un des constructeurs HTMLDocument().
• Utilisez la méthode validate(document) du validator pour vérifier le HTMLDocument chargé par rapport aux règles définies. Le résultat de la validation est l’objet ValidationResult.
• Appeler la méthode saveToString() sur l’objet ValidationResult pour formater les résultats, y compris les erreurs et les avertissements, sous forme de chaîne de caractères.
• Affichez les résultats de la validation sur la console ou enregistrez-les en vue d’une analyse ou d’un rapport ultérieur.

Voir aussi

• Vous trouverez des conseils utiles sur l’évaluation et l’amélioration de la visibilité du texte dans l’article Accessibilité du contraste des couleurs, qui couvre la vérification du contraste basée sur les WCAG à l’aide d’Aspose.HTML for Java.
• L’article Accessibilité aux lecteurs d’écran contient des instructions sur la manière de vérifier que le contenu web est compatible avec les lecteurs d’écran. Vous y apprendrez comment vérifier le texte alt et d’autres éléments clés.
• Si vous souhaitez savoir comment afficher les résultats de la validation et identifier les problèmes d’accessibilité du web, consultez l’article Résultats de la validation.
• Dans l’article Vérification de l’accessibilité du web – Erreurs et avertissements, vous apprendrez comment collecter par programmation en Java des informations sur les erreurs et les avertissements lors de la vérification de l’accessibilité d’un site web.
  

Aspose.HTML propose gratuitement en ligne Vérificateur d’accessibilité Web. Cet outil analyse les pages web, valide leur conformité aux WCAG, identifie les problèmes et suggère des améliorations. Il vous permet de déterminer l’ampleur des corrections nécessaires et l’écart entre l’état actuel de votre site web ou de votre document HTML et les exigences des WCAG.