Guide

Nouvelles mises à jour et améliorations de Roundfleet.
Suivez-nous sur X.com

Avis important

Les exemples de code et scripts fournis dans ces tutoriels sont uniquement à des fins éducatives. Roundfleet n'est pas responsable des problèmes, dommages ou vulnérabilités de sécurité qui pourraient survenir lors de l'utilisation, modification ou implémentation de ces exemples. Toujours vérifier et tester le code dans un environnement sécurisé avant de l'utiliser dans des systèmes de production.

← Tous les articles

Sonnerie à Distance et Gestion de Localisation d'Appareils sur macOS

Gérez la localisation d'appareils et les alertes audio sur vos appareils Roundfleet avec une fonctionnalité de sonnerie à distance complète, le suivi de localisation et les solutions de récupération d'appareils d'entreprise. Ce tutoriel couvre l'implémentation de sonnerie à distance, la gestion audio et les services de localisation d'appareils à l'échelle de la flotte.

Comprendre la Sonnerie à Distance et la Localisation d'Appareils

La fonctionnalité de sonnerie à distance sur macOS fournit des capacités essentielles de localisation d'appareils :

  • Alertes Audio - Jouer des sons pour aider à localiser les appareils à proximité
  • Localisation d'Appareils - Trouver les appareils égarés ou perdus dans les environnements d'entreprise
  • Gestion de Flotte - Suivi et récupération d'appareils centralisés
  • Amélioration de Sécurité - Capacités anti-vol et de récupération d'appareils

Cas d'Usage d'Entreprise

La sonnerie à distance et les services de localisation bénéficient aux environnements d'entreprise :

  • Récupération d'Actifs - Localiser rapidement les appareils égarés dans de grands bureaux
  • Réponse de Sécurité - Alertes audio pour la prévention du vol et la récupération d'appareils
  • Gestion d'Inventaire - Suivre les emplacements d'appareils pendant les audits et transitions
  • Protocoles d'Urgence - Localiser les appareils pendant les évacuations ou urgences
  • Assistance Utilisateur - Aider les utilisateurs à trouver leurs appareils sans intervention IT

Implémentation de Base de Sonnerie à Distance

Script Simple de Sonnerie à Distance

#!/bin/bash

# Implémentation basique de sonnerie à distance
basic_remote_ring() {
    local ring_count="${1:-5}"
    local sound_file="${2:-/System/Library/Sounds/Submarine.aiff}"
    
    echo "=== Sonnerie à Distance Basique ==="
    echo "Nombre de sonneries : $ring_count"
    echo "Fichier son : $sound_file"
    echo ""
    
    # Valider que le fichier son existe
    if [[ ! -f "$sound_file" ]]; then
        echo "Erreur : Fichier son non trouvé : $sound_file"
        echo "Utilisation du son système par défaut..."
        sound_file="/System/Library/Sounds/Ping.aiff"
    fi
    
    # Exécuter la sonnerie à distance
    local count=1
    while [[ $count -le $ring_count ]]; do
        echo "Sonnerie $count sur $ring_count"
        afplay "$sound_file"
        count=$(( count + 1 ))
        
        # Ajouter un petit délai entre les sonneries pour une meilleure séparation audio
        sleep 1
    done
    
    echo "Sonnerie à distance terminée : $ring_count sonneries jouées"
}

# Sonnerie à distance améliorée avec validation
enhanced_remote_ring() {
    local ring_count="${1:-5}"
    local sound_file="${2:-/System/Library/Sounds/Submarine.aiff}"
    local volume_level="${3:-75}"
    
    echo "=== Sonnerie à Distance Améliorée ==="
    echo "Nombre de sonneries : $ring_count"
    echo "Fichier son : $sound_file"
    echo "Niveau de volume : $volume_level%"
    echo ""
    
    # Définir le volume système
    osascript -e "set volume output volume $volume_level"
    
    # Valider les paramètres
    if [[ $ring_count -lt 1 || $ring_count -gt 50 ]]; then
        echo "Avertissement : Le nombre de sonneries doit être entre 1 et 50, utilisation par défaut de 5"
        ring_count=5
    fi
    
    # Jouer les sonneries avec retour amélioré
    local count=1
    while [[ $count -le $ring_count ]]; do
        echo "Sonnerie $count/$ring_count - $(date '+%H:%M:%S')"
        
        if afplay "$sound_file" 2>/dev/null; then
            echo "✓ Sonnerie jouée avec succès"
        else
            echo "✗ Échec de lecture de sonnerie"
        fi
        
        count=$(( count + 1 ))
        
        # Délai progressif (plus court pour plusieurs sonneries)
        if [[ $ring_count -gt 1 ]]; then
            sleep 0.5
        fi
    done
    
    echo "Sonnerie à distance améliorée terminée à $(date '+%H:%M:%S')"
}

