Identifier une langue grâce au package google_mlkit_language_id
Le package google_mlkit_language_id est une passerelle entre Flutter et l’API native de Google ML Kit pour l’identification de langue. Il permet de déterminer la langue d’une chaîne de texte saisie par un utilisateur ou bien générée par votre application. Ce package est donc particulièrement utile pour analyser du texte et en déterminer la langue, comme pour des messages ou des commentaires ou des recherches.
Comment ça fonctionne ?
Le package utilise des canaux de plateforme (Platform Channels) pour communiquer avec les API natives de Google ML Kit sur iOS et Android. Lorsqu’un texte est soumis, l’API analyse la chaîne et renvoie soit :
- Le code d’une langue principale identifiée (par exemple, fr pour français).
- Une liste de langues possibles avec des scores de confiance (par exemple, fr: 0.48, es: 0.52).
L’API prend en charge plus de 100 langues, y compris des écritures non latines comme l’arabe, le chinois ou le japonais, ainsi que leurs versions romanisées. Si aucune langue n’est détectée, elle retourne und (indéterminé).
Exemples concrets d’utilisation
Voici quelques cas où ce package peut être utile :
- Pour une applications de messagerie : Identifier la langue d’un message pour suggérer une traduction ou un clavier adapté.
- Pour des réseaux sociaux : Analyser les commentaires pour détecter la langue majoritaire et proposer des filtres ou des publicités ciblées.
- Outils éducatifs : Vérifier si un texte saisi correspond à la langue étudiée (par exemple, un exercice de français).
- Moteurs de recherche : Affiner les résultats en fonction de la langue détectée dans la requête.
Mettre en place google_mlkit_language_id dans Flutter
Dans ce guide, je vais vous montrer comment implémenter ce package dans votre application Flutter, puis comment l’utiliser.
Implémentation
Pour commencer, installer le package google_mlkit_language_id dans votre application Flutter en ajoutant sa dépendance dans votre fichier pubspec.yaml :
dependencies:
google_mlkit_language_id: ^0.13.0 #Remplacer par la dernière version disponiblePuis importez le package dans les fichiers où vous en avez besoin, en ajoutant cette ligne tout en haut :
import 'package:google_mlkit_language_id/google_mlkit_language_id.dart';Configuration pour Android
Pour que le package fonctionne, assurez-vous que votre projet respecte les exigences minimales :
- minSdkVersion: 21
- targetSdkVersion: 35
- compileSdkVersion: 35
Personnellement, voici comment j’ai modifié mon fichier android/app/build.gradle :
android {
namespace //
compileSdkVersion flutter.compileSdkVersion
ndkVersion "26.1.10909125"
defaultConfig {
applicationId //
minSdkVersion 23
targetSdkVersion flutter.targetSdkVersion
versionCode flutterVersionCode.toInteger()
versionName flutterVersionName
multiDexEnabled true
}
}Aucune configuration supplémentaire n’est généralement nécessaire pour Android, car le package utilise les API natives de Google.
Configuration pour iOS
Pour iOS, vous devez ajuster les paramètres pour exclure les architectures 32 bits non prises en charge (armv7) et définir une version minimale de déploiement.
Ouvrez votre projet dans Xcode et allez dans Project > Runner > Build Settings > Excluded Architectures. Ajoutez armv7 pour « Any SDK ». Pensez à l’inclure pour les trois modes Debug, profile et Release.
Ensuite, modifiez votre fichier ios/Podfile pour inclure la version minimale d’iOS (15.5 ou plus récente) et les configurations nécessaires :
platform :ios, '15.5'
# Ajoutez cette ligne
$iOSVersion = '15.5'
post_install do |installer|
installer.pods_project.build_configurations.each do |config|
config.build_settings["EXCLUDED_ARCHS[sdk=*]"] = "armv7"
config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = $iOSVersion
end
installer.pods_project.targets.each do |target|
flutter_additional_ios_build_settings(target)
target.build_configurations.each do |config|
if Gem::Version.new($iOSVersion) > Gem::Version.new(config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'])
config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = $iOSVersion
end
end
end
endÀ partir d’ici, le package google_mlkit_language_id devrait fonctionner correctement sur les deux plateformes, Android et IOS.
Utiliser le package
Voici un exemple simple d’application Flutter qui utilise google_mlkit_language_id pour identifier la langue d’un texte saisi par l’utilisateur.
import 'package:flutter/material.dart';
import 'package:google_mlkit_language_id/google_mlkit_language_id.dart';
void main() {
runApp(const MaterialApp(home: LanguageIdentifierView()));
}
class LanguageIdentifierView extends StatefulWidget {
const LanguageIdentifierView({super.key});
@override
State<LanguageIdentifierView> createState() => _LanguageIdentifierViewState();
}
class _LanguageIdentifierViewState extends State<LanguageIdentifierView> {
final _controller = TextEditingController();
final _languageIdentifier = LanguageIdentifier(confidenceThreshold: 0.5);
String _identifiedLanguage = '';
List<IdentifiedLanguage> _identifiedLanguages = [];
@override
void dispose() {
_languageIdentifier.close();
_controller.dispose();
super.dispose();
}
Future<void> _identifyLanguage() async {
if (_controller.text.isEmpty) return;
try {
final language = await _languageIdentifier.identifyLanguage(_controller.text);
setState(() {
_identifiedLanguage = language == 'und' ? 'Langue non identifiée' : language;
});
} catch (e) {
setState(() {
_identifiedLanguage = 'Erreur : $e';
});
}
}
Future<void> _identifyPossibleLanguages() async {
if (_controller.text.isEmpty) return;
try {
final possibleLanguages = await _languageIdentifier.identifyPossibleLanguages(_controller.text);
setState(() {
_identifiedLanguages = possibleLanguages;
});
} catch (e) {
setState(() {
_identifiedLanguages = [];
_identifiedLanguage = 'Erreur : $e';
});
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Identification de langue')),
body: Padding(
padding: const EdgeInsets.all(16.0),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
TextField(
controller: _controller,
decoration: const InputDecoration(
border: OutlineInputBorder(),
labelText: 'Entrez un texte',
),
),
const SizedBox(height: 20),
if (_identifiedLanguage.isNotEmpty)
Text(
'Langue identifiée : $_identifiedLanguage',
style: const TextStyle(fontSize: 18),
),
const SizedBox(height: 20),
ElevatedButton(
onPressed: _identifyLanguage,
child: const Text('Identifier la langue'),
),
ElevatedButton(
onPressed: _identifyPossibleLanguages,
child: const Text('Identifier toutes les langues possibles'),
),
const SizedBox(height: 20),
if (_identifiedLanguages.isNotEmpty)
Expanded(
child: ListView.builder(
itemCount: _identifiedLanguages.length,
itemBuilder: (context, index) {
final lang = _identifiedLanguages[index];
return ListTile(
title: Text('Langue : ${lang.languageTag}'),
subtitle: Text('Confiance : ${(lang.confidence * 100).toStringAsFixed(2)}%'),
);
},
),
),
],
),
),
);
}
}Voici un peu comment fonctionne le code
- Initialisation : Une instance de LanguageIdentifier est créée avec un seuil de confiance de 0.5 pour filtrer les résultats moins probables.
- Interface utilisateur : Un TextField permet à l’utilisateur de saisir un texte. Deux boutons déclenchent l’identification : un pour la langue principale (identifyLanguage) et un pour toutes les langues possibles (identifyPossibleLanguages).
- Affichage des résultats : La langue principale est affichée immédiatement, et une liste déroulante montre les langues possibles avec leurs scores de confiance.
- Gestion des erreurs : Les exceptions sont capturées pour éviter les plantages, avec des messages comme « Langue non identifiée » pour und.
