Gestion des Langues d'Applications sur macOS

Gérez les paramètres de langue spécifiques aux applications sur vos appareils Roundfleet à l'aide d'outils en ligne de commande. Ce tutoriel couvre la découverte de langues, la configuration d'applications individuelles, la gestion en bloc et l'application de politiques de langue à l'échelle de l'entreprise pour les déploiements internationaux.

Comprendre la Gestion des Langues sur macOS

macOS permet de définir différentes langues pour les applications individuelles sans changer la langue du système :

Niveaux de Configuration de Langue

Langue Système - Langue globale de l'interface macOS
Langue Application - Remplacement de langue par application
Paramètres Régionaux - Formats de date, heure, nombres, devises
Saisie Clavier - Préférences de méthode et disposition de saisie

Outils de Gestion des Langues

defaults - Modifier les préférences d'applications et paramètres de langue
languagesetup - Afficher les langues système disponibles
locale - Afficher les informations de locale actuelles
Préférences Système - Interface de gestion des langues en mode graphique

Découverte et Analyse des Langues

Découvrir les Langues Disponibles

#!/bin/bash

# Afficher toutes les langues supportées par l'appareil
echo "🌍 Découverte des langues disponibles sur l'appareil..."

# Obtenir les langues système supportées
echo "=== Langues Système Supportées ==="
languagesetup

echo -e "\n=== Informations de Locale Actuelles ==="
locale