# Exemples d'utilisation
# basic_remote_ring 3
# enhanced_remote_ring 5 "/System/Library/Sounds/Glass.aiff" 80

Sons Système Disponibles

#!/bin/bash

# Lister et tester les sons système disponibles
list_system_sounds() {
    echo "=== Sons Système Disponibles ==="
    echo "Emplacement : /System/Library/Sounds/"
    echo ""
    
    local sounds_dir="/System/Library/Sounds"
    
    if [[ -d "$sounds_dir" ]]; then
        echo "Fichiers son disponibles :"
        ls -1 "$sounds_dir"/*.aiff 2>/dev/null | while read -r sound_file; do
            local sound_name=$(basename "$sound_file" .aiff)
            echo "  - $sound_name"
        done
    else
        echo "Répertoire des sons système non trouvé"
    fi
    
    echo ""
    echo "Choix populaires pour sonnerie à distance :"
    echo "  - Submarine.aiff (profond, attire l'attention)"
    echo "  - Glass.aiff (clair, distinctif)"
    echo "  - Ping.aiff (aigu, remarquable)"
    echo "  - Sosumi.aiff (son Mac classique)"
    echo "  - Purr.aiff (option plus douce)"
}

# Tester un fichier son spécifique
test_sound_file() {
    local sound_file="$1"
    
    if [[ -z "$sound_file" ]]; then
        echo "Usage : test_sound_file <chemin_fichier_son>"
        return 1
    fi
    
    echo "Test du fichier son : $sound_file"
    
    if [[ -f "$sound_file" ]]; then
        echo "Lecture du son de test..."
        afplay "$sound_file"
        echo "✓ Test de son terminé"
    else
        echo "✗ Fichier son non trouvé : $sound_file"
        return 1
    fi
}

# Usage
list_system_sounds

Gestion du Volume et Audio

#!/bin/bash

# Gérer le volume système pour sonnerie à distance
manage_system_volume() {
    local action="${1:-get}"
    local volume_level="${2:-50}"
    
    case "$action" in
        "get")
            echo "=== Volume Système Actuel ==="
            local current_volume=$(osascript -e "output volume of (get volume settings)")
            echo "Volume actuel : $current_volume%"
            
            # Vérifier si en sourdine
            local mute_status=$(osascript -e "output muted of (get volume settings)")
            if [[ "$mute_status" == "true" ]]; then
                echo "Statut : EN SOURDINE"
            else
                echo "Statut : SON ACTIVÉ"
            fi
            ;;
        "set")
            echo "=== Définition Volume Système ==="
            echo "Volume cible : $volume_level%"
            
            # Désactiver sourdine si activée
            osascript -e "set volume without output muted"
            
            # Définir le niveau de volume
            osascript -e "set volume output volume $volume_level"
            
            echo "✓ Volume défini à $volume_level%"
            ;;
        "mute")
            echo "=== Mise en Sourdine Système ==="
            osascript -e "set volume with output muted"
            echo "✓ Système mis en sourdine"
            ;;
        "unmute")
            echo "=== Désactivation Sourdine Système ==="
            osascript -e "set volume without output muted"
            echo "✓ Sourdine système désactivée"
            ;;
        "max")
            echo "=== Définition Volume Maximum ==="
            osascript -e "set volume without output muted"
            osascript -e "set volume output volume 100"
            echo "✓ Volume défini au maximum (100%)"
            ;;
        *)
            echo "Usage : manage_system_volume [get|set|mute|unmute|max] [niveau_volume]"
            return 1
            ;;
    esac
}

# Surcharge de volume d'urgence pour sonnerie à distance
emergency_volume_override() {
    echo "=== Surcharge de Volume d'Urgence ==="
    echo "Surcharge de tous les paramètres audio pour audibilité maximale"
    
    # Stocker les paramètres actuels
    local current_volume=$(osascript -e "output volume of (get volume settings)")
    local current_mute=$(osascript -e "output muted of (get volume settings)")
    
    echo "Paramètres actuels sauvegardés - Volume : $current_volume%, Sourdine : $current_mute"
    
    # Définir le volume d'urgence
    osascript -e "set volume without output muted"
    osascript -e "set volume output volume 100"
    
    echo "✓ Volume d'urgence activé (100%, son activé)"
    
    # Fonction de retour pour restaurer les paramètres
    echo "Pour restaurer les paramètres précédents, exécuter :"
    echo "osascript -e \"set volume output volume $current_volume\""
    if [[ "$current_mute" == "true" ]]; then
        echo "osascript -e \"set volume with output muted\""
    fi
}

# Usage
manage_system_volume "get"

Fonctionnalités Avancées de Sonnerie à Distance

Système de Sonnerie à Distance Intelligent

#!/bin/bash

# Sonnerie à distance intelligente avec comportement adaptatif
intelligent_remote_ring() {
    local ring_pattern="${1:-standard}"
    local duration="${2:-30}"
    local priority_level="${3:-normal}"
    
    echo "=== Système de Sonnerie à Distance Intelligent ==="
    echo "Motif : $ring_pattern"
    echo "Durée : ${duration}s"
    echo "Priorité : $priority_level"
    echo ""
    
    # Définir le volume basé sur la priorité
    case "$priority_level" in
        "low")
            local volume=40
            local sound="/System/Library/Sounds/Purr.aiff"
            ;;
        "normal")
            local volume=70
            local sound="/System/Library/Sounds/Submarine.aiff"
            ;;
        "high")
            local volume=85
            local sound="/System/Library/Sounds/Glass.aiff"
            ;;
        "emergency")
            local volume=100
            local sound="/System/Library/Sounds/Sosumi.aiff"
            emergency_volume_override
            ;;
        *)
            local volume=70
            local sound="/System/Library/Sounds/Submarine.aiff"
            ;;
    esac
    
    # Définir le volume système
    osascript -e "set volume output volume $volume"
    
    # Exécuter le motif de sonnerie
    case "$ring_pattern" in
        "standard")
            standard_ring_pattern "$duration" "$sound"
            ;;
        "pulse")
            pulse_ring_pattern "$duration" "$sound"
            ;;
        "escalating")
            escalating_ring_pattern "$duration" "$sound"
            ;;
        "morse_sos")
            morse_sos_pattern "$duration" "$sound"
            ;;
        "heartbeat")
            heartbeat_pattern "$duration" "$sound"
            ;;
        *)
            echo "Motif inconnu : $ring_pattern, utilisation standard"
            standard_ring_pattern "$duration" "$sound"
            ;;
    esac
}

# Motif de sonnerie standard
standard_ring_pattern() {
    local duration="$1"
    local sound="$2"
    local end_time=$(($(date +%s) + duration))
    
    echo "Lecture motif sonnerie standard pour ${duration}s"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        afplay "$sound"
        sleep 2
    done
}

# Motif de sonnerie pulsée (rafales rapides)
pulse_ring_pattern() {
    local duration="$1"
    local sound="$2"
    local end_time=$(($(date +%s) + duration))
    
    echo "Lecture motif sonnerie pulsée pour ${duration}s"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        # Triple pulsation
        for i in {1..3}; do
            afplay "$sound" &
            sleep 0.3
        done
        sleep 2
    done
}

# Motif de sonnerie croissante (fréquence augmentant)
escalating_ring_pattern() {
    local duration="$1"
    local sound="$2"
    local end_time=$(($(date +%s) + duration))
    local sleep_interval=3
    
    echo "Lecture motif sonnerie croissante pour ${duration}s"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        afplay "$sound"
        sleep $sleep_interval
        
        # Diminuer l'intervalle (augmenter la fréquence)
        if [[ $sleep_interval -gt 1 ]]; then
            sleep_interval=$((sleep_interval - 1))
        fi
    done
}

# Motif code Morse SOS
morse_sos_pattern() {
    local duration="$1"
    local sound="$2"
    local end_time=$(($(date +%s) + duration))
    
    echo "Lecture motif Morse SOS pour ${duration}s"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        # S (3 courts)
        for i in {1..3}; do
            afplay "$sound" &
            sleep 0.2
            sleep 0.3
        done
        sleep 0.5
        
        # O (3 longs)
        for i in {1..3}; do
            afplay "$sound" &
            sleep 0.6
            sleep 0.3
        done
        sleep 0.5
        
        # S (3 courts)
        for i in {1..3}; do
            afplay "$sound" &
            sleep 0.2
            sleep 0.3
        done
        
        sleep 3
    done
}

# Motif battement de cœur
heartbeat_pattern() {
    local duration="$1"
    local sound="$2"
    local end_time=$(($(date +%s) + duration))
    
    echo "Lecture motif battement de cœur pour ${duration}s"
    
    while [[ $(date +%s) -lt $end_time ]]; do
        # Double battement
        afplay "$sound" &
        sleep 0.2
        afplay "$sound" &
        sleep 1.5
    done
}

# Exemples d'utilisation
# intelligent_remote_ring "pulse" 30 "high"
# intelligent_remote_ring "morse_sos" 60 "emergency"

Gestion de Sonnerie Basée sur la Localisation

#!/bin/bash

# Sonnerie à distance consciente de la localisation
location_based_ring() {
    local location_context="${1:-office}"
    local time_context="${2:-business_hours}"
    
    echo "=== Gestion de Sonnerie Basée sur la Localisation ==="
    echo "Contexte de localisation : $location_context"
    echo "Contexte temporel : $time_context"
    echo ""
    
    # Déterminer les paramètres de sonnerie appropriés basés sur le contexte
    case "$location_context" in
        "office")
            handle_office_environment "$time_context"
            ;;
        "meeting_room")
            handle_meeting_room_environment "$time_context"
            ;;
        "public_space")
            handle_public_space_environment "$time_context"
            ;;
        "home_office")
            handle_home_office_environment "$time_context"
            ;;
        "warehouse")
            handle_warehouse_environment "$time_context"
            ;;
        *)
            echo "Contexte de localisation inconnu, utilisation paramètres par défaut"
            intelligent_remote_ring "standard" 30 "normal"
            ;;
    esac
}

# Paramètres environnement bureau
handle_office_environment() {
    local time_context="$1"
    
    echo "Configuration pour environnement bureau..."
    
    case "$time_context" in
        "business_hours")
            # Volume modéré, son professionnel
            intelligent_remote_ring "standard" 20 "normal"
            ;;
        "after_hours")
            # Volume plus élevé, plus accrocheur
            intelligent_remote_ring "escalating" 45 "high"
            ;;
        "lunch_break")
            # Approche plus douce pendant les pauses
            intelligent_remote_ring "pulse" 25 "low"
            ;;
    esac
}

# Paramètres environnement salle de réunion
handle_meeting_room_environment() {
    local time_context="$1"
    
    echo "Configuration pour environnement salle de réunion..."
    
    # Toujours utiliser paramètres discrets dans les zones de réunion
    intelligent_remote_ring "heartbeat" 15 "low"
}

# Paramètres environnement espace public
handle_public_space_environment() {
    local time_context="$1"
    
    echo "Configuration pour environnement espace public..."
    
    # Discret mais efficace
    intelligent_remote_ring "pulse" 30 "normal"
}

# Paramètres environnement bureau à domicile
handle_home_office_environment() {
    local time_context="$1"
    
    echo "Configuration pour environnement bureau à domicile..."
    
    case "$time_context" in
        "business_hours")
            # Peut être plus assertif à domicile
            intelligent_remote_ring "escalating" 40 "high"
            ;;
        "evening")
            # Respectueux du foyer
            intelligent_remote_ring "standard" 20 "low"
            ;;
    esac
}

# Paramètres environnement entrepôt
handle_warehouse_environment() {
    local time_context="$1"
    
    echo "Configuration pour environnement entrepôt..."
    
    # Environnement bruyant nécessite volume maximum
    intelligent_remote_ring "morse_sos" 60 "emergency"
}

# Usage
# location_based_ring "office" "business_hours"

Système de Gestion de Sonnerie à Distance d'Entreprise

#!/bin/bash

# Outil de Gestion de Sonnerie à Distance et Localisation d'Appareils Roundfleet
# Localisation d'appareils complète, alertes audio et suivi de flotte

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_remote_ring.log"
REPORT_DIR="/etc/roundfleet/reports/location"
CONFIG_DIR="/etc/roundfleet/location"
SOUND_DIR="/etc/roundfleet/sounds"
POLICY_DIR="/etc/roundfleet/policies/location"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$SOUND_DIR" "$POLICY_DIR"

# Politiques de sonnerie pour différents scénarios
declare -A RING_POLICIES=(
    ["standard_office"]="volume:70,pattern:standard,duration:30,sound:submarine"
    ["quiet_environment"]="volume:40,pattern:pulse,duration:15,sound:purr"
    ["emergency_locate"]="volume:100,pattern:morse_sos,duration:120,sound:sosumi"
    ["meeting_room"]="volume:30,pattern:heartbeat,duration:10,sound:glass"
    ["warehouse_floor"]="volume:100,pattern:escalating,duration:60,sound:submarine"
    ["public_area"]="volume:60,pattern:pulse,duration:25,sound:ping"
    ["after_hours"]="volume:85,pattern:escalating,duration:45,sound:glass"
    ["healthcare_facility"]="volume:50,pattern:heartbeat,duration:20,sound:purr"
    ["education_campus"]="volume:65,pattern:standard,duration:30,sound:ping"
    ["retail_store"]="volume:75,pattern:pulse,duration:35,sound:submarine"
)

# Configurations de suivi de localisation
declare -A LOCATION_CONFIGS=(
    ["high_security"]="gps_tracking,wifi_triangulation,bluetooth_beacons,audit_logging"
    ["standard_office"]="wifi_tracking,bluetooth_detection,basic_logging"
    ["public_access"]="limited_tracking,privacy_compliant,minimal_logging"
    ["healthcare"]="hipaa_compliant,secure_tracking,encrypted_logs,audit_trail"
    ["education"]="ferpa_compliant,student_privacy,controlled_tracking,parent_notification"
    ["retail"]="customer_privacy,basic_tracking,loss_prevention,inventory_integration"
)

# Niveaux de réponse d'urgence
declare -A EMERGENCY_LEVELS=(
    ["green"]="normal_operation,standard_ring,basic_logging"
    ["yellow"]="elevated_response,enhanced_ring,increased_logging"
    ["orange"]="urgent_response,emergency_ring,comprehensive_logging"
    ["red"]="critical_response,maximum_ring,full_audit_trail"
)

# Fonction de journalisation
log_action() {
    local message="$1"
    local severity="${2:-INFO}"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] [$severity] $message" | tee -a "$LOG_FILE"
}

# Sonnerie à distance d'entreprise avec gestion complète
enterprise_remote_ring() {
    local device_id="${1:-$(hostname)}"
    local ring_policy="${2:-standard_office}"
    local location_context="${3:-office}"
    local emergency_level="${4:-green}"
    local initiated_by="${5:-$(whoami)}"
    
    log_action "Démarrage sonnerie à distance d'entreprise" "INFO"
    log_action "Appareil : $device_id, Politique : $ring_policy, Contexte : $location_context" "INFO"
    
    echo "=== Gestion de Sonnerie à Distance d'Entreprise ==="
    echo "ID Appareil : $device_id"
    echo "Politique de Sonnerie : $ring_policy"
    echo "Contexte de Localisation : $location_context"
    echo "Niveau d'Urgence : $emergency_level"
    echo "Initié Par : $initiated_by"
    echo "ID Sonnerie : $(uuidgen)"
    echo ""
    
    # Analyser la politique de sonnerie
    local policy_settings="${RING_POLICIES[$ring_policy]}"
    if [[ -z "$policy_settings" ]]; then
        log_action "Politique de sonnerie inconnue : $ring_policy, utilisation standard_office" "WARNING"
        policy_settings="${RING_POLICIES[standard_office]}"
    fi
    
    # Extraire les paramètres de politique
    local volume=$(echo "$policy_settings" | grep -o 'volume:[0-9]*' | cut -d: -f2)
    local pattern=$(echo "$policy_settings" | grep -o 'pattern:[^,]*' | cut -d: -f2)
    local duration=$(echo "$policy_settings" | grep -o 'duration:[0-9]*' | cut -d: -f2)
    local sound=$(echo "$policy_settings" | grep -o 'sound:[^,]*' | cut -d: -f2)
    
    echo "--- Configuration de Politique ---"
    echo "Volume : $volume%"
    echo "Motif : $pattern"
    echo "Durée : ${duration}s"
    echo "Son : $sound"
    
    # Appliquer les modifications de niveau d'urgence
    apply_emergency_modifications "$emergency_level" volume pattern duration
    
    # Exécuter les vérifications pré-sonnerie
    if ! pre_ring_validation "$device_id" "$location_context"; then
        log_action "Validation pré-sonnerie échouée" "ERROR"
        return 1
    fi
    
    # Enregistrer l'initiation de sonnerie
    record_ring_event "$device_id" "$ring_policy" "$location_context" "$initiated_by" "started"
    
    # Exécuter la sonnerie basée sur la politique
    execute_policy_ring "$volume" "$pattern" "$duration" "$sound"
    
    # Enregistrer la fin de sonnerie
    record_ring_event "$device_id" "$ring_policy" "$location_context" "$initiated_by" "completed"
    
    # Générer le rapport de localisation
    generate_location_report "$device_id" "$ring_policy" "$location_context"
    
    log_action "Sonnerie à distance d'entreprise terminée pour appareil : $device_id" "INFO"
}

# Appliquer les modifications de niveau d'urgence
apply_emergency_modifications() {
    local emergency_level="$1"
    local -n vol_ref=$2
    local -n pat_ref=$3
    local -n dur_ref=$4
    
    echo "--- Niveau d'Urgence : $emergency_level ---"
    
    case "$emergency_level" in
        "yellow")
            vol_ref=$((vol_ref + 15))
            dur_ref=$((dur_ref + 10))
            echo "Réponse améliorée : Volume +15%, Durée +10s"
            ;;
        "orange")
            vol_ref=$((vol_ref + 25))
            dur_ref=$((dur_ref + 20))
            pat_ref="escalating"
            echo "Réponse urgente : Volume +25%, Durée +20s, Motif croissant"
            ;;
        "red")
            vol_ref=100
            dur_ref=$((dur_ref * 2))
            pat_ref="morse_sos"
            echo "Réponse critique : Volume maximum, Durée double, Motif SOS"
            ;;
    esac
    
    # Limiter le volume à 100%
    if [[ $vol_ref -gt 100 ]]; then
        vol_ref=100
    fi
}

# Validation pré-sonnerie
pre_ring_validation() {
    local device_id="$1"
    local location_context="$2"
    
    echo "--- Validation Pré-Sonnerie ---"
    
    # Vérifier la disponibilité du système audio
    if ! command -v afplay >/dev/null 2>&1; then
        echo "✗ Système audio non disponible"
        log_action "Vérification système audio échouée" "ERROR"
        return 1
    fi
    
    # Vérifier si l'appareil est en mode ne pas déranger
    local dnd_status=$(defaults read ~/Library/Preferences/ByHost/com.apple.notificationcenterui.* doNotDisturb 2>/dev/null || echo "0")
    if [[ "$dnd_status" == "1" ]]; then
        echo "⚠️ L'appareil est en mode Ne Pas Déranger"
        log_action "Appareil en mode NPD - sonnerie peut être en sourdine" "WARNING"
    fi
    
    # Vérifier le volume système
    local current_volume=$(osascript -e "output volume of (get volume settings)" 2>/dev/null || echo "50")
    echo "Volume système actuel : $current_volume%"
    
    # Vérifier si en sourdine
    local mute_status=$(osascript -e "output muted of (get volume settings)" 2>/dev/null || echo "false")
    if [[ "$mute_status" == "true" ]]; then
        echo "⚠️ Système actuellement en sourdine"
        log_action "Système en sourdine - sera surchargé pour sonnerie" "WARNING"
    fi
    
    # Validations spécifiques à la localisation
    case "$location_context" in
        "meeting_room")
            echo "Contexte salle de réunion - utilisation paramètres discrets"
            ;;
        "healthcare_facility")
            echo "Contexte santé - assurance conformité HIPAA"
            ;;
        "education_campus")
            echo "Contexte éducation - assurance niveaux de volume appropriés"
            ;;
    esac
    
    echo "✓ Validation pré-sonnerie terminée"
    return 0
}

# Exécuter la sonnerie basée sur la politique
execute_policy_ring() {
    local volume="$1"
    local pattern="$2"
    local duration="$3"
    local sound="$4"
    
    echo "--- Exécution de Sonnerie ---"
    
    # Mapper le nom du son vers le chemin de fichier
    local sound_file="/System/Library/Sounds/Submarine.aiff"  # Par défaut
    case "$sound" in
        "submarine") sound_file="/System/Library/Sounds/Submarine.aiff" ;;
        "glass") sound_file="/System/Library/Sounds/Glass.aiff" ;;
        "ping") sound_file="/System/Library/Sounds/Ping.aiff" ;;
        "sosumi") sound_file="/System/Library/Sounds/Sosumi.aiff" ;;
        "purr") sound_file="/System/Library/Sounds/Purr.aiff" ;;
    esac
    
    # Stocker les paramètres audio actuels
    local original_volume=$(osascript -e "output volume of (get volume settings)" 2>/dev/null || echo "50")
    local original_mute=$(osascript -e "output muted of (get volume settings)" 2>/dev/null || echo "false")
    
    # Définir le volume de sonnerie et désactiver sourdine
    osascript -e "set volume without output muted" 2>/dev/null
    osascript -e "set volume output volume $volume" 2>/dev/null
    
    echo "Paramètres sonnerie : Volume $volume%, Motif $pattern, Durée ${duration}s"
    echo "Heure de début : $(date '+%H:%M:%S')"
    
    # Exécuter le motif de sonnerie
    case "$pattern" in
        "standard")
            standard_ring_pattern "$duration" "$sound_file"
            ;;
        "pulse")
            pulse_ring_pattern "$duration" "$sound_file"
            ;;
        "escalating")
            escalating_ring_pattern "$duration" "$sound_file"
            ;;
        "morse_sos")
            morse_sos_pattern "$duration" "$sound_file"
            ;;
        "heartbeat")
            heartbeat_pattern "$duration" "$sound_file"
            ;;
    esac
    
    echo "Heure de fin : $(date '+%H:%M:%S')"
    
    # Restaurer les paramètres audio originaux
    osascript -e "set volume output volume $original_volume" 2>/dev/null
    if [[ "$original_mute" == "true" ]]; then
        osascript -e "set volume with output muted" 2>/dev/null
    fi
    
    echo "✓ Paramètres audio originaux restaurés"
}

# Enregistrer les événements de sonnerie pour piste d'audit
record_ring_event() {
    local device_id="$1"
    local ring_policy="$2"
    local location_context="$3"
    local initiated_by="$4"
    local event_type="$5"
    
    local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
    local event_file="$CONFIG_DIR/ring_events.log"
    
    echo "$timestamp,$device_id,$ring_policy,$location_context,$initiated_by,$event_type" >> "$event_file"
    
    log_action "Événement sonnerie enregistré : $event_type pour appareil $device_id" "INFO"
}

# Générer un rapport de localisation complet
generate_location_report() {
    local device_id="$1"
    local ring_policy="$2"
    local location_context="$3"
    
    local report_file="$REPORT_DIR/location_report_${device_id}_$(date +%Y%m%d_%H%M%S).json"
    
    # Obtenir les informations de localisation système (si disponibles)
    local wifi_network=$(networksetup -getairportnetwork en0 2>/dev/null | cut -d: -f2 | sed 's/^ *//' || echo "Inconnu")
    local ip_address=$(ifconfig en0 | grep "inet " | awk '{print $2}' || echo "Inconnu")
    
    cat > "$report_file" << EOF
{
    "location_report": {
        "report_metadata": {
            "report_id": "$(uuidgen)",
            "generated_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
            "device_id": "$device_id",
            "hostname": "$(hostname)",
            "script_version": "$SCRIPT_VERSION"
        },
        "ring_details": {
            "ring_policy": "$ring_policy",
            "location_context": "$location_context",
            "execution_timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
        },
        "location_information": {
            "wifi_network": "$wifi_network",
            "ip_address": "$ip_address",
            "system_timezone": "$(date +%Z)",
            "estimated_location": "$location_context"
        },
        "system_information": {
            "os_version": "$(sw_vers -productVersion)",
            "hardware_model": "$(system_profiler SPHardwareDataType | grep 'Model Identifier' | awk '{print $3}')",
            "audio_devices": "$(system_profiler SPAudioDataType | grep -A1 'Audio Devices:' | tail -1 | sed 's/^[ ]*//')"
        }
    }
}
EOF
    
    echo "Rapport de localisation généré : $report_file"
    log_action "Rapport de localisation généré : $report_file" "INFO"
}

