Guide

Contrôlez et gérez les paramètres Bluetooth sur vos appareils Roundfleet en utilisant des outils en ligne de commande avancés. Ce tutoriel couvre la surveillance du statut Bluetooth, la gestion des états d'alimentation, et le contrôle de flotte de niveau entreprise avec journalisation complète et fonctionnalités de sécurité.

Comprendre la Gestion Bluetooth de macOS

macOS fournit un contrôle Bluetooth complet via plusieurs mécanismes :

• defaults - Manipulation directe des préférences Bluetooth via les fichiers plist
• bluetoothd - Le daemon Bluetooth central qui gère toutes les opérations Bluetooth
• launchctl - Gestion des services pour démarrer/arrêter les services Bluetooth
• blued - Nom du daemon Bluetooth hérité utilisé dans les anciennes versions de macOS

Le fichier de configuration principal est situé à /Library/Preferences/com.apple.Bluetooth avec la clé ControllerPowerState contrôlant l'état d'alimentation.

Gestion de Base du Statut Bluetooth

Vérifier le Statut Bluetooth

#!/bin/bash

# Vérifier l'état d'alimentation Bluetooth actuel
check_bluetooth_status() {
    local status
    status=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    if [[ "$status" == "1" ]]; then
        echo "Bluetooth est ACTIVÉ"
        return 0
    elif [[ "$status" == "0" ]]; then
        echo "Bluetooth est DÉSACTIVÉ"
        return 1
    else
        echo "Statut Bluetooth inconnu ou non configuré"
        return 2
    fi
}

# Exécuter la vérification du statut
check_bluetooth_status

Activer le Bluetooth

#!/bin/bash

# Activer le Bluetooth en utilisant defaults et redémarrage du daemon
turn_bluetooth_on() {
    echo "Activation du Bluetooth..."
    
    # Définir l'état d'alimentation Bluetooth sur ACTIVÉ
    sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 1
    
    # Redémarrer le daemon Bluetooth (essayer les noms de daemon moderne et hérité)
    if pgrep bluetoothd >/dev/null 2>&1; then
        sudo killall -HUP bluetoothd
        echo "Daemon Bluetooth (bluetoothd) redémarré"
    elif pgrep blued >/dev/null 2>&1; then
        sudo killall -HUP blued
        echo "Daemon Bluetooth (blued) redémarré"
    else
        echo "Attention : Daemon Bluetooth non trouvé"
    fi
    
    # Attendre que les changements prennent effet
    sleep 3
    
    # Vérifier le changement
    if check_bluetooth_status >/dev/null; then
        echo "✅ Bluetooth activé avec succès"
        return 0
    else
        echo "❌ Échec de l'activation du Bluetooth"
        return 1
    fi
}

# Fonction d'aide pour la vérification du statut
check_bluetooth_status() {
    local status
    status=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    [[ "$status" == "1" ]]
}

# Exécuter
turn_bluetooth_on

Désactiver le Bluetooth

#!/bin/bash

# Désactiver le Bluetooth en utilisant defaults et redémarrage du daemon
turn_bluetooth_off() {
    echo "Désactivation du Bluetooth..."
    
    # Définir l'état d'alimentation Bluetooth sur DÉSACTIVÉ
    sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 0
    
    # Redémarrer le daemon Bluetooth
    if pgrep bluetoothd >/dev/null 2>&1; then
        sudo killall -HUP bluetoothd
        echo "Daemon Bluetooth (bluetoothd) redémarré"
    elif pgrep blued >/dev/null 2>&1; then
        sudo killall -HUP blued
        echo "Daemon Bluetooth (blued) redémarré"
    else
        echo "Attention : Daemon Bluetooth non trouvé"
    fi
    
    # Attendre que les changements prennent effet
    sleep 3
    
    # Vérifier le changement
    if ! check_bluetooth_status >/dev/null; then
        echo "✅ Bluetooth désactivé avec succès"
        return 0
    else
        echo "❌ Échec de la désactivation du Bluetooth"
        return 1
    fi
}

# Fonction d'aide pour la vérification du statut
check_bluetooth_status() {
    local status
    status=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    [[ "$status" == "1" ]]
}

# Exécuter
turn_bluetooth_off

Gestion Avancée du Bluetooth avec launchctl

Utilisation de launchctl pour la Gestion des Services

#!/bin/bash

# Contrôle Bluetooth avancé utilisant la gestion des services launchctl
bluetooth_service_control() {
    local action="$1"  # on, off, restart, status
    local daemon_name
    
    # Déterminer le nom du daemon correct basé sur la version macOS
    if launchctl list | grep -q "com.apple.bluetoothd"; then
        daemon_name="com.apple.bluetoothd"
    elif launchctl list | grep -q "com.apple.blued"; then
        daemon_name="com.apple.blued"
    else
        echo "❌ Daemon Bluetooth non trouvé dans launchctl"
        return 1
    fi
    
    case "$action" in
        "on")
            echo "Activation du Bluetooth..."
            sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 1
            sudo launchctl stop "$daemon_name"
            sleep 2
            sudo launchctl start "$daemon_name"
            sleep 3
            echo "✅ Bluetooth activé avec launchctl"
            ;;
        "off")
            echo "Désactivation du Bluetooth..."
            sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 0
            sudo launchctl stop "$daemon_name"
            sleep 2
            sudo launchctl start "$daemon_name"
            sleep 3
            echo "✅ Bluetooth désactivé avec launchctl"
            ;;
        "restart")
            echo "Redémarrage du service Bluetooth..."
            sudo launchctl stop "$daemon_name"
            sleep 2
            sudo launchctl start "$daemon_name"
            sleep 3
            echo "✅ Service Bluetooth redémarré"
            ;;
        "status")
            echo "Statut du daemon Bluetooth : $daemon_name"
            if launchctl list | grep -q "$daemon_name"; then
                echo "✅ Service Bluetooth en cours d'exécution"
                
                # Vérifier l'état d'alimentation
                local power_state
                power_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
                echo "État d'alimentation : $([[ "$power_state" == "1" ]] && echo "ACTIVÉ" || echo "DÉSACTIVÉ")"
            else
                echo "❌ Service Bluetooth non en cours d'exécution"
            fi
            ;;
        *)
            echo "Usage : bluetooth_service_control {on|off|restart|status}"
            return 1
            ;;
    esac
}

# Exemples
bluetooth_service_control "status"
# bluetooth_service_control "on"
# bluetooth_service_control "off"
# bluetooth_service_control "restart"

Système de Gestion Bluetooth d'Entreprise

#!/bin/bash

# Système de Gestion Bluetooth d'Entreprise Roundfleet
# Contrôle Bluetooth complet avec journalisation, surveillance, et gestion de flotte

# Configuration
LOG_FILE="/var/log/roundfleet_bluetooth.log"
CONFIG_FILE="/etc/roundfleet/bluetooth_config.conf"
BACKUP_DIR="/var/backups/roundfleet/bluetooth"
API_ENDPOINT="https://api.roundfleet.com/v1/bluetooth"

# Créer la structure des répertoires
setup_directories() {
    mkdir -p "$(dirname "$LOG_FILE")" "$BACKUP_DIR" "$(dirname "$CONFIG_FILE")"
    touch "$LOG_FILE"
}

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

# Obtenir des informations Bluetooth détaillées
get_bluetooth_info() {
    local info_json="{"
    
    # État d'alimentation
    local power_state
    power_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null || echo "unknown")
    info_json+="\"power_state\": \"$power_state\","
    
    # Statut du daemon
    local daemon_running=false
    if pgrep bluetoothd >/dev/null 2>&1 || pgrep blued >/dev/null 2>&1; then
        daemon_running=true
    fi
    info_json+="\"daemon_running\": $daemon_running,"
    
    # Version macOS
    local macos_version
    macos_version=$(sw_vers -productVersion)
    info_json+="\"macos_version\": \"$macos_version\","
    
    # Matériel système
    local hardware_model
    hardware_model=$(system_profiler SPHardwareDataType | grep "Model Name" | awk -F': ' '{print $2}' | xargs)
    info_json+="\"hardware_model\": \"$hardware_model\","
    
    # Informations du contrôleur Bluetooth
    local bt_controller=""
    if system_profiler SPBluetoothDataType >/dev/null 2>&1; then
        bt_controller=$(system_profiler SPBluetoothDataType | grep -A5 "Apple Bluetooth Software" | grep "Version" | awk -F': ' '{print $2}' | xargs)
    fi
    info_json+="\"bluetooth_version\": \"$bt_controller\","
    
    # Horodatage
    info_json+="\"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\""
    info_json+="}"
    
    echo "$info_json"
}

# Sauvegarder la configuration Bluetooth actuelle
backup_bluetooth_config() {
    local backup_file="$BACKUP_DIR/bluetooth_backup_$(date +%Y%m%d_%H%M%S).plist"
    
    if [[ -f "/Library/Preferences/com.apple.Bluetooth.plist" ]]; then
        cp "/Library/Preferences/com.apple.Bluetooth.plist" "$backup_file"
        log_action "Configuration Bluetooth sauvegardée dans : $backup_file"
        echo "$backup_file"
    else
        log_action "ATTENTION : Fichier de préférences Bluetooth non trouvé pour la sauvegarde"
        return 1
    fi
}

# Définir l'état Bluetooth avec validation complète
set_bluetooth_state() {
    local desired_state="$1"  # "on" ou "off"
    local force_restart="${2:-false}"
    
    # Valider l'entrée
    if [[ "$desired_state" != "on" && "$desired_state" != "off" ]]; then
        log_action "ERREUR : État spécifié invalide. Utilisez 'on' ou 'off'"
        return 1
    fi
    
    # Obtenir l'état actuel
    local current_state
    current_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    local target_value
    if [[ "$desired_state" == "on" ]]; then
        target_value=1
    else
        target_value=0
    fi
    
    # Vérifier si un changement est nécessaire
    if [[ "$current_state" == "$target_value" && "$force_restart" == "false" ]]; then
        log_action "Bluetooth déjà dans l'état désiré : $desired_state"
        return 0
    fi
    
    # Créer une sauvegarde avant les changements
    backup_bluetooth_config
    
    # Définir le nouvel état
    log_action "Définition de l'état Bluetooth à : $desired_state"
    sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int "$target_value"
    
    # Redémarrer le daemon Bluetooth
    restart_bluetooth_daemon
    
    # Attendre que les changements se propagent
    sleep 5
    
    # Vérifier le changement
    local new_state
    new_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    if [[ "$new_state" == "$target_value" ]]; then
        log_action "✅ Bluetooth défini avec succès à : $desired_state"
        return 0
    else
        log_action "❌ Échec de la définition du Bluetooth à : $desired_state"
        return 1
    fi
}