echo -e "\n=== Codes de Langue Disponibles ==="
ls /System/Library/CoreServices/SystemUIServer.app/Contents/Resources/*.lproj | \
    sed 's/.*\/\(.*\)\.lproj/\1/' | sort

echo "✅ Découverte des langues terminée avec succès"

Obtenir la Langue Système Actuelle

#!/bin/bash

# Afficher les paramètres de langue système et d'applications actuels
echo "🔍 Analyse de la configuration de langue actuelle..."

# Langue système
echo "Langue Système : $(defaults read -g AppleLanguages | head -1 | tr -d '[:space:],"()')"

# Paramètres régionaux
echo "Région : $(defaults read -g AppleLocale)"

# Utilisateur actuel
CURRENT_USER=$(stat -f%Su /dev/console)
echo "Utilisateur Actuel : $CURRENT_USER"

# Sources de saisie
echo -e "\nSources de Saisie :"
defaults read com.apple.HIToolbox AppleEnabledInputSources | grep -E 'InputSourceKind|KeyboardLayout Name'

echo "✅ Analyse de langue terminée"

Gestion des Langues d'Applications Individuelles

Définir la Langue d'Application

#!/bin/bash

# Définir la langue pour une application spécifique
APP_NAME="$1"
LANGUAGE_CODE="$2"

if [[ -z "$APP_NAME" || -z "$LANGUAGE_CODE" ]]; then
    echo "❌ Utilisation : $0 <NomApp> <CodeLangue>"
    echo "Exemple : $0 Calendar de"
    echo "Exemple : $0 Safari fr"
    exit 1
fi

# Obtenir l'utilisateur actuel
CURRENT_USER=$(stat -f%Su /dev/console)
echo "🌐 Définition de la langue pour $APP_NAME en $LANGUAGE_CODE"

# Valider le code de langue
if ! languagesetup | grep -q "$LANGUAGE_CODE"; then
    echo "⚠️ Attention : Le code de langue '$LANGUAGE_CODE' pourrait ne pas être supporté"
fi

# Définir la langue de l'application
if sudo su "$CURRENT_USER" -c "defaults write -app '$APP_NAME' AppleLanguages -array '$LANGUAGE_CODE'"; then
    echo "✅ Langue définie avec succès pour $APP_NAME"
    echo "ℹ️ Redémarrez $APP_NAME pour voir les changements"
else
    echo "❌ Échec de définition de langue pour $APP_NAME"
    exit 1
fi

Vérifier la Langue d'Application

#!/bin/bash

# Vérifier le paramètre de langue actuel pour une application
APP_NAME="$1"

if [[ -z "$APP_NAME" ]]; then
    echo "❌ Utilisation : $0 <NomApp>"
    echo "Exemple : $0 Calendar"
    exit 1
fi

CURRENT_USER=$(stat -f%Su /dev/console)
echo "🔍 Vérification du paramètre de langue pour $APP_NAME..."

# Lire le paramètre de langue actuel
CURRENT_LANG=$(sudo su "$CURRENT_USER" -c "defaults read -app '$APP_NAME' AppleLanguages 2>/dev/null" | head -1 | tr -d '[:space:],"()')

if [[ -n "$CURRENT_LANG" ]]; then
    echo "Langue actuelle pour $APP_NAME : $CURRENT_LANG"
else
    echo "Aucune langue spécifique définie pour $APP_NAME (utilise la langue système par défaut)"
fi

Réinitialiser la Langue d'Application

#!/bin/bash

# Réinitialiser la langue d'application à la langue système par défaut
APP_NAME="$1"

if [[ -z "$APP_NAME" ]]; then
    echo "❌ Utilisation : $0 <NomApp>"
    exit 1
fi

CURRENT_USER=$(stat -f%Su /dev/console)
echo "🔄 Réinitialisation de la langue pour $APP_NAME à la langue système par défaut..."

# Supprimer le paramètre de langue spécifique à l'application
if sudo su "$CURRENT_USER" -c "defaults delete -app '$APP_NAME' AppleLanguages 2>/dev/null"; then
    echo "✅ Langue réinitialisée avec succès pour $APP_NAME"
else
    echo "ℹ️ Aucun paramètre de langue personnalisé trouvé pour $APP_NAME"
fi

Gestion de Langues en Bloc

Définir Plusieurs Applications

#!/bin/bash

# Définir la langue pour plusieurs applications
LANGUAGE_CODE="$1"
shift
APPS=("$@")

if [[ -z "$LANGUAGE_CODE" || ${#APPS[@]} -eq 0 ]]; then
    echo "❌ Utilisation : $0 <CodeLangue> <App1> <App2> <App3>..."
    echo "Exemple : $0 fr Safari Calendar Mail"
    exit 1
fi

CURRENT_USER=$(stat -f%Su /dev/console)
echo "🌐 Définition de la langue '$LANGUAGE_CODE' pour ${#APPS[@]} applications..."

SUCCESS_COUNT=0
FAILED_APPS=()

for app in "${APPS[@]}"; do
    echo "Traitement : $app"
    
    if sudo su "$CURRENT_USER" -c "defaults write -app '$app' AppleLanguages -array '$LANGUAGE_CODE'" 2>/dev/null; then
        echo "  ✅ Succès : $app"
        ((SUCCESS_COUNT++))
    else
        echo "  ❌ Échec : $app"
        FAILED_APPS+=("$app")
    fi
done

echo -e "\n📊 Résumé :"
echo "Configurées avec succès : $SUCCESS_COUNT applications"
echo "Échecs : ${#FAILED_APPS[@]} applications"

if [[ ${#FAILED_APPS[@]} -gt 0 ]]; then
    echo "Applications en échec : ${FAILED_APPS[*]}"
fi

Configuration d'Applications Communes

#!/bin/bash

# Définir la langue pour les applications macOS communes
LANGUAGE_CODE="$1"

if [[ -z "$LANGUAGE_CODE" ]]; then
    echo "❌ Utilisation : $0 <CodeLangue>"
    echo "Codes disponibles : en, fr, de, es, it, ja, ko, zh-Hans, zh-Hant, etc."
    exit 1
fi

CURRENT_USER=$(stat -f%Su /dev/console)
echo "🌍 Configuration des applications communes pour la langue : $LANGUAGE_CODE"

# Définir les applications communes
COMMON_APPS=(
    "Safari"
    "Mail"
    "Calendar"
    "Contacts"
    "Notes"
    "Reminders"
    "Pages"
    "Numbers"
    "Keynote"
    "TextEdit"
    "Preview"
    "Finder"
    "System Preferences"
)

SUCCESS_COUNT=0
CONFIGURED_APPS=()

echo "Configuration de ${#COMMON_APPS[@]} applications communes..."

for app in "${COMMON_APPS[@]}"; do
    echo -n "  $app : "
    
    if sudo su "$CURRENT_USER" -c "defaults write -app '$app' AppleLanguages -array '$LANGUAGE_CODE'" 2>/dev/null; then
        echo "✅"
        CONFIGURED_APPS+=("$app")
        ((SUCCESS_COUNT++))
    else
        echo "❌"
    fi
done

echo -e "\n📊 Résumé de Configuration :"
echo "Configurées avec succès : $SUCCESS_COUNT applications"
echo "Applications configurées : ${CONFIGURED_APPS[*]}"

Script de Gestion de Langues d'Entreprise

#!/bin/bash

# Outil de Gestion des Langues d'Applications Roundfleet
# Gestion complète des langues pour les environnements d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_language.log"
BACKUP_DIR="/var/backups/roundfleet/language"
REPORT_DIR="/var/reports/roundfleet/language"
CONFIG_FILE="/etc/roundfleet/language_policy.conf"

# Paramètres de politique de langue par défaut
DEFAULT_LANGUAGE="en"
ENFORCE_LANGUAGE_POLICY=false
ALLOWED_LANGUAGES=("en" "fr" "de" "es" "it" "ja" "ko" "zh-Hans" "zh-Hant")
RESTRICTED_APPS=()

# Fonction de journalisation
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Configurer les répertoires
setup_directories() {
    for dir in "$BACKUP_DIR" "$REPORT_DIR" "$(dirname "$CONFIG_FILE")"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            log_action "Répertoire créé : $dir"
        fi
    done
}

# Obtenir l'utilisateur actuel
get_current_user() {
    stat -f%Su /dev/console
}

# Découvrir les langues disponibles
discover_languages() {
    echo "🌍 Découverte des langues disponibles..."
    
    {
        echo "=== Découverte des Langues Système ==="
        echo "Date : $(date)"
        echo "Appareil : $(hostname)"
        echo ""
        
        echo "=== Langues Disponibles ==="
        languagesetup
        echo ""
        
        echo "=== Paramètres Système Actuels ==="
        echo "Langue Système : $(defaults read -g AppleLanguages | head -1 | tr -d '[:space:],"()')"
        echo "Région : $(defaults read -g AppleLocale)"
        echo "Devise : $(defaults read -g AppleCurrencies | head -1 | tr -d '[:space:],"()')"
        echo ""
        
        echo "=== Répertoires de Ressources de Langues ==="
        find /System/Library/CoreServices -name "*.lproj" -type d | head -20
        
    } > "$REPORT_DIR/decouverte_langues_$(date +%Y%m%d_%H%M%S).txt"
    
    log_action "Découverte des langues terminée"
}

# Sauvegarder les paramètres de langue actuels
backup_language_settings() {
    local backup_file="$BACKUP_DIR/sauvegarde_langue_$(date +%Y%m%d_%H%M%S).txt"
    local current_user=$(get_current_user)
    
    echo "💾 Sauvegarde des paramètres de langue actuels..."
    
    {
        echo "=== Sauvegarde des Paramètres de Langue Roundfleet ==="
        echo "Date : $(date)"
        echo "Utilisateur : $current_user"
        echo "Appareil : $(hostname)"
        echo ""
        
        echo "=== Paramètres de Langue Système ==="
        echo "AppleLanguages : $(defaults read -g AppleLanguages 2>/dev/null || echo 'Non défini')"
        echo "AppleLocale : $(defaults read -g AppleLocale 2>/dev/null || echo 'Non défini')"
        echo ""
        
        echo "=== Langues Spécifiques aux Applications ==="
        
        # Obtenir la liste des applications avec paramètres de langue personnalisés
        local apps_with_custom_lang=()
        
        # Vérifier les applications communes
        local check_apps=(
            "Safari" "Mail" "Calendar" "Contacts" "Notes" "Reminders"
            "Pages" "Numbers" "Keynote" "TextEdit" "Preview" "Finder"
            "System Preferences" "Photos" "Music" "TV" "Books"
        )
        
        for app in "${check_apps[@]}"; do
            local app_lang
            app_lang=$(sudo su "$current_user" -c "defaults read -app '$app' AppleLanguages 2>/dev/null" | head -1 | tr -d '[:space:],"()')
            if [[ -n "$app_lang" ]]; then
                echo "$app : $app_lang"
                apps_with_custom_lang+=("$app")
            fi
        done
        
        if [[ ${#apps_with_custom_lang[@]} -eq 0 ]]; then
            echo "Aucune application avec paramètres de langue personnalisés trouvée"
        fi
        
    } > "$backup_file"
    
    echo "✅ Sauvegarde enregistrée dans : $backup_file"
    log_action "Paramètres de langue sauvegardés dans : $backup_file"
}

# Générer un rapport d'audit de langue
generate_language_report() {
    local report_file="$REPORT_DIR/audit_langue_$(date +%Y%m%d_%H%M%S).txt"
    local current_user=$(get_current_user)
    
    echo "📊 Génération du rapport d'audit de langue..."
    
    {
        echo "Rapport d'Audit de Langue Roundfleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "Utilisateur : $current_user"
        echo "================================="
        echo ""
        
        echo "=== Configuration de Langue Système ==="
        local sys_lang=$(defaults read -g AppleLanguages | head -1 | tr -d '[:space:],"()')
        echo "Langue Principale : $sys_lang"
        echo "Région : $(defaults read -g AppleLocale)"
        echo "Devise : $(defaults read -g AppleCurrencies | head -1 | tr -d '[:space:],"()')"
        echo ""
        
        echo "=== Langues Disponibles ==="
        languagesetup | grep -v "Language setup tool" | head -20
        echo ""
        
        echo "=== Audit des Langues d'Applications ==="
        local total_apps=0
        local custom_lang_apps=0
        
        # Auditer les applications communes
        local audit_apps=(
            "Safari" "Mail" "Calendar" "Contacts" "Notes" "Reminders"
            "Pages" "Numbers" "Keynote" "TextEdit" "Preview" "Finder"
            "System Preferences" "Photos" "Music" "TV" "Books" "Maps"
            "FaceTime" "Messages" "Calculator" "Clock mini" "Dictionary"
        )
        
        for app in "${audit_apps[@]}"; do
            ((total_apps++))
            local app_lang
            app_lang=$(sudo su "$current_user" -c "defaults read -app '$app' AppleLanguages 2>/dev/null" | head -1 | tr -d '[:space:],"()')
            
            if [[ -n "$app_lang" ]]; then
                echo "$app : $app_lang (personnalisé)"
                ((custom_lang_apps++))
            else
                echo "$app : $sys_lang (système par défaut)"
            fi
        done
        
        echo ""
        echo "=== Résumé ==="
        echo "Total d'applications auditées : $total_apps"
        echo "Applications avec langue personnalisée : $custom_lang_apps"
        echo "Applications utilisant la langue système par défaut : $((total_apps - custom_lang_apps))"
        
        # Vérifier la conformité
        if [[ "$ENFORCE_LANGUAGE_POLICY" == "true" ]]; then
            echo ""
            echo "=== Conformité aux Politiques ==="
            echo "Application de politique de langue : ACTIVÉE"
            echo "Langue requise par défaut : $DEFAULT_LANGUAGE"
            echo "Langues autorisées : ${ALLOWED_LANGUAGES[*]}"
            
            local non_compliant_apps=()
            for app in "${audit_apps[@]}"; do
                local app_lang
                app_lang=$(sudo su "$current_user" -c "defaults read -app '$app' AppleLanguages 2>/dev/null" | head -1 | tr -d '[:space:],"()')
                
                if [[ -n "$app_lang" ]]; then
                    # Vérifier si la langue est dans la liste autorisée
                    local is_allowed=false
                    for allowed_lang in "${ALLOWED_LANGUAGES[@]}"; do
                        if [[ "$app_lang" == "$allowed_lang" ]]; then
                            is_allowed=true
                            break
                        fi
                    done
                    
                    if [[ "$is_allowed" == "false" ]]; then
                        non_compliant_apps+=("$app:$app_lang")
                    fi
                fi
            done
            
            if [[ ${#non_compliant_apps[@]} -gt 0 ]]; then
                echo "Applications non conformes :"
                for app_info in "${non_compliant_apps[@]}"; do
                    echo "  - ${app_info//:/ (langue: }")"
                done
            else
                echo "Toutes les applications sont conformes à la politique de langue"
            fi
        fi
        
    } > "$report_file"
    
    echo "📊 Rapport sauvegardé dans : $report_file"
    log_action "Rapport d'audit de langue généré : $report_file"
}

# Appliquer la politique de langue
enforce_language_policy() {
    local target_language="${1:-$DEFAULT_LANGUAGE}"
    local current_user=$(get_current_user)
    
    echo "🔒 Application de la politique de langue : $target_language"
    log_action "Application de politique de langue démarrée : $target_language"
    
    # Valider la langue cible
    local is_allowed=false
    for allowed_lang in "${ALLOWED_LANGUAGES[@]}"; do
        if [[ "$target_language" == "$allowed_lang" ]]; then
            is_allowed=true
            break
        fi
    done
    
    if [[ "$is_allowed" == "false" ]]; then
        echo "❌ La langue '$target_language' n'est pas dans la liste des langues autorisées"
        echo "Langues autorisées : ${ALLOWED_LANGUAGES[*]}"
        return 1
    fi
    
    # Applications sur lesquelles appliquer la politique
    local enforce_apps=(
        "Safari" "Mail" "Calendar" "Contacts" "Notes" "Reminders"
        "Pages" "Numbers" "Keynote" "TextEdit" "Preview"
        "System Preferences" "Photos" "Music" "TV" "Books"
    )
    
    local success_count=0
    local failed_apps=()
    
    for app in "${enforce_apps[@]}"; do
        # Ignorer les applications restreintes
        local is_restricted=false
        for restricted_app in "${RESTRICTED_APPS[@]}"; do
            if [[ "$app" == "$restricted_app" ]]; then
                is_restricted=true
                break
            fi
        done
        
        if [[ "$is_restricted" == "true" ]]; then
            echo "  Ignorer l'application restreinte : $app"
            continue
        fi
        
        echo -n "  Configuration $app : "
        
        if sudo su "$current_user" -c "defaults write -app '$app' AppleLanguages -array '$target_language'" 2>/dev/null; then
            echo "✅"
            ((success_count++))
        else
            echo "❌"
            failed_apps+=("$app")
        fi
    done
    
    echo -e "\n📊 Résumé d'Application de Politique :"
    echo "Configurées avec succès : $success_count applications"
    echo "Échecs : ${#failed_apps[@]} applications"
    
    if [[ ${#failed_apps[@]} -gt 0 ]]; then
        echo "Applications en échec : ${failed_apps[*]}"
    fi
    
    log_action "Application de politique de langue terminée : $success_count succès, ${#failed_apps[@]} échecs"
}

# Fonction d'exécution principale
main() {
    local action="${1:-aide}"
    local target="${2:-}"
    local apps_or_backup=("${@:3}")
    
    log_action "=== Gestion des Langues Roundfleet Démarrée ==="
    
    setup_directories
    
    case "$action" in
        "decouvrir"|"langues")
            discover_languages
            ;;
        "audit"|"rapport")
            generate_language_report
            ;;
        "sauvegarder")
            backup_language_settings
            ;;
        "definir")
            if [[ -n "$target" && ${#apps_or_backup[@]} -gt 0 ]]; then
                # Définir la langue pour des applications spécifiques
                local language_code="$target"
                local apps=("${apps_or_backup[@]}")
                local current_user=$(get_current_user)
                
                echo "🌐 Définition de la langue '$language_code' pour les applications spécifiées..."
                
                local success_count=0
                for app in "${apps[@]}"; do
                    echo -n "  $app : "
                    if sudo su "$current_user" -c "defaults write -app '$app' AppleLanguages -array '$language_code'" 2>/dev/null; then
                        echo "✅"
                        ((success_count++))
                    else
                        echo "❌"
                    fi
                done
                
                echo "✅ $success_count applications configurées"
            else
                echo "❌ Utilisation : $0 definir <code_langue> <app1> <app2> ..."
                echo "Exemple : $0 definir fr Safari Mail Calendar"
            fi
            ;;
        "appliquer")
            local target_lang="${target:-$DEFAULT_LANGUAGE}"
            enforce_language_policy "$target_lang"
            ;;
        "reinitialiser")
            if [[ -n "$target" ]]; then
                local current_user=$(get_current_user)
                echo "🔄 Réinitialisation de la langue pour $target à la langue système par défaut..."
                
                if sudo su "$current_user" -c "defaults delete -app '$target' AppleLanguages" 2>/dev/null; then
                    echo "✅ Langue réinitialisée pour $target"
                else
                    echo "ℹ️ Aucun paramètre de langue personnalisé trouvé pour $target"
                fi
            else
                echo "❌ Utilisation : $0 reinitialiser <nom_app>"
            fi
            ;;
        "verifier")
            if [[ -n "$target" ]]; then
                local current_user=$(get_current_user)
                local app_lang
                app_lang=$(sudo su "$current_user" -c "defaults read -app '$target' AppleLanguages 2>/dev/null" | head -1 | tr -d '[:space:],"()')
                
                if [[ -n "$app_lang" ]]; then
                    echo "Langue pour $target : $app_lang"
                else
                    echo "Aucune langue personnalisée définie pour $target (utilise la langue système par défaut)"
                fi
            else
                echo "❌ Utilisation : $0 verifier <nom_app>"
            fi
            ;;
        "aide"|*)
            echo "Outil de Gestion des Langues d'Applications Roundfleet"
            echo "Utilisation : $0 [action] [options]"
            echo ""
            echo "Actions :"
            echo "  decouvrir             - Découvrir les langues disponibles sur l'appareil"
            echo "  audit                 - Générer un rapport d'audit de langue"
            echo "  sauvegarder           - Sauvegarder les paramètres de langue actuels"
            echo "  definir <lang> <apps...> - Définir la langue pour des applications spécifiques"
            echo "  appliquer [langue]    - Appliquer la politique de langue sur les applications"
            echo "  reinitialiser <app>   - Réinitialiser l'application à la langue système par défaut"
            echo "  verifier <app>        - Vérifier le paramètre de langue actuel pour l'application"
            echo "  aide                  - Afficher ce message d'aide"
            echo ""
            echo "Codes de Langue :"
            echo "  en        - Anglais"
            echo "  fr        - Français"
            echo "  de        - Allemand"
            echo "  es        - Espagnol"
            echo "  it        - Italien"
            echo "  ja        - Japonais"
            echo "  ko        - Coréen"
            echo "  zh-Hans   - Chinois (Simplifié)"
            echo "  zh-Hant   - Chinois (Traditionnel)"
            ;;
    esac
    
    log_action "=== Gestion des Langues Roundfleet Terminée ==="
}

# Exécuter la fonction principale
main "$@"

Référence des Codes de Langue

Codes de Langue Courants

Langue	Code	Région
Anglais	en	International
Français	fr	France
Allemand	de	Allemagne
Espagnol	es	Espagne
Italien	it	Italie
Portugais	pt	Portugal
Portugais (Brésil)	pt-BR	Brésil
Japonais	ja	Japon
Coréen	ko	Corée
Chinois (Simplifié)	zh-Hans	Chine
Chinois (Traditionnel)	zh-Hant	Taiwan/Hong Kong
Russe	ru	Russie
Arabe	ar	Moyen-Orient
Néerlandais	nl	Pays-Bas
Suédois	sv	Suède
Norvégien	no	Norvège
Danois	da	Danemark
Finnois	fi	Finlande

Variantes Régionales

# Codes de langue régionaux courants
en-US    # Anglais (États-Unis)
en-GB    # Anglais (Royaume-Uni)
en-CA    # Anglais (Canada)
en-AU    # Anglais (Australie)
fr-FR    # Français (France)
fr-CA    # Français (Canada)
de-DE    # Allemand (Allemagne)
de-CH    # Allemand (Suisse)
es-ES    # Espagnol (Espagne)
es-MX    # Espagnol (Mexique)

Exemples Spécifiques aux Applications

Applications macOS Populaires

# Définir le français pour les applications de productivité
./gestionnaire_langue.sh definir fr "Pages" "Numbers" "Keynote"

# Définir l'allemand pour les applications de communication
./gestionnaire_langue.sh definir de "Mail" "Messages" "FaceTime"

# Définir le japonais pour les applications créatives
./gestionnaire_langue.sh definir ja "Photos" "GarageBand" "iMovie"

# Définir l'espagnol pour les applications système
./gestionnaire_langue.sh definir es "Calendar" "Contacts" "Reminders"

Configuration d'Applications d'Entreprise

# Configurer Microsoft Office
defaults write -app "Microsoft Word" AppleLanguages -array "fr"
defaults write -app "Microsoft Excel" AppleLanguages -array "fr"
defaults write -app "Microsoft PowerPoint" AppleLanguages -array "fr"

# Configurer Adobe Creative Suite
defaults write -app "Adobe Photoshop 2024" AppleLanguages -array "de"
defaults write -app "Adobe Illustrator 2024" AppleLanguages -array "de"
defaults write -app "Adobe InDesign 2024" AppleLanguages -array "de"

Gestion des Politiques de Langue

Application de Langue d'Organisation

# Créer une politique de langue d'organisation
ORGANIZATION_LANGUAGE="en"
DEPARTMENT_LANGUAGES=("en" "fr" "de")  # Langues autorisées

# Appliquer sur toutes les applications standard
for app in Safari Mail Calendar Contacts Notes; do
    defaults write -app "$app" AppleLanguages -array "$ORGANIZATION_LANGUAGE"
done

Vérification de Conformité

# Vérifier la conformité avec la politique de langue
check_language_compliance() {
    local required_lang="$1"
    local non_compliant_apps=()
    
    for app in Safari Mail Calendar Contacts Notes Reminders; do
        local current_lang=$(defaults read -app "$app" AppleLanguages 2>/dev/null | head -1 | tr -d '[:space:],"()')
        
        if [[ -n "$current_lang" && "$current_lang" != "$required_lang" ]]; then
            non_compliant_apps+=("$app:$current_lang")
        fi
    done
    
    if [[ ${#non_compliant_apps[@]} -gt 0 ]]; then
        echo "⚠️ Applications non conformes trouvées :"
        printf '%s\n' "${non_compliant_apps[@]}"
        return 1
    else
        echo "✅ Toutes les applications sont conformes à la politique de langue"
        return 0
    fi
}

Dépannage

Problèmes Courants

# Vérifier si l'application existe
app_exists() {
    local app_name="$1"
    if mdfind "kMDItemKind == 'Application'" | grep -q "$app_name.app"; then
        return 0
    else
        echo "❌ Application '$app_name' non trouvée"
        return 1
    fi
}

# Forcer le redémarrage de l'application
restart_application() {
    local app_name="$1"
    echo "🔄 Redémarrage de $app_name..."
    
    # Arrêter l'application si elle fonctionne
    pkill -f "$app_name" 2>/dev/null
    
    # Attendre et relancer
    sleep 2
    open -a "$app_name" 2>/dev/null
}

Vérification du Changement de Langue

# Vérifier que le changement de langue a pris effet
verify_language_change() {
    local app_name="$1"
    local expected_lang="$2"
    
    local actual_lang=$(defaults read -app "$app_name" AppleLanguages 2>/dev/null | head -1 | tr -d '[:space:],"()')
    
    if [[ "$actual_lang" == "$expected_lang" ]]; then
        echo "✅ Langue de $app_name vérifiée : $expected_lang"
        return 0
    else
        echo "❌ Décalage de langue pour $app_name. Attendu : $expected_lang, Actuel : $actual_lang"
        return 1
    fi
}

Notes Importantes

Redémarrage d'Application Requis - La plupart des applications doivent être redémarrées pour appliquer les changements de langue
Langue Système vs Application - Les paramètres spécifiques aux applications remplacent la langue système
Contexte Utilisateur - Les paramètres de langue s'appliquent uniquement à l'utilisateur actuel
Sauvegarde Avant Changements - Toujours sauvegarder les paramètres actuels avant les modifications en bloc
Tester les Applications Individuelles - Vérifier que les changements de langue fonctionnent pour des applications spécifiques
Considérations Régionales - Certaines applications peuvent nécessiter des codes de langue régionaux spécifiques

Guide

Avis important