# Gestion de sonnerie de flotte
fleet_ring_management() {
    local operation="$1"
    local device_list="$2"
    local ring_policy="${3:-standard_office}"
    local emergency_level="${4:-green}"
    
    echo "=== Gestion de Sonnerie de Flotte ==="
    echo "Opération : $operation"
    echo "Politique de Sonnerie : $ring_policy"
    echo "Niveau d'Urgence : $emergency_level"
    echo ""
    
    case "$operation" in
        "mass_ring")
            echo "Exécution opération sonnerie de masse..."
            IFS=',' read -ra DEVICES <<< "$device_list"
            for device in "${DEVICES[@]}"; do
                echo "Sonnerie appareil : $device"
                enterprise_remote_ring "$device" "$ring_policy" "office" "$emergency_level"
                sleep 2  # Délai entre appareils
            done
            ;;
        "emergency_locate")
            echo "Protocole de localisation d'urgence activé..."
            enterprise_remote_ring "$(hostname)" "emergency_locate" "unknown" "red"
            ;;
        "zone_ring")
            echo "Opération sonnerie basée sur zone..."
            # Implémentation pour sonnerie basée sur zone
            ;;
        *)
            echo "Opération inconnue : $operation"
            return 1
            ;;
    esac
}

# Fonction d'exécution principale
main() {
    local action="${1:-help}"
    local param1="${2:-}"
    local param2="${3:-}"
    local param3="${4:-}"
    local param4="${5:-}"
    local param5="${6:-}"
    
    log_action "=== Gestion de Sonnerie à Distance Roundfleet Démarrée ===" "INFO"
    log_action "Action : $action" "INFO"
    
    case "$action" in
        "ring")
            if [[ -z "$param1" ]]; then
                param1="$(hostname)"
            fi
            enterprise_remote_ring "$param1" "$param2" "$param3" "$param4" "$param5"
            ;;
        "emergency")
            echo "Sonnerie d'urgence activée pour appareil actuel"
            enterprise_remote_ring "$(hostname)" "emergency_locate" "unknown" "red" "$(whoami)"
            ;;
        "test")
            echo "Test du système audio..."
            test_sound_file "/System/Library/Sounds/Ping.aiff"
            ;;
        "volume")
            if [[ -z "$param1" ]]; then
                manage_system_volume "get"
            else
                manage_system_volume "$param1" "$param2"
            fi
            ;;
        "sounds")
            list_system_sounds
            ;;
        "fleet")
            if [[ -z "$param1" ]]; then
                echo "Usage : $0 fleet <opération> [liste_appareils] [politique] [niveau_urgence]"
                echo "Opérations : mass_ring, emergency_locate, zone_ring"
                exit 1
            fi
            fleet_ring_management "$param1" "$param2" "$param3" "$param4"
            ;;
        "help")
            echo "Usage : $0 [action] [options...]"
            echo "Actions :"
            echo "  ring [id_appareil] [politique] [localisation] [niveau_urgence] [initié_par] - Exécuter sonnerie à distance"
            echo "  emergency - Sonnerie d'urgence pour appareil actuel"
            echo "  test - Tester le système audio"
            echo "  volume [action] [niveau] - Gérer le volume système"
            echo "  sounds - Lister les sons système disponibles"
            echo "  fleet <opération> [liste_appareils] [politique] [niveau_urgence] - Opérations de flotte"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Politiques de Sonnerie : ${!RING_POLICIES[*]}"
            echo "Niveaux d'Urgence : ${!EMERGENCY_LEVELS[*]}"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action" "ERROR"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion de sonnerie à distance terminée ===" "INFO"
}

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