# Redémarrer le daemon Bluetooth avec gestion d'erreurs
restart_bluetooth_daemon() {
    log_action "Redémarrage du daemon Bluetooth..."
    
    # Essayer d'abord bluetoothd moderne
    if pgrep bluetoothd >/dev/null 2>&1; then
        if sudo killall -HUP bluetoothd 2>/dev/null; then
            log_action "Daemon Bluetooth (bluetoothd) redémarré avec succès"
            return 0
        else
            log_action "ATTENTION : Échec du redémarrage de bluetoothd avec le signal HUP"
        fi
    fi
    
    # Essayer blued hérité
    if pgrep blued >/dev/null 2>&1; then
        if sudo killall -HUP blued 2>/dev/null; then
            log_action "Daemon Bluetooth (blued) redémarré avec succès"
            return 0
        else
            log_action "ATTENTION : Échec du redémarrage de blued avec le signal HUP"
        fi
    fi
    
    # Essayer l'approche launchctl
    local daemon_service=""
    if launchctl list | grep -q "com.apple.bluetoothd"; then
        daemon_service="com.apple.bluetoothd"
    elif launchctl list | grep -q "com.apple.blued"; then
        daemon_service="com.apple.blued"
    fi
    
    if [[ -n "$daemon_service" ]]; then
        log_action "Tentative de redémarrage launchctl pour : $daemon_service"
        sudo launchctl stop "$daemon_service" 2>/dev/null
        sleep 2
        sudo launchctl start "$daemon_service" 2>/dev/null
        log_action "Service Bluetooth redémarré via launchctl"
        return 0
    fi
    
    log_action "ERREUR : Impossible de redémarrer le daemon Bluetooth"
    return 1
}

# Surveiller la connectivité Bluetooth et les appareils appairés
monitor_bluetooth_devices() {
    log_action "Démarrage de la surveillance des appareils Bluetooth..."
    
    # Obtenir l'état d'alimentation actuel
    local power_state
    power_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    if [[ "$power_state" != "1" ]]; then
        log_action "Bluetooth est DÉSACTIVÉ - pas d'appareils à surveiller"
        return 0
    fi
    
    # Vérifier la disponibilité de system_profiler
    if ! command -v system_profiler >/dev/null 2>&1; then
        log_action "ATTENTION : system_profiler non disponible pour la surveillance des appareils"
        return 1
    fi
    
    # Obtenir les informations des appareils Bluetooth
    local bt_devices
    bt_devices=$(system_profiler SPBluetoothDataType 2>/dev/null | grep -A10 "Devices:" || echo "Aucun appareil trouvé")
    
    log_action "Statut des appareils Bluetooth :"
    echo "$bt_devices" | while IFS= read -r line; do
        log_action "  $line"
    done
    
    # Compter les appareils connectés
    local connected_count
    connected_count=$(echo "$bt_devices" | grep -c "Connected: Yes" || echo "0")
    log_action "Total d'appareils Bluetooth connectés : $connected_count"
    
    return 0
}

# Générer un rapport Bluetooth complet
generate_bluetooth_report() {
    local report_file="/tmp/bluetooth_report_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Génération du rapport Bluetooth : $report_file"
    
    {
        echo "{"
        echo "  \"report_type\": \"bluetooth_status\","
        echo "  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","
        echo "  \"hostname\": \"$(hostname)\","
        echo "  \"device_info\": $(get_bluetooth_info),"
        
        # Informations système
        echo "  \"system_info\": {"
        echo "    \"macos_version\": \"$(sw_vers -productVersion)\","
        echo "    \"build_version\": \"$(sw_vers -buildVersion)\","
        echo "    \"hardware_uuid\": \"$(system_profiler SPHardwareDataType | grep 'Hardware UUID' | awk -F': ' '{print $2}' | xargs)\""
        echo "  },"
        
        # Préférences Bluetooth
        echo "  \"bluetooth_preferences\": {"
        if [[ -f "/Library/Preferences/com.apple.Bluetooth.plist" ]]; then
            echo "    \"preferences_file_exists\": true,"
            echo "    \"file_size\": $(stat -f%z "/Library/Preferences/com.apple.Bluetooth.plist"),"
            echo "    \"last_modified\": \"$(stat -f%Sm -t%Y-%m-%dT%H:%M:%SZ "/Library/Preferences/com.apple.Bluetooth.plist")\""
        else
            echo "    \"preferences_file_exists\": false"
        fi
        echo "  }"
        echo "}"
    } > "$report_file"
    
    log_action "Rapport Bluetooth généré avec succès"
    echo "$report_file"
}

# Vérification de conformité de sécurité
check_bluetooth_security() {
    log_action "Exécution de la vérification de conformité de sécurité Bluetooth..."
    
    local security_issues=()
    
    # Vérifier si Bluetooth est activé quand il devrait être désactivé
    if [[ -f "$CONFIG_FILE" ]] && grep -q "BLUETOOTH_POLICY=disabled" "$CONFIG_FILE"; then
        local current_state
        current_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
        
        if [[ "$current_state" == "1" ]]; then
            security_issues+=("Bluetooth activé malgré une politique exigeant l'état désactivé")
        fi
    fi
    
    # Vérifier la découvrabilité Bluetooth (si system_profiler disponible)
    if command -v system_profiler >/dev/null 2>&1; then
        local discoverable
        discoverable=$(system_profiler SPBluetoothDataType 2>/dev/null | grep -i "discoverable" || echo "unknown")
        
        if echo "$discoverable" | grep -qi "yes"; then
            security_issues+=("Bluetooth est découvrable - risque de sécurité potentiel")
        fi
    fi
    
    # Rapporter le statut de sécurité
    if [[ ${#security_issues[@]} -eq 0 ]]; then
        log_action "✅ Vérification de conformité de sécurité Bluetooth réussie"
        return 0
    else
        log_action "⚠️  Problèmes de sécurité Bluetooth trouvés :"
        for issue in "${security_issues[@]}"; do
            log_action "  - $issue"
        done
        return 1
    fi
}

# Fonction de gestion principale
main() {
    local action="${1:-status}"
    local parameter="$2"
    
    setup_directories
    log_action "Gestion Bluetooth Roundfleet démarrée avec l'action : $action"
    
    case "$action" in
        "on"|"enable")
            set_bluetooth_state "on"
            ;;
        "off"|"disable")
            set_bluetooth_state "off"
            ;;
        "restart"|"reload")
            restart_bluetooth_daemon
            ;;
        "status"|"info")
            get_bluetooth_info | python3 -m json.tool 2>/dev/null || get_bluetooth_info
            ;;
        "monitor")
            monitor_bluetooth_devices
            ;;
        "report")
            generate_bluetooth_report
            ;;
        "security")
            check_bluetooth_security
            ;;
        "backup")
            backup_bluetooth_config
            ;;
        "force-on")
            set_bluetooth_state "on" true
            ;;
        "force-off")
            set_bluetooth_state "off" true
            ;;
        *)
            echo "Usage : $0 {on|off|restart|status|monitor|report|security|backup|force-on|force-off}"
            echo ""
            echo "Commandes :"
            echo "  on/enable    - Activer le Bluetooth"
            echo "  off/disable  - Désactiver le Bluetooth"
            echo "  restart      - Redémarrer le daemon Bluetooth"
            echo "  status       - Afficher le statut Bluetooth détaillé"
            echo "  monitor      - Surveiller les appareils connectés"
            echo "  report       - Générer un rapport complet"
            echo "  security     - Exécuter la vérification de conformité de sécurité"
            echo "  backup       - Sauvegarder la configuration actuelle"
            echo "  force-on     - Forcer l'activation du Bluetooth (redémarrer daemon)"
            echo "  force-off    - Forcer la désactivation du Bluetooth (redémarrer daemon)"
            exit 1
            ;;
    esac
    
    log_action "Gestion Bluetooth Roundfleet terminée avec l'action : $action"
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Fonctions de Gestion Rapide

Vérification Rapide du Statut

#!/bin/bash

# Vérification rapide du statut Bluetooth avec sortie colorée
bluetooth_quick_status() {
    local status
    status=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    case "$status" in
        "1")
            echo "🔵 Bluetooth : ACTIVÉ"
            ;;
        "0")
            echo "⚪ Bluetooth : DÉSACTIVÉ"
            ;;
        *)
            echo "❓ Bluetooth : INCONNU"
            ;;
    esac
}

bluetooth_quick_status

Basculer l'État Bluetooth

#!/bin/bash

# Basculer le Bluetooth entre les états ACTIVÉ et DÉSACTIVÉ
toggle_bluetooth() {
    local current_state
    current_state=$(defaults read /Library/Preferences/com.apple.Bluetooth ControllerPowerState 2>/dev/null)
    
    if [[ "$current_state" == "1" ]]; then
        echo "Bluetooth est ACTIVÉ, désactivation..."
        sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 0
        sudo killall -HUP bluetoothd 2>/dev/null || sudo killall -HUP blued 2>/dev/null
        echo "✅ Bluetooth désactivé"
    else
        echo "Bluetooth est DÉSACTIVÉ, activation..."
        sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 1
        sudo killall -HUP bluetoothd 2>/dev/null || sudo killall -HUP blued 2>/dev/null
        echo "✅ Bluetooth activé"
    fi
}

toggle_bluetooth

Modèles de Configuration

Configuration de Politique Bluetooth

# /etc/roundfleet/bluetooth_config.conf
# Configuration de Gestion Bluetooth Roundfleet

# Paramètres de politique
BLUETOOTH_POLICY="enabled"  # enabled, disabled, user_controlled
AUTO_DISABLE_ON_IDLE="false"
IDLE_TIMEOUT_MINUTES="30"

# Paramètres de sécurité
ALLOW_DISCOVERABLE="false"
REQUIRE_PAIRING_CONFIRMATION="true"
LOG_DEVICE_CONNECTIONS="true"

# Paramètres de surveillance
MONITOR_INTERVAL_SECONDS="300"
ALERT_ON_NEW_DEVICES="true"
COMPLIANCE_CHECK_ENABLED="true"

# Paramètres de sauvegarde
AUTO_BACKUP_ENABLED="true"
BACKUP_RETENTION_DAYS="30"

Dépannage des Problèmes Courants

Daemon Bluetooth qui ne Répond Pas

#!/bin/bash