Considérations Importantes

Exigences du Système Audio

  • Commande afplay - Lecteur audio intégré de macOS pour lecture de fichiers son
  • Sons Système - Situés dans le répertoire /System/Library/Sounds/
  • Contrôle de Volume - Utilise AppleScript pour gestion du volume système
  • Permissions Audio - Certaines fonctionnalités peuvent nécessiter des permissions d'entrée/sortie audio

Notes de Déploiement d'Entreprise

  • Latence Réseau - Les commandes de sonnerie à distance peuvent avoir des délais réseau
  • États d'Appareils - Les appareils peuvent être en veille, en sourdine ou en mode ne pas déranger
  • Conformité de Confidentialité - Le suivi de localisation doit respecter les réglementations de confidentialité
  • Protocoles d'Urgence - Les sonneries d'urgence doivent outrepasser les restrictions de volume normales
  • Coordination de Flotte - Les opérations de sonnerie de masse doivent être échelonnées pour éviter les conflits

Considérations de Sécurité

  • Contrôle d'Accès - La fonctionnalité de sonnerie doit être restreinte aux administrateurs autorisés
  • Journalisation d'Audit - Toutes les opérations de sonnerie doivent être journalisées pour sécurité et conformité
  • Confidentialité de Localisation - Les informations de localisation d'appareil doivent être traitées selon les politiques de confidentialité
  • Surcharge d'Urgence - Les situations d'urgence peuvent nécessiter de contourner les restrictions normales

Related Tutorials

Suivi de Localisation des Appareils sur macOS

Apprenez à suivre la localisation des appareils Mac en utilisant la géolocalisation par adresse IP, implémenter la surveillance de sécurité, et gérer les appareils de flotte avec des politiques basées sur la localisation et des rapports de conformité.

7 juil. 2025

Gérer les Services de Localisation sur macOS

Apprenez à activer, désactiver et surveiller les Services de Localisation sur les appareils macOS en utilisant des scripts en ligne de commande pour une gestion avancée de la confidentialité et de la sécurité.

7 juil. 2025

Gestion d'Entreprise des Sauvegardes Time Machine sur macOS

Guide complet pour gérer les sauvegardes Time Machine sur les flottes macOS avec politiques d'entreprise, planification automatisée, récupération d'urgence, surveillance de conformité et capacités de déploiement de flotte.

7 juil. 2025

Gestion à Distance d'Entreprise et Contrôle d'Accès Sécurisé sur macOS

Configuration complète de la gestion à distance, contrôle d'accès sécurisé, support multi-protocoles et cadres de conformité d'entreprise pour les appareils macOS avec surveillance de sécurité avancée et application automatisée des politiques.

7 juil. 2025

Gestion d'Identité et Nomenclature d'Appareils Entreprise sur macOS

Gérez les noms d'appareils, noms d'hôtes et identités réseau sur les appareils Roundfleet avec des conventions de nomenclature standardisées, un provisioning automatisé et des fonctionnalités de conformité d'entreprise.

7 juil. 2025

Gestion d'Entreprise des Utilisateurs de Partage sur macOS

Apprenez à créer et gérer des comptes utilisateurs de partage uniquement sur les appareils macOS en utilisant les commandes dscl avec sécurité de niveau entreprise, déploiement en masse et capacités de gestion de flotte.

7 juil. 2025

Gestion des Préférences Système sur macOS

Apprenez à masquer, désactiver et gérer les panneaux des Préférences Système sur les appareils macOS en utilisant des scripts en ligne de commande pour la configuration d'entreprise et le contrôle des restrictions utilisateur.

7 juil. 2025

Gestion de Stockage d'Entreprise sur macOS

Surveillez l'utilisation du disque, implémentez les politiques de stockage et optimisez les performances de stockage sur les appareils macOS avec la gestion avancée de stockage, le nettoyage automatisé et l'analytique d'entreprise pour l'infrastructure de stockage organisationnelle.

7 juil. 2025
View all tutorials →