# Dépanner et corriger les problèmes de daemon Bluetooth
fix_bluetooth_daemon() {
    echo "Diagnostic des problèmes de daemon Bluetooth..."
    
    # Vérifier si le daemon fonctionne
    if ! pgrep bluetoothd >/dev/null 2>&1 && ! pgrep blued >/dev/null 2>&1; then
        echo "❌ Aucun daemon Bluetooth trouvé en cours d'exécution"
        
        # Essayer de démarrer via launchctl
        if launchctl list | grep -q "com.apple.bluetoothd"; then
            echo "Démarrage de bluetoothd via launchctl..."
            sudo launchctl start com.apple.bluetoothd
        elif launchctl list | grep -q "com.apple.blued"; then
            echo "Démarrage de blued via launchctl..."
            sudo launchctl start com.apple.blued
        else
            echo "❌ Service Bluetooth non trouvé dans launchctl"
            return 1
        fi
    fi
    
    # Forcer le redémarrage en cas de problèmes persistants
    echo "Redémarrage forcé du système Bluetooth..."
    sudo pkill -f bluetooth
    sleep 3
    
    # Redémarrer via launchctl
    for service in "com.apple.bluetoothd" "com.apple.blued"; do
        if launchctl list | grep -q "$service"; then
            sudo launchctl stop "$service" 2>/dev/null
            sleep 2
            sudo launchctl start "$service" 2>/dev/null
            echo "Service redémarré : $service"
        fi
    done
    
    # Vérifier la récupération
    sleep 5
    if pgrep bluetoothd >/dev/null 2>&1 || pgrep blued >/dev/null 2>&1; then
        echo "✅ Récupération du daemon Bluetooth réussie"
        return 0
    else
        echo "❌ Récupération du daemon Bluetooth échouée"
        return 1
    fi
}

fix_bluetooth_daemon

Réinitialiser la Configuration Bluetooth

#!/bin/bash

# Réinitialiser le Bluetooth aux paramètres d'usine
reset_bluetooth_config() {
    echo "⚠️  Réinitialisation de la configuration Bluetooth aux paramètres par défaut..."
    
    # Créer une sauvegarde
    if [[ -f "/Library/Preferences/com.apple.Bluetooth.plist" ]]; then
        cp "/Library/Preferences/com.apple.Bluetooth.plist" "/tmp/bluetooth_backup_$(date +%s).plist"
        echo "Sauvegarde créée dans /tmp/"
    fi
    
    # Arrêter les services Bluetooth
    sudo launchctl stop com.apple.bluetoothd 2>/dev/null
    sudo launchctl stop com.apple.blued 2>/dev/null
    
    # Supprimer les fichiers de configuration
    sudo rm -f "/Library/Preferences/com.apple.Bluetooth.plist"
    sudo rm -f "/Library/Preferences/ByHost/com.apple.Bluetooth.*.plist"
    
    # Redémarrer les services
    sudo launchctl start com.apple.bluetoothd 2>/dev/null
    sudo launchctl start com.apple.blued 2>/dev/null
    
    # Définir l'état par défaut
    sleep 3
    sudo defaults write /Library/Preferences/com.apple.Bluetooth ControllerPowerState -int 1
    sudo killall -HUP bluetoothd 2>/dev/null || sudo killall -HUP blued 2>/dev/null
    
    echo "✅ Réinitialisation de la configuration Bluetooth terminée"
}

# Décommenter pour exécuter
# reset_bluetooth_config

Notes Techniques Importantes

Gestion des Daemons

• bluetoothd : Daemon Bluetooth moderne (macOS 10.10+)
• blued : Daemon Bluetooth hérité (anciennes versions macOS)
• killall -HUP : Envoie un signal de raccrochage pour redémarrer le daemon gracieusement
• launchctl : Méthode préférée pour la gestion des services

Détails de Configuration

• Emplacement du fichier : /Library/Preferences/com.apple.Bluetooth
• Clé d'état d'alimentation : ControllerPowerState
• Valeurs : 1 (ACTIVÉ), 0 (DÉSACTIVÉ)
• Persistance : Les changements persistent après redémarrage

Considérations de Sécurité

1. Privilèges Administratifs : Toutes les modifications Bluetooth nécessitent sudo
2. Redémarrage du Daemon : Les changements ne prennent effet qu'après redémarrage du daemon
3. Impact Utilisateur : Désactiver le Bluetooth déconnecte tous les appareils appairés
4. Conformité Politique : Surveiller les changements Bluetooth non autorisés

Meilleures Pratiques

1. Toujours sauvegarder les configurations avant d'apporter des modifications
2. Tester les méthodes de redémarrage du daemon pour votre version macOS
3. Surveiller les délais - le redémarrage du daemon peut prendre plusieurs secondes
4. Implémenter la journalisation pour les pistes d'audit et le dépannage
5. Utiliser launchctl pour une gestion des services plus fiable
6. Valider les changements après avoir appliqué les modifications
7. Considérer l'impact utilisateur lors de la désactivation du Bluetooth à distance
8. Tester les scripts minutieusement avant le déploiement de flotte

N'oubliez pas de valider tous les scripts sur des appareils de test avant de les déployer sur votre environnement Roundfleet, et soyez conscient que les changements Bluetooth peuvent prendre quelques minutes pour se propager complètement dans le système.

Surveillez et gérez la santé, les performances et le cycle de vie de la batterie sur vos appareils Roundfleet en utilisant des outils de surveillance de batterie avancés et des systèmes de gestion de batterie d'entreprise. Ce tutoriel couvre la surveillance de santé de batterie, l'optimisation d'alimentation, le suivi de conformité et la gestion du cycle de vie de batterie d'entreprise.

Comprendre la Gestion de Batterie macOS

macOS fournit plusieurs outils en ligne de commande pour la gestion et surveillance de batterie :

• pmset - Paramètres de gestion d'alimentation et surveillance d'état de batterie
• system_profiler - Informations système et batterie complètes
• ioreg - Informations de registre I/O incluant détails de batterie
• Gestion de Santé de Batterie - Optimisation de batterie intégrée macOS
• Mode Économie d'Énergie - Conservation d'énergie au niveau système

Opérations de Batterie de Base

Voir l'État de la Batterie

#!/bin/bash

# État de batterie de base
pmset -g batt

echo "État de batterie récupéré avec succès"

Informations de Batterie Améliorées

#!/bin/bash

# Informations de batterie complètes avec analyse détaillée
get_comprehensive_battery_info() {
    echo "=== Analyse Complète de Batterie ==="
    
    # État de batterie de base
    echo "Aperçu de l'État de Batterie :"
    pmset -g batt
    
    echo -e "\nSanté Détaillée de Batterie :"
    system_profiler SPPowerDataType
    
    echo -e "\nParamètres de Gestion d'Alimentation :"
    pmset -g
    
    echo -e "\nInformations de Registre de Batterie :"
    ioreg -n AppleSmartBattery -r
    
    echo -e "\nÉtat Thermique :"
    pmset -g therm
    
    echo -e "\nDétails de Source d'Alimentation :"
    pmset -g ps
}

# Exécuter l'analyse complète
get_comprehensive_battery_info

Catégories de Gestion de Batterie

Classifications d'Appareils à Batterie

#!/bin/bash

# Catégories de gestion de batterie d'entreprise pour surveillance et application de politiques
declare -A BATTERY_DEVICE_CATEGORIES=(
    ["mobile_direction"]="MacBooks de direction nécessitant temps de fonctionnement et fiabilité maximums"
    ["poste_creatif"]="MacBooks haute performance pour professionnels créatifs avec usage intensif"
    ["ordinateur_developpeur"]="MacBooks de développement avec usage CPU élevé et sessions longues"
    ["service_terrain"]="MacBooks de service terrain nécessitant autonomie étendue et durabilité"
    ["flotte_education"]="MacBooks éducatifs avec modèles d'usage partagé et contraintes budgétaires"
    ["salle_conference"]="MacBooks de salle de réunion pour présentations et visioconférence"
    ["appareils_secours"]="Appareils de sauvegarde et prêt avec modèles d'usage peu fréquents"
    ["systemes_heritage"]="MacBooks anciens nécessitant gestion de batterie spécialisée"
    ["labo_test"]="Appareils de test et QA avec modèles d'usage variables"
    ["affichage_kiosque"]="MacBooks kiosque avec exigences d'opération continue"
)

# Seuils de santé de batterie
declare -A HEALTH_THRESHOLDS=(
    ["mobile_direction"]="excellent:90,bon:80,alerte:70,critique:60"
    ["poste_creatif"]="excellent:85,bon:75,alerte:65,critique:55"
    ["ordinateur_developpeur"]="excellent:85,bon:75,alerte:65,critique:55"
    ["service_terrain"]="excellent:95,bon:85,alerte:75,critique:65"
    ["flotte_education"]="excellent:80,bon:70,alerte:60,critique:50"
    ["salle_conference"]="excellent:85,bon:75,alerte:65,critique:55"
    ["appareils_secours"]="excellent:75,bon:65,alerte:55,critique:45"
    ["systemes_heritage"]="excellent:70,bon:60,alerte:50,critique:40"
    ["labo_test"]="excellent:80,bon:70,alerte:60,critique:50"
    ["affichage_kiosque"]="excellent:90,bon:80,alerte:70,critique:60"
)

print_battery_categories() {
    echo "=== Catégories de Gestion de Batterie ==="
    for category in "${!BATTERY_DEVICE_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${BATTERY_DEVICE_CATEGORIES[$category]}"
        echo "  Seuils de Santé : ${HEALTH_THRESHOLDS[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_battery_categories

Politiques de Gestion de Batterie

Moteur de Politique de Gestion d'Alimentation

#!/bin/bash

# Politiques de gestion de batterie pour différentes exigences organisationnelles
declare -A BATTERY_POLICIES=(
    ["performance_maximale"]="Politique priorité performance avec restrictions d'alimentation minimales"
    ["efficacite_equilibree"]="Optimisation équilibrée performance et autonomie batterie"
    ["autonomie_etendue"]="Autonomie maximale avec optimisation performance"
    ["entreprise_standard"]="Gestion batterie d'entreprise standard avec surveillance"
    ["mobile_haute_securite"]="Gestion batterie mobile axée sécurité"
    ["professionnel_creatif"]="Optimisé pour flux créatifs avec demandes d'alimentation élevées"
    ["operations_terrain"]="Opération étendue pour service terrain et travail distant"
    ["conformite_stricte"]="Conformité stricte avec suivi santé et cycle de vie batterie"
)

# Appliquer une politique de batterie
apply_battery_policy() {
    local policy="$1"
    local config_file="/tmp/politique_batterie.json"
    
    echo "Application de la politique de batterie : $policy"
    
    case "$policy" in
        "autonomie_etendue")
            cat > "$config_file" << EOF
{
    "mode_alimentation": "economie_etendue",
    "gestion_sante_batterie": true,
    "seuil_mode_economie": 20,
    "parametres_veille": {
        "veille_ecran": 5,
        "veille_systeme": 10,
        "veille_disque": 5
    },
    "performance_processeur": "efficace",
    "commutation_graphiques": "gpu_integre_seulement",
    "actualisation_apps_arriere_plan": false,
    "services_localisation": "essentiel_seulement",
    "optimisation_notification": true,
    "gestion_thermique": "priorite_batterie",
    "optimisation_charge": true,
    "charge_optimisee": true,
    "surveillance_batterie": "complete"
}
EOF
            ;;
        "entreprise_standard")
            cat > "$config_file" << EOF
{
    "mode_alimentation": "equilibre",
    "gestion_sante_batterie": true,
    "seuil_mode_economie": 15,
    "parametres_veille": {
        "veille_ecran": 15,
        "veille_systeme": 30,
        "veille_disque": 10
    },
    "performance_processeur": "equilibre",
    "commutation_graphiques": "automatique",
    "actualisation_apps_arriere_plan": true,
    "services_localisation": "standard",
    "optimisation_notification": true,
    "gestion_thermique": "equilibre",
    "optimisation_charge": true,
    "surveillance_batterie": "entreprise",
    "suivi_conformite": true,
    "gestion_cycle_vie": true,
    "analyse_usage": true,
    "alertes_sante": true,
    "rapports_flotte": true
}
EOF
            ;;
        *)
            echo "Politique de batterie inconnue : $policy"
            return 1
            ;;
    esac
    
    echo "✅ Politique de batterie appliquée avec succès"
    echo "Configuration : $config_file"
    
    return 0
}

Surveillance Avancée de Batterie

Analyse de Santé de Batterie

#!/bin/bash

# Surveillance et analyse complètes de santé de batterie
monitor_battery_health() {
    local device_category="$1"
    local monitoring_profile="${2:-standard}"
    local health_report="/tmp/sante_batterie_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Surveillance de Santé de Batterie ==="
    echo "Catégorie d'Appareil : $device_category"
    echo "Profil de Surveillance : $monitoring_profile"
    
    # Extraire les informations de batterie
    echo "Collecte des données de batterie..."
    local battery_info
    battery_info=$(system_profiler SPPowerDataType)
    
    # Analyser les métriques clés de batterie
    local cycle_count
    cycle_count=$(echo "$battery_info" | grep "Cycle Count:" | awk -F': ' '{print $2}' | tr -d ' ')
    
    local condition
    condition=$(echo "$battery_info" | grep "Condition:" | awk -F': ' '{print $2}' | tr -d ' ')
    
    local max_capacity
    max_capacity=$(echo "$battery_info" | grep "Maximum Capacity:" | awk -F': ' '{print $2}' | tr -d ' %')
    
    local state_of_charge
    state_of_charge=$(echo "$battery_info" | grep "State of Charge" | awk -F': ' '{print $2}' | tr -d ' %')
    
    local charging_status
    charging_status=$(pmset -g batt | grep -o "charging\|discharging\|charged" | head -1)
    
    # Calculer le score de santé de batterie
    local health_score=100
    
    # Impact du nombre de cycles
    if [[ $cycle_count -gt 1000 ]]; then
        ((health_score -= 20))
    elif [[ $cycle_count -gt 500 ]]; then
        ((health_score -= 10))
    fi
    
    # Impact de la capacité
    if [[ $max_capacity -lt 80 ]]; then
        ((health_score -= 25))
    elif [[ $max_capacity -lt 90 ]]; then
        ((health_score -= 15))
    fi
    
    # Impact de la condition
    if [[ "$condition" == "Service Recommended" ]]; then
        ((health_score -= 30))
    elif [[ "$condition" == "Replace Soon" ]]; then
        ((health_score -= 50))
    elif [[ "$condition" == "Replace Now" ]]; then
        ((health_score -= 70))
    fi
    
    # Déterminer l'état de santé
    local health_status="excellent"
    if [[ $health_score -lt 60 ]]; then
        health_status="critique"
    elif [[ $health_score -lt 70 ]]; then
        health_status="mauvais"
    elif [[ $health_score -lt 80 ]]; then
        health_status="alerte"
    elif [[ $health_score -lt 90 ]]; then
        health_status="bon"
    fi
    
    # Générer les recommandations
    local recommendations=()
    
    if [[ $cycle_count -gt 800 ]]; then
        recommendations+=("Considérer la planification de remplacement de batterie")
    fi
    
    if [[ $max_capacity -lt 85 ]]; then
        recommendations+=("Surveiller la dégradation de capacité de batterie")
    fi
    
    if [[ "$condition" != "Normal" ]]; then
        recommendations+=("Programmer rendez-vous de service batterie")
    fi
    
    if [[ $state_of_charge -lt 20 && "$charging_status" == "discharging" ]]; then
        recommendations+=("Connecter à une source d'alimentation immédiatement")
    fi
    
    # Afficher les résultats
    echo ""
    echo "Résultats d'Analyse de Santé de Batterie :"
    echo "  Score de Santé Global : $health_score/100 ($health_status)"
    echo "  Nombre de Cycles : ${cycle_count:-0}"
    echo "  Condition : $condition"
    echo "  Capacité Maximale : ${max_capacity:-0}%"
    echo "  Charge Actuelle : ${state_of_charge:-0}%"
    echo "  État de Charge : $charging_status"
    
    if [[ ${#recommendations[@]} -gt 0 ]]; then
        echo "  Recommandations :"
        for rec in "${recommendations[@]}"; do
            echo "    - $rec"
        done
    else
        echo "  ✅ Aucune action immédiate requise"
    fi
    
    echo "  Rapport de Santé : $health_report"
    
    return 0
}

Système de Gestion de Batterie d'Entreprise

#!/bin/bash

# Système de Gestion de Batterie d'Entreprise Roundfleet
# Surveillance, optimisation et gestion de cycle de vie de batterie complètes

# Configuration
CONFIG_DIR="/etc/roundfleet/batterie"
LOG_FILE="/var/log/roundfleet_gestion_batterie.log"
DATA_DIR="/var/data/roundfleet/batterie"
REPORTS_DIR="/var/reports/roundfleet/batterie"
AUDIT_LOG="/var/log/roundfleet_audit_batterie.log"

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

log_error() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [ERREUR] $1" | tee -a "$LOG_FILE" >&2
}

audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}

# Optimisation de performance de batterie
optimize_battery_performance() {
    local optimization_profile="$1"
    local target_usage="${2:-standard}"
    
    log_action "Début d'optimisation batterie (Profil : $optimization_profile)"
    
    echo "=== Optimisation de Performance de Batterie ==="
    echo "Profil d'Optimisation : $optimization_profile"
    echo "Usage Cible : $target_usage"
    
    local optimizations_applied=()
    
    case "$optimization_profile" in
        "autonomie_maximale")
            echo "Application des optimisations d'autonomie maximale..."
            
            # Activer le mode basse consommation
            sudo pmset -b lowpowermode 1 2>/dev/null && {
                optimizations_applied+=("mode_basse_consommation_active")
                echo "  ✅ Mode basse consommation activé"
            }
            
            # Optimiser les paramètres de veille pour batterie
            sudo pmset -b displaysleep 2 sleep 5 disksleep 3 && {
                optimizations_applied+=("parametres_veille_optimises")
                echo "  ✅ Paramètres de veille optimisés pour batterie"
            }
            
            # Désactiver les services non essentiels
            sudo pmset -b ttyskeepawake 0 && {
                optimizations_applied+=("veille_tty_optimisee")
                echo "  ✅ Optimisation de veille TTY activée"
            }
            ;;
            
        "performance_equilibree")
            echo "Application des optimisations de performance équilibrée..."
            
            # Optimiser les modèles de charge
            sudo pmset -b acwake 0 && {
                optimizations_applied+=("reveil_ac_optimise")
                echo "  ✅ Optimisation de réveil AC appliquée"
            }
            
            # Définir paramètres de veille équilibrés
            sudo pmset -b displaysleep 10 sleep 15 disksleep 10 && {
                optimizations_applied+=("parametres_veille_equilibres")
                echo "  ✅ Paramètres de veille équilibrés appliqués"
            }
            ;;
            
        "operations_terrain")
            echo "Application des optimisations d'opérations terrain..."
            
            # Paramètres d'alimentation ultra-conservateurs
            sudo pmset -b displaysleep 1 sleep 3 disksleep 1 && {
                optimizations_applied+=("veille_ultra_conservative")
                echo "  ✅ Paramètres de veille ultra-conservateurs pour usage terrain"
            }
            
            # Désactiver tous les événements de réveil
            sudo pmset -b wake 0 womp 0 && {
                optimizations_applied+=("evenements_reveil_desactives")
                echo "  ✅ Événements de réveil désactivés pour conservation maximale"
            }
            
            # Activer l'hibernation
            sudo pmset -b hibernatemode 25 && {
                optimizations_applied+=("hibernation_activee")
                echo "  ✅ Hibernation activée pour veille prolongée"
            }
            ;;
            
        *)
            echo "❌ Profil d'optimisation inconnu : $optimization_profile"
            return 1
            ;;
    esac
    
    echo ""
    echo "Résultats d'Optimisation :"
    echo "  Profil : $optimization_profile"
    echo "  Optimisations Appliquées : ${#optimizations_applied[@]}"
    
    audit_log "Optimisation batterie terminée : $optimization_profile (${#optimizations_applied[@]} optimisations)"
    
    return 0
}

# Surveillance de conformité de batterie
monitor_battery_compliance() {
    local compliance_framework="$1"
    
    log_action "Début surveillance conformité batterie : $compliance_framework"
    
    echo "=== Surveillance de Conformité de Batterie ==="
    echo "Cadre : $compliance_framework"
    
    local violations=()
    local compliance_score=100
    
    case "$compliance_framework" in
        "entreprise_standard")
            # Vérifier la gestion de santé de batterie
            if ! pmset -g | grep -q "Battery Health Management.*1"; then
                violations+=("gestion_sante_batterie_desactivee")
                ((compliance_score -= 20))
            fi
            
            # Vérifier la charge optimisée
            if ! pmset -g | grep -q "Optimized Battery Charging.*1"; then
                violations+=("charge_optimisee_desactivee")
                ((compliance_score -= 15))
            fi
            ;;
            
        "conformite_environnementale")
            # Vérifier la condition de batterie
            local condition
            condition=$(system_profiler SPPowerDataType | grep "Condition:" | awk -F': ' '{print $2}' | tr -d ' ')
            
            if [[ "$condition" != "Normal" ]]; then
                violations+=("condition_batterie_degradee")
                ((compliance_score -= 30))
            fi
            
            # Vérifier le nombre de cycles
            local cycle_count
            cycle_count=$(system_profiler SPPowerDataType | grep "Cycle Count:" | awk -F': ' '{print $2}' | tr -d ' ')
            
            if [[ $cycle_count -gt 1000 ]]; then
                violations+=("nombre_cycles_eleve_preoccupation_environnementale")
                ((compliance_score -= 25))
            fi
            ;;
            
        *)
            echo "❌ Cadre de conformité inconnu : $compliance_framework"
            return 1
            ;;
    esac
    
    echo ""
    echo "Résultats de Conformité :"
    echo "  Cadre : $compliance_framework"
    echo "  Score de Conformité : $compliance_score/100"
    echo "  Violations Trouvées : ${#violations[@]}"
    
    if [[ ${#violations[@]} -gt 0 ]]; then
        echo "  Violations :"
        for violation in "${violations[@]}"; do
            echo "    - $violation"
        done
    else
        echo "  ✅ Aucune violation trouvée"
    fi
    
    audit_log "Surveillance conformité batterie terminée : $compliance_framework (Score : $compliance_score/100)"
    
    return 0
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    case "$command" in
        "statut")
            # État de batterie amélioré
            get_comprehensive_battery_info
            ;;
        "verification_sante")
            monitor_battery_health "$@"
            ;;
        "optimiser")
            optimize_battery_performance "$@"
            ;;
        "appliquer_politique")
            apply_battery_policy "$@"
            ;;
        "verification_conformite")
            monitor_battery_compliance "$@"
            ;;
        "afficher_categories")
            print_battery_categories
            ;;
        *)
            echo "Système de Gestion de Batterie d'Entreprise Roundfleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  statut                                    - État et informations de batterie améliorés"
            echo "  verification_sante <categorie> [profil]  - Surveillance complète de santé de batterie"
            echo "  optimiser <profil> [usage]               - Optimisation de performance de batterie"
            echo "  appliquer_politique <politique>          - Appliquer politique de gestion de batterie"
            echo "  verification_conformite <cadre>          - Surveillance de conformité de batterie"
            echo "  afficher_categories                      - Afficher catégories d'appareils à batterie"
            echo ""
            echo "Exemples :"
            echo "  $0 statut"
            echo "  $0 verification_sante mobile_direction entreprise"
            echo "  $0 optimiser autonomie_maximale mobile"
            echo "  $0 appliquer_politique entreprise_standard"
            echo "  $0 verification_conformite entreprise_standard"
            ;;
    esac
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Considérations de Sécurité

Sécurité de Batterie

• Intégrité de Gestion d'Alimentation - S'assurer que les paramètres de gestion d'alimentation ne peuvent pas être altérés
• Surveillance de Santé de Batterie - Surveillance continue pour problèmes de batterie liés à la sécurité
• Gestion Thermique - Surveiller la température de batterie pour sécurité et protection
• Sécurité de Charge - Protocoles de charge sécurisés et protection contre logiciels malveillants
• Sécurité Physique - Surveiller altération ou remplacement de batterie

Cadre de Conformité

• Conformité Environnementale - Élimination et conformité de cycle de vie de batterie
• Santé et Sécurité - Surveillance de sécurité de batterie et signalement d'incidents
• Efficacité Énergétique - Suivi et optimisation de consommation d'énergie
• Gestion d'Actifs - Suivi de remplacement et maintenance de batterie
• Pistes d'Audit - Journalisation complète de toutes les opérations liées à la batterie

Guide de Dépannage

Problèmes Courants

Batterie Ne Se Charge Pas

• Vérifier fonctionnalité du câble et adaptateur de charge
• Vérifier port de charge pour débris ou dommages
• Réinitialiser SMC (Contrôleur de Gestion Système)
• Vérifier restrictions de charge basées sur logiciel

Décharge Rapide de Batterie

• Identifier applications énergivores avec Moniteur d'Activité
• Vérifier processus en fuite consommant CPU
• Vérifier luminosité d'écran et autres paramètres d'alimentation
• Surveiller actualisation d'apps en arrière-plan et services de localisation

Dégradation de Santé de Batterie

• Surveiller tendances de nombre de cycles et capacité
• Vérifier exposition à températures extrêmes
• Vérifier modèles de charge et optimiser pour longévité
• Considérer remplacement de batterie basé sur métriques de santé

Commandes de Diagnostic

# État complet de batterie
pmset -g batt

# Santé détaillée de batterie
system_profiler SPPowerDataType

# Paramètres de gestion d'alimentation
pmset -g

# Informations de registre de batterie
ioreg -n AppleSmartBattery -r

# Surveillance d'état thermique
pmset -g therm

Notes Importantes

• Sécurité de Batterie - Surveiller température et modèles de charge pour sécurité
• Gestion de Cycle de Vie - Surveillance proactive et planification de remplacement
• Impact Environnemental - Procédures appropriées d'élimination et recyclage de batterie
• Impact sur Performance - Équilibrer optimisation batterie avec besoins de performance système
• Exigences de Conformité - Maintenir conformité avec standards environnementaux et de sécurité
• Documentation - Conserver enregistrements détaillés de santé et activités de maintenance de batterie

Gérez les limites de charge de batterie sur vos appareils Roundfleet pour optimiser la santé de la batterie et implémenter des politiques de gestion d'énergie d'entreprise. Ce tutoriel couvre l'installation d'outils de gestion de batterie, la configuration des limites de charge, les paramètres de persistance et la surveillance complète de la santé de la batterie à l'échelle de la flotte.

Comprendre les Limites de Charge de Batterie

Les limites de charge de batterie aident à préserver la santé de la batterie en empêchant la surcharge, particulièrement bénéfique pour les appareils qui restent branchés en permanence :

Pourquoi Définir des Limites de Charge ?

• Longévité de la Batterie - Évite la dégradation due à une charge constante à 100%
• Réduction de la Chaleur - Les niveaux de charge plus bas génèrent moins de chaleur pendant le fonctionnement
• Économies d'Entreprise - Une durée de vie de batterie prolongée réduit les coûts de remplacement
• Gestion d'Énergie - Charge optimisée pour les postes de travail stationnaires
• Avantages Environnementaux - Une durée de vie de batterie plus longue réduit les déchets électroniques

Outils de Gestion de Batterie

• bclm - Battery Charge Limit Max (outil principal)
• SMC - System Management Controller (interface matérielle)
• Homebrew - Gestionnaire de paquets pour les outils macOS
• Gestion d'Énergie - Contrôles d'énergie intégrés de macOS

Prérequis et Installation

Installer le Gestionnaire de Paquets Homebrew

#!/bin/bash

# Installer le gestionnaire de paquets Homebrew
echo "🍺 Installation du gestionnaire de paquets Homebrew..."

# Vérifier si Homebrew est déjà installé
if command -v brew >/dev/null 2>&1; then
    echo "ℹ️ Homebrew est déjà installé"
    echo "Version Homebrew : $(brew --version | head -1)"
else
    echo "Installation de Homebrew..."
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Homebrew installé avec succès"
    else
        echo "❌ Échec de l'installation de Homebrew"
        exit 1
    fi
fi

# Vérifier l'installation et ajouter au PATH si nécessaire
if [[ -f /opt/homebrew/bin/brew ]]; then
    echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
    eval "$(/opt/homebrew/bin/brew shellenv)"
elif [[ -f /usr/local/bin/brew ]]; then
    echo 'eval "$(/usr/local/bin/brew shellenv)"' >> ~/.zprofile
    eval "$(/usr/local/bin/brew shellenv)"
fi

echo "Emplacement Homebrew : $(which brew)"

Installer BCLM (Battery Charge Limit Max)

#!/bin/bash

# Installer bclm (Battery Charge Limit Max)
echo "🔋 Installation de bclm (Battery Charge Limit Max)..."

# S'assurer que Homebrew est disponible
if ! command -v brew >/dev/null 2>&1; then
    echo "❌ Homebrew non trouvé. Veuillez installer Homebrew d'abord."
    exit 1
fi

# Installer bclm
echo "Ajout du tap zackelia/formulae..."
if brew tap zackelia/formulae; then
    echo "✅ Tap ajouté avec succès"
else
    echo "❌ Échec de l'ajout du tap"
    exit 1
fi

echo "Installation de bclm..."
if brew install bclm; then
    echo "✅ bclm installé avec succès"
else
    echo "❌ Échec de l'installation de bclm"
    exit 1
fi

# Vérifier l'installation
if command -v bclm >/dev/null 2>&1; then
    echo "Emplacement bclm : $(which bclm)"
    echo "Test d'accès à bclm..."
    
    # Tester l'accès en lecture (ne nécessite pas sudo)
    if bclm read >/dev/null 2>&1; then
        echo "✅ bclm fonctionne correctement"
        echo "Limite de charge actuelle : $(bclm read)%"
    else
        echo "⚠️ bclm installé mais peut nécessiter des permissions supplémentaires"
    fi
else
    echo "❌ bclm non trouvé dans PATH"
    exit 1
fi

Gestion de Base des Limites de Charge

Définir la Limite de Charge

#!/bin/bash

# Définir la limite de charge de batterie
LIMIT="$1"

if [[ -z "$LIMIT" ]]; then
    echo "❌ Utilisation : $0 <pourcentage>"
    echo "Exemple : $0 80"
    echo "Plage valide : 50-100"
    exit 1
fi

# Valider la plage de limite
if [[ "$LIMIT" -lt 50 || "$LIMIT" -gt 100 ]]; then
    echo "❌ Limite invalide : $LIMIT"
    echo "La limite de charge doit être entre 50% et 100%"
    exit 1
fi

echo "🔋 Définition de la limite de charge de batterie à $LIMIT%..."

# Obtenir la limite actuelle pour comparaison
CURRENT_LIMIT=$(bclm read 2>/dev/null)
if [[ -n "$CURRENT_LIMIT" ]]; then
    echo "Limite actuelle : $CURRENT_LIMIT%"
fi

# Définir la nouvelle limite de charge
if sudo bclm write "$LIMIT"; then
    echo "✅ Limite de charge définie à $LIMIT%"
    
    # Vérifier le paramètre
    NEW_LIMIT=$(bclm read 2>/dev/null)
    if [[ "$NEW_LIMIT" == "$LIMIT" ]]; then
        echo "✅ Paramètre vérifié : $NEW_LIMIT%"
    else
        echo "⚠️ Attention : La vérification montre $NEW_LIMIT% au lieu de $LIMIT%"
    fi
else
    echo "❌ Échec de définition de la limite de charge"
    exit 1
fi

echo "ℹ️ Note : Un redémarrage peut être nécessaire pour que les changements prennent effet"

Lire la Limite de Charge Actuelle

#!/bin/bash

# Lire la limite de charge de batterie actuelle
echo "🔍 Lecture de la limite de charge de batterie actuelle..."

if command -v bclm >/dev/null 2>&1; then
    CURRENT_LIMIT=$(bclm read 2>/dev/null)
    
    if [[ -n "$CURRENT_LIMIT" ]]; then
        echo "Limite de charge actuelle : $CURRENT_LIMIT%"
        
        # Fournir le contexte sur la limite
        if [[ "$CURRENT_LIMIT" -eq 100 ]]; then
            echo "ℹ️ La batterie se charge à la capacité maximale (aucune limite définie)"
        elif [[ "$CURRENT_LIMIT" -ge 80 ]]; then
            echo "ℹ️ Limite de charge conservatrice pour la longévité de la batterie"
        elif [[ "$CURRENT_LIMIT" -ge 60 ]]; then
            echo "ℹ️ Limite de charge modérée pour une durée de vie de batterie prolongée"
        else
            echo "ℹ️ Limite de charge agressive pour une préservation maximale de la batterie"
        fi
    else
        echo "❌ Impossible de lire la limite de charge"
        echo "Cela peut indiquer que bclm n'est pas correctement installé ou manque de permissions"
        exit 1
    fi
else
    echo "❌ bclm non trouvé. Veuillez installer bclm d'abord."
    exit 1
fi

Rendre la Limite de Charge Persistante

#!/bin/bash

# Rendre la limite de charge persistante entre les redémarrages
echo "💾 Rendre la limite de charge persistante..."

if ! command -v bclm >/dev/null 2>&1; then
    echo "❌ bclm non trouvé. Veuillez installer bclm d'abord."
    exit 1
fi

# Obtenir la limite actuelle
CURRENT_LIMIT=$(bclm read 2>/dev/null)
if [[ -z "$CURRENT_LIMIT" ]]; then
    echo "❌ Impossible de lire la limite de charge actuelle"
    exit 1
fi

echo "Limite de charge actuelle : $CURRENT_LIMIT%"

# Rendre persistant
if sudo bclm persist; then
    echo "✅ La limite de charge ($CURRENT_LIMIT%) est maintenant persistante"
    echo "La limite sera maintenue lors des redémarrages du système"
else
    echo "❌ Échec de rendre la limite de charge persistante"
    exit 1
fi

echo "ℹ️ Pour supprimer la persistance, exécutez : sudo bclm unpersist"

Supprimer la Persistance de la Limite de Charge

#!/bin/bash

# Supprimer la persistance de la limite de charge
echo "🔄 Suppression de la persistance de la limite de charge..."

if ! command -v bclm >/dev/null 2>&1; then
    echo "❌ bclm non trouvé. Veuillez installer bclm d'abord."
    exit 1
fi

# Obtenir la limite actuelle avant de supprimer la persistance
CURRENT_LIMIT=$(bclm read 2>/dev/null)
if [[ -n "$CURRENT_LIMIT" ]]; then
    echo "Limite de charge actuelle : $CURRENT_LIMIT%"
fi

# Supprimer la persistance
if sudo bclm unpersist; then
    echo "✅ Persistance de la limite de charge supprimée"
    echo "La limite peut se réinitialiser à 100% après le prochain redémarrage"
else
    echo "❌ Échec de suppression de la persistance de la limite de charge"
    exit 1
fi

echo "ℹ️ Pour restaurer la persistance, exécutez : sudo bclm persist"

Gestion Avancée de Batterie

Vérification de Santé de Batterie d'Entreprise

#!/bin/bash

# Évaluation complète de la santé de la batterie
echo "🔋 Exécution d'une vérification complète de la santé de la batterie..."

# Vérifier si une batterie est présente
if ! system_profiler SPPowerDataType | grep -q "Battery Information"; then
    echo "❌ Aucune batterie trouvée sur ce système"
    exit 1
fi

echo "=== Évaluation de la Santé de la Batterie ==="

# Obtenir les informations de batterie
BATTERY_INFO=$(system_profiler SPPowerDataType)

# Extraire les métriques clés
CYCLE_COUNT=$(echo "$BATTERY_INFO" | grep "Cycle Count" | awk '{print $3}')
CONDITION=$(echo "$BATTERY_INFO" | grep "Condition" | awk '{print $2}')
MAX_CAPACITY=$(echo "$BATTERY_INFO" | grep "Maximum Capacity" | awk '{print $3}' | sed 's/%//')

echo "État de la Batterie : $CONDITION"
echo "Nombre de Cycles : $CYCLE_COUNT"
echo "Capacité Maximale : $MAX_CAPACITY%"

# Vérifier la limite de charge si bclm est disponible
if command -v bclm >/dev/null 2>&1; then
    CHARGING_LIMIT=$(bclm read 2>/dev/null)
    if [[ -n "$CHARGING_LIMIT" ]]; then
        echo "Limite de Charge : $CHARGING_LIMIT%"
    else
        echo "Limite de Charge : Non définie (100%)"
    fi
fi

# Informations sur l'adaptateur secteur
POWER_ADAPTER=$(echo "$BATTERY_INFO" | grep -A5 "AC Charger Information" | grep "Wattage" | awk '{print $2}')
if [[ -n "$POWER_ADAPTER" ]]; then
    echo "Adaptateur Secteur : ${POWER_ADAPTER}W"
fi

# Évaluation de santé
echo -e "\n=== Évaluation de Santé ==="

if [[ "$CONDITION" == "Normal" ]]; then
    echo "✅ L'état de la batterie est normal"
elif [[ "$CONDITION" == "Replace Soon" ]]; then
    echo "⚠️ La batterie devrait être remplacée bientôt"
elif [[ "$CONDITION" == "Replace Now" ]]; then
    echo "❌ La batterie nécessite un remplacement immédiat"
else
    echo "ℹ️ État de la batterie : $CONDITION"
fi

if [[ -n "$CYCLE_COUNT" ]]; then
    if [[ "$CYCLE_COUNT" -lt 500 ]]; then
        echo "✅ Le nombre de cycles est sain ($CYCLE_COUNT cycles)"
    elif [[ "$CYCLE_COUNT" -lt 1000 ]]; then
        echo "⚠️ Nombre de cycles modéré ($CYCLE_COUNT cycles)"
    else
        echo "❌ Nombre de cycles élevé ($CYCLE_COUNT cycles)"
    fi
fi

if [[ -n "$MAX_CAPACITY" ]]; then
    if [[ "$MAX_CAPACITY" -ge 90 ]]; then
        echo "✅ La capacité maximale est excellente ($MAX_CAPACITY%)"
    elif [[ "$MAX_CAPACITY" -ge 80 ]]; then
        echo "✅ La capacité maximale est bonne ($MAX_CAPACITY%)"
    elif [[ "$MAX_CAPACITY" -ge 70 ]]; then
        echo "⚠️ La capacité maximale décline ($MAX_CAPACITY%)"
    else
        echo "❌ La capacité maximale est faible ($MAX_CAPACITY%)"
    fi
fi

# Recommandations
echo -e "\n=== Recommandations ==="

if [[ -z "$CHARGING_LIMIT" || "$CHARGING_LIMIT" -eq 100 ]]; then
    echo "💡 Considérez définir une limite de charge (80-90%) pour une meilleure santé de batterie"
fi

if [[ "$CYCLE_COUNT" -gt 1000 && "$MAX_CAPACITY" -lt 80 ]]; then
    echo "💡 Un remplacement de batterie peut être nécessaire bientôt"
fi

Script de Gestion de Batterie d'Entreprise

#!/bin/bash

# Outil de Gestion de Batterie Roundfleet
# Gestion complète des limites de charge de batterie pour les environnements d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_battery.log"
BACKUP_DIR="/var/backups/roundfleet/battery"
REPORT_DIR="/var/reports/roundfleet/battery"
CONFIG_FILE="/etc/roundfleet/battery_policy.conf"

# Paramètres de politique de batterie
DEFAULT_CHARGING_LIMIT=80
MOBILE_DEVICE_LIMIT=90
STATIONARY_DEVICE_LIMIT=75
ENFORCE_BATTERY_POLICY=false
HEALTH_CHECK_ENABLED=true
ALERT_CAPACITY_THRESHOLD=80
ALERT_CYCLE_THRESHOLD=1000

# 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
}

# Vérifier si l'appareil a une batterie
check_battery_presence() {
    if system_profiler SPPowerDataType | grep -q "Battery Information"; then
        return 0
    else
        echo "❌ Aucune batterie trouvée sur ce système"
        log_action "Aucune batterie détectée sur l'appareil"
        return 1
    fi
}

# Installer les outils de gestion de batterie
install_battery_tools() {
    echo "🔧 Installation des outils de gestion de batterie..."
    log_action "Installation des outils de batterie démarrée"
    
    # Vérifier et installer Homebrew
    if ! command -v brew >/dev/null 2>&1; then
        echo "Installation de Homebrew..."
        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
        
        # Ajouter au PATH
        if [[ -f /opt/homebrew/bin/brew ]]; then
            eval "$(/opt/homebrew/bin/brew shellenv)"
        elif [[ -f /usr/local/bin/brew ]]; then
            eval "$(/usr/local/bin/brew shellenv)"
        fi
    fi
    
    # Installer bclm
    if ! command -v bclm >/dev/null 2>&1; then
        echo "Installation de bclm..."
        brew tap zackelia/formulae && brew install bclm
        
        if command -v bclm >/dev/null 2>&1; then
            echo "✅ bclm installé avec succès"
            log_action "bclm installé avec succès"
        else
            echo "❌ Échec de l'installation de bclm"
            log_action "Échec de l'installation de bclm"
            return 1
        fi
    else
        echo "✅ bclm déjà installé"
    fi
    
    return 0
}

# Générer un rapport de batterie complet
generate_battery_report() {
    local report_file="$REPORT_DIR/rapport_batterie_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "📊 Génération d'un rapport de batterie complet..."
    
    {
        echo "Rapport de Gestion de Batterie Roundfleet"
        echo "Généré : $(date)"
        echo "Appareil : $(hostname)"
        echo "================================="
        echo ""
        
        # Informations système
        echo "=== Informations Système ==="
        system_profiler SPHardwareDataType | grep -E "Model Name|Model Identifier|Processor|Memory"
        echo ""
        
        # Informations matérielles de batterie
        echo "=== Informations Matérielles de Batterie ==="
        local battery_info=$(system_profiler SPPowerDataType)
        echo "$battery_info" | grep -E "Condition|Cycle Count|Maximum Capacity|Manufacturer|Device Name|Pack Lot Code|PCB Lot Code|Firmware Version|Hardware Revision"
        echo ""
        
        # Limite de charge actuelle
        echo "=== Configuration de Limite de Charge ==="
        if command -v bclm >/dev/null 2>&1; then
            local current_limit=$(bclm read 2>/dev/null)
            if [[ -n "$current_limit" ]]; then
                echo "Limite de charge actuelle : $current_limit%"
                
                # Vérifier si persistant
                local smc_value=$(sudo bclm read 2>/dev/null)
                if [[ "$smc_value" == "$current_limit" ]]; then
                    echo "État de persistance : Activé"
                else
                    echo "État de persistance : Désactivé"
                fi
            else
                echo "Limite de charge actuelle : Non définie (100%)"
                echo "État de persistance : N/A"
            fi
        else
            echo "État bclm : Non installé"
        fi
        echo ""
        
        # Analyse d'utilisation d'énergie
        echo "=== Analyse d'Utilisation d'Énergie ==="
        echo "Adaptateur secteur connecté : $(system_profiler SPPowerDataType | grep -q "AC Charger Information" && echo "Oui" || echo "Non")"
        
        # Obtenir les infos de l'adaptateur si disponible
        local adapter_info=$(system_profiler SPPowerDataType | grep -A3 "AC Charger Information" | grep "Wattage")
        if [[ -n "$adapter_info" ]]; then
            echo "Adaptateur secteur : $(echo "$adapter_info" | awk '{print $2}')W"
        fi
        
        # Température et tension de batterie
        echo "Température batterie : $(ioreg -l | grep Temperature | awk '{print $3/100}' | head -1)°C"
        echo "Tension batterie : $(ioreg -l | grep Voltage | awk '{print $3/1000}' | head -1)V"
        echo ""
        
        # Évaluation de santé
        echo "=== Évaluation de Santé de Batterie ==="
        local condition=$(echo "$battery_info" | grep "Condition" | awk '{print $2}')
        local cycle_count=$(echo "$battery_info" | grep "Cycle Count" | awk '{print $3}')
        local max_capacity=$(echo "$battery_info" | grep "Maximum Capacity" | awk '{print $3}' | sed 's/%//')
        
        echo "État général : $condition"
        echo "Nombre de cycles : $cycle_count"
        echo "Capacité maximale : $max_capacity%"
        
        # Score de santé
        local health_score=100
        
        if [[ "$condition" != "Normal" ]]; then
            health_score=$((health_score - 20))
        fi
        
        if [[ -n "$cycle_count" ]]; then
            if [[ "$cycle_count" -gt 1000 ]]; then
                health_score=$((health_score - 20))
            elif [[ "$cycle_count" -gt 500 ]]; then
                health_score=$((health_score - 10))
            fi
        fi
        
        if [[ -n "$max_capacity" ]]; then
            if [[ "$max_capacity" -lt 70 ]]; then
                health_score=$((health_score - 30))
            elif [[ "$max_capacity" -lt 80 ]]; then
                health_score=$((health_score - 20))
            elif [[ "$max_capacity" -lt 90 ]]; then
                health_score=$((health_score - 10))
            fi
        fi
        
        echo "Score de santé : $health_score/100"
        
        # Recommandations
        echo ""
        echo "=== Recommandations ==="
        
        if [[ "$health_score" -ge 80 ]]; then
            echo "✅ La santé de la batterie est bonne"
            echo "💡 Considérez définir une limite de charge à 80% pour une longévité optimale"
        elif [[ "$health_score" -ge 60 ]]; then
            echo "⚠️ La santé de la batterie décline"
            echo "💡 Définissez une limite de charge à 75% et surveillez de près"
        else
            echo "❌ La santé de la batterie est faible"
            echo "💡 Considérez un remplacement de batterie et une limite immédiate à 70%"
        fi
        
    } > "$report_file"
    
    echo "📊 Rapport sauvegardé dans : $report_file"
    log_action "Rapport de batterie généré : $report_file"
}

# Fonction d'exécution principale
main() {
    local action="${1:-aide}"
    local target="${2:-}"
    
    log_action "=== Gestion de Batterie Roundfleet Démarrée ==="
    
    setup_directories
    
    case "$action" in
        "installer"|"configurer")
            install_battery_tools
            ;;
        "rapport"|"statut")
            generate_battery_report
            ;;
        "definir")
            if [[ -n "$target" ]]; then
                echo "🔋 Définition de la limite de charge à $target%..."
                if sudo bclm write "$target"; then
                    echo "✅ Limite de charge définie à $target%"
                    if sudo bclm persist; then
                        echo "✅ Limite de charge rendue persistante"
                    fi
                else
                    echo "❌ Échec de définition de la limite de charge"
                fi
            else
                echo "❌ Veuillez spécifier un pourcentage"
                echo "Usage: $0 definir <pourcentage>"
            fi
            ;;
        "lire"|"actuel")
            if command -v bclm >/dev/null 2>&1; then
                local current=$(bclm read 2>/dev/null)
                if [[ -n "$current" ]]; then
                    echo "Limite de charge actuelle : $current%"
                else
                    echo "Aucune limite de charge définie (100%)"
                fi
            else
                echo "❌ bclm non installé"
            fi
            ;;
        "persistant")
            if command -v bclm >/dev/null 2>&1; then
                if sudo bclm persist; then
                    echo "✅ Limite de charge rendue persistante"
                else
                    echo "❌ Échec de rendre la limite de charge persistante"
                fi
            else
                echo "❌ bclm non installé"
            fi
            ;;
        "non-persistant")
            if command -v bclm >/dev/null 2>&1; then
                if sudo bclm unpersist; then
                    echo "✅ Persistance de limite de charge supprimée"
                else
                    echo "❌ Échec de suppression de la persistance de limite de charge"
                fi
            else
                echo "❌ bclm non installé"
            fi
            ;;
        "sante")
            if check_battery_presence; then
                local battery_info=$(system_profiler SPPowerDataType)
                echo "=== Résumé de Santé de Batterie ==="
                echo "$battery_info" | grep -E "Condition|Cycle Count|Maximum Capacity"
                
                if command -v bclm >/dev/null 2>&1; then
                    local limit=$(bclm read 2>/dev/null)
                    echo "Limite de Charge : ${limit:-100}%"
                fi
            fi
            ;;
        "aide"|*)
            echo "Outil de Gestion de Batterie Roundfleet"
            echo "Utilisation : $0 [action] [options]"
            echo ""
            echo "Actions :"
            echo "  installer             - Installer les outils de gestion de batterie (Homebrew, bclm)"
            echo "  rapport               - Générer un rapport de batterie complet"
            echo "  definir [limite]      - Définir la limite de charge optimale (ou spécifier pourcentage)"
            echo "  lire                  - Lire la limite de charge actuelle"
            echo "  persistant            - Rendre la limite de charge persistante"
            echo "  non-persistant        - Supprimer la persistance de limite de charge"
            echo "  sante                 - Afficher le résumé de santé de batterie"
            echo "  aide                  - Afficher ce message d'aide"
            echo ""
            echo "Exemples :"
            echo "  $0 installer          # Installer les outils requis"
            echo "  $0 definir 80         # Définir limite de charge à 80%"
            echo "  $0 rapport            # Générer rapport détaillé"
            echo ""
            echo "Directives de Limite de Charge :"
            echo "  50-100%     - Plage valide"
            echo "  80%         - Recommandé pour la plupart des appareils"
            echo "  75%         - Pour les Macs stationnaires/de bureau"
            echo "  90%         - Pour les Macs mobiles/portables"
            ;;
    esac
    
    log_action "=== Gestion de Batterie Roundfleet Terminée ==="
}

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

Surveillance de la Santé de Batterie

Vérifications de Santé Automatisées

# Planifier la surveillance quotidienne de la santé de batterie
create_health_monitoring_schedule() {
    local plist_file="$HOME/Library/LaunchAgents/com.roundfleet.battery-monitor.plist"
    
    cat > "$plist_file" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.roundfleet.battery-monitor</string>
    <key>ProgramArguments</key>
    <array>
        <string>/bin/bash</string>
        <string>$(realpath "$0")</string>
        <string>surveiller</string>
    </array>
    <key>StartCalendarInterval</key>
    <dict>
        <key>Hour</key>
        <integer>9</integer>
        <key>Minute</key>
        <integer>0</integer>
    </dict>
    <key>RunAtLoad</key>
    <false/>
</dict>
</plist>
EOF
    
    launchctl load "$plist_file" 2>/dev/null
    echo "✅ Surveillance quotidienne de batterie planifiée"
}

Recommandations de Limite de Charge

Notes Importantes

• Appareils Supportés - Fonctionne uniquement sur les appareils Mac avec batteries
• Privilèges Administrateur - Nécessite un accès sudo pour les modifications SMC
• Compatibilité Système - Compatible avec les versions macOS modernes
• Exigences de Redémarrage - Certains changements peuvent nécessiter un redémarrage système
• Déploiement de Flotte - Testez sur des appareils individuels avant le déploiement en bloc
• Santé de Batterie - Surveillez régulièrement l'état de la batterie pour des résultats optimaux

Contrôlez et gérez les notifications de badge sur vos appareils Roundfleet en utilisant des outils en ligne de commande. Ce tutoriel couvre la suppression des notifications de badge pour des applications spécifiques, la gestion des notifications à l'échelle du dock, et l'implémentation de politiques de notification d'entreprise.

Comprendre les Notifications de Badge

Les notifications de badge sont les icônes circulaires rouges qui apparaissent au-dessus des icônes d'application dans le dock macOS, affichant généralement des numéros pour indiquer des éléments non lus comme des emails, messages ou mises à jour. Bien qu'utiles pour les utilisateurs individuels, les environnements d'entreprise nécessitent souvent une gestion centralisée des notifications.

Fonctionnalités Clés

• Contrôle spécifique aux applications - Supprimer les badges d'applications individuelles
• Gestion à l'échelle du dock - Effacer toutes les notifications de badge en une fois
• Restauration automatique - Les badges réapparaissent lorsque les applications sont ouvertes
• Intégration des préférences système - Fonctionne avec les paramètres de notification macOS

Supprimer les Notifications de Badge pour des Applications Spécifiques

Suppression de Badge Basique

#!/bin/bash

# Supprimer la notification de badge pour une application spécifique
APP_NAME="Mail"

defaults write com.apple.systempreferences AttentionPrefBundleIDs 0 && killall "$APP_NAME"

echo "Notification de badge supprimée pour $APP_NAME"

Gestion Avancée des Badges d'Application

#!/bin/bash

# Suppression avancée de notification de badge avec validation
remove_app_badge() {
    local app_name="$1"
    
    if [[ -z "$app_name" ]]; then
        echo "❌ Erreur : Nom d'application requis"
        return 1
    fi
    
    # Vérifier si l'application est en cours d'exécution
    if pgrep -x "$app_name" > /dev/null; then
        echo "📱 Suppression de la notification de badge pour $app_name..."
        
        # Supprimer la notification de badge
        defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
        
        # Terminer et redémarrer l'application pour appliquer les changements
        if killall "$app_name" 2>/dev/null; then
            echo "✅ Notification de badge supprimée pour $app_name"
            echo "ℹ️  Note : Le badge réapparaîtra lorsque $app_name sera rouvert"
        else
            echo "⚠️  Avertissement : Impossible de redémarrer $app_name (peut ne pas être en cours d'exécution)"
        fi
    else
        echo "ℹ️  $app_name n'est pas actuellement en cours d'exécution"
        defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
        echo "✅ Paramètre de notification de badge mis à jour pour $app_name"
    fi
}

# Exemples d'utilisation
remove_app_badge "Mail"
remove_app_badge "Messages"
remove_app_badge "Calendar"

Suppression des Badges d'Applications Communes

#!/bin/bash

# Supprimer les notifications de badge pour les applications d'entreprise communes
COMMON_APPS=("Mail" "Messages" "Calendar" "Reminders" "FaceTime" "App Store" "System Preferences")

echo "🧹 Suppression des notifications de badge pour les applications communes..."

for app in "${COMMON_APPS[@]}"; do
    echo "Traitement de $app..."
    
    # Définir la préférence de notification
    defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
    
    # Tuer l'application si elle est en cours d'exécution
    if pgrep -x "$app" > /dev/null; then
        killall "$app" 2>/dev/null
        echo "  ✅ Badge effacé pour $app"
    else
        echo "  ⏭️  $app n'est pas en cours d'exécution, préférence mise à jour"
    fi
done

echo "🎉 Nettoyage des notifications de badge terminé"

Supprimer Toutes les Notifications de Badge (À l'échelle du Dock)

Effacement Basique des Badges du Dock

#!/bin/bash

# Supprimer toutes les notifications de badge du dock
defaults write com.apple.systempreferences AttentionPrefBundleIDs 0 && killall Dock

echo "Toutes les notifications de badge effacées du dock"

Gestion Complète du Dock

#!/bin/bash

# Gestion avancée des notifications de badge du dock
clear_all_dock_badges() {
    echo "🏗️  Effacement de toutes les notifications de badge du dock..."
    
    # Sauvegarder les préférences actuelles du dock
    local backup_file="/tmp/dock_backup_$(date +%s).plist"
    defaults export com.apple.dock "$backup_file"
    echo "📋 Préférences du dock sauvegardées dans : $backup_file"
    
    # Effacer les notifications de badge
    defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
    
    # Obtenir la liste des applications du dock en cours d'exécution
    local dock_apps
    dock_apps=$(osascript -e 'tell application "System Events" to get name of every application process whose background only is false')
    
    echo "🔄 Redémarrage du dock pour appliquer les changements..."
    killall Dock
    
    # Attendre que le dock redémarre
    sleep 3
    
    echo "✅ Toutes les notifications de badge effacées du dock"
    echo "ℹ️  Les badges réapparaîtront lorsque les applications recevront de nouvelles notifications"
    
    return 0
}

# Exécuter l'effacement des badges du dock
clear_all_dock_badges

Script de Gestion des Badges d'Entreprise

#!/bin/bash

# Outil de Gestion des Notifications de Badge Roundfleet
# Contrôle centralisé des notifications de badge sur les appareils d'entreprise

# Configuration
LOG_FILE="/var/log/roundfleet_badges.log"
CONFIG_FILE="/etc/roundfleet/badge_policy.conf"
BACKUP_DIR="/var/backups/roundfleet/badges"

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

# Créer les répertoires nécessaires
setup_directories() {
    sudo mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null
    sudo mkdir -p "$BACKUP_DIR" 2>/dev/null
    sudo mkdir -p "$(dirname "$CONFIG_FILE")" 2>/dev/null
}

# Charger la configuration
load_config() {
    if [[ -f "$CONFIG_FILE" ]]; then
        source "$CONFIG_FILE"
        log_action "Configuration chargée depuis $CONFIG_FILE"
    else
        # Configuration par défaut
        BADGE_POLICY="disabled"  # Options : enabled, disabled, selective
        ALLOWED_BADGE_APPS=("Calendar" "Reminders")
        BLOCKED_BADGE_APPS=("App Store" "System Preferences")
        AUTO_CLEAR_INTERVAL=3600  # 1 heure
        
        log_action "Utilisation de la configuration par défaut"
    fi
}

# Sauvegarder les paramètres de badge actuels
backup_badge_settings() {
    local backup_file="$BACKUP_DIR/badge_settings_$(date +%Y%m%d_%H%M%S).plist"
    
    defaults export com.apple.systempreferences "$backup_file" 2>/dev/null
    
    if [[ -f "$backup_file" ]]; then
        log_action "Paramètres de badge sauvegardés dans : $backup_file"
        echo "$backup_file"
    else
        log_action "Avertissement : Impossible de sauvegarder les paramètres de badge"
        return 1
    fi
}

# Obtenir le statut actuel des badges
get_badge_status() {
    echo "📊 Statut Actuel des Notifications de Badge :"
    echo "============================================="
    
    # Vérifier le paramètre des préférences système
    local attention_pref
    attention_pref=$(defaults read com.apple.systempreferences AttentionPrefBundleIDs 2>/dev/null || echo "non défini")
    echo "AttentionPrefBundleIDs du système : $attention_pref"
    
    # Lister les applications avec des badges potentiels
    echo -e "\n📱 Applications pouvant afficher des badges :"
    local badge_apps=("Mail" "Messages" "Calendar" "Reminders" "FaceTime" "App Store" "System Preferences" "Contacts")
    
    for app in "${badge_apps[@]}"; do
        if pgrep -x "$app" > /dev/null; then
            echo "  🟢 $app (en cours d'exécution)"
        else
            echo "  ⚪ $app (non en cours d'exécution)"
        fi
    done
    
    # Vérifier les processus du dock
    echo -e "\n🏗️  Statut du dock :"
    if pgrep -x "Dock" > /dev/null; then
        echo "  🟢 Le dock est en cours d'exécution"
    else
        echo "  🔴 Le dock n'est pas en cours d'exécution"
    fi
}

# Appliquer la politique de badge
apply_badge_policy() {
    log_action "Application de la politique de badge : $BADGE_POLICY"
    
    case "$BADGE_POLICY" in
        "disabled")
            disable_all_badges
            ;;
        "enabled")
            enable_all_badges
            ;;
        "selective")
            apply_selective_policy
            ;;
        *)
            log_action "Erreur : Politique de badge inconnue : $BADGE_POLICY"
            return 1
            ;;
    esac
}

# Désactiver toutes les notifications de badge
disable_all_badges() {
    echo "🚫 Désactivation de toutes les notifications de badge..."
    
    backup_badge_settings
    
    # Définir la préférence système pour désactiver les badges
    defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
    
    # Redémarrer le dock pour appliquer les changements
    killall Dock 2>/dev/null
    
    log_action "Toutes les notifications de badge désactivées"
    echo "✅ Toutes les notifications de badge ont été désactivées"
}

# Activer toutes les notifications de badge
enable_all_badges() {
    echo "✅ Activation de toutes les notifications de badge..."
    
    backup_badge_settings
    
    # Supprimer la restriction (supprimer la clé)
    defaults delete com.apple.systempreferences AttentionPrefBundleIDs 2>/dev/null
    
    # Redémarrer le dock pour appliquer les changements
    killall Dock 2>/dev/null
    
    log_action "Toutes les notifications de badge activées"
    echo "✅ Toutes les notifications de badge ont été activées"
}

# Appliquer une politique de badge sélective
apply_selective_policy() {
    echo "🎯 Application de la politique de badge sélective..."
    
    # Pour la politique sélective, nous devons gérer les notifications d'applications individuelles
    # Cela nécessite une gestion plus complexe des notifications
    
    for app in "${BLOCKED_BADGE_APPS[@]}"; do
        echo "  🚫 Blocage des badges pour $app"
        # Tuer l'application pour effacer le badge actuel
        killall "$app" 2>/dev/null
    done
    
    # Définir la préférence système
    defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
    
    log_action "Politique de badge sélective appliquée"
    echo "✅ La politique de badge sélective a été appliquée"
}

# Surveiller et effacer automatiquement les badges
monitor_badges() {
    echo "👁️  Démarrage de la surveillance des badges (intervalle : ${AUTO_CLEAR_INTERVAL}s)..."
    
    while true; do
        if [[ "$BADGE_POLICY" == "disabled" ]]; then
            # Effacer les badges qui peuvent être apparus
            defaults write com.apple.systempreferences AttentionPrefBundleIDs 0
            log_action "Badges effacés automatiquement pendant la surveillance"
        fi
        
        sleep "$AUTO_CLEAR_INTERVAL"
    done
}

# Générer un rapport de gestion des badges
generate_report() {
    local report_file="/tmp/roundfleet_badge_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport de Notification de Badge Roundfleet"
        echo "========================================"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Politique : $BADGE_POLICY"
        echo ""
        
        echo "Configuration Système :"
        echo "  AttentionPrefBundleIDs : $(defaults read com.apple.systempreferences AttentionPrefBundleIDs 2>/dev/null || echo 'non défini')"
        echo ""
        
        echo "Statut des Applications :"
        local apps=("Mail" "Messages" "Calendar" "Reminders" "App Store")
        for app in "${apps[@]}"; do
            if pgrep -x "$app" > /dev/null; then
                echo "  $app : En cours d'exécution"
            else
                echo "  $app : Non en cours d'exécution"
            fi
        done
        
        echo ""
        echo "Actions Récentes :"
        tail -10 "$LOG_FILE" 2>/dev/null || echo "Aucune entrée de journal récente"
        
    } > "$report_file"
    
    echo "📄 Rapport de gestion des badges généré : $report_file"
    log_action "Rapport généré : $report_file"
}

# Fonction principale
main() {
    case "${1:-status}" in
        "disable")
            setup_directories
            load_config
            log_action "=== Gestion des Badges : Désactiver Tout ==="
            disable_all_badges
            ;;
        "enable")
            setup_directories
            load_config
            log_action "=== Gestion des Badges : Activer Tout ==="
            enable_all_badges
            ;;
        "policy")
            setup_directories
            load_config
            log_action "=== Gestion des Badges : Appliquer la Politique ==="
            apply_badge_policy
            ;;
        "monitor")
            setup_directories
            load_config
            log_action "=== Gestion des Badges : Démarrer la Surveillance ==="
            monitor_badges
            ;;
        "report")
            setup_directories
            load_config
            generate_report
            ;;
        "status"|*)
            setup_directories
            load_config
            get_badge_status
            ;;
    esac
}

# Exécuter la fonction principale avec les paramètres
main "$@"