<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Oui"</string>
    <string name="no" msgid="6731231425810196216">"Non"</string>
    <string name="create" msgid="3578857613172647409">"Créer"</string>
    <string name="allow" msgid="3349662621170855910">"Autoriser"</string>
    <string name="deny" msgid="6947806159746484865">"Refusers"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Inconnu"</string>
  <plurals name="show_dev_countdown">
    <item quantity="one" msgid="5295687242294085452">"Plus que <xliff:g id="STEP_COUNT">%1$d</xliff:g> étape pour devenir un développeur."</item>
    <item quantity="other" msgid="6722953419953594148">"Plus que <xliff:g id="STEP_COUNT">%1$d</xliff:g> étapes pour devenir un développeur."</item>
  </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Vous êtes désormais un développeur!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Inuti, vous êtes déjà un développeur."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Sans fil et réseaux"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Connexions"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Appareil"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Personnel"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Accès"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Système"</string>
    <string name="turn_on_radio" msgid="8706561489788373676">"Allumer le signal radio"</string>
    <string name="turn_off_radio" msgid="1820294552893884115">"Éteindre le signal radio"</string>
    <string name="sms_over_ims_on" msgid="5085290395865632925">"Activer SMS over IMS"</string>
    <string name="sms_over_ims_off" msgid="8354792045992793959">"Désactiver SMS over IMS"</string>
    <string name="ims_reg_required_on" msgid="3885152087309614653">"Activation de l\'enregistrement IMS requise"</string>
    <string name="ims_reg_required_off" msgid="1720570343422743943">"Désactivation de l\'enregistrement IMS requise"</string>
    <string name="lte_ram_dump_on" msgid="8568568019520172177">"Activer le vidage de la mémoire RAM du LTE"</string>
    <string name="lte_ram_dump_off" msgid="2514507918652378283">"Désactiver le vidage de la mémoire RAM du LTE"</string>
    <string name="radioInfo_menu_viewADN" msgid="8743377494429930831">"Afficher le carnet d\'adresses de la carte SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Afficher les numéros autorisés"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Afficher les numéros de service"</string>
    <string name="radioInfo_menu_getPDP" msgid="560610293888406317">"Récupérer la liste PDP"</string>
    <string name="radioInfo_service_in" msgid="1915416319177520020">"In service"</string>
    <string name="radioInfo_service_out" msgid="5238736759641916278">"Hors-service"</string>
    <string name="radioInfo_service_emergency" msgid="2485604591272668370">"Appels d\'urgence uniquement"</string>
    <string name="radioInfo_service_off" msgid="1434084741785525415">"Signal radio désactivé"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Itinérance"</string>
    <string name="radioInfo_roaming_not" msgid="2851853244069662307">"Sans itinérance"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Absent(e)"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Sonnerie"</string>
    <string name="radioInfo_phone_offhook" msgid="4174402846862780998">"Appel en cours"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Déconnecté"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Connexion en cours…"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Connecté"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Suspendu"</string>
    <string name="radioInfo_unknown" msgid="737385314432468266">"inconnu"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paquets"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"octets"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID ou IDC"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Désinstaller la mémoire de stockage USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Désinstaller la carte SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Effacer la mémoire de stockage USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Effacer la carte SD"</string>
    <string name="small_font" msgid="2295331917424072635">"Petit"</string>
    <string name="medium_font" msgid="2068475425515133701">"Moyen"</string>
    <string name="large_font" msgid="599055175160971446">"Grande"</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Mémoire de stockage USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Carte SD"</string>
    <string name="battery_info_status_label" msgid="8109155295509700309">"État de la batterie :"</string>
    <string name="battery_info_power_label" msgid="7465140230991349382">"Prise électrique :"</string>
    <string name="battery_info_scale_label" msgid="3649763192389778437">"Batterie :"</string>
    <string name="battery_info_level_label" msgid="8706526709307788737">"Niveau de la batterie :"</string>
    <string name="battery_info_health_label" msgid="6416051542741886958">"État de la batterie :"</string>
    <string name="battery_info_technology_label" msgid="788304533220748681">"Technologie de la batterie :"</string>
    <string name="battery_info_voltage_label" msgid="8971764146757637863">"Voltage de la batterie :"</string>
    <string name="battery_info_voltage_units" msgid="8658490792208288107">"mV"</string>
    <string name="battery_info_temperature_label" msgid="1968383098818648037">"Température de la batterie :"</string>
    <string name="battery_info_temperature_units" msgid="9098950587249987550">"° C"</string>
    <string name="battery_info_uptime" msgid="5548545143573527992">"Temps depuis le démarrage :"</string>
    <string name="battery_info_awake_battery" msgid="2557725975486185849">"Temps de veille sur batterie :"</string>
    <string name="battery_info_awake_plugged" msgid="176716874713478188">"Temps en activité lors du rechargement :"</string>
    <string name="battery_info_screen_on" msgid="376277447175613889">"Écran activé :"</string>
    <string name="battery_info_status_unknown" msgid="196130600938058547">"Inconnu"</string>
    <string name="battery_info_status_charging" msgid="1705179948350365604">"Batterie en charge"</string>
    <string name="battery_info_status_charging_ac" msgid="2909861890674399949">"En charge (c.a.)"</string>
    <string name="battery_info_status_charging_usb" msgid="2207489369680923929">"En charge par USB"</string>
    <string name="battery_info_status_charging_wireless" msgid="3574032603735446573">"En charge sans fil"</string>
    <string name="battery_info_status_discharging" msgid="310932812698268588">"N\'est pas en charge"</string>
    <string name="battery_info_status_not_charging" msgid="2820070506621483576">"N\'est pas en charge"</string>
    <string name="battery_info_status_full" msgid="2824614753861462808">"Pleine"</string>
    <string name="battery_info_power_unplugged" msgid="5987246575519551081">"Débranché"</string>
    <string name="battery_info_power_ac" msgid="6808516193001604634">"CA"</string>
    <string name="battery_info_power_usb" msgid="8012931702516331797">"USB"</string>
    <string name="battery_info_power_wireless" msgid="6819163295739305097">"sans fil"</string>
    <string name="battery_info_power_ac_usb" msgid="6777734146838328688">"CA + USB"</string>
    <string name="battery_info_power_unknown" msgid="7344115502868899881">"Inconnu"</string>
    <string name="battery_info_health_unknown" msgid="5664295556921944255">"Inconnu"</string>
    <string name="battery_info_health_good" msgid="8070356565806711806">"Bon"</string>
    <string name="battery_info_health_overheat" msgid="8442959549291368806">"Surchauffe"</string>
    <string name="battery_info_health_dead" msgid="1725917445762829059">"Introuvable"</string>
    <string name="battery_info_health_over_voltage" msgid="2420269351664490121">"Voltage dépassé"</string>
    <string name="battery_info_health_unspecified_failure" msgid="6347021103185471590">"Erreur inconnue"</string>
    <string name="battery_info_health_cold" msgid="3835692786176707318">"Peu populaire"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Identifiable par tous appareils Bluetooth à proximité (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Identifiable par appareils Bluetooth à proximité"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Non identifiable par d\'autres appareils Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Identifiable uniquement par les appareils associés"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Délai de visibilité"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Bloquer les appels par reconnaissance vocale"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Désactiver les appels via Bluetooth lorsque l\'écran est verrouillé"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Appareils Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Nom de l\'appareil"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Paramètres de l\'appareil"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Paramètres du profil"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Aucun nom n\'a été défini. Utilisation du nom du compte..."</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Recherche d\'appareils"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Renommer cet appareil"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Renommer"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Voulez-vous vraiment vous déconnecter?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"Cette opération va mettre fin à votre connexion avec :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="1185354873716211496">"Vous n\'êtes pas autorisé à modifier les paramètres Bluetooth."</string>
    <string name="bluetooth_is_visible_message" msgid="3956514990287788968">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> est visible aux app prox. si param. Bluetooth ouverts"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Déconnecter <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Diffusion"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Désactiver le profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"Le profil :&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;va être désactivé sur :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_connected" msgid="6038755206916626419">"Connecté"</string>
    <string name="bluetooth_connected_no_headset" msgid="2866994875046035609">"Connecté (sans audio pour appels tél.)"</string>
    <string name="bluetooth_connected_no_a2dp" msgid="4576188601581440337">"Connecté (sans audio contenu mutimédia)"</string>
    <string name="bluetooth_connected_no_map" msgid="6504436917057479986">"Connecté (sans accès aux messages)"</string>
    <string name="bluetooth_connected_no_headset_no_a2dp" msgid="9195757766755553810">"Connecté (sans audio tel./multimédia)"</string>
    <string name="bluetooth_disconnected" msgid="6557104142667339895">"Déconnecté"</string>
    <string name="bluetooth_disconnecting" msgid="8913264760027764974">"Déconnexion…"</string>
    <string name="bluetooth_connecting" msgid="8555009514614320497">"Connexion en cours…"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_pairing" msgid="1426882272690346242">"Association…"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Appareil Bluetooth sans nom"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Searching"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Aucun appareil Bluetooth détecté."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Demande d\'association Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Demande d\'association"</string>
    <string name="bluetooth_notif_message" msgid="5300852675110479862">"Appuyez pour associer l\'appareil à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Afficher les fichiers reçus"</string>
    <string name="device_picker" msgid="4978696506172252813">"Sélectionner un appareil Bluetooth"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Demande d\'autorisation Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="637355677176904990">"Une application requiert l\'activation du Bluetooth."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Une application nécessite que d\'autres appareils Bluetooth puissent détecter votre tablette pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Une application nécessite que d\'autres appareils Bluetooth puissent détecter votre téléphone pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Une application nécessite que d\'autres appareils Bluetooth puissent détecter votre tablette. Vous pourrez ensuite annuler cette opération dans les paramètres du Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Une application nécessite que d\'autres appareils Bluetooth puissent détecter votre téléphone. Vous pourrez ensuite annuler cette opération dans les paramètres du Bluetooth."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer la diffusion par Bluetooth pour communiquer avec d\'autres appareils à proximité. Vous pourrez ensuite annuler cette opération dans les paramètres Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"<xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer Bluetooth et la diffusion par Bluetooth pour communiquer avec d\'autres appareils à proximité. Vous pourrez ensuite annuler cette opération dans les paramètres Bluetooth."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Lorsque cette fonctionnalité est activée, votre téléphone peut communiquer avec les autres appareils à proximité.\n\nLa diffusion utilise les signaux Bluetooth à basse consommation."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Une application requiert l\'activation du Bluetooth et nécessite que d\'autres appareils puissent détecter votre tablette pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Une application requiert l\'activation du Bluetooth et nécessite que d\'autres appareils puissent détecter votre téléphone pendant <xliff:g id="TIMEOUT">%1$d</xliff:g> secondes."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Une application requiert l\'activation du Bluetooth et nécessite que d\'autres appareils puissent détecter votre tablette. Vous pourrez ensuite annuler cette opération dans les paramètres du Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Une application requiert l\'activation du Bluetooth et nécessite que d\'autres appareils puissent détecter votre téléphone. Vous pourrez ensuite annuler cette opération dans les paramètres du Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Activation du Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Désactivation du Bluetooth..."</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Connexion automatique"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Demande de connexion Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3687933246423942977">"Appuyez pour vous connecter à « <xliff:g id="DEVICE_NAME">%1$s</xliff:g> »."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Voulez-vous vous connecter à « <xliff:g id="DEVICE_NAME">%1$s</xliff:g> »?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Demande d\'accès au répertoire téléphonique"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s souhaite accéder à vos contacts et à l\'historique de vos appels. Autoriser l\'accès à %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6198284561603824931">"Ne plus me demander"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2901499974259177202">"Ne plus me demander"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Demande d\'accès aux messages"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s souhaite accéder à vos messages. Autoriser l\'accès à %2$s?"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Date et heure"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Sélectionner le fuseau horaire"</string>
    <string name="normal_date_format" msgid="7636406984925498359">"Format régional (<xliff:g id="DATE">%s</xliff:g>)"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Aperçu :"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Taille de police :"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Envoyer <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g> :"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Démarrer <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g> :"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"COMPTE"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Serveur mandataire"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Effacer"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Port du serveur mandataire"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Ignorer le serveur mandataire pour"</string>
    <string name="proxy_exclusionlist_hint" msgid="6084099226687226948">"exemple.com,monordi.test.com,hôtelocal"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Rétablir les paramètres par défaut"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Terminé"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Nom d\'hôte du serveur mandataire"</string>
    <string name="proxy_hostname_hint" msgid="2076157057003936176">"exemple.proxy.com"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Attention"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="8052095511862922213">"Le nom d\'hôte saisi n\'est pas valide."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6467799485443290961">"Le format de la liste d\'exclusion spécifiée n\'est pas correct. Séparez les noms de domaine à exclure par une virgule."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Le champ « Port » est obligatoire."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Le champ Port doit rester vide si le champ Hôte n\'est pas renseigné."</string>
    <string name="proxy_error_invalid_port" msgid="2671425042711054494">"Le port indiqué n\'est pas valide."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Le serveur mandataire HTTP est utilisé par le navigateur, mais ne peut pas l\'être par les autres applications."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL config. auto mand. : "</string>
    <string name="radio_info_signal_location_label" msgid="16475158265551708">"Emplacement :"</string>
    <string name="radio_info_neighboring_location_label" msgid="2385625674055934880">"CID voisin :"</string>
    <string name="radio_info_cellinfo_label" msgid="1300937728020622362">"Infos sur la cellule :"</string>
    <string name="radio_info_dcrtinfo_label" msgid="6802395441317448068">"DcRtInfo :"</string>
    <string name="radio_info_data_attempts_label" msgid="1731106244577323381">"Tentatives :"</string>
    <string name="radio_info_gprs_service_label" msgid="2331818110375395364">"Service GPRS :"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Itinérance :"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"Code IMEI :"</string>
    <string name="radio_info_call_redirect_label" msgid="1654674226961476872">"Redirection des appels :"</string>
    <string name="radio_info_ppp_resets_label" msgid="3241667824729310546">"Nombre de réinitialisations PPP depuis le démarrage :"</string>
    <string name="radio_info_gsm_disconnects_label" msgid="1683069665736339820">"Déconnexions GSM :"</string>
    <string name="radio_info_current_network_label" msgid="3256402602440102610">"Réseau actuel :"</string>
    <string name="radio_info_data_successes_label" msgid="4417894113689054945">"Réussites des données :"</string>
    <string name="radio_info_ppp_received_label" msgid="3345184342444878849">"PPP reçus :"</string>
    <string name="radio_info_gsm_service_label" msgid="2082332114596916985">"Service GSM :"</string>
    <string name="radio_info_signal_strength_label" msgid="1931937920896925766">"Intensité du signal :"</string>
    <string name="radio_info_call_status_label" msgid="4896238900685510883">"État de l\'appel :"</string>
    <string name="radio_info_ppp_sent_label" msgid="5009102250704375687">"PPP envoyés :"</string>
    <string name="radio_info_radio_resets_label" msgid="9211343458143291617">"Réinitialisations du signal radio :"</string>
    <string name="radio_info_message_waiting_label" msgid="6981842420058672207">"Message en attente :"</string>
    <string name="radio_info_phone_number_label" msgid="7192944627907412169">"Numéro de téléphone :"</string>
    <string name="radio_info_band_mode_label" msgid="441469694142042022">"Choisir une bande radio"</string>
    <string name="radio_info_network_type_label" msgid="3706382548257257987">"Type de réseau :"</string>
    <string name="radio_info_set_perferred_label" msgid="9039200405863503267">"Définir le type de réseau préféré :"</string>
    <string name="radio_info_ping_ipaddr" msgid="498747917793263530">"Faire un ping sur adresse IP :"</string>
    <string name="radio_info_ping_hostname" msgid="3054888474808217853">"Nom de l\'hôte du ping (www.google.com) :"</string>
    <string name="radio_info_http_client_test" msgid="5733604021077701555">"Test du client HTTP :"</string>
    <string name="ping_test_label" msgid="7255376471490860631">"Effectuer un test de ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC :"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Mettre à jour"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Actualiser"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="8292252930563286858">"Activer le contrôle DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Infos/paramètres OEM"</string>
    <string name="band_mode_title" msgid="954174198903776205">"Définir la bande GSM/UMTS"</string>
    <string name="band_mode_loading" msgid="548764766363847336">"Chargement de la liste de bandes..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Paramètres"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Échec"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Opération effectuée"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Les modifications prendront effet lors de la prochaine connexion du câble USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Activer la mémoire de stockage USB de masse"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Nombre d\'octets au total :"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Mémoire USB non installée"</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Aucune carte SD"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Octets disponibles :"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"Mémoire USB utilisée comme stockage de masse"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"La carte SD est utilisée comme périphérique de stockage."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="9191210735703409245">"Retirez mémoire USB en toute sécurité."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="6462544066195404905">"Vous pouvez maintenant retirer la carte SD en toute sécurité."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"La mémoire USB a été retirée en cours d\'utilisation."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"La carte SD a été retirée pendant son utilisation."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Octets utilisés :"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Recherche de médias sur la mémoire de stockage USB…"</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Recherche de fichiers multimédia sur la carte SD…"</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Mémoire USB en lecture seule"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Carte SD installée en lecture seule"</string>
    <string name="skip_label" msgid="47510779345218297">"Passer"</string>
    <string name="next_label" msgid="4693520878012668114">"SUIVANTE"</string>
    <string name="language_picker_title" msgid="5349877711342869319">"Langue"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Sélectionnez une activité"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informations sur l\'appareil"</string>
    <string name="battery_info_label" msgid="4132685016148679403">"Informations sur la batterie"</string>
    <string name="display_label" msgid="8074070940506840792">"Écran"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Informations sur la tablette"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informations sur le téléphone"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Mémoire de stockage USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Carte SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Paramètres du serveur mandataire"</string>
    <string name="cancel" msgid="6859253417269739139">"Annuler"</string>
    <string name="cancel_all_caps" msgid="3183966387632229461">"ANNULER"</string>
    <string name="continue_all_caps" msgid="5152713914673789893">"CONTINUER"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="yes_all_caps" msgid="5454685069075197457">"OUI"</string>
    <string name="no_all_caps" msgid="3242375449351298529">"NON"</string>
    <string name="forget" msgid="7267115980248732932">"SUPPRIMER"</string>
    <string name="settings_label" msgid="1626402585530130914">"Paramètres"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Paramètres"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Raccourci vers les paramètres"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Mode avion"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Plus"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Sans fil et réseaux"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"Gérer le Wi‑Fi, le Bluetooth, le mode Avion, les réseaux cellulaires et les RPV"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Données cellulaires"</string>
    <string name="calls_title" msgid="3544471959217176768">"Appels"</string>
    <string name="sms_messages_title" msgid="3188611825992624879">"Messages texte"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Autoriser l\'utilisation des données sur le réseau cellulaire"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Autor. util. données en itin."</string>
    <string name="roaming" msgid="3596055926335478572">"Itinérance des données"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Se connecter aux services de données lors de l\'itinérance"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Se connecter aux services de données lors de l\'itinérance"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Vous avez été déconnecté, car vous avez quitté votre réseau domestique et l\'itinérance des données est désactivée."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Activer"</string>
    <string name="roaming_warning" msgid="7625933694709170887">"Lorsque vous activez l\'itinérance des données, des frais d\'itinérance importants peuvent s\'appliquer."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Lorsque vous autorisez l\'itinérance des données, des frais d\'itinérance importants peuvent s\'appliquer!\n\nCe paramètre affecte tous les utilisateurs de cette tablette."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Lorsque vous autorisez l\'itinérance des données, des frais d\'itinérance importants peuvent s\'appliquer!\n\nCe paramètre affecte tous les utilisateurs de ce téléphone."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Autoriser l\'itinérance des données?"</string>
    <string name="networks" msgid="6333316876545927039">"Sélection de l\'opérateur"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Sélectionner un opérateur réseau"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Date et heure"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Régler la date et l\'heure"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Configurer la date, l\'heure, le fuseau horaire et les formats"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Date/Heure automatique"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Utiliser la date et l\'heure fournies par le réseau"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Utiliser la date et l\'heure fournies par le réseau"</string>
    <string name="zone_auto" msgid="334783869352026648">"Fuseau horaire automatique"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Utiliser le fuseau horaire fourni par le réseau"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Utiliser le fuseau horaire fourni par le réseau"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"Format 24 heures"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Utiliser le format sur 24 h"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Heure"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Définir l\'heure"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Fuseau horaire"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Sélectionner le fuseau horaire"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Date"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Définir la date"</string>
    <string name="date_time_date_format_title" msgid="3976171711988766411">"Format de la date"</string>
    <string name="date_time_date_format" msgid="6951498879879281102">"Sél le format de la date"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Trier par ordre alphabétique"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Trier par fuseau horaire"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Date"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Heures"</string>
    <string name="biometric_weak_improve_matching_title" msgid="8754080894393195194">"Améliorer la correspondance faciale"</string>
    <string name="biometric_weak_liveliness_title" msgid="2661613702124561096">"Détection des mouvements"</string>
    <string name="biometric_weak_liveliness_summary" msgid="4199587000948042325">"Exiger un clin d\'œil lors du déverrouillage"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Verrouiller automatiquement"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"Après <xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> de veille"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> après la mise en veille, sauf lorsque l\'appareil est maintenu en activité par <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Coordonnées du propriétaire sur l\'écran verrouillé"</string>
    <string name="owner_info_settings_title" msgid="2723190010708381889">"Infos propriétaire"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Activer les widgets"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Désactivé par l\'administrateur"</string>
    <string name="owner_info_settings_summary" msgid="3800834657847339570"></string>
    <string name="owner_info_settings_edit_text_hint" msgid="4608681417960923911">"Saisir texte à afficher sur écran de verrouillage"</string>
    <string name="show_user_info_on_lockscreen_label" msgid="8408914624925608365">"Afficher infos utilisateur sur écran verrouillage"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Informations sur l\'utilisateur"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Afficher infos de profil sur écran de verrouillage"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Infos de profil"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Comptes"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Position"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Comptes"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Sécurité"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Définir les paramètres de l\'option Ma position et de verrouillage"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Définir les paramètres de la fonction Ma position, de déverrouillage de l\'écran et de verrouillage du stockage des identifiants"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Mots de passe"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Chiffrement (ou cryptage)"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Chiffrer la tablette"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Crypter le téléphone"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Chiffré"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="2876073029767953111">"Vous pouvez chiffrer vos comptes, vos paramètres, les applications téléchargées et les données associées, les contenus multimédias et d\'autres fichiers. Si vous avez chiffré votre tablette en définissant un verrouillage d\'écran (au moyen d\'un motif, d\'un NIP ou d\'un mot de passe), vous devez déverrouiller l\'écran pour déchiffrer la tablette à chaque fois que vous l\'allumez. La seule autre manière de déchiffrer cette dernière consiste à rétablir la configuration d\'usine, ce qui entraîne la suppression de l\'ensemble de vos données.\n\nLa procédure de chiffrement dure au moins une heure. La pile de la tablette doit être chargée au départ, et la tablette doit rester branchée pendant tout le processus. Toute interruption entraîne la perte d\'une partie ou de la totalité des données."</string>
    <string name="crypt_keeper_desc" product="default" msgid="5573427498609458721">"Vous pouvez chiffrer vos comptes, vos paramètres, les applications téléchargées et les données associées, les contenus multimédias et d\'autres fichiers. Si vous avez chiffré votre téléphone en définissant un verrouillage d\'écran (au moyen d\'un motif, d\'un NIP ou d\'un mot de passe), vous devez déverrouiller l\'écran pour déchiffrer le téléphone à chaque fois que vous l\'allumez. La seule autre manière de déchiffrer ce dernier consiste à rétablir la configuration d\'usine, ce qui entraîne la suppression de l\'ensemble de vos données.\n\nLa procédure de chiffrement dure au moins une heure. La pile du téléphone doit être chargée au départ, et le téléphone doit rester branché pendant tout le processus. Toute interruption entraîne la perte d\'une partie ou de la totalité des données."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Chiffrer la tablette"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Crypter le téléphone"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Veuillez charger votre batterie, puis réessayer."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Veuillez brancher votre chargeur, puis réessayer."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Aucun NIP ni mot de passe saisi pour le verrouillage de l\'écran"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Vous devez définir un NIP ou un mot de passe pour le verrouillage de l\'écran avant de lancer le chiffrement."</string>
    <string name="crypt_keeper_confirm_encrypt" msgid="736289627726831055">"Vous devez dessiner votre schéma de déverrouillage pour confirmer le chiffrement de votre appareil."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Chiffrer?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="4453629424172409792">"Le chiffrement est irréversible, et toute interruption du processus peut entraîner la perte de données. L\'opération peut prendre une heure, voire plus, au cours de laquelle la tablette sera redémarrée à plusieurs reprises."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="5682944380460921880">"Le chiffrement est irréversible, et toute interruption du processus peut entraîner la perte de données. L\'opération peut prendre une heure, voire plus, au cours de laquelle le téléphone sera redémarré à plusieurs reprises."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Chiffrement en cours"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Veuillez patienter pendant le chiffrement de votre tablette. <xliff:g id="PERCENT">^1</xliff:g> % effectué(s)."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Veuillez patienter pendant le chiffrement de votre téléphone. <xliff:g id="PERCENT">^1</xliff:g> % effectué(s)."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Veuillez patienter pendant le chiffrement de votre tablette. Temps restant : <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Veuillez patienter pendant le chiffrement de votre téléphone. Temps restant : <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_cooldown" msgid="685210918307862395">"Réessayez dans <xliff:g id="DELAY">^1</xliff:g> secondes."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Attention : Les données de votre appareil seront effacées si vous effectuez encore <xliff:g id="COUNT">^1</xliff:g> tentatives de déverrouillage infructueuses."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Saisissez votre mot de passe."</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Échec du chiffrement"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="4478225241476039013">"Impossible de terminer le chiffrement, car celui-ci a été interrompu. Par conséquent, les données de votre tablette ne sont plus accessibles.\n\nPour continuer d\'utiliser votre tablette, vous devez rétablir la configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données sauvegardées sur votre compte Google lors de la nouvelle configuration de votre tablette."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3083477162766772532">"Impossible de terminer le chiffrement, car celui-ci a été interrompu. Par conséquent, les données de votre téléphone ne sont plus accessibles.\n\nPour continuer d\'utiliser votre téléphone, vous devez rétablir la configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données sauvegardées sur votre compte Google lors de la nouvelle configuration de votre téléphone."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Échec du déchiffrement"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="3775740783651700375">"Le mot de passe entré est correct. Malheureusement, vos données sont corrompues.\n\nPour continuer d\'utiliser votre tablette, vous devez rétablir sa configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données que vous aviez sauvegardées dans votre compte Google lors de la nouvelle configuration de votre tablette."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="6898436151871328007">"Le mot de passe entré est correct. Malheureusement, vos données sont corrompues.\n\nPour continuer d\'utiliser votre téléphone, vous devez rétablir sa configuration d\'usine. Une fois cette opération terminée, vous pourrez restaurer toutes les données que vous aviez sauvegardées dans votre compte Google lors de la nouvelle configuration de votre téléphone."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Changer le mode de saisie"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Sélect. verr. écran"</string>
    <string name="backup_lock_settings_picker_title" msgid="8530380598637963916">"Verrouillage secondaire"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Verrouillage de l\'écran"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Modifier écran verr."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Modifier ou désactiver la sécurité : schéma, NIP ou mot de passe"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Choisir une méthode pour verrouiller l\'écran"</string>
    <string name="unlock_backup_info_summary" msgid="108524727803788172">"Lorsque vous ne pouvez pas utiliser Face Unlock, comment voulez-vous effectuer le déverrouillage?"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Aucun"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Aucune sécurité"</string>
    <string name="unlock_set_unlock_biometric_weak_title" msgid="2227215291604628670">"Face Unlock"</string>
    <string name="unlock_set_unlock_biometric_weak_summary" msgid="180083326982058964">"Sécurité faible, expérimental"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Schéma"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Sécurité moyenne"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"NIP"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Sécurité moyenne à élevée"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Mot de passe"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Sécurité élevée"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Désactivé par admin., règles chiffrement ou stockage des identifiants"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Aucun"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Balayer l\'écran"</string>
    <string name="unlock_set_unlock_mode_biometric_weak" msgid="3008473624490350142">"Face Unlock"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Schéma"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"NIP"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Mot de passe"</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Désactiver le verrouillage de l\'écran"</string>
    <string name="unlock_disable_lock_pattern_summary" msgid="6801602880568869201">"Supprimer le schéma de déverrouillage"</string>
    <string name="unlock_disable_lock_pin_summary" msgid="8856842745366993387">"Supprimer le NIP de déverrouillage"</string>
    <string name="unlock_disable_lock_password_summary" msgid="192161194564577025">"Supprimer le mot de passe de déverrouillage"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Modifier le schéma"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Modifier le NIP de déverrouillage"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Modifier le mot de passe de déverrouillage"</string>
    <string name="lockpassword_password_too_short" msgid="7328975683669256660">"Le mot de passe doit comporter au moins %d caractères."</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"Le NIP doit comporter au moins %d chiffres."</string>
    <string name="lockpassword_press_continue" msgid="122706614386757182">"Appuyez sur Continuer une fois l\'opération terminée."</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Continuer"</string>
    <string name="lockpassword_password_too_long" msgid="7016906583950201704">"Le mot de passe doit comporter moins de <xliff:g id="NUMBER">%d</xliff:g> caractères."</string>
    <string name="lockpassword_pin_too_long" msgid="6419879099090294052">"Le NIP doit comporter moins de <xliff:g id="NUMBER">%d</xliff:g> chiffres."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="1079053457942945709">"Le NIP ne doit contenir que des chiffres compris entre 0 et 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="7909781183925861119">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un NIP récent."</string>
    <string name="lockpassword_illegal_character" msgid="8742901630116866738">"Le mot de passe contient un caractère non autorisé."</string>
    <string name="lockpassword_password_requires_alpha" msgid="5203836082520634764">"Le mot de passe doit comporter au moins une lettre."</string>
    <string name="lockpassword_password_requires_digit" msgid="3958033271435659825">"Le mot de passe doit comporter au moins un chiffre."</string>
    <string name="lockpassword_password_requires_symbol" msgid="7226621405629726899">"Le mot de passe doit comporter au moins un symbole."</string>
  <plurals name="lockpassword_password_requires_letters">
    <item quantity="one" msgid="3063853802158131458">"Le mot de passe doit comporter au moins une lettre."</item>
    <item quantity="other" msgid="8186027808415585970">"Le mot de passe doit comporter au moins %d lettres."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_lowercase">
    <item quantity="one" msgid="5583986519662091001">"Le mot de passe doit comporter au moins une lettre minuscule."</item>
    <item quantity="other" msgid="2693910942679679225">"Le mot de passe doit comporter au moins %d lettres minuscules."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_uppercase">
    <item quantity="one" msgid="2611909966725502768">"Le mot de passe doit comporter au moins une lettre majuscule."</item>
    <item quantity="other" msgid="3030801209112209245">"Le mot de passe doit comporter au moins %d lettres majuscules."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_numeric">
    <item quantity="one" msgid="3820355568839621231">"Le mot de passe doit comporter au moins un chiffre."</item>
    <item quantity="other" msgid="4703982391407595924">"Le mot de passe doit comporter au moins %dchiffres."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_symbols">
    <item quantity="one" msgid="8456579939292408631">"Le mot de passe doit comporter au moins un caractère spécial."</item>
    <item quantity="other" msgid="1221290525051187757">"Le mot de passe doit comporter au moins %d caractères spéciaux."</item>
  </plurals>
  <plurals name="lockpassword_password_requires_nonletter">
    <item quantity="one" msgid="4594051152085925921">"Le mot de passe doit comporter au moins un caractère autre qu\'une lettre."</item>
    <item quantity="other" msgid="3952508584649046404">"Le mot de passe doit comporter au moins %d caractères autres que des lettres."</item>
  </plurals>
    <string name="lockpassword_password_recently_used" msgid="6098087796784262081">"L\'administrateur de l\'appareil ne permet pas l\'utilisation d\'un mot de passe récent."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Les suites de chiffres croissantes, décroissantes ou répétitives ne sont pas autorisées."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Annuler"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Annuler"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Suivant"</string>
    <string name="lock_setup" msgid="3355847066343753943">"La configuration est terminée."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Administration du périphérique"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Administrateurs de l\'appareil"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Afficher ou désactiver les administrateurs de l\'appareil"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Agents de confiance"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Pour l\'utiliser, définissez d\'abord un écran de verrouillage"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Afficher ou désactiver les agents de confiance"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Activer Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Gérer les connexions, configurer le nom et l\'identification de l\'appareil"</string>
    <string name="bluetooth_pairing_request" msgid="6385750334766370310">"Demande d\'association Bluetooth"</string>
    <string name="bluetooth_enter_pin_msg" msgid="4954085254142996877">"Appareil"</string>
    <string name="bluetooth_pairing_key_msg" msgid="333005542843637754">"Code d\'association"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Entrez le code d\'association, puis appuyez sur Retour ou Entrée"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"Le NIP contient des lettres ou des symboles."</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Habituellement 0000 ou 1234"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Vous devrez peut-être également saisir ce NIP sur l\'autre appareil."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Vous devrez peut-être également saisir ce mot de passe sur l\'autre appareil."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Pour associer votre appareil à :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Assurez-vous que le mot de passe &lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt; s\'affiche."</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"De :&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Associer à cet appareil?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Pour l\'association à :<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Saisissez <xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, puis appuyez sur « Retour » ou sur « Entrée »."</string>
    <string name="bluetooth_pairing_accept" msgid="6163520056536604875">"Associer"</string>
    <string name="bluetooth_pairing_accept_all_caps" msgid="6061699265220789149">"ASSOCIER"</string>
    <string name="bluetooth_pairing_decline" msgid="4185420413578948140">"Annuler"</string>
    <string name="bluetooth_pairing_will_share_phonebook" msgid="4982239145676394429">"L\'association vous permet d\'accéder à vos contacts et à l\'historique des appels lorsque vous êtes connecté."</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_pairing_error_message" msgid="3748157733635947087">"Impossible d\'associer à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_pin_error_message" msgid="8337234855188925274">"Impossible d\'établir l\'association avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g> en raison d\'un NIP ou d\'une clé d\'accès incorrects."</string>
    <string name="bluetooth_pairing_device_down_error_message" msgid="7870998403045801381">"Impossible d\'établir la communication avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_pairing_rejected_error_message" msgid="1648157108520832454">"Association refusée par <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_connecting_error_message" msgid="229861986106185022">"Impossible de se connecter à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Recherche d\'appareils"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Actualiser"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Searching…"</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Paramètres de l\'appareil"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Appareil associé"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Nom"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Connexion Internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Clavier"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Contacts et historique des appels"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Associer avec cet appareil?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Partager le répertoire de contacts?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> veut accéder à vos contacts et à votre historique d\'appels."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> demande une association par Bluetooth. Il aura alors accès aux contacts et à l\'histor. des appels."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Périphériques associés"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Appareils disponibles"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Aucun appareil à proximité"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Connexion"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Déconnecter"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Associer et connecter"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Dissocier"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Déconnecter et dissocier"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Options…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Options avancées"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Paramètres Bluetooth avancés"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Si Bluetooth activé, appareil peut communiquer avec autres appareils Bluetooth à proximité."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Se connecter à…"</string>
    <string name="bluetooth_profile_a2dp" msgid="2031475486179830674">"Paramètres audio du support"</string>
    <string name="bluetooth_profile_headset" msgid="8658779596261212609">"Paramètres audio du téléphone"</string>
    <string name="bluetooth_profile_opp" msgid="9168139293654233697">"Transfert de fichier"</string>
    <string name="bluetooth_profile_hid" msgid="3680729023366986480">"Périphérique d\'entrée"</string>
    <string name="bluetooth_profile_pan" msgid="3391606497945147673">"Accès Internet"</string>
    <string name="bluetooth_profile_pbap" msgid="5372051906968576809">"Partage de contact"</string>
    <string name="bluetooth_profile_pbap_summary" msgid="6605229608108852198">"Utiliser pour le partage de contacts"</string>
    <string name="bluetooth_profile_pan_nap" msgid="8429049285027482959">"Partage de connexion Internet"</string>
    <string name="bluetooth_profile_map" msgid="5465271250454324383">"Accès aux messages"</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté de l\'audio du support."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté de l\'audio en mains libres."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté du périphérique d\'entrée"</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"L\'accès à Internet via <xliff:g id="DEVICE_NAME">%1$s</xliff:g> va être interrompu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="5455448395850929200">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ne partagera plus la connexion Internet de la tablette."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5266851881175033601">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> sera déconnecté et ne partagera plus la connexion Internet du téléphone."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Appareil Bluetooth associé"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Connexion"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Connecter à un appareil Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Utiliser pour"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Renommer"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Autoriser le transfert de fichiers entrants"</string>
    <string name="bluetooth_a2dp_profile_summary_connected" msgid="963376081347721598">"Connecté aux paramètres audio du média"</string>
    <string name="bluetooth_headset_profile_summary_connected" msgid="7661070206715520671">"Connecté à l\'audio du téléphone"</string>
    <string name="bluetooth_opp_profile_summary_connected" msgid="2611913495968309066">"Connexion au serveur de transfert de fichiers"</string>
    <string name="bluetooth_map_profile_summary_connected" msgid="8191407438851351713">"Connecté à la carte"</string>
    <string name="bluetooth_opp_profile_summary_not_connected" msgid="1267091356089086285">"Connexion au serveur de transfert de fichiers non établie"</string>
    <string name="bluetooth_hid_profile_summary_connected" msgid="3381760054215168689">"Connecté au périphérique d\'entrée"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Connecté à l\'appareil pour accès Internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Connexion Internet locale partagée"</string>
    <string name="bluetooth_a2dp_profile_summary_use_for" msgid="4630849022250168427">"Utiliser pour les paramètres audio du support"</string>
    <string name="bluetooth_headset_profile_summary_use_for" msgid="8705753622443862627">"Utiliser pour les paramètres audio du téléphone"</string>
    <string name="bluetooth_opp_profile_summary_use_for" msgid="1255674547144769756">"Utiliser pour le transfert de fichiers"</string>
    <string name="bluetooth_hid_profile_summary_use_for" msgid="232727040453645139">"Utiliser comme entrée"</string>
    <string name="bluetooth_pan_profile_summary_use_for" msgid="5664884523822068653">"Utiliser pour l\'accès à Internet"</string>
    <string name="bluetooth_map_profile_summary_use_for" msgid="5154200119919927434">"Utiliser pour la carte"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Paramètres station d\'accueil"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Utiliser la station d’accueil pour l\'audio"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Comme téléphone à haut-parleur"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Pour la musique et le multimédia"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Mémoriser ces paramètres"</string>
    <string name="wifi_assistant_intro_setup" msgid="4605105515416995110">"Présentation de l\'\nAssistant Wi‑Fi"</string>
    <string name="wifi_assistant_no_thanks" msgid="2776983751990143934">"NON, MERCI"</string>
    <string name="wifi_assistant_setup" msgid="3772423650475730906">"CONFIGURER"</string>
    <string name="wifi_assistant_card_message" msgid="107811647784658536">"Connectez-vous automatiquement aux réseaux à proximité à l\'aide d\'un assistant Wi‑Fi."</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"Assistant Wi‑Fi"</string>
    <string name="wifi_assistant_title_message" msgid="6240721017579074015">"<xliff:g id="WIFI_ASSISTANT">%1$s</xliff:g> vous connecte automatiquement au meilleur réseau Wi‑Fi disponible."</string>
    <string name="wifi_assistant_open_app" msgid="4803044899535675063">"OUVRIR L\'APPLICATION"</string>
    <string name="wifi_display_settings_title" msgid="2925465988657380522">"Écran de diffusion"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Activer l\'affichage sans fil"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Aucun appareil détecté à proximité."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Connexion en cours…"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Connecté"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"En cours d\'utilisation"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Non accessible"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Paramètres d\'affichage"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Options d\'affichage sans fil"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Supprimer"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Terminé"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"nom"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Autoriser l\'échange de données lorsque la tablette est en contact avec un autre appareil"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Autoriser l\'échange de données lorsque le téléphone est en contact avec un autre appareil"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Prêt à partager le contenu de l\'application via NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Désactivées"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Indisponible, car la NFC est désactivée"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="6981652347448777459">"Lorsque cette fonctionnalité est activée, vous pouvez partager le contenu d\'une application avec un appareil compatible NFC en rapprochant les appareils. Vous pouvez, par exemple, partager des pages de navigateur, des vidéos YouTube, des contacts et plus encore.\n\nIl vous suffit de rapprocher les appareils (en les plaçant dos à dos), puis d\'appuyer sur votre écran. L\'application détermine le contenu à transférer."</string>
    <string name="nsd_quick_toggle_title" msgid="3125572815278848258">"Identification du service réseau"</string>
    <string name="nsd_quick_toggle_summary" msgid="155692215972781276">"Autoriser les applications sur d\'autres appareils à identifier les applications sur celui-ci"</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Activer le Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Paramètres Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Configurer et gérer les points d\'accès sans fil"</string>
    <string name="wifi_setup_wizard_title" msgid="8242230950011819054">"Sélectionner le Wi-Fi"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Sélectionner le Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Activation du Wi-Fi en cours…"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Désactivation du Wi-Fi en cours…"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Erreur"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"En mode Avion"</string>
    <string name="wifi_fail_to_scan" msgid="1265540342578081461">"Impossible de rechercher des réseaux."</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Notification de réseau"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Me notifier lorsqu\'un réseau public est disponible"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Éviter les connexions instables"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7843672905900544785">"Ne pas utiliser de réseau Wi-Fi, sauf en cas de connexion Internet de bonne qualité"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"N\'utiliser que réseaux dotés d\'une connexion Internet stable"</string>
    <string name="wifi_scan_always_available" msgid="3470564139944368030">"Recherche toujours disponible"</string>
    <string name="wifi_scan_always_available_title" msgid="1518769058260729007">"Toujours autoriser la recherche"</string>
    <string name="wifi_scan_always_available_summary" msgid="5442775583708315387">"Autoriser le service de localisation de Google et les autres applications à rechercher des réseaux, même si le Wi-Fi est désactivé"</string>
    <string name="wifi_automatically_manage_title" msgid="6249976570008992746">"Gérer automatiquement le Wi‑Fi"</string>
    <string name="wifi_automatically_manage_summary" msgid="6952470763378312488">"Laisser <xliff:g id="WIFI_ASSISTANT">%1$s</xliff:g> gérer votre connexion Wi-Fi"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Installer les certificats"</string>
    <string name="wifi_scan_notify_text_location_on" msgid="8135076005488914200">"Pour améliorer la précision, entre autres, le service de localisation de Google et d\'autres applications peuvent rechercher des réseaux Wi-Fi à proximité, même lorsque le Wi-Fi est désactivé. Vous pouvez modifier ce paramètre dans Options avancées &gt; Recherche toujours disponible."</string>
    <string name="wifi_scan_notify_text_location_off" msgid="6323983741393280935">"Les applications peuvent rechercher des réseaux à proximité, même lorsque le Wi-Fi est désactivé. Vous pouvez modifier ce paramètre dans Options avancées &gt; Recherche toujours disponible."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="5340097010842405981">"Ne plus afficher"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Wi-Fi actif en veille"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi activé pendant la veille"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Un problème est survenu lors de la modification des paramètres."</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Améliorer l\'efficacité"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimisation du Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimiser la consommation de la batterie lorsque le Wi-Fi est activé"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Limiter énergie util. par Wi‑Fi"</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Ajouter un réseau"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Réseaux Wi-Fi"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"Bouton commande WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Plus d\'options"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Saisie NIP WPS"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Scanner"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Options avancées"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Se connecter au réseau"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Retirer le réseau"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modifier le réseau"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Écrire sur la balise NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Activez le Wi-Fi pour voir les réseaux disponibles."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Recherche de réseaux Wi-Fi en cours…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="8280257225419947565">"Vous n\'avez pas l\'autorisation de modifier le réseau Wi‑Fi."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Ajouter un autre réseau"</string>
    <string name="wifi_more" msgid="3195296805089107950">"More"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Configuration auto (WPS)"</string>
    <string name="wifi_required_info_text" msgid="7442238187557620087">"Pour terminer la configuration de votre tablette, vous devez disposer d\'un accès Wi-Fi. Une fois la configuration effectuée, vous pouvez choisir d\'utiliser un réseau de données cellulaires ou le Wi-Fi."</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Options avancées"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Configuration Wi-Fi protégée"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Démarrage de la configuration WPS…"</string>
    <string name="wifi_wps_onstart_pbc" msgid="5940801028985255304">"Appuyez sur le bouton « Configuration Wi-Fi protégée » de votre routeur. Celui-ci peut s\'appeler « WPS » ou contenir ce symbole :"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Saisissez le code d\'accès « <xliff:g id="NUMBER">%1$s</xliff:g> » sur votre routeur Wi-Fi. La configuration peut prendre jusqu\'à deux minutes."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Configuration WPS réussie. Connexion au réseau en cours…"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Connecté au réseau Wi-Fi « <xliff:g id="NETWORK_NAME">%s</xliff:g> »"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"La configuration WPS est déjà en cours et peut prendre jusqu\'à deux minutes."</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Échec de la configuration WPS. Veuillez réessayer dans quelques minutes."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"La configuration de sécurité du routeur sans fil (WEP) n\'est pas compatible."</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"La configuration de sécurité du routeur sans fil (TKIP) n\'est pas compatible."</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Échec de l\'authentification. Veuillez réessayer."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Une autre session WPS a été détectée. Veuillez réessayer dans quelques minutes."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Nom du réseau"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Saisissez le SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Sécurité"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Intensité du signal"</string>
    <string name="wifi_status" msgid="4824568012414605414">"État"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Vitesse de connexion"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Fréquence"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Adresse IP"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Méthode EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Authentification de la phase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certificat CA"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certificat utilisateur"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identité"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonyme"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Mot de passe"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Afficher le mot de passe"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Paramètres IP"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(aucune modification)"</string>
    <string name="wifi_unspecified" msgid="5431501214192991253">"(non spécifié)"</string>
    <string name="wifi_remembered" msgid="4955746899347821096">"Enregistré"</string>
    <string name="wifi_disabled_generic" msgid="4259794910584943386">"Désactivés"</string>
    <string name="wifi_disabled_network_failure" msgid="3111321240793227690">"Mauvaise connexion Internet évitée"</string>
    <string name="wifi_disabled_password_failure" msgid="8659805351763133575">"Problème d\'authentification"</string>
    <string name="wifi_not_in_range" msgid="1136191511238508967">"Hors de portée"</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS disponible"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS disponible)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Entrez votre mot de passe réseau"</string>
    <string name="wifi_security_none" msgid="7985461072596594400">"Aucun"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Pour améliorer la précision de la position et à d\'autres fins, <xliff:g id="APP_NAME">%1$s</xliff:g> souhaite activer la recherche de réseaux, même lorsque le Wi-Fi est désactivé.\n\nDonner cette autorisation à toutes les applications souhaitant activer la recherche de réseaux?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Pour désactiver cette option, sélectionnez « Paramètres avancés » dans le menu à développer."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Autoriser"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Refuser"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Se connecter au point d\'accès pour la connexion?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> requiert connexion pour autoriser l\'accès réseau."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"CONNEXION"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Connexion"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Échec de la connexion au réseau."</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Supprimer"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Échec de la suppression du réseau."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Enregistrer"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Échec de l\'enregistrement du réseau."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Annuler"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Ignorer quand même"</string>
    <string name="wifi_dont_skip" msgid="7350341524881124808">"Ne pas ignorer"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre tablette n\'utilisera que les données cellulaires pour les mises à jour et les téléchargements initiaux. Connectez-vous au Wi-Fi afin d\'éviter d\'éventuels frais liés à la consommation de données."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre appareil n\'utilisera que les données cellulaires pour les mises à jour et les téléchargements initiaux. Connectez-vous au Wi-Fi afin d\'éviter d\'éventuels frais liés à la consommation de données."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre téléphone n\'utilisera que les données cellulaires pour les mises à jour et les téléchargements initiaux. Connectez-vous au Wi-Fi afin d\'éviter d\'éventuels frais liés à la consommation de données."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="2393880108322835846">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre tablette ne disposera d\'aucune connexion Internet pour les mises à jour ou les téléchargements initiaux."</string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1707391993265558787">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre appareil ne disposera d\'aucune connexion Internet pour les mises à jour ou les téléchargements initiaux."</string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="1556858507920033022">"AVERTISSEMENT : Si vous ne configurez pas le Wi-Fi, votre téléphone ne disposera d\'aucune connexion Internet pour les mises à jour ou les téléchargements initiaux."</string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Connexion impossible de la tablette à ce réseau Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Impossible de connecter l\'appareil à ce réseau Wi-Fi."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Connexion impossible du téléphone à ce réseau Wi-Fi."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Réseaux enregistrés"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Paramètres Wi-Fi avancés"</string>
    <string name="wifi_setting_frequency_band_title" msgid="3655327399028584656">"Plage de fréquences Wi-Fi"</string>
    <string name="wifi_setting_frequency_band_summary" msgid="3250740757118009784">"Définir la plage de fréquences"</string>
    <string name="wifi_setting_frequency_band_error" msgid="837281974489794378">"Erreur de paramétrage de la plage de fréquences."</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Adresse MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Adresse IP"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Réseaux enregistrés"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Paramètres IP"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Enregistrer"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Annuler"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Saisissez une adresse IP valide."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Saisissez une adresse de passerelle valide."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Saisissez une adresse DNS correcte."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Le préfixe réseau doit être compris entre 0 et 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Passerelle"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Longueur préfixe réseau"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Données relatives à l\'appareil utilisé"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Mémoriser cette connexion"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Rechercher des appareils"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Searching…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Renommer l\'appareil"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Appareils associés"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Groupes mémorisés"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8921447388048243547">"Impossible de se connecter."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Échec du changement de nom de l\'appareil."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Voulez-vous vraiment vous déconnecter?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"If you disconnect, your connection with <xliff:g id="PEER_NAME">%1$s</xliff:g> will end."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Si vous vous déconnectez, votre connexion avec <xliff:g id="PEER_NAME">%1$s</xliff:g> et <xliff:g id="PEER_COUNT">%2$s</xliff:g> autres appareils prendra fin."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Annuler l\'invitation?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Voulez-vous annuler l\'invitation à se connecter avec <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Voulez-vous vraiment supprimer ce groupe?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Point d\'accès Wi-Fi mobile"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Point d\'accès Wi‑Fi"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Util. conn. cell. pour fournir rés. Wi‑Fi"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Activation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Désactivation du point d\'accès Wi-Fi en cours…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Point d\'accès Wi-Fi mobile <xliff:g id="NETWORK_SSID">%1$s</xliff:g> actif"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Erreur liée au point d\'accès Wi-Fi mobile."</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Configurer le point d\'accès Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Configuration point accès Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"Point acc. Wi‑Fi port. AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"Point d\'accès Wi-Fi mobile <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="home_settings" msgid="212375129455718176">"Accueil"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Affichage"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Son"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volume"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Effets musicaux"</string>
    <string name="ring_volume_title" msgid="7938706566797464165">"Volume de la sonnerie"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrer en mode silencieux"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Son de notification par défaut"</string>
    <string name="heads_up_enabled_title" msgid="1031078221910921622">"Fen. context. priorité élevée"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Sonnerie"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Notification"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Utiliser le volume des appels entrants pour les notifications"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Non compatible avec les profils professionnels"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Son de notification par défaut"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Médias"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Régler le volume pour la musique et les vidéos"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarme"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Paramètres audio de la station d\'accueil associée"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Numérotation sonore"</string>
    <string name="sound_effects_enable_title" msgid="1171590821131077296">"Sons des touches"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Son au verrouillage écran"</string>
    <string name="haptic_feedback_enable_title" msgid="2438293710530828760">"Vibrer au toucher"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Suppression du bruit"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Musique, vidéo, jeux et autres fichiers multimédias"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Sonnerie et notifications"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Notifications"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmes"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Couper la sonnerie et le son des notifications"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Couper le son de la musique et des autres médias"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Désactiver les notifications"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Couper le son des alarmes"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dock"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Paramètres station d’accueil"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Paramètres de la station d\'accueil de bureau associée"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Paramètres du support voiture associé"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablette non insérée dans la station d\'accueil"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Le téléphone n\'est pas sur sa base."</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Paramètres de la station d’accueil associée"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Station d\'accueil introuvable"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Vous devez poser la tablette sur la station d\'accueil avant de configurer les paramètres audio de cette dernière."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Vous devez poser le téléphone sur la station d\'accueil avant de configurer les paramètres audio de celle-ci."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Son d\'insertion dans la station d\'accueil"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Émettre un son lorsque la tablette est insérée dans la station d\'accueil ou retirée de celle-ci"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Émettre un son lorsque le téléphone est inséré dans la station d\'accueil ou retiré de celle-ci"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="5077843049805652363">"N\'émettre aucun son lorsque la tablette est insérée dans la station d\'accueil ou retirée de celle-ci"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="3151046599205265919">"N\'émettre aucun son lorsque le téléphone est inséré dans la station d\'accueil ou retiré de celle-ci"</string>
    <string name="account_settings" msgid="6403589284618783461">"Comptes"</string>
    <string name="category_personal" msgid="1299663247844969448">"Personnel"</string>
    <string name="category_work" msgid="8699184680584175622">"Travail"</string>
    <string name="search_settings" msgid="1910951467596035063">"Rechercher"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Configurer les paramètres et l\'historique de recherche"</string>
    <string name="display_settings" msgid="7965901687241669598">"Affichage"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Rotation auto de l\'écran"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Changer automatiquement d\'orientation lors de la rotation de la tablette"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Changer automatiquement d\'orientation lors de la rotation"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Changer automatiquement d\'orientation lors de la rotation de la tablette"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Changer automatiquement d\'orientation lors de la rotation"</string>
    <string name="brightness" msgid="8480105032417444275">"Niveau de luminosité"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Luminosité"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Régler la luminosité de l\'écran"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Luminosité adaptative"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimise le niveau de luminosité en fonction de l\'éclairage ambiant"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Veille"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"L\'écran s\'éteint"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Après <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> d\'inactivité"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Fond d\'écran"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Sélectionnez un fond d\'écran dans"</string>
    <string name="screensaver_settings_title" msgid="3349790120327233241">"Écran de veille interactif"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Lorsque l\'appareil est installé sur la station d\'accueil ou lorsqu\'il est en veille et en charge"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Les deux"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"En charge"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Sur la station d\'accueil"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Désactivé"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="3857507943322777651">"Pour contrôler le comportement du téléphone lorsqu\'il se trouve sur une station d\'accueil et/ou lorsqu\'il est en veille, activez l\'écran de veille interactif."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8352267826043957746">"Quand passer en mode veille"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Commencer maintenant"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Paramètres"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Ajuster automatiquement la luminosité"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Soulever pour activer"</string>
    <string name="doze_title" msgid="2259176504273878294">"Affichage en mode Veille"</string>
    <string name="doze_summary" msgid="8300817661725517088">"Activer l\'écran en cas de déplacement de l\'appareil ou d\'arrivée d\'une notification"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Taille de police"</string>
    <string name="dialog_title_font_size" msgid="2231507851258955038">"Taille de police"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Paramètres de verrouillage de la carte SIM"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Configurer le blocage de la carte SIM"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Verrouillage de la carte SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Bloquer la carte SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Demander le NIP pour utiliser la tablette"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Demander le NIP pour utiliser le téléphone"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Demander le NIP pour utiliser la tablette"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Demander le NIP pour utiliser le téléphone"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Modifier le NIP de la carte SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"NIP de la carte SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Bloquer la carte SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Débloquer la carte SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Ancien NIP de la carte SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nouveau NIP de la carte SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Confirmez le nouveau NIP"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"NIP de la carte SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"NIP incorrect."</string>
    <string name="sim_pins_dont_match" msgid="8449681619822460312">"Les NIP ne correspondent pas."</string>
    <string name="sim_change_failed" msgid="304964924772218382">"Impossible de modifier le NIP.\nLe NIP est peut-être incorrect."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Le NIP de la carte SIM a été modifié."</string>
    <string name="sim_lock_failed" msgid="5651596916127873626">"Impossible de changer l\'état de verrouillage de la carte SIM.\nLe NIP est peut-être incorrect."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Annuler"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Plusieurs cartes SIM détectées"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Sélectionnez la carte SIM que vous préférez pour les données cellulaires."</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"NIP de carte SIM incorrect. Vous devez maintenant communiquer avec votre fournisseur de services pour déverrouiller votre appareil."</string>
  <plurals name="wrong_pin_code">
    <item quantity="one" msgid="4840607930166101114">"NIP de carte SIM incorrect. Il vous reste <xliff:g id="NUMBER">%d</xliff:g> tentative. Après cela, vous devrez communiquer avec votre fournisseur de services pour déverrouiller votre appareil."</item>
    <item quantity="other" msgid="77103619544346451">"NIP de carte SIM incorrect. Il vous reste <xliff:g id="NUMBER">%d</xliff:g> tentative(s)."</item>
  </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Le déverrouillage par NIP de carte SIM a échoué."</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"État de la tablette"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"État du téléphone"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Mises à jour du système"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Version d\'Android"</string>
    <string name="model_number" msgid="3765737700545384794">"Numéro du modèle"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Equipment ID"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Version de bande de base"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Version du noyau"</string>
    <string name="build_number" msgid="3075795840572241758">"Numéro de build"</string>
    <string name="selinux_status" msgid="6212165375172061672">"État SELinux"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Non disponible"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"État"</string>
    <string name="device_status" msgid="607405385799807324">"État"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"État de la batterie, état du réseau et autres informations"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Numéro de téléphone, signal, etc."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Stockage"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Paramètres de stockage"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Désinstaller la mémoire de stockage USB, afficher l\'espace disponible"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Désinstaller la carte SD, afficher la mémoire disponible"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Mon numéro de téléphone"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Version de la liste d\'itinérance préférée"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Type de réseau cellulaire"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Informations sur l\'opérateur"</string>
    <string name="status_data_state" msgid="4578972321533789767">"État du réseau cellulaire"</string>
    <string name="status_service_state" msgid="2323931627519429503">"État du service"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Intensité du signal"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Itinérance"</string>
    <string name="status_operator" msgid="2274875196954742087">"Réseau de chaînes"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Adresse MAC Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Adresse Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Numéro de série"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Non accessible"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Durée d\'activité"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Temps en activité"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Mémoire de stockage interne"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Mémoire de stockage USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Carte SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Disponible"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Disponible (en lecture seule)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Espace total"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Calcul en cours"</string>
    <string name="memory_apps_usage" msgid="2348501997988663688">"Applis (données des applis et contenu multimédia)"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Médias"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"téléchargements"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Images, vidéos"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (musique, sonneries, podcasts, etc.)"</string>
    <string name="memory_media_misc_usage" msgid="235452944021647124">"Divers"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Données mises en cache"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Démonter le stockage partagé"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Désinstaller la carte SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Désinstaller la mémoire de stockage USB interne"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Désinstaller la carte SD pour la retirer en toute sécurité"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Insérer la mémoire de stockage USB à installer"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Insérer la carte SD à installer"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Installer mémoire stockage USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Installer la carte SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Effacer la mémoire de stockage USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Effacer la carte SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Effacer les données de la mémoire de stockage USB interne (ex. : musique, photos)"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Effacer toutes les données de la carte SD, telles que la musique et les photos"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Effacer les données mises en cache?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Les données en cache des applis seront effacées."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"La fonctionnalité MTP ou PTP est active."</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Désinstaller mémoire USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Désinstaller la carte SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Si vous désinstallez la mémoire de stockage USB, certaines applications en cours d\'utilisation seront fermées. Elles risquent de rester indisponibles jusqu\'à ce que la mémoire de stockage USB soit réinstallée."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Si vous désinstallez la carte SD, certaines applications en cours d\'utilisation s\'arrêteront et risquent de ne plus être disponibles tant que vous n\'aurez pas réinstallé la carte SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="4346280469528260684">"Impossible de désinstaller la mémoire de stockage USB. Réessayez plus tard."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3073562815631781894">"Impossible de désinstaller la carte SD. Réessayez plus tard."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"La mémoire de stockage USB va être désinstallée."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"La carte SD va être retirée."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Désinstallation"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Désinstallation en cours"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Espace de stockage bientôt saturé"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Il est possible que certaines fonctionnalités du système, comme la synchronisation, ne soient pas opérationnelles. Libérez de l\'espace en supprimant certains éléments (applications ou contenu multimédia, par exemple) ou en annulant leur épinglage."</string>
    <string name="storage_menu_usb" msgid="5708207885333243384">"Connexion USB à l\'ordinateur"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Connexion USB à l\'ordinateur"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Connecter en tant que"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Périphérique multimédia (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Permet de transférer des fichiers multimédias sous Windows ou à l\'aide de l\'application Android File Transfer pour Mac (voir www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Appareil photo (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7673397474756664929">"Permet de transférer des photos à l\'aide du logiciel photo et de transférer des fichiers sur les ordinateurs non compatibles avec le protocole MTP."</string>
    <string name="usb_label_installer_cd" msgid="4331173824920630215">"Installer des outils de transfert de fichiers"</string>
    <string name="storage_other_users" msgid="808708845102611856">"Autres utilisateurs"</string>
    <string name="battery_status_title" msgid="9159414319574976203">"État de la batterie"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Niveau de la batterie"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Modifier le point d\'accès"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Non défini"</string>
    <string name="apn_name" msgid="4115580098369824123">"nom"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Nom du point d\'accès"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Serveur mandataire"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Nom d\'utilisateur"</string>
    <string name="apn_password" msgid="5412301994998250968">"Mot de passe"</string>
    <string name="apn_server" msgid="2436185314756372858">"Serveur"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Serveur mandataire MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Port MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Type d\'authentification"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Aucun"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ou CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Type d\'APN"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protocole de l\'APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protocole APN en itinérance"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Activer/Désactiver l\'APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN activé"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN désactivé"</string>
    <string name="bearer" msgid="594270280031923558">"Réseau"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Type MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Valeur MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Supprimer l\'APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nouvel APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Enregistrer"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Annuler"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="8418502878620394756">"Le champ « Nom » est obligatoire."</string>
    <string name="error_apn_empty" msgid="6056233831214537267">"L\'APN est obligatoire."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Le champ MCC doit contenir 3 chiffres."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Le champ MNC doit contenir 2 ou 3 chiffres."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Restauration des paramètres APN par défaut en cours..."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Rétablir les valeurs par défaut"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"La réinitialisation des paramètres APN par défaut est terminée."</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Réinitialiser l\'appareil"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Rétablir configuration d\'usine"</string>
    <string name="master_clear_summary" product="tablet" msgid="4036344100254678429">"Effacer toutes les données de la tablette"</string>
    <string name="master_clear_summary" product="default" msgid="4986154238001088492">"Effacer toutes les données du téléphone"</string>
    <string name="master_clear_desc" product="tablet" msgid="8317211882509025841">"Cette action effacera toutes les données de la "<b>"mémoire de stockage interne"</b>" de votre tablette, y compris :\n\n"<li>"Votre compte Google"</li>\n<li>"Les données et paramètres du système et de l\'application"</li>\n<li>"Les applications téléchargées"</li></string>
    <string name="master_clear_desc" product="default" msgid="9165016501623540228">"Cette action effacera toutes les données du "<b>"stockage interne"</b>" de votre téléphone, y compris :\n\n"<li>"Votre compte Google"</li>\n<li>"Les données et paramètres du système et de l\'application"</li>\n<li>"Les applications téléchargées"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Vous êtes actuellement connecté aux comptes suivants :\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Musique"</li>\n<li>"Photos"</li>\n<li>"Autres données utilisateur"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Pour supprimer la musique, les photos et les autres données utilisateur, vous devez effacer la "<b>"mémoire de stockage USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Pour supprimer la musique, les photos et les autres données utilisateur, vous devez effacer la "<b>"carte SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Effacer la mémoire de stockage USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Effacer la carte SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Effacer toutes les données de la mémoire de stockage USB interne, telles que la musique ou les photos"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Effacer toutes les données de la carte SD, telles que la musique ou les photos"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Réinitialiser la tablette"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Réinitialiser le téléphone"</string>
    <string name="master_clear_final_desc" msgid="7209547812233487345">"Effacer toutes vos informations personnelles et les applications téléchargées? Cette action est irréversible."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Tout effacer"</string>
    <string name="master_clear_gesture_prompt" msgid="1428645764883536750">"Dessinez votre schéma de déverrouillage."</string>
    <string name="master_clear_gesture_explanation" msgid="826193821455182780">"Vous devez dessiner votre schéma de déverrouillage pour confirmer le rétablissement de la configuration d\'usine."</string>
    <string name="master_clear_failed" msgid="7959646179737950703">"Les données n\'ont pas été réinitialisées, car le service de nettoyage du système n\'est pas disponible."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Réinitialiser?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Le rétablissement de la configuration d\'usine n\'est pas possible pour cet utilisateur"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Suppression en cours..."</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Veuillez patienter..."</string>
    <string name="media_format_title" product="nosdcard" msgid="3999653431422767156">"Effacer la mémoire de stockage USB"</string>
    <string name="media_format_title" product="default" msgid="4427528440306787972">"Effacer la carte SD"</string>
    <string name="media_format_summary" product="nosdcard" msgid="776603298628082065">"Efface toutes les données de la mémoire de stockage USB."</string>
    <string name="media_format_summary" product="default" msgid="3805714639375830120">"Permet d\'effacer toutes les données de la carte SD"</string>
    <string name="media_format_desc" product="nosdcard" msgid="4557243156946319034">"Effacer toute la mémoire de stockage USB? Vous allez perdre "<b>"toutes"</b>" les données stockées."</string>
    <string name="media_format_desc" product="default" msgid="8764037252319942415">"Effacer la carte SD? "<b>"Toutes"</b>" les données de la carte seront perdues."</string>
    <string name="media_format_button_text" product="nosdcard" msgid="6293669371185352810">"Effacer la mémoire de stockage USB"</string>
    <string name="media_format_button_text" product="default" msgid="6721544380069373626">"Effacer la carte SD"</string>
    <string name="media_format_final_desc" product="nosdcard" msgid="699929778486375913">"Effacer la mémoire de stockage USB en supprimant tous les fichiers qu\'elle contient? Cette action est irréversible."</string>
    <string name="media_format_final_desc" product="default" msgid="3344525419872744989">"Effacer la carte SD en supprimant tous les fichiers qu\'elle contient? Cette action est irréversible."</string>
    <string name="media_format_final_button_text" msgid="4881713344315923175">"Tout effacer"</string>
    <string name="media_format_gesture_prompt" msgid="3109349468816856670">"Dessinez votre schéma de déverrouillage."</string>
    <string name="media_format_gesture_explanation" product="nosdcard" msgid="2192044794228379224">"Vous devez dessiner votre schéma de déverrouillage pour confirmer l\'effacement de la mémoire de stockage USB."</string>
    <string name="media_format_gesture_explanation" product="default" msgid="6288926293245938415">"Vous devez dessiner votre schéma de déverrouillage pour confirmer l\'effacement de la carte SD."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Paramètres d\'appel"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Configurer la messagerie vocale, le transfert d\'appel, la mise en attente d\'appels, le numéro de l\'appelant"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Partage de connexion par USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Point d\'accès Wi-Fi mobile"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Via Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Partage de connexion"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Partage de connexion et point d\'accès mobile"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Partage de connexion par USB"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"Connexion USB établie, cochez l\'option adéquate pour partager la connexion."</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Partage de connexion"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="5210094834194907094">"Impossible de partager la connexion lorsqu\'une mémoire de stockage USB est utilisée."</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB non connecté"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Connectez-vous pour activer cette fonction"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Erreur liée au partage de connexion via USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Via Bluetooth"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="8811610320942954709">"Connexion Internet de la tablette partagée"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="4229220575771946723">"Connexion Internet du téléphone partagée"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="2730938191906597896">"Connexion Internet de la tablette partagée avec un appareil"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="1666736165420290466">"Connexion Internet du téléphone partagée avec un appareil"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="1180765608259580143">"Connexion Internet tablette partagée avec <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> appareils"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8248942539362173005">"Connexion Internet du téléphone partagée avec <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> appareils"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="1790242032929221788">"Partager la connexion Internet de <xliff:g id="DEVICE_NAME">%1$d</xliff:g>"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="2093881379028235555">"Connexion Internet de la tablette non partagée"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="706860924389041342">"Connexion Internet du téléphone non partagée"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Pas de partage de connexion."</string>
    <string name="bluetooth_tethering_overflow_error" msgid="6285122039489881969">"Partage connexion impossible au-delà de <xliff:g id="MAXCONNECTION">%1$d</xliff:g> appareils."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Le partage de connexion avec <xliff:g id="DEVICE_NAME">%1$s</xliff:g> va être annulé."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Aide"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Réseaux cellulaires"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Forfait de données cellulaires"</string>
    <string name="sms_application_title" msgid="6134351177937015839">"Application de texto par défaut"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Modifier l\'application de messagerie texte?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Utiliser <xliff:g id="NEW_APP">%1$s</xliff:g> au lieu de <xliff:g id="CURRENT_APP">%2$s</xliff:g> comme application de messagerie texte?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> comme application de messagerie texte?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Changer d\'assistant Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Utilisez <xliff:g id="NEW_APP">%1$s</xliff:g> au lieu de <xliff:g id="CURRENT_APP">%2$s</xliff:g> pour gérer vos connexions réseau?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> pour gérer vos connexions réseau?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Fournisseur de la carte SIM inconnu"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"Aucun site Web de configuration connu pour %1$s"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Insérez la carte SIM, puis redémarrez."</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Connectez-vous à Internet."</string>
    <string name="location_title" msgid="1029961368397484576">"My Location"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Mode"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Haute précision"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Économie de la batterie"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Appareil uniquement"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Localisation désactivée"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Demandes localisation récentes"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Aucune application n\'a récemment demandé l\'accès à votre position"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Services de localisation"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Forte utilisation de la pile"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Faible utilisation de la pile"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Mode de localisation"</string>
    <string name="location_mode_high_accuracy_description" msgid="5349014493087338351">"Utiliser le GPS, le Wi‑Fi et les réseaux cellulaires pour déterminer la position"</string>
    <string name="location_mode_battery_saving_description" msgid="7581657383062066461">"Utiliser le Wi‑Fi et les réseaux cellulaires pour déterminer la position"</string>
    <string name="location_mode_sensors_only_description" msgid="7178415350457794366">"Utiliser le GPS pour déterminer la position"</string>
    <string name="location_network_based" msgid="6010456018401296590">"Local. par Wi-Fi et rés. cell."</string>
    <string name="location_neighborhood_level" msgid="5626515380188353712">"Autoriser applis à utiliser localisation Google pour estimer position plus rapidement. Infos localisation anonymes envoyées à Google."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Position déterminée par le Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satellites GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Autoriser les applications à utiliser le GPS sur votre tablette pour vous localiser"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Autoriser les applications à utiliser le GPS sur votre téléphone pour vous localiser"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Utiliser le GPS assisté"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Utiliser le serveur pour assister le GPS (désactiver pour réduire l\'utilisation du réseau)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Utiliser le serveur pour assister le GPS (désactiver pour améliorer les performances du GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Localisation/recherche Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Autoriser Google à utiliser votre position pour améliorer les résultats de recherche et les services"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Accès à ma position"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Permettre aux applis ayant demandé l\'autorisation d\'utiliser vos infos de localisation"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Sources de localisation"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"À propos de la tablette"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"À propos du téléphone"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Informations légales, état et version du logiciel"</string>
    <string name="legal_information" msgid="5769301644270604095">"Renseignements juridiques"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Contributeurs"</string>
    <string name="regulatory_information" msgid="5695464367088752150">"Infos réglementaires"</string>
    <string name="copyright_title" msgid="865906688917260647">"Droits d\'auteur"</string>
    <string name="license_title" msgid="1990487604356037871">"Licence"</string>
    <string name="terms_title" msgid="7697580845616764642">"Conditions d\'utilisation"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Fonds d\'écran"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Fournisseurs d\'images satellite :\n© CNES/Astrium, DigitalGlobe, Bluesky 2014"</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Licences Open Source"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Un problème est survenu lors du chargement des licences."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Chargement en cours..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informations de sécurité"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informations de sécurité"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="232523852222964470">"Vous n\'avez pas de connexion Internet. Pour consulter ces informations maintenant, accédez à %s depuis un ordinateur connecté à Internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Chargement en cours..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Choisir votre mot de passe"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Choisissez votre schéma"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Choisir votre NIP"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Confirmer le mot de passe"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Confirmez votre schéma"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Confirmer votre NIP"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="6850677112663979120">"Les mots de passe ne correspondent pas."</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="4757532830594400147">"Les NIP ne correspondent pas."</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Méthode de déverrouillage"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Le mot de passe a été défini."</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Le NIP a été défini."</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Le schéma a été défini."</string>
    <string name="lock_settings_title" msgid="335025124489630932">"Sécurité de l\'écran"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Modifier le schéma"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Modifier le NIP de déverrouillage"</string>
    <string name="lockpattern_need_to_unlock" msgid="757935356911054465">"Confirmer le schéma enregistré"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="4694973540770105678">"Réessayer :"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Dessiner un schéma de déverrouillage"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Appuyez sur Menu pour obtenir de l\'aide."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Retirez le doigt lorsque vous avez terminé."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Reliez au moins <xliff:g id="NUMBER">%d</xliff:g> points. Veuillez réessayer."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Schéma enregistré"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Redessinez le schéma pour confirmer"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Votre nouveau schéma de déverrouillage est le suivant :"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Confirmer"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Redessiner"</string>
    <string name="lockpattern_retry_button_text" msgid="1949847413862309134">"Réessayer"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Continuer"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Schéma de déverrouillage"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Schéma obligatoire"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Dessiner un schéma pour déverrouiller l\'écran"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Faire apparaître le schéma"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="8898518337442601027">"Vibrer au toucher"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Verr. auto MARCHE-ARRÊT"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Sauf lorsque l\'appareil est maintenu en activité par <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Créer un schéma"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Modifier le schéma"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Comment dessiner un schéma de déverrouillage :"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_header" msgid="819903817323783498">"Trop de tentatives échouées!"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer" msgid="6759029360597122873">"Veuillez réessayer dans <xliff:g id="NUMBER">%d</xliff:g> secondes."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"L\'application n\'est pas installée sur votre téléphone."</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Gérer les applications"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Gérer et supprimer les applications installées"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Applications"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Gérer les applications, configurer des raccourcis de lancement rapide"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Paramètres de l\'application"</string>
    <string name="install_applications" msgid="4872012136210802181">"Sources inconnues"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Autoriser toutes sources appli"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Vous permet d\'installer applis de sources autres que Google Play."</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Autoriser l\'installation d\'applications issues de sources inconnues"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Votre tablette et vos données personnelles sont plus vulnérables face aux attaques d\'applications provenant de sources inconnues. Vous reconnaissez être seul responsable de tout dommage subi par votre tablette ou de toute perte de données pouvant découler de l\'utilisation de ces applications."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Votre téléphone et vos données personnelles sont plus vulnérables face aux attaques d\'applications provenant de sources inconnues. Vous reconnaissez être seul responsable de tout dommage subi par votre téléphone ou de toute perte de données pouvant découler de l\'utilisation de ces applications."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Paramètres avancés"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Activer d\'autres paramètres"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Informations sur l\'application"</string>
    <string name="storage_label" msgid="8700867073480107253">"Stockage"</string>
    <string name="auto_launch_label" msgid="3012617472833815382">"Lancer par défaut"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Valeurs par défaut"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Compatibilité de l\'écran"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Permissions"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Vider le cache"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Cache"</string>
    <string name="controls_label" msgid="7611113077086853799">"Commandes"</string>
    <string name="force_stop" msgid="7435006169872876756">"Forcer l\'arrêt"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Total"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Application"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Application sur USB"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Données"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Données sur USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Carte SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Désinstaller"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Uninstall for all users"</string>
    <string name="install_text" msgid="884360662922471113">"Installer"</string>
    <string name="disable_text" msgid="6544054052049395202">"Désactiver"</string>
    <string name="enable_text" msgid="9217362512327828987">"enable"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Effacer les données"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Désinstaller mises à jour"</string>
    <string name="auto_launch_enable_text" msgid="2652825923953591251">"Vous avez choisi de lancer cette application par défaut pour certaines actions."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="3368654672141202604">"Vous avez choisi de permettre à cette application de créer des widgets et d\'accéder à leurs données."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Aucun paramètre par défaut défini"</string>
    <string name="clear_activities" msgid="7408923511535174430">"Effacer les actions par défaut"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Cette application n\'est peut-être pas adaptée à votre écran. Vous pouvez modifier les paramètres d\'ajustement ici."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Demander au moment du lancement"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Mettre l\'application à l\'échelle"</string>
    <string name="unknown" msgid="1592123443519355854">"Inconnu"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Trier par nom"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Trier par taille"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Afficher les services en cours"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Afficher processus en cache"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Réinitialiser préf. applis"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Réinitialiser préférences?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"Cette opération a pour effet de réinitialiser toutes les préférences relatives aux éléments suivants :\n\n "<li>"Applications désactivées"</li>\n" "<li>"Notifications associées aux applications désactivées"</li>\n" "<li>"Applications par défaut pour les actions"</li>\n" "<li>"Restrictions de données en arrière-plan pour les applications"</li>\n" "<li>"Toutes les restrictions d\'autorisations"</li>\n\n" Vous ne perdrez aucune donnée liée aux applications."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Réinitialiser applis"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Gérer l\'espace"</string>
    <string name="filter" msgid="2018011724373033887">"Filtre"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Sélectionner les options du filtre"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Tous"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Désactivées"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Téléchargée"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Diffusion en cours"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Mémoire de stockage USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Sur la carte SD"</string>
    <string name="disabled" msgid="9206776641295849915">"Désactivés"</string>
    <string name="not_installed" msgid="1475144352069281880">"Non installée"</string>
    <string name="no_applications" msgid="7336588977497084921">"Aucune application"</string>
    <string name="internal_storage" msgid="1584700623164275282">"Mémoire de stockage interne"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Mémoire de stockage USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Stockage sur la carte SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Calcul de la taille..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Supprimer les données de l\'application?"</string>
    <string name="clear_data_dlg_text" msgid="8847257251846779938">"Toutes les données de cette application vont être définitivement supprimées, y compris tous les fichiers, les paramètres, les comptes, les bases de données, etc."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Annuler"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="8333723538280257243">"L\'application ne figure pas dans la liste des applications installées."</string>
    <string name="clear_data_failed" msgid="1907582169616856698">"Impossible d\'effacer les données de l\'application."</string>
    <string name="app_factory_reset_dlg_title" msgid="7441012826373143593">"Désinstaller les mises à jour?"</string>
    <string name="app_factory_reset_dlg_text" msgid="6371247225487725860">"Toutes les mises à jour de cette application système Android vont être désinstallées."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Effacer les données"</string>
    <string name="clear_failed_dlg_text" msgid="1092177570631523106">"Impossible de supprimer les données de l\'application."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Cette application peut accéder aux éléments suivants de votre tablette :"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Cette application peut accéder aux éléments suivants de votre téléphone :"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Cette application peut accéder aux éléments de votre tablette répertoriés ci-dessous. Afin d\'améliorer les performances et de réduire l\'utilisation de la mémoire, certaines autorisations sont accordées à <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, car elle s\'exécute au sein du même processus que les applications <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g> :"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Cette application peut accéder aux éléments de votre téléphone répertoriés ci-dessous. Afin d\'améliorer les performances et de réduire l\'utilisation de la mémoire, certaines autorisations sont accordées à <xliff:g id="BASE_APP_NAME">%1$s</xliff:g>, car elle s\'exécute au sein du même processus que les applications <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g> :"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> et <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> et <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Cette application peut engendrer des frais :"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Envoyer un SMS premium"</string>
    <string name="computing_size" msgid="1599186977475211186">"Traitement..."</string>
    <string name="invalid_size_value" msgid="7563537715280712285">"Impossible de calculer la taille du package."</string>
    <string name="empty_list_msg" msgid="5993162337235907160">"Aucune application tierce n\'est installée."</string>
    <string name="version_text" msgid="9189073826278676425">"version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Déplacer"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Déplacer vers la tablette"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Déplacer vers le téléphone"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Déplacer vers la mémoire de stockage USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Déplacer vers la carte SD"</string>
    <string name="moving" msgid="6431016143218876491">"Déplacement en cours"</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Espace de stockage insuffisant."</string>
    <string name="does_not_exist" msgid="3476487214886606748">"L\'application n\'existe pas."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"L\'application est protégée contre la copie."</string>
    <string name="invalid_location" msgid="2786030127356312746">"L\'emplacement d\'installation n\'est pas valide."</string>
    <string name="system_package" msgid="6222593098063037137">"Les mises à jour du système ne peuvent pas être installées sur des supports externes."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Forcer l\'arrêt?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Si vous forcez l\'arrêt d\'une application, cela peut provoquer son dysfonctionnement."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="3465267182923054022">"Impossible de déplacer l\'application. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Emplacement d\'installation souhaité"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Modifier l\'emplacement d\'installation par défaut pour les nouvelles applications"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Désactiver appli intégrée?"</string>
    <string name="app_disable_dlg_text" msgid="3562567756362627323">"Si vous désactivez une application intégrée, cela peut provoquer des dysfonctionnements d\'autres applications."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Supprimer les données et désactiver l\'application?"</string>
    <string name="app_special_disable_dlg_text" msgid="3447657419284854195">"Si vous désactivez une application intégrée, d\'autres applications peuvent avoir un comportement défaillant. Vos données seront également supprimées."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Désactiver les notifications?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Si vous désactivez les notifications de cette application, vous risquez de manquer des alertes et des mises à jour importantes."</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Fonctionnement des applications"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"En cours d\'exécution"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Jamais utilisé)"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Utilisation de la mémoire"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Afficher l\'espace de stockage utilisé par les applications"</string>
    <string name="runningservices_settings_title" msgid="8097287939865165213">"Services en cours d\'exécution"</string>
    <string name="runningservices_settings_summary" msgid="854608995821032748">"Afficher et contrôler les services en cours d\'exécution"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Redémarrage"</string>
    <string name="cached" msgid="1059590879740175019">"Processus d\'arrière-plan en cache"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Aucun service en cours"</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Démarré par l\'application"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> disponible"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> utilisé(s)"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Utilisateur : <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Utilisateur supprimé"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> service"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processus et <xliff:g id="NUMSERVICES">%2$d</xliff:g> services"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Mémoire de l\'appareil"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Utilisation de la mémoire vive par l\'application"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Système"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Applications"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Disponible"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Utilisée"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"En cache"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> de mémoire vive"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Application en cours d\'exécution"</string>
    <string name="no_services" msgid="7133900764462288263">"Inactif"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Services"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Processus"</string>
    <string name="service_stop" msgid="6369807553277527248">"Arrêter"</string>
    <string name="service_manage" msgid="1876642087421959194">"Paramètres"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Ce service a été démarré par son application. L\'application peut échouer si vous l\'arrêtez."</string>
    <string name="heavy_weight_stop_description" msgid="2979218727598321095">"Impossible d\'arrêter cette application en toute sécurité. Si vous l\'arrêtez, vous risquez de perdre une partie du travail en cours."</string>
    <string name="background_process_stop_description" msgid="5034773197139654588">"Ceci est un ancien processus d\'application qui peut toujours être exécuté en cas de besoin. Il n\'existe généralement aucune raison de l\'arrêter."</string>
    <string name="service_manage_description" msgid="7050092269951613102">"En cours d\'utilisation : <xliff:g id="CLIENT_NAME">%1$s</xliff:g>. Appuyez sur Paramètres pour contrôler ce client."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Processus principal en cours d\'utilisation."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Le service <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"L\'opérateur <xliff:g id="COMP_NAME">%1$s</xliff:g> est actuellement utilisé."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Arrêter le service système?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Si vous arrêtez ce service, certaines fonctionnalités de votre tablette peuvent cesser de fonctionner correctement jusqu\'à ce que vous ayez éteint, puis rallumé votre appareil."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Si vous arrêtez ce service, certaines fonctionnalités de votre téléphone peuvent cesser de fonctionner correctement jusqu\'à ce que vous ayez éteint, puis rallumé votre appareil."</string>
    <string name="language_settings" msgid="5292716747264442359">"Langue et saisie"</string>
    <string name="language_keyboard_settings_title" msgid="243220021717425813">"Langue et saisie"</string>
    <string name="language_settings_category" msgid="2288258489940617043">"Paramètres de langue"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Clavier et modes de saisie"</string>
    <string name="phone_language" msgid="8870144109924299673">"Langue"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Remplacement automatique"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Corriger les mots mal saisis"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Majuscules automatiques"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Mettre une majuscule en début de phrase"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Ponctuation automatique"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Paramètres du clavier physique"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Appuyez deux fois sur la touche Espace pour insérer « . »"</string>
    <string name="show_password" msgid="3001113966880559611">"Faire apparaître mots de passe"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"Ce mode de saisie est susceptible d\'enregistrer le texte que vous saisissez, y compris vos données personnelles, telles que les mots de passe et les numéros de carte de paiement. Il provient de l\'application <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Voulez-vous vraiment l\'activer?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ce correcteur orthographique peut recueillir l\'ensemble du texte saisi, y compris des données personnelles comme des mots de passe et des numéros de carte de paiement. Il provient de l\'application <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Utiliser ce correcteur orthographique?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Paramètres"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Langue"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Échec de l\'ouverture des paramètres de l\'application <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g>."</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Souris/Pavé tactile"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Vitesse du pointeur"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Manette de jeu"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Utiliser le vibreur"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Rediriger le vibreur vers la manette de jeu lorsque vous êtes connecté"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Sélectionner disposition du clavier"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Configurer dispositions clavier"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Appuyez sur Ctrl+Espace pour changer disposition"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Par défaut"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Dispositions du clavier"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Dictionnaire personnel"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Add"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Ajouter au dictionnaire"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Expression"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Plus d\'options"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Moins d\'options"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Mot :"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Raccourci :"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Langue :"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Saisissez un mot"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Raccourci facultatif"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Modifier le mot"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Modifier"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Supprimer"</string>
    <string name="user_dict_settings_empty_text" msgid="8165273379942105271">"Votre dictionnaire personnel ne contient aucun mot. Ajoutez un mot en appuyant sur le bouton d\'ajout (« + »)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Pour toutes les langues"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Plus de langues…"</string>
    <string name="testing" msgid="6584352735303604146">"Tests"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informations sur la tablette"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informations sur le téléphone"</string>
    <string name="testing_battery_info" msgid="3497865525976497848">"Informations sur la batterie"</string>
    <string name="quick_launch_title" msgid="7904609846945905306">"Lancement rapide"</string>
    <string name="quick_launch_summary" msgid="8101133819188001190">"Configurer des raccourcis clavier pour lancer des applications"</string>
    <string name="quick_launch_assign_application" msgid="6240064079456617501">"Attribuer l\'application"</string>
    <string name="quick_launch_no_shortcut" msgid="5998005833838278693">"Aucun raccourci"</string>
    <string name="quick_launch_shortcut" msgid="5090405067413522300">"Rechercher + <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g>"</string>
    <string name="quick_launch_clear_dialog_title" msgid="5546543501250320220">"Effacer"</string>
    <string name="quick_launch_clear_dialog_message" msgid="3921015601470260722">"Vos raccourcis pour <xliff:g id="SHORTCUT_LETTER">%1$s</xliff:g> (<xliff:g id="APPLICATION_NAME">%2$s</xliff:g>) vont être effacés."</string>
    <string name="quick_launch_clear_ok_button" msgid="2634568926597586716">"OK"</string>
    <string name="quick_launch_clear_cancel_button" msgid="1892854652197747064">"Annuler"</string>
    <string name="quick_launch_display_mode_applications" msgid="1734058461846126775">"Applications"</string>
    <string name="quick_launch_display_mode_shortcuts" msgid="4177934019174169042">"Raccourcis"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Saisie de texte"</string>
    <string name="input_method" msgid="5434026103176856164">"Mode de saisie"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Clavier actuel"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Sélection du mode de saisie"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automatique"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Toujours afficher"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Toujours masquer"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Configurer les modes de saisie"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Paramètres"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Paramètres"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Modes de saisie actifs"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="3346751753141428573">"Utiliser la langue du système"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Paramètres <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Sélectionner modes de saisie actifs"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Paramètres du clavier à l\'écran"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Clavier physique"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Paramètres du clavier physique"</string>
    <string name="development_settings_title" msgid="215179176067683667">"Options pour les développeurs"</string>
    <string name="development_settings_summary" msgid="1815795401632854041">"Définir les options pour le développement de l\'application"</string>
    <string name="development_settings_not_available" msgid="4308569041701535607">"Les options proposées aux développeurs ne sont pas disponibles pour cet utilisateur."</string>
    <string name="vpn_settings_not_available" msgid="956841430176985598">"Les paramètres de RPV ne sont pas disponibles pour cet utilisateur"</string>
    <string name="tethering_settings_not_available" msgid="6765770438438291012">"Les paramètres de partage de connexion ne sont pas disponibles pour cet utilisateur"</string>
    <string name="apn_settings_not_available" msgid="7873729032165324000">"Les paramètres de point d\'accès ne sont pas disponibles pour cet utilisateur"</string>
    <string name="enable_adb" msgid="7982306934419797485">"Débogage USB"</string>
    <string name="enable_adb_summary" msgid="4881186971746056635">"Mode débogage lorsqu\'un câble USB est connecté"</string>
    <string name="clear_adb_keys" msgid="4038889221503122743">"Annuler les autorisations relatives au débogage USB"</string>
    <string name="bugreport_in_power" msgid="7923901846375587241">"Raccourci de rapport de bogue"</string>
    <string name="bugreport_in_power_summary" msgid="1778455732762984579">"Afficher un bouton permettant d\'établir un rapport de bogue dans le menu de démarrage"</string>
    <string name="keep_screen_on" msgid="1146389631208760344">"Rester activé"</string>
    <string name="keep_screen_on_summary" msgid="2173114350754293009">"L\'écran ne se met jamais en veille lors du chargement"</string>
    <string name="bt_hci_snoop_log" msgid="3340699311158865670">"Activer le journal HCI Snoop Bluetooth"</string>
    <string name="bt_hci_snoop_log_summary" msgid="730247028210113851">"Capturer tous les paquets HCI Bluetooth dans un fichier"</string>
    <string name="oem_unlock_enable" msgid="6629321276287913315">"Activer le déverrouillage par le fabricant"</string>
    <string name="oem_unlock_enable_summary" msgid="3546686263996628110">"Autoriser le déverrouillage de l\'appareil par le fabricant"</string>
    <string name="wifi_display_certification" msgid="8611569543791307533">"Certification de l\'affichage sans fil"</string>
    <string name="wifi_verbose_logging" msgid="4203729756047242344">"Autoriser enreg. données Wi-Fi détaillées"</string>
    <string name="wifi_aggressive_handover" msgid="9194078645887480917">"Passage forcé du Wi-Fi aux données cellulaires"</string>
    <string name="wifi_allow_scan_with_traffic" msgid="3601853081178265786">"Toujours autoriser la détection de réseaux Wi-Fi en itinérance"</string>
    <string name="wifi_display_certification_summary" msgid="1155182309166746973">"Afficher les options pour la certification d\'affichage sans fil"</string>
    <string name="wifi_verbose_logging_summary" msgid="6615071616111731958">"Détailler davantage les données Wi-Fi, afficher par SSID RSSI dans sélect. Wi-Fi"</string>
    <string name="wifi_aggressive_handover_summary" msgid="6328455667642570371">"Si cette option est activée, le passage du Wi-Fi aux données cellulaires est forcé lorsque le signal Wi-Fi est faible"</string>
    <string name="wifi_allow_scan_with_traffic_summary" msgid="2575101424972686310">"Autoriser ou non la détection de réseaux Wi-Fi en itinérance en fonction de l\'importance du transfert de données dans l\'interface"</string>
    <string name="select_logd_size_title" msgid="7433137108348553508">"Tailles des mémoires tampons d\'enregistreur"</string>
    <string name="select_logd_size_dialog_title" msgid="1206769310236476760">"Tailles enreg. par tampon journal"</string>
    <string name="allow_mock_location" msgid="2787962564578664888">"Autoriser les positions fictives"</string>
    <string name="allow_mock_location_summary" msgid="317615105156345626">"Autoriser les positions fictives"</string>
    <string name="debug_view_attributes" msgid="6485448367803310384">"Activer l\'inspection d\'attribut d\'affichage"</string>
    <string name="adb_warning_title" msgid="6234463310896563253">"Autoriser le débogage USB?"</string>
    <string name="adb_warning_message" msgid="7316799925425402244">"Le débogage USB est conçu uniquement pour le développement. Utilisez-le pour copier des données entre votre ordinateur et votre appareil, installer des applications sur votre appareil sans notification et lire les données de journal."</string>
    <string name="adb_keys_warning_message" msgid="6932230298032192937">"Voulez-vous vraiment désactiver l\'accès au débogage USB de tous les ordinateurs précédemment autorisés?"</string>
    <string name="dev_settings_warning_title" msgid="7244607768088540165">"Activer les paramètres de développement?"</string>
    <string name="dev_settings_warning_message" msgid="2298337781139097964">"Ces paramètres sont en cours de développement. Ils peuvent endommager votre appareil et les applications qui s\'y trouvent, ou provoquer leur dysfonctionnement."</string>
    <string name="verify_apps_over_usb_title" msgid="4177086489869041953">"Vérifier les applis via USB"</string>
    <string name="verify_apps_over_usb_summary" msgid="9164096969924529200">"Vérifiez que les applications installées par ADB/ADT ne présentent pas de comportement dangereux."</string>
    <string name="enforce_read_external_title" product="nosdcard" msgid="7733257271454664956">"Protéger mémoire de stockage USB"</string>
    <string name="enforce_read_external_summary" product="nosdcard" msgid="1798088409346660567">"Les applis doivent demander l\'autorisation pour lire la mémoire"</string>
    <string name="enforce_read_external_confirm_title" product="nosdcard" msgid="2112813067171502209">"Protéger mémoire stockage USB?"</string>
    <string name="enforce_read_external_confirm_message" product="nosdcard" msgid="605444326545922054">"Lorsque la mémoire de stockage USB est protégée, les applications doivent demander l\'autorisation de lire les données de la mémoire de stockage externe.\n\nCertaines applications peuvent ne pas fonctionner jusqu\'à ce que leurs développeurs les mettent à jour."</string>
    <string name="enforce_read_external_title" product="default" msgid="2226662853797940829">"Protéger la carte SD"</string>
    <string name="enforce_read_external_summary" product="default" msgid="2750027486786530064">"Les applications doivent demander autorisation de lire carte SD."</string>
    <string name="enforce_read_external_confirm_title" product="default" msgid="273220585729800783">"Protéger la carte SD?"</string>
    <string name="enforce_read_external_confirm_message" product="default" msgid="3858482712337574407">"Lorsque la carte SD est protégée, les applications doivent demander l\'autorisation de lire les données de la mémoire de stockage externe.\n\nCertaines applications peuvent ne pas fonctionner jusqu\'à ce que leurs développeurs les mettent à jour."</string>
    <string name="enable_terminal_title" msgid="95572094356054120">"Terminal local"</string>
    <string name="enable_terminal_summary" msgid="67667852659359206">"Activer l\'application Terminal permettant l\'accès au shell local"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Choisir un gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Choisir un widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Créer un widget et autoriser l\'accès?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Une fois le widget créé, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> peut accéder à toutes les données qu\'il affiche."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Toujours autoriser <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> à créer des widgets et accéder à leurs données"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> j <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> mn <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> mn <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> mn <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> j <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Données statistiques"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Données statistiques"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Trier par :"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Application"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Dernière utilisation :"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Temps d\'utilisation"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Accessibilité"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Paramètres d\'accessibilité"</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Services"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Système"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Affichage"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Sous-titres"</string>
    <string name="accessibility_screen_magnification_title" msgid="7001782548715744981">"Gestes d\'agrandissement"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2380627654189671754">"Lorsque cette fonctionnalité est activée, vous pouvez effectuer des zooms avant et arrière en appuyant trois fois sur l\'écran.\n\nLorsque vous effectuez un zoom avant, vous pouvez :\n"<ul><li>"Effectuer un panoramique : faites glisser deux doigts ou plus sur l\'écran."</li>\n<li>"Régler le niveau de zoom : pincez deux doigts ou plus, ou écartez-les."</li></ul>\n\n"Vous pouvez également agrandir le contenu se trouvant sous votre doigt en appuyant trois fois sur l\'écran et en prolongeant la troisième pression. Lorsque la loupe est activée, vous pouvez faire glisser votre doigt sur l\'écran pour en explorer les différentes parties. Relevez votre doigt pour revenir à l\'état précédent.\n\nRemarque : vous pouvez appuyer trois fois sur l\'écran pour agrandir le contenu partout, sauf sur le clavier et la barre de navigation."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Raccourci d\'accessibilité"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Activé"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Désactivé"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="750438015254396963">"Lorsque cette fonctionnalité est activée, vous pouvez rapidement activer les fonctionnalités d\'accessibilité en deux étapes :\n\nÉtape 1 : Appuyez de manière prolongée sur le bouton Marche/Arrêt jusqu\'à ce que le téléphone sonne ou vibre.\n\nÉtape 2 : Appuyez de manière prolongée avec deux doigts jusqu\'à ce que vous entendiez la confirmation audio.\n\nSi l\'appareil est utilisé par plusieurs personnes, l’utilisation de ce raccourci sur l\'écran de verrouillage active l\'accessibilité de manière temporaire jusqu\'au déverrouillage de l\'appareil."</string>
    <string name="accessibility_toggle_large_text_preference_title" msgid="6307247527580207161">"Grands caractères"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Texte de contraste élevé"</string>
    <string name="accessibility_toggle_screen_magnification_preference_title" msgid="2472285215737820469">"Loupe"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Mise à jour auto de la loupe"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Mettre à jour la loupe si transition entre applis"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Marche/arrêt pour raccrocher"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Énoncer les mots de passe"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Délai de pression"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inversion des couleurs"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Expérimental) Peut toucher les performances."</string>
    <string name="accessibility_display_daltonizer_preference_title" msgid="5800761362678707872">"Correction des couleurs"</string>
    <string name="accessibility_display_daltonizer_preference_subtitle" msgid="3484969015295282911">"Cette fonctionnalité est expérimentale et peut toucher les performances."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Afficher dans la fenêtre de configuration rapide"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Mode de correction"</string>
    <string name="daltonizer_type_overridden" msgid="3116947244410245916">"Remplacé par <xliff:g id="TITLE">%1$s</xliff:g>"</string>
    <string name="daltonizer_mode_disabled" msgid="7482661936053801862">"Désactivé"</string>
    <string name="daltonizer_mode_monochromacy" msgid="8485709880666106721">"Monochromatisme"</string>
    <string name="daltonizer_mode_deuteranomaly" msgid="5475532989673586329">"Deutéranomalie (rouge/vert)"</string>
    <string name="daltonizer_mode_protanomaly" msgid="8424148009038666065">"Protanomalie (rouge/vert)"</string>
    <string name="daltonizer_mode_tritanomaly" msgid="481725854987912389">"Tritanomalie (bleu/jaune)"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Paramètres"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Activé"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Désactivé"</string>
    <string name="accessibility_feature_or_input_method_not_allowed" msgid="5950315477009501647">"Non autorisée par votre organisation"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Aperçu"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Options standards"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Langue"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Taille de la police"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Style de sous-titres"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Options de personnalisation"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Couleur de l\'arrière-plan"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Opacité du fond"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Couleur de la zone de sous-titres"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Opacité de la zone de sous-titres"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Couleur du texte"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Opacité du texte"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Couleur de la bordure"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Type de bordure"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Famille de polices"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Les sous-titres ressembleront à ceci"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Par défaut"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Par défaut"</string>
    <string name="color_none" msgid="3475640044925814795">"Aucun"</string>
    <string name="color_white" msgid="8045195170201590239">"Blanc"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gris"</string>
    <string name="color_black" msgid="7517353520909872561">"Noir"</string>
    <string name="color_red" msgid="4949354900304125428">"Rouge"</string>
    <string name="color_green" msgid="5537717328428845841">"Vert"</string>
    <string name="color_blue" msgid="7731984529016953223">"Bleu"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cyan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Jaune"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Utiliser <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> doit pouvoir :"</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Si vous activez <xliff:g id="SERVICE">%1$s</xliff:g>, votre appareil n\'utilisera pas le verrouillage de l\'écran pour améliorer le chiffrement des données."</string>
    <string name="secure_lock_encryption_warning" msgid="464101518421886337">"Vous avez activé un service d\'accessibilité. Votre appareil n\'utilisera donc pas le verrouillage de l\'écran pour améliorer le chiffrement des données."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre motif."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre NIP."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Étant donné que l\'activation du service <xliff:g id="SERVICE">%1$s</xliff:g> touche le chiffrement de données, vous devez confirmer votre mot de passe."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Observer vos actions"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="2095111008854376237">"Recevoir des notifications lorsque vous interagissez avec une application"</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Arrêter <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2012273739481042318">"Si vous appuyez sur \"OK\", cela interrompt <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Aucun service installé"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Aucune description fournie"</string>
    <string name="settings_button" msgid="3006713718908152930">"Paramètres"</string>
    <string name="print_settings" msgid="4742428530112487843">"Impression"</string>
    <string name="print_settings_title" msgid="3685449667822217816">"Services d\'impression"</string>
    <string name="print_service_security_warning_title" msgid="2338435517408144841">"Utiliser <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="print_service_security_warning_summary" msgid="7567131958613064363">"Votre document peut passer par un ou plusieurs serveurs avant d\'arriver à l\'imprimante."</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Aucun service installé"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Aucune imprimante trouvée"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Paramètres"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Ajouter des imprimantes"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Activé"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Désactivé"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Ajouter le service"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Ajouter une imprimante"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Rechercher"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Recherche d\'imprimantes en cours..."</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Service désactivé"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Tâches d\'impression"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tâches d\'impression"</string>
    <string name="print_restart" msgid="8373999687329384202">"Recommencer"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Annuler"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Impression de <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> en cours…"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Annulation de « <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> »…"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Erreur d\'impression : <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> bloquée par l\'imprimante"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Champ de recherche affiché"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Champ de recherche masqué"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Batterie"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Répartition·de·l\'utilisation·de·la·batterie"</string>
    <string name="power_usage_not_available" msgid="3214000535532434353">"Info d\'utilisation batterie indispo"</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Temps restant : <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> avant le chargement complet"</string>
    <string name="power_discharging_duration" msgid="7125493014448497620">"<xliff:g id="LEVEL">%1$d</xliff:g> %% – Temps restant : environ <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="power_charging" msgid="712751285832976915">"<xliff:g id="LEVEL">%1$d</xliff:g> %% – <xliff:g id="STATE">%2$s</xliff:g>"</string>
    <string name="power_charging_duration" msgid="4802183864773082009">"<xliff:g id="LEVEL">%1$d</xliff:g> %% (chargée à 100 %% dans <xliff:g id="TIME">%2$s</xliff:g>)"</string>
    <string name="power_charging_duration_ac" msgid="3611179931297824699">"<xliff:g id="LEVEL">%1$d</xliff:g> %% (chargée à 100 %% sur prise de courant dans <xliff:g id="TIME">%2$s</xliff:g>)"</string>
    <string name="power_charging_duration_usb" msgid="1106605348913397583">"<xliff:g id="LEVEL">%1$d</xliff:g> %% (chargée à 100 %% par USB dans <xliff:g id="TIME">%2$s</xliff:g>)"</string>
    <string name="power_charging_duration_wireless" msgid="633606920144617227">"<xliff:g id="LEVEL">%1$d</xliff:g> %% (chargée à 100 %% avec chargeur sans fil dans <xliff:g id="TIME">%2$s</xliff:g>)"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Usage depuis la dernière charge complète"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Utilisation de la batterie depuis le débranchement"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Utilisation de la batterie depuis la dernière réinitialisation"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> de la batterie"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"Débranché depuis <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Batterie en charge"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Écran activé"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS activé"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"En activité"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Signal réseau cellulaire"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Durée de fonctionnement de l\'appareil"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Wi-Fi/temps"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Wi-Fi/temps"</string>
    <string name="usage_name_percent" msgid="7976919382448235858">"<xliff:g id="NAME">%1$s</xliff:g> -  <xliff:g id="NUMBER">%2$s</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Détails de l\'historique"</string>
    <string name="details_title" msgid="3792801565213935385">"Détails d\'utilisation"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Détails d\'utilisation"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Ajuster la consommation"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Modules inclus"</string>
    <string name="power_screen" msgid="3023346080675904613">"Écran"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Lampe de poche"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Veille GSM"</string>
    <string name="power_phone" msgid="5392641106474567277">"Appels vocaux"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablette inactive"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Téléphone inactif"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Divers"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Surestimée"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Durée d\'utilisation totale de l\'UC"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"UC - Premier plan"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Maintenir activé"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi actif"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablette"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Téléphone"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paquets mobiles envoyés"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paquets mobiles reçus"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Radio mobile active"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paquets Wi-Fi envoyés"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paquets Wi-Fi reçus"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Vidéo"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Durée d\'activation"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Durée sans signal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Capacité totale de la pile"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Consommation d\'énergie calculée"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Consommation d\'énergie observée"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Forcer l\'arrêt"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Informations sur l\'application"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Paramètres de l\'application"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Paramètres de l\'écran"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Paramètres Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Paramètres Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Batterie utilisée par les appels vocaux"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Batterie utilisée lorsque la tablette est inactive"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Batterie utilisée lorsque le téléphone est inactif"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Batterie utilisée par le signal radio cellulaire"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Passez en mode Avion pour économiser la batterie dans les zones sans couverture cellulaire."</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Énergie utilisée par la lampe de poche"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Batterie utilisée par l\'affichage et le rétro-éclairage"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Réduire la luminosité et/ou le délai de mise en veille de l\'écran"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Batterie utilisée par le Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="3355461362094706957">"Désactivez le Wi-Fi lorsque vous ne l\'utilisez pas ou qu\'il n\'est pas disponible."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Batterie utilisée par Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="1942935021750897422">"Désactivez Bluetooth lorsque vous ne l\'utilisez pas."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Essayez de vous connecter à un autre appareil Bluetooth."</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Batterie utilisée par l\'application"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Arrêter ou désinstaller l\'application"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Sélectionnez le mode Économie de la pile"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"L\'application dispose peut-être de paramètres permettant de réduire l\'utilisation de la batterie."</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Batterie utilisée par l\'utilisateur"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Consommation d\'énergie diverse"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"L\'utilisation de la pile est une approximation de la consommation d\'énergie de l\'appareil; cela ne comprend pas toutes les sources qui puisent de l\'énergie. Le champ « Divers » représente la différence entre la consommation approximative calculée et la consommation réelle observée."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Utilisation surestimée de la pile"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"Débranché depuis <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Depuis le dernier débranchement (<xliff:g id="UNPLUGGED">%1$s</xliff:g>)"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Utilisation totale"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Actualiser"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Système d\'exploitation Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Serveur multimédia"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Économie d\'énergie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Activer automatiquement"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Jamais"</string>
    <!-- String.format failed for translation -->
    <!-- no translation found for battery_saver_turn_on_automatically_pct (3033681629861428940) -->
    <skip />
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistiques des processus"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistiques détaillées sur les processus en cours d\'exécution"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Mémoire utilisée"</string>
    <string name="process_stats_total_duration" msgid="1869761515101180444">"Applications <xliff:g id="TYPE">%1$s</xliff:g> en <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"Arrière-plan"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Avant-plan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"En cache"</string>
    <string name="process_stats_memory_status" msgid="4251599550196193093">"L\'état de la mémoire de l\'appareil est actuellement : <xliff:g id="MEMSTATE">%1$s</xliff:g>"</string>
    <string name="process_stats_avg_ram_use" msgid="6972943528929394396">"Taux d\'utilisation moyen de la mémoire vive"</string>
    <string name="process_stats_max_ram_use" msgid="3273876448926689261">"Taux d\'utilisation maximal de la mémoire vive"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Durée d\'exécution"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Services"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Durée"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Détails de la mémoire"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"États de la mémoire"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Utilisation de la mémoire"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Noyau"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Natif"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Caches du noyau"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Échange de zRAM"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Disponible"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Total"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 heures"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 heures"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 heures"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 jour"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Afficher le système"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Utiliser USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Type de statistiques"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Arrière-plan"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Avant-plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"En cache"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Saisie et sortie vocales"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Paramètres de saisie et de sortie vocales"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Recherche vocale"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Clavier Android"</string>
    <string name="voice_category" msgid="1430370497125803904">"Reconnaissance vocale"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Paramètres d\'entrée vocale"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Entrée vocale"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Services d\'entrée vocale"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Détection de mot clé et interaction totales"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Synthèse vocale simple"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Ce service d\'entrée vocale pourra contrôler en permanence les fonctionnalités vocales et utiliser en votre nom les applications commandées par la voix. Il provient de l\'application <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Autoriser l\'utilisation de ce service?"</string>
    <string name="tts_settings" msgid="8186971894801348327">"Synthèse vocale"</string>
    <string name="tts_settings_title" msgid="1237820681016639683">"Sortie de la synthèse vocale"</string>
    <string name="use_default_tts_settings_title" msgid="1577063839539732930">"Toujours utiliser mes paramètres"</string>
    <string name="use_default_tts_settings_summary" msgid="5916421806783703823">"Remplacer les paramètres de l\'application par les paramètres ci-dessous"</string>
    <string name="tts_default_settings_section" msgid="5787915620218907443">"Paramètres par défaut"</string>
    <string name="tts_default_synth_title" msgid="4755558388333117572">"Moteur par défaut"</string>
    <string name="tts_default_synth_summary" msgid="6482936537135251690">"Définir le moteur de synthèse vocale à utiliser"</string>
    <string name="tts_default_rate_title" msgid="6030550998379310088">"Cadence"</string>
    <string name="tts_default_rate_summary" msgid="4061815292287182801">"Vitesse à laquelle le texte est énoncé"</string>
    <string name="tts_default_pitch_title" msgid="6135942113172488671">"Ton"</string>
    <string name="tts_default_pitch_summary" msgid="1328298665182885277">"Affecte le ton utilisé par la synthèse vocale"</string>
    <string name="tts_default_lang_title" msgid="8018087612299820556">"Langue"</string>
    <string name="tts_lang_use_system" msgid="2679252467416513208">"Utiliser la langue du système"</string>
    <string name="tts_lang_not_selected" msgid="7395787019276734765">"Langue non sélectionnée"</string>
    <string name="tts_default_lang_summary" msgid="5219362163902707785">"Définit la langue utilisée par la syntèse vocale"</string>
    <string name="tts_play_example_title" msgid="7094780383253097230">"Écouter un échantillon"</string>
    <string name="tts_play_example_summary" msgid="8029071615047894486">"Lire une courte démonstration de la synthèse vocale"</string>
    <string name="tts_install_data_title" msgid="4264378440508149986">"Installer les données vocales"</string>
    <string name="tts_install_data_summary" msgid="5742135732511822589">"Installer les données nécessaires à la synthèse vocale"</string>
    <string name="tts_data_installed_summary" msgid="9162111552859972809">"Les données nécessaires à la synthèse vocale sont déjà correctement installées."</string>
    <string name="tts_settings_changed_demo" msgid="4926518555912328645">"Vos paramètres ont été modifiés. Voici un échantillon illustrant les nouveaux paramètres."</string>
    <string name="tts_engine_error" msgid="3305141107104670703">"Le moteur sélectionné ne peut pas fonctionner."</string>
    <string name="tts_engine_error_config" msgid="5820525416624637313">"Configurer"</string>
    <string name="tts_engine_error_reselect" msgid="2415399149293842112">"Sélectionner un autre moteur"</string>
    <string name="tts_engine_security_warning" msgid="8786238102020223650">"Ce moteur de synthèse vocale est susceptible d\'enregistrer tout ce que vous direz, y compris des données personnelles telles que les mots de passe et les numéros de carte de paiement. Il provient du moteur <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>. Voulez-vous l\'activer?"</string>
    <string name="tts_engine_network_required" msgid="1190837151485314743">"Une connexion réseau est nécessaire pour la synthèse vocale dans cette langue."</string>
    <string name="tts_default_sample_string" msgid="4040835213373086322">"Voici un échantillon de synthèse vocale"</string>
    <string name="tts_status_title" msgid="7268566550242584413">"État de la langue par défaut"</string>
    <string name="tts_status_ok" msgid="1309762510278029765">"Les paramètres régionaux <xliff:g id="LOCALE">%1$s</xliff:g> sont compatibles"</string>
    <string name="tts_status_requires_network" msgid="6042500821503226892">"Les paramètres régionaux <xliff:g id="LOCALE">%1$s</xliff:g> nécessitent une connexion réseau"</string>
    <string name="tts_status_not_supported" msgid="4491154212762472495">"Les paramètres régionaux <xliff:g id="LOCALE">%1$s</xliff:g> ne sont pas compatibles"</string>
    <string name="tts_status_checking" msgid="4983413982985913047">"Vérification en cours..."</string>
    <string name="tts_engines_section" msgid="7515470972378742429">"Moteurs"</string>
    <string name="tts_engine_name_settings" msgid="4974538563074395920">"Paramètres <xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="tts_engine_name_is_enabled_summary" msgid="4909484006804022115">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> est activé."</string>
    <string name="tts_engine_name_is_disabled_summary" msgid="7644198182255168200">"<xliff:g id="TTS_PLUGIN_ENGINE_NAME">%s</xliff:g> est désactivé"</string>
    <string name="tts_engine_settings_section" msgid="2346105138448751893">"Paramètres du moteur"</string>
    <string name="tts_engine_settings_title" msgid="3499112142425680334">"Paramètres de <xliff:g id="TTS_ENGINE_NAME">%s</xliff:g>"</string>
    <string name="pico_languages_and_voices" msgid="4611320375917773238">"Langues et voix"</string>
    <string name="pico_installed" msgid="2452546687858267414">"Installée"</string>
    <string name="pico_not_installed" msgid="6266845418419994311">"Non installée"</string>
    <string name="pico_voice_summary_female" msgid="8047327176247727492">"Femme"</string>
    <string name="pico_voice_summary_male" msgid="8331266854058577610">"Homme"</string>
    <string name="tts_notif_engine_install_title" msgid="7000346872482649034">"Moteur synthèse vocale installé"</string>
    <string name="tts_notif_engine_install_message" msgid="7250804349781973329">"Activer moteur avant utilisation"</string>
    <string name="tts_engine_settings_button" msgid="1030512042040722285">"Lancer les paramètres du moteur"</string>
    <string name="tts_engine_preference_section_title" msgid="448294500990971413">"Moteur préféré"</string>
    <string name="tts_general_section_title" msgid="4402572014604490502">"Général"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Contrôle de l\'alimentation"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Mise à jour des paramètres Wi-Fi"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Mise à jour des paramètres Bluetooth"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"Activé"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"désactivé"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"activation"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"désactivation"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi-Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Position"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Synchroniser"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Luminosité <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automatique"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"maximale"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"moyenne"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"désactivée"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Stockage des identifiants"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Installer depuis la mémoire"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Installer à partir de la carte SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Installer les certificats depuis la mémoire de stockage"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Installer les certificats depuis la carte SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Effacer les identifiants"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Supprimer tous les certificats"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Certificats de confiance"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Afficher les certificats d\'autorité de confiance"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Avancés"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Type de stockage"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Intégré au matériel"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Uniquement logiciel"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Les identifiants ne sont pas accessibles pour cet utilisateur"</string>
    <string name="credentials_install_gesture_prompt" msgid="2207390278112395082">"Dessinez votre schéma de déverrouillage."</string>
    <string name="credentials_install_gesture_explanation" msgid="7408921172253634829">"Pour confirmer l\'installation des certificats, vous devez dessiner votre schéma de déverrouillage."</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Saisir le mot de passe de stockage des identifiants"</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Mot de passe actuel :"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Supprimer l\'intégralité du contenu?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Le mot de passe doit comporter au moins 8 caractères."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Mot de passe incorrect"</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Mot de passe incorrect. Vous disposez d\'une tentative supplémentaire avant la suppression des identifiants."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Mot de passe incorrect. Vous disposez de <xliff:g id="NUMBER">%1$d</xliff:g> tentatives supplémentaires avant la suppression des identifiants."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Les identifiants sont effacés."</string>
    <string name="credentials_not_erased" msgid="93461830775441220">"Impossible eff. stockage identifiants."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Stockage des identifiants activé."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Avant d\'utiliser le stockage d\'identifiants, vous devez définir un NIP ou un mot de passe pour le verrouillage d\'écran."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Applis avec accès données util."</string>
    <string name="allow_usage_access_title" msgid="2134237975190472249">"Autoriser l\'accès?"</string>
    <string name="allow_usage_access_message" msgid="2295847177051307496">"Si vous autorisez cette application à accéder aux données d\'utilisation, elle pourra obtenir des renseignements généraux sur les applications de votre appareil, tels que la fréquence à laquelle vous les utilisez."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Sonnerie d\'urgence"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Définir le comportement en cas d\'appel d\'urgence"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Sauvegarder et réinitialiser"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Sauvegarder et réinitialiser"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Sauvegarde et restauration"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Données personnelles"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Sauvegarder mes données"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Sauvegarder les données d\'applications, les mots de passe Wi-Fi et d\'autres paramètres sur les serveurs Google"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Compte de sauvegarde"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Actuellement, aucun compte n\'enregistre de données de sauvegarde"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Inclure données applications"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restauration automatique"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Lors de la réinstallation d\'une application, restaurer les paramètres et les données sauvegardées"</string>
    <string name="local_backup_password_title" msgid="3860471654439418822">"Mot de passe sauvegarde PC"</string>
    <string name="local_backup_password_summary_none" msgid="393503434408227110">"Les sauvegardes complètes sur PC ne sont pas protégées actuellement."</string>
    <string name="local_backup_password_summary_change" msgid="2731163425081172638">"Appuyez pour modifier ou supprimer le mot de passe utilisé pour les sauvegardes complètes sur PC."</string>
    <string name="local_backup_password_toast_success" msgid="582016086228434290">"Le nouveau mot de passe de secours a bien été défini."</string>
    <string name="local_backup_password_toast_confirmation_mismatch" msgid="3495167398824569524">"Le nouveau mot de passe et sa confirmation ne correspondent pas."</string>
    <string name="local_backup_password_toast_validation_failure" msgid="5646377234895626531">"Échec de la définition du mot de passe de secours."</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Voulez-vous vraiment arrêter de sauvegarder vos mots de passe Wi-Fi, vos favoris, ainsi que d\'autres paramètres et données d\'applications, et en effacer toutes les copies des serveurs Google?"</string>
    <string name="device_admin_settings_title" msgid="1335557832906433309">"Paramètres d\'administration du périphérique"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Administrateur du périphérique"</string>
    <string name="remove_device_admin" msgid="3596845261596451437">"Désactiver"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Administrateurs de l\'appareil"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Aucun administrateur de périphérique disponible"</string>
    <string name="managed_profile_device_admin_info" msgid="5048846624960067582">"Pour empêcher <xliff:g id="APP_NAME">%1$s</xliff:g> d\'accéder à votre profil professionnel, supprimez le profil sous Paramètres &gt; Comptes."</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Personnel"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Travail"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Aucun agent de confiance disponible"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Activer l\'administrateur du périphérique?"</string>
    <string name="add_device_admin" msgid="7133327675884827091">"Activer"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Administrateur du périphérique"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"L\'activation de cet administrateur permettra à l\'application <xliff:g id="APP_NAME">%1$s</xliff:g> d\'effectuer les opérations suivantes :"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"Cet administrateur est activé et permet à l\'application <xliff:g id="APP_NAME">%1$s</xliff:g> d\'effectuer les opérations suivantes :"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Activer le gestionnaire de profil?"</string>
    <string name="adding_profile_owner_warning" msgid="6469780138110334180">"Si vous continuez, votre utilisateur sera géré par votre administrateur, qui pourra également stocker des données associées, en plus de vos données personnelles.\n\nVotre administrateur a la possibilité de surveiller et de gérer les paramètres, l\'accès, les applications et les données associées à cet utilisateur, y compris l\'activité réseau et les données de localisation de votre appareil."</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Sans titre"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Général"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Journal des notifications"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Sonnerie et vibreur pour les appels"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Système"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Configuration Wi-Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Se connecter au réseau Wi-Fi « <xliff:g id="NETWORK_NAME">%s</xliff:g> »"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Connexion au réseau Wi-Fi « <xliff:g id="NETWORK_NAME">%s</xliff:g> » en cours…"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Connecté au réseau Wi-Fi « <xliff:g id="NETWORK_NAME">%s</xliff:g> »"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Ajouter un réseau"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Non connecté"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Ajouter un réseau"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Actualiser la liste"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Passer"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"SUIVANTE"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Précédent"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Informations sur le réseau"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Connexion"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Supprimer"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Enregistrer"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Annuler"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Recherche de réseaux…"</string>
    <string name="wifi_setup_status_select_network" msgid="7519563569903137003">"Appuyez sur un réseau pour vous y connecter."</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Se connecter à un réseau existant"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Se connecter à un réseau non sécurisé"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Saisissez la configuration réseau."</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Se connecter à un nouveau réseau"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Connexion en cours…"</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Passer à l\'étape suivante"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="5335338851032315905">"L\'EAP n\'est pas compatible."</string>
    <string name="wifi_setup_eap_not_supported" msgid="1955087534276570962">"Impossible de paramétrer de connexion Wi-Fi EAP lors de la configuration. Une fois celle-ci effectuée, vous pourrez le faire via Paramètres &gt; Sans fil et réseaux."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"La connexion peut prendre quelques minutes…"</string>
    <string name="wifi_setup_description_connected" msgid="736032046548460779">"Appuyez sur "<b>"Suivant"</b>" pour poursuivre la configuration.\n\nAppuyez sur "<b>"Précédent"</b>" pour vous connecter à un autre réseau Wi-Fi."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Synchronisation activée"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Synchronisation désactivée"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Synchronisation en cours…"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Erreur de synchronisation."</string>
    <string name="sync_failed" msgid="1696499856374109647">"Échec de la synchronisation"</string>
    <string name="sync_active" msgid="8476943765960863040">"Synchronisation activée"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Synchroniser"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"La synchronisation rencontre actuellement des problèmes. Elle sera rétablie sous peu."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Ajouter un compte"</string>
    <string name="managed_profile_not_available_label" msgid="3489771164851107822">"Le profil professionnel n\'est pas encore disponible"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Supprimer le profil professionnel"</string>
    <string name="background_data" msgid="5779592891375473817">"Données en arrière-plan"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Synchronisation, envoi et réception de données à tout moment"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Dés. données arr.-plan?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"La désactivation des données en arrière-plan économise la batterie et réduit l\'utilisation des données. Certaines applications peuvent continuer d\'utiliser la connexion Internet en arrière-plan."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Synchro auto des données des applis"</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Synchronisation activée"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Synchronisation désactivée"</string>
    <string name="sync_error" msgid="5060969083117872149">"Erreur de synchronisation"</string>
    <string name="last_synced" msgid="4242919465367022234">"Dernière synchronisation : <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Synchronisation en cours…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Sauvegarder les paramètres"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Sauvegarder mes paramètres"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Synchroniser"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Annuler la synchronisation"</string>
    <string name="sync_one_time_sync" msgid="6766593624598183090">"Appuyez ici pour lancer la synchronisation<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"# CALENDAR:"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Contacts"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Bienvenue sur Google Sync!"</font>\n"Une solution Google pour synchroniser vos données et vous permettre d\'accéder à vos contacts, vos rendez-vous et plus, où que vous soyez."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Paramètres de synchronisation de l\'application"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Données et synchronisation"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Modifier le mot de passe"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Paramètres de compte"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Supprimer le compte"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Ajouter un compte"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Terminer"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Supprimer le compte?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"La suppression de ce compte entraînera la suppression de tous les messages, contacts et autres données de la tablette."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"La suppression de ce compte entraînera la suppression de tous les messages, contacts et autres données du téléphone."</string>
    <string name="remove_account_failed" msgid="4010643669489606536">"Cette modification n\'est pas autorisée par votre administrateur"</string>
    <string name="provider_label" msgid="7724593781904508866">"Abonnements Push"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="8923508322291625282">"Impossible de procéder à la synchronisation manuelle."</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"La synchronisation de cet élément est actuellement désactivée. Pour modifier ce paramètre, activez temporairement les données en arrière-plan et la synchronisation automatique."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Adresse MAC 4G"</string>
    <string name="enter_password" msgid="8035706727471334122">"Pour lancer Android, entrez votre mot de passe"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Pour lancer Android, entrez votre NIP"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Pour lancer Android, dessinez votre schéma."</string>
    <string name="try_again" msgid="4272075051293936921">"Réessayer."</string>
    <string name="delete" msgid="4219243412325163003">"Supprimer"</string>
    <string name="misc_files" msgid="6720680815969643497">"Fichiers divers"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"<xliff:g id="NUMBER">%1$d</xliff:g> fichiers sélectionnés sur <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> sur <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Tout sélectionner"</string>
    <string name="hdcp_checking_title" msgid="8605478913544273282">"Vérification HDCP"</string>
    <string name="hdcp_checking_dialog_title" msgid="5141305530923283">"Config. vérification HDCP"</string>
    <string name="debug_debugging_category" msgid="6781250159513471316">"Débogage"</string>
    <string name="debug_app" msgid="8349591734751384446">"Sélectionner une application à déboguer"</string>
    <string name="debug_app_not_set" msgid="718752499586403499">"Aucune application à déboguer définie"</string>
    <string name="debug_app_set" msgid="2063077997870280017">"Application à déboguer : <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="select_application" msgid="5156029161289091703">"Sél. application"</string>
    <string name="no_application" msgid="2813387563129153880">"Aucune"</string>
    <string name="wait_for_debugger" msgid="1202370874528893091">"Attendre l\'intervention du débogueur"</string>
    <string name="wait_for_debugger_summary" msgid="1766918303462746804">"Avant de s\'exécuter, l\'application déboguée doit attendre que le débogueur soit attaché."</string>
    <string name="debug_input_category" msgid="1811069939601180246">"Entrée"</string>
    <string name="debug_drawing_category" msgid="6755716469267367852">"Dessin"</string>
    <string name="debug_hw_drawing_category" msgid="6220174216912308658">"Accélération matérielle"</string>
    <string name="media_category" msgid="4388305075496848353">"Médias"</string>
    <string name="debug_monitoring_category" msgid="7640508148375798343">"Surveillance"</string>
    <string name="strict_mode" msgid="1938795874357830695">"Mode Strict activé"</string>
    <string name="strict_mode_summary" msgid="142834318897332338">"Afficher un cadre rouge si le thread principal reste occupé"</string>
    <string name="pointer_location" msgid="6084434787496938001">"Emplacement du curseur"</string>
    <string name="pointer_location_summary" msgid="840819275172753713">"Superposition écran indiquant données actuelles"</string>
    <string name="show_touches" msgid="1356420386500834339">"Afficher élément sélectionné"</string>
    <string name="show_touches_summary" msgid="6684407913145150041">"Afficher repère visuel pour éléments sélectionnés"</string>
    <string name="show_screen_updates" msgid="5470814345876056420">"Affich. mise à jour surface"</string>
    <string name="show_screen_updates_summary" msgid="2569622766672785529">"Faire clignoter les surfaces à chaque mise à jour"</string>
    <string name="show_hw_screen_updates" msgid="5036904558145941590">"Afficher mises à jour GPU"</string>
    <string name="show_hw_screen_updates_summary" msgid="1115593565980196197">"Faire clignoter les éléments dessinés avec le GPU"</string>
    <string name="show_hw_layers_updates" msgid="5645728765605699821">"Mises à jour couches mat."</string>
    <string name="show_hw_layers_updates_summary" msgid="5296917233236661465">"Couches matérielles en vert une fois mises à jour"</string>
    <string name="debug_hw_overdraw" msgid="2968692419951565417">"Déboguer les conflits GPU"</string>
    <string name="disable_overlays" msgid="2074488440505934665">"Désact. superpos. matér."</string>
    <string name="disable_overlays_summary" msgid="3578941133710758592">"Toujours utiliser le GPU pour la composition écran"</string>
    <string name="simulate_color_space" msgid="6745847141353345872">"Simuler esp. colorimétrique"</string>
    <string name="enable_opengl_traces_title" msgid="6790444011053219871">"Enable OpenGL traces"</string>
    <string name="use_nuplayer" msgid="5699257393367904387">"NuPlayer (expérimental)"</string>
    <string name="use_nuplayer_summary" msgid="1991479067478516714">"Utiliser NuPlayer au lieu d\'AwesomePlayer"</string>
    <string name="usb_audio_disable_routing" msgid="8114498436003102671">"Désact. routage audio USB"</string>
    <string name="usb_audio_disable_routing_summary" msgid="980282760277312264">"Désactiver routage automatique appareils audio USB"</string>
    <string name="debug_layout" msgid="5981361776594526155">"Afficher les contours"</string>
    <string name="debug_layout_summary" msgid="2001775315258637682">"Afficher les limites, les marges de clip, etc."</string>
    <string name="force_rtl_layout_all_locales" msgid="2259906643093138978">"Forcer orient. : g. à d."</string>
    <string name="force_rtl_layout_all_locales_summary" msgid="9192797796616132534">"Forcer l\'orientation: g. à droite (toutes langues)"</string>
    <string name="show_cpu_usage" msgid="2389212910758076024">"Afficher mém. CPU utilisée"</string>
    <string name="show_cpu_usage_summary" msgid="2113341923988958266">"Superposition écran indiquant mémoire CPU utilisée"</string>
    <string name="force_hw_ui" msgid="6426383462520888732">"Forcer le rendu GPU"</string>
    <string name="force_hw_ui_summary" msgid="5535991166074861515">"Forcer l\'utilisation du GPU pour le dessin 2D"</string>
    <string name="force_msaa" msgid="7920323238677284387">"Forcer MSAA 4x"</string>
    <string name="force_msaa_summary" msgid="9123553203895817537">"Activer MSAA 4x dans les applications OpenGL ES 2.0"</string>
    <string name="show_non_rect_clip" msgid="505954950474595172">"Déboguer opérations de découpage non rectangulaire"</string>
    <string name="track_frame_time" msgid="6146354853663863443">"Rendu GPU du profil"</string>
    <string name="window_animation_scale_title" msgid="6162587588166114700">"Échelle animation fenêtres"</string>
    <string name="transition_animation_scale_title" msgid="387527540523595875">"Échelle anim. transitions"</string>
    <string name="animator_duration_scale_title" msgid="3406722410819934083">"Échelle durée animation"</string>
    <string name="overlay_display_devices_title" msgid="5364176287998398539">"Simul. affich. secondaires"</string>
    <string name="debug_applications_category" msgid="4206913653849771549">"Applications"</string>
    <string name="immediately_destroy_activities" msgid="8366775083630234121">"Ne pas conserver activités"</string>
    <string name="immediately_destroy_activities_summary" msgid="3592221124808773368">"Supprimer immédiatement les activités abandonnées"</string>
    <string name="app_process_limit_title" msgid="4280600650253107163">"Limite processus arr.-plan"</string>
    <string name="show_all_anrs" msgid="28462979638729082">"Afficher tous les messages «L\'application ne répond pas»"</string>
    <string name="show_all_anrs_summary" msgid="641908614413544127">"Afficher « L\'application ne répond plus » pour applis en arrière-plan"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Utilisation des données"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Util. données aplication"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"La manière dont le fournisseur de services effectue les calcul des données peut être différente."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Utilisation de l\'application"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"DÉTAILS DE L\'APPLICATION"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Données cellulaires"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Définir limite consommation de données"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cycle de consommation"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Utilisation de l\'application"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Itinérance des données"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Limiter données en arrière-plan"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Autor. données arrière-plan"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Utilisation 4G séparée"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Afficher le Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Masquer consom. Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Afficher l\'utilisation Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Masquer consom. Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Restrictions réseau"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Synchronisation automatique des données"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Cartes SIM"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Réseaux cellulaires"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Synchronisation auto données"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Synchro auto des données perso"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Synchro auto données profess."</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Changer le cycle..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Jour du mois de réinitialisation du cycle utilisation données :"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Aucune donnée utilisée par les applications pendant cette période."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Couleur du texte"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Arrière-plan"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"limitée"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Désactiver les données cellulaires?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Définir limite don. cell."</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Définir le quota de données 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Définir quota de données 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Définir quota données Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Cellulaire"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Cellulaire"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Aucun"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Données cellulaires"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Données 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Données 4G"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Premier plan :"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Arrière-plan :"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Paramètres de l\'application"</string>
    <string name="data_usage_app_restrict_background" msgid="7510046552380574925">"Limiter données en arrière-plan"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="3720075732277934106">"Désactiver données en arrière-plan sur les réseaux cellulaires."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Pour limit. données arrière-plan, définissez limite données cell."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Limiter les données en arrière-plan?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Cette fonctionnalité peut empêcher certaines applications de fonctionner lorsque celles-ci sont dépendantes des données en arrière-plan et que seuls des réseaux cellulaires sont disponibles.\n\nVous trouverez des options plus adaptées en matière de contrôle de la consommation des données dans les paramètres de l\'application."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="4674085030810350875">"La restriction des données en arrière-plan n\'est possible que si vous avez défini une limite pour les données cellulaires."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Activer synchro auto données?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Toutes les modifications que vous apportez à vos comptes sur le Web sont automatiquement copiés sur votre tablette.\n\nCertains comptes peuvent également copier automatiquement sur le Web toutes les modifications que vous apportez sur la tablette. Les comptes Google fonctionnent de cette façon."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Toutes les modifications que vous apportez à vos comptes sur le Web sont automatiquement copiés sur votre téléphone.\n\nCertains comptes peuvent également copier automatiquement sur le Web toutes les modifications que vous apportez sur le téléphone. Les comptes Google fonctionnent de cette façon."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Désactiver synchro auto données?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4744145757533455623">"Cela limite la consommation des données et l\'utilisation de la batterie, mais vous devrez synchroniser manuellement chaque compte pour recueillir les informations récentes. Par ailleurs, vous ne recevrez pas de notifications en cas de mise à jour."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Date de réinitialisation du cycle de consommation"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Jour du mois :"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Paramètres"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Définir l\'avertissement d\'utilisation des données"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Définir la limite de consommation des données"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Limitation de la consommation de données mobiles"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Les données cellulaires sont désactivées par votre tablette lorsque la limite que vous avez définie est atteinte.\n\nLa consommation des données mesurée par la tablette peut différer de celle mesurée par votre fournisseur de services. Nous vous recommandons donc de définir un seuil plus bas."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Les données cellulaires sont désactivées par votre téléphone lorsque la limite que vous avez définie est atteinte.\n\nLa consommation des données mesurée par le téléphone peut différer de celle mesurée par votre fournisseur de services. Nous vous recommandons donc de définir un seuil plus bas."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Limiter les données en arrière-plan?"</string>
    <string name="data_usage_restrict_background" msgid="8210134218644196511">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="3262993384666280985">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi.\n\nCe paramètre touche tous les utilisateurs de cette tablette."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="4352615206362479722">"Si vous limitez les données cellulaires en arrière-plan, certains services et applications ne fonctionneront que si vous êtes connecté au réseau Wi‑Fi.\n\nCe paramètre touche tous les utilisateurs de ce téléphone."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"alerte"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="21">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Applications supprimées"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Applications et utilisateurs supprimés"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> reçus, <xliff:g id="SENT">%2$s</xliff:g> envoyés"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g> : environ <xliff:g id="TOTAL">%1$s</xliff:g> utilisés"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="5961720793603268572">"<xliff:g id="RANGE">%2$s</xliff:g> : env. <xliff:g id="TOTAL">%1$s</xliff:g> utilisés,  selon votre tablette. Le suivi conso de votre opérateur peut différer."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="1625833170144610767">"<xliff:g id="RANGE">%2$s</xliff:g> : env. <xliff:g id="TOTAL">%1$s</xliff:g> utilisés, selon votre téléphone. Le suivi conso de votre opérateur peut différer."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Restrictions réseau"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Les réseaux mesurés sont considérés comme des réseaux cellulaires lorsque les données en arrière-plan sont limitées. Les applications peuvent émettre un avertissement avant d\'utiliser ces réseaux pour les téléchargements volumineux."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Réseaux cellulaires"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Réseaux Wi-Fi mesurés"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Pour sélectionner les réseaux mesurés, activez le Wi‑Fi."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Le suivi de consommation du f. de services peut différer de celui de l\'appareil."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Appel d\'urgence"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Retour à l\'appel"</string>
    <string name="vpn_name" msgid="4689699885361002297">"nom"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Type"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Adresse du serveur"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Chiffrement PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Secret L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifiant IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Clé pré-partagée IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certificat utilisateur IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certificat d\'autorité IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certificat de serveur IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Afficher les options avancées"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domaines de recherche DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Serveurs DNS (Ex. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Itinéraires transfert (Ex. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Nom d\'utilisateur"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Mot de passe"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Enregistrer les informations de compte"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(non utilisé)"</string>
    <string name="vpn_no_ca_cert" msgid="2095005387500126113">"(ne pas valider le serveur)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(certificat reçu du serveur)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Annuler"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Enregistrer"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Connexion"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Modifier le profil VPN"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Se connecter à <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Ajouter un profil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Modifier le profil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Supprimer le profil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"VPN permanent"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Sélectionnez un profil VPN auquel rester connecté en permanence. Le trafic réseau ne sera autorisé que lorsque vous serez connecté à ce VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Aucun"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Le VPN permanent nécessite une adresse IP pour le serveur et le DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Aucune connexion réseau. Veuillez réessayer plus tard."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Certificat manquant. Veuillez modifier le profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Système"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Utilisateur"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Désactiver"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"activer"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Supprimer"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Activer le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Désactiver le certificat d\'autorité du système?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Supprimer définitivement le certificat d\'autorité utilisateur?"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Correcteur orthographique"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Saisissez le mot de passe actuel utilisé pour les sauvegardes complètes."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Saisissez votre nouveau mot de passe pour les sauvegardes complètes."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Confirmez ici votre nouveau mot de passe de sauvegarde complète."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Définir le mot de passe de sauvegarde"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Annuler"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Mises à jour supplémentaires du système"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Désactivé"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Permissif"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Application"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Le réseau peut être surveillé"</string>
    <string name="done_button" msgid="1991471253042622230">"Terminé"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="5339377665264149395">"Surveillance réseau"</string>
    <string name="ssl_ca_cert_info_message" msgid="4583879256548819713">"Cet appareil est géré au sein du domaine suivant :\n<xliff:g id="MANAGING_DOMAIN">%s</xliff:g>\n\nL\'administrateur de ce domaine a la possibilité de surveiller vos activités sur le réseau, notamment vos courriels, vos applications et les sites Web sécurisés.\n\nPour en savoir plus à ce sujet, communiquez avec votre administrateur."</string>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Un tiers peut surveiller votre activité réseau, y compris les courriels, les applications et les sites Web sécurisés. \n\nUn certificat de confiance installé sur votre appareil rend cela possible."</string>
    <string name="ssl_ca_cert_settings_button" msgid="8760495070836213605">"Vérifier les certificats de confiance"</string>
    <string name="user_settings_title" msgid="6151874007858148344">"Utilisateurs"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Utilisateurs et profils"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Ajouter un utilisateur ou un profil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Ajouter utilisateur"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Profil limité"</string>
    <string name="user_summary_managed_profile" msgid="7369539529693048111">"Profil professionnel"</string>
    <string name="user_need_lock_message" msgid="2596365678651842785">"Avant de créer un profil limité, vous devez définir un écran de verrouillage pour protéger vos applications et vos données personnelles."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Définir verrouillage écran"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Non configuré"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Non configuré : profil limité"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Non configuré : profil professionnel"</string>
    <string name="user_owner" msgid="3879126011135546571">"Propriétaire"</string>
    <string name="user_you" msgid="1639158809315025986">"Vous (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Pseudonyme"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Ajouter"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Les utilisateurs disposent de leurs propres applications et de leur propre contenu."</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Vous pouvez limiter l\'accès aux applications et au contenu depuis votre compte."</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Utilisateur"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Profil limité"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Ajouter un utilisateur?"</string>
    <string name="user_add_user_message_long" msgid="718192651887726259">"Vous pouvez partager cet appareil avec d\'autres personnes en ajoutant des utilisateurs. Chaque utilisateur dispose de son propre espace, où il peut personnaliser, entre autres, ses applications et son fond d\'écran. Chacun peut également modifier les paramètres de l\'appareil, comme les réseaux Wi-Fi, qui touchent tous les utilisateurs.\n\nLorsque vous ajoutez un utilisateur, celui-ci doit configurer son espace.\n\nN\'importe quel utilisateur peut mettre à jour les applications pour tous les autres utilisateurs."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Lorsque vous ajoutez un utilisateur, celui-ci doit configurer son espace.\n\nN\'importe quel utilisateur peut mettre à jour les applications pour tous les autres utilisateurs."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Configurer l\'utilisateur?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Assurez-vous que la personne est disponible, et qu\'elle peut utiliser l\'appareil pour configurer son espace."</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Configurer le profil maintenant?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Configurer maintenant"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Pas maintenant"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="8440449301994432789">"Seul le propriétaire de la tablette peut gérer les utilisateurs."</string>
    <string name="user_cannot_manage_message" product="default" msgid="1133251987818014757">"Seul le propriétaire de la tablette peut gérer les utilisateurs."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Les profils limités ne peuvent pas ajouter de compte."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Supp. <xliff:g id="USER_NAME">%1$s</xliff:g> de l\'appareil"</string>
    <string name="user_add_on_lockscreen_menu" msgid="3025132738715222247">"Aj. utilis. quand appar. verr."</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nouvel utilisateur"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nouveau profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Vous supprimer?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Supprimer cet utilisateur?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Supprimer ce profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Supprimer le profil professionnel?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="8167855311779740207">"Votre espace et vos données vont disparaître de cette tablette. Cette action est irréversible."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5391888073786090274">"Votre espace et vos données vont être supprimés de ce téléphone. Cette action est irréversible."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="work_profile_confirm_remove_message" msgid="7593793549364168783">"Toutes les applications et les données de ce profil seront supprimées."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"L\'ensemble des applications et des données seront supprimées."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Ajout de l\'utilisateur…"</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Supprimer l\'utilisateur"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Supprimer"</string>
    <string name="user_guest" msgid="8475274842845401871">"Invité"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Supprimer l\'invité"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Supprimer l\'invité?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Toutes les applications et les données de cette session seront supprimées."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Supprimer"</string>
    <string name="user_enable_calling" msgid="8310589470979488255">"Autoriser les appels téléphoniques"</string>
    <string name="user_enable_calling_sms" msgid="794823380737672333">"Autoriser les appels et les textos"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Supprimer l\'utilisateur"</string>
    <string name="user_enable_calling_confirm_title" msgid="440218975766968124">"Autoriser les appels téléphoniques?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"L\'historique des appels sera partagé avec cet utilisateur."</string>
    <string name="user_enable_calling_sms_confirm_title" msgid="188164598768941316">"Autoriser les appels et les textos?"</string>
    <string name="user_enable_calling_sms_confirm_message" msgid="9101983352082865696">"L\'historique des appels et des textos sera partagé avec cet utilisateur."</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Autoriser des applications et des contenus"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Applications avec restrictions"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Développer paramètres applis"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Désinstaller cette application"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Les paramètres de la page d\'accueil seront masqués jusqu\'à ce que vous installiez une autre application sur la page d\'accueil."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Ce paramètre affecte tous les utilisateurs de cette tablette."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Ce paramètre affecte tous les utilisateurs de cette tablette."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Modifier la langue"</string>
    <string name="global_font_change_title" msgid="1887126466191012035">"Modifier la taille de la police"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Toucher et payer"</string>
    <string name="google_wallet" msgid="9122936252378589227">"Google Portefeuille"</string>
    <string name="nfc_payment_no_apps" msgid="2481080809791416010">"Payez en un toucher sur l\'écran"</string>
    <string name="nfc_payment_favor_foreground" msgid="8881893980929835838">"Privilégier l\'application au premier plan"</string>
    <string name="nfc_payment_learn_more" msgid="5583407773744324447">"En savoir plus"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Plus..."</string>
    <string name="nfc_payment_menu_item_add_service" msgid="2885947408068969081">"Trouver des applications"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Définir comme application de paiement par défaut?"</string>
    <string name="nfc_payment_set_default" msgid="8961120988148253016">"Toujours utiliser <xliff:g id="APP">%1$s</xliff:g> pour les achats « toucher et payer »?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="3803693771001226795">"Toujours utiliser <xliff:g id="APP_0">%1$s</xliff:g> au lieu de <xliff:g id="APP_1">%2$s</xliff:g> pour les achats « toucher et payer »?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Restrictions"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Annuler les restrictions"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Modifier le NIP"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Afficher les notifications"</string>
    <string name="help_label" msgid="6886837949306318591">"Aide et commentaires"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Compte pour contenu"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID de photo"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Menaces extrêmes"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Recevoir alertes pour menaces extrêmes à la vie et aux biens"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Menaces sévères"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Recevoir alertes pour menaces sévères à la vie et aux biens"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Alertes AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Recevoir les bulletins sur les enlèvements d\'enfants"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Répéter"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Activer le gestionnaire d\'appels"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Autoriser ce service à gérer comment vous faites vos appels."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Gestionnaire d\'appels"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Diffusions d\'urgence"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Fournisseurs de services cellulaires"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Noms des points d\'accès"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Mode LTE 4G avancé"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Utiliser les données LTE pour améliorer les appels et les communications (recommandé)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Type de réseau préféré"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (recommandé)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Carte SIM professionnelle"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Accès aux applications et au contenu"</string>
    <string name="user_rename" msgid="8523499513614655279">"RENOMMER"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Définir des restrictions d\'applis"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Contrôlées par <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_not_supported_in_limited" msgid="913035259626149121">"Cette application n\'accepte pas les profils limités."</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Cette application peut accéder à vos comptes."</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi‑Fi et données mobiles"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Autoriser les modifications des paramètres du Wi‑Fi et des données mobiles"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Autoriser les modifications des associations et des paramètres Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Autoriser l\'échange de données lorsque cet appareil (<xliff:g id="DEVICE_NAME">%1$s</xliff:g>) touche un autre appareil NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Autoriser l\'échange de données lorsque la tablette est en contact avec un autre appareil"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Autoriser l\'échange de données lorsque le téléphone est en contact avecun autre appareil"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Position"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Autoriser les applications à utiliser vos données de localisation"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Précédent"</string>
    <string name="wizard_next" msgid="3606212602795100640">"SUIVANTE"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Terminer"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Prendre une photo"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Sélectionner une photo dans la galerie"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Sélectionner une photo"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Cartes SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Cartes SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Les cartes SIM ont été changées."</string>
    <string name="sim_cards_changed_message_summary" msgid="5452545583546944683">"Touchez pour définir les activités"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Imposs. accéder rés. donn. cellulaires"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="3654805961942166428">"Touchez pour choisir une carte SIM pour les données."</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Toujours l\'utiliser pour les appels"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Sélectionnez une carte SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"Carte SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"La fente pour carte SIM est vide"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Nom de la carte SIM"</string>
    <string name="sim_editor_title" msgid="6364331907415443358">"Carte SIM"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Fournisseur de services"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Numéro"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Couleur de la carte SIM"</string>
    <string name="sim_editor_num_format" msgid="4681231191387098783">"Afficher les numéros"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Sélectionner une carte SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"Orange"</string>
    <string name="color_purple" msgid="3888532466427762504">"Mauve"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Aucune carte SIM insérée"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"État de la carte SIM"</string>
    <string name="sim_status_summary" msgid="4934558018015161369">"Reenseignements concernant la carte SIM"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Rappeler avec la carte SIM par défaut"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Carte SIM pour les appels sortants"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Autres paramètres d\'appel"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Décharg. réseau préféré"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Désact. diff. nom réseau"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"La désactivation de la diffusion du nom du réseau empêche les tiers d\'accéder aux détails du réseau."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"La désactivation de la diffusion du nom du réseau bloque la connexion automatique aux réseaux masqués"</string>
    <string name="sim_pref_divider" msgid="4194064766764348209">"Activités"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="2897913529999035350">"Demander d\'abord"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Veuillez indiquer votre préférence"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Paramètres"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Paramètres"</string>
    <string name="search_menu" msgid="7053532283559077164">"Rechercher"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Paramètres de recherche"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Recherches récentes"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Résultats"</string>
    <string name="keywords_wifi" msgid="8947676711698613374">"wifi connexion réseau wi-fi"</string>
    <string name="keywords_more_default_sms_app" msgid="2744404159003574745">"message texte"</string>
    <string name="keywords_more_mobile_networks" msgid="7813380887358745769">"cellulaire fournisseur de services sans fil"</string>
    <string name="keywords_home" msgid="3626170808219458848">"lanceur d\'applications"</string>
    <string name="keywords_display" msgid="6709007669501628320">"écran tactile"</string>
    <string name="keywords_display_brightness_level" msgid="8636451602230815191">"réduire la luminosité de l\'écran tactile"</string>
    <string name="keywords_display_auto_brightness" msgid="8070218600502753102">"réduire la luminosité de l\'écran tactile"</string>
    <string name="keywords_display_wallpaper" msgid="4315466287469834939">"arrière-plan"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"taille du texte"</string>
    <string name="keywords_display_cast_screen" msgid="8887412173792143329">"projet"</string>
    <string name="keywords_storage" msgid="7007275853993419928">"espace disque dur"</string>
    <string name="keywords_battery" msgid="3992479295298655138">"alimentation"</string>
    <string name="keywords_spell_checker" msgid="4509482591225399210">"orthographe"</string>
    <string name="keywords_voice_input" msgid="3519547605812413860">"détecteur entrée voix parler langue mains libres reconnaissance mains libres terme choquant historique audio écouteur bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="8207889472282225512">"débit langue par défaut parler parole"</string>
    <string name="keywords_date_and_time" msgid="7666950126499155141">"horloge"</string>
    <string name="keywords_factory_data_reset" msgid="3693730656843989732">"réinitialiser et effacer"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"imprimante"</string>
    <string name="keywords_sounds_and_notifications" msgid="5965996187974887000">"haut-parleur signal sonore"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="2912933812460077912">"ne pas déranger interrompre interruption pause"</string>
    <string name="keywords_app" msgid="6334757056536837791">"Mémoire vive"</string>
    <string name="keywords_location" msgid="782326973714313480">"à proximité historique des positions mise à jour de la position"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"précision"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"compte"</string>
    <string name="keywords_users" msgid="4673901601478559100">"limitation limiter limité"</string>
    <string name="keywords_keyboard_and_ime" msgid="1103378692379215672">"texte correction corriger son vibreur auto langue geste suggérer suggestion thème terme choquant type emoji"</string>
    <string name="keywords_lockscreen" msgid="4806191868723291541">"glisser mot de passe schéma nip"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Créer une balise NFC par Wi-Fi"</string>
    <string name="write_tag" msgid="8571858602896222537">"Écrire"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Touchez une balise pour pour écrire..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Mot de passe non valide, veuillez réessayer."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Succès!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Impossible d\'écrire des données sur la balise NFC. Si le problème persiste, essayez avec une autre balise."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"La balise NFC n\'est pas accessible en écriture. Veuillez en utiliser un autre."</string>
    <string name="default_sound" msgid="8821684447333687810">"Son par défaut"</string>
    <string name="notification_settings" msgid="8791730980212496561">"Sons et notifications"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Volume des médias"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Volume de l\'alarme"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Volume de la sonnerie"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Volume des notifications"</string>
    <string name="zen_mode_settings_title" msgid="7014915558669122902">"Interruptions"</string>
    <string name="zen_mode_option_title" msgid="5061978632306007914">"À la réception d\'appels et de notifications"</string>
    <string name="zen_mode_option_title_novoice" msgid="6680706009915204785">"À la réception de notifications"</string>
    <string name="zen_mode_option_off" msgid="3167702608910820883">"Toujours interrompre"</string>
    <string name="zen_mode_option_important_interruptions" msgid="2320263300561981257">"N\'autoriser que les interruptions prioritaires"</string>
    <string name="zen_mode_option_no_interruptions" msgid="5664234817617301449">"Ne pas interrompre"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Sonnerie du téléphone"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Sonnerie de notification par défaut"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibreur aussi pour les appels"</string>
    <string name="notification_section_header" msgid="95661783916799134">"Notification"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Faire clignoter le voyant de notification"</string>
    <string name="lock_screen_notifications_title" msgid="9118805570775519455">"Si l\'appareil est verrouillé"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Afficher l\'intégralité du contenu des notifications"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Masquer le contenu sensible des notifications"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3001013816427963576">"N\'afficher aucune notification"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Lorsque votre appareil est verrouillé, comment voulez-vous que les notifications s\'affichent?"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Notifications de l\'application"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Autres sons"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonalités du clavier"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Sons du verrouillage d\'écran"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Sons de la station d\'accueil"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Sons des touches"</string>
    <string name="vibrate_on_touch_title" msgid="674710566941697253">"Vibrer au toucher"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Lecture : station d\'accueil"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Tout l\'audio"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Audio des médias seulement"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Mode silencieux"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Alerte"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibreur"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Accès aux notifications"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Les applications ne peuvent pas lire les notifications."</string>
  <plurals name="manage_notification_access_summary_nonzero">
    <item quantity="one" msgid="8344183614159211585">"%d application peut lire les notifications."</item>
    <item quantity="other" msgid="980049191810249052">"%d applications peuvent lire les notifications."</item>
  </plurals>
    <string name="no_notification_listeners" msgid="2767405417723149879">"Aucun outil d\'écoute des notifications installé."</string>
    <string name="notification_listener_security_warning_title" msgid="6494221261778885893">"Activer <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="2780319203595885564">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> pourra lire toutes les notifications publiées par le système ou toute application installée. Ces notifications peuvent comporter des informations personnelles, telles que des noms de contacts et le texte de messages qui vous ont été envoyés. L\'application pourra également masquer ces notifications ou sélectionner les boutons d\'action qu\'elles contiennent."</string>
    <string name="manage_condition_providers" msgid="3039306415273606730">"Fournisseurs de conditions"</string>
    <string name="manage_condition_providers_summary_zero" msgid="3760902189574984100">"Aucune application ne fournit de conditions"</string>
  <plurals name="manage_condition_providers_summary_nonzero">
    <item quantity="one" msgid="7871716594997778198">"%d application fournit des conditions"</item>
    <item quantity="other" msgid="358057362115673258">"%d applications fournissent des conditions"</item>
  </plurals>
    <string name="no_condition_providers" msgid="6183782892066424125">"Aucun fournisseur de conditions n\'est installé."</string>
    <string name="condition_provider_security_warning_title" msgid="5834347345913614926">"Activer <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="condition_provider_security_warning_summary" msgid="640037330610551763">"<xliff:g id="CONDITION_PROVIDER_NAME">%1$s</xliff:g> pourra ajouter des conditions de sortie au mode Ne pas déranger."</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Chargement des applications en cours..."</string>
    <string name="app_notification_block_title" msgid="172237877395761371">"Bloquer"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Ne jamais afficher les notifications de cette application"</string>
    <string name="app_notification_priority_title" msgid="1967189807102076587">"Priorité"</string>
    <string name="app_notification_priority_summary" msgid="7513344552201639232">"Afficher des notifications dans le haut de la liste et continuer de les afficher tant que l\'appareil n\'est pas configuré de manière à n\'afficher que les interruptions prioritaires"</string>
    <string name="app_notification_sensitive_title" msgid="7707233094233553192">"Sensible"</string>
    <string name="app_notification_sensitive_summary" msgid="2505314249332316395">"Lorsque l\'appareil est verrouillé, masquer tout le contenu sensible des notifications de cette application"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Bloqué"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Priorité"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Sensible"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Terminé"</string>
    <string name="zen_mode_default_option" msgid="6940069025071935243">"Jusqu\'à la désactivation"</string>
    <string name="zen_mode_important_category" msgid="8123274463331022993">"Interruptions prioritaires"</string>
    <string name="zen_mode_downtime_category" msgid="4730179065426038108">"Arrêt (interruptions prio. seulement)"</string>
    <string name="zen_mode_downtime_days" msgid="3361856902633311616">"Jours"</string>
    <string name="zen_mode_downtime_days_none" msgid="8454857121193391322">"Aucun"</string>
    <string name="zen_mode_automation_category" msgid="4653551005950835761">"Automatisation"</string>
    <string name="zen_mode_entry_conditions_title" msgid="8467976490601914289">"Activation automatique"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="zen_mode_entry_conditions_summary_none" msgid="6589476427475076533">"Jamais"</string>
    <string name="zen_mode_phone_calls" msgid="8956214416859303966">"Appels"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Messages"</string>
    <string name="zen_mode_from" msgid="1033337300289871697">"Appels/Messages de"</string>
    <string name="zen_mode_from_anyone" msgid="1180865188673992959">"N\'importe qui"</string>
    <string name="zen_mode_from_contacts" msgid="8751503728985572786">"Contacts seulement"</string>
    <string name="zen_mode_from_starred" msgid="2168651127340381533">"Contacts favoris seulement"</string>
    <string name="zen_mode_events" msgid="2456995649835437565">"Événements et rappels"</string>
    <string name="zen_mode_alarm_info" msgid="3195430795475795398">"Les alarmes sont toujours des interruptions prioritaires."</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Activation auto"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Jamais"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Tous les soirs"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Les soirs de semaine"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Heure de début"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Heure de fin"</string>
    <string name="zen_mode_end_time_summary_format" msgid="1941585278888784451">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> le lendemain"</string>
    <string name="notification_settings_apps_title" msgid="1125354590652967250">"Notif. application"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Paramètres de notification"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Commentaires sur cet appareil"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Entrez le NIP d\'administrateur"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Activé"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Désactivé"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Épinglage à l\'écran"</string>
    <string name="screen_pinning_description" msgid="7091642350452605379">"Lorsque cette fonction est activée, vous pouvez utiliser l\'épinglage d\'écran pour garder l\'écran en cours actif jusqu\'à ce que vous annuliez l\'épinglage.\n\nPour utiliser l\'épinglage d\'écran : \n\n1. Assurez-vous que l\'épinglage d\'écran est activé.\n\n2. Ouvrez l\'écran que vous souhaitez épingler.\n\n3. Touchez Aperçu.\n\n4. Touchez l\'icône d\'épingle."</string>
    <string name="managed_user_title" msgid="8101244883654409696">"Profil professionnel"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Expérimentale)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Lorsque l\'utilisateur pivote l\'appareil"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Pivoter le contenu de l\'écran"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Rester en mode portrait"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Rester en mode paysage"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Garder l\'orientation actuelle"</string>
    <string name="encryption_interstitial_header" msgid="5790264941172726485">"Chiffrement"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Continuer"</string>
    <string name="encryption_interstitial_message_pin" msgid="3705622704667901162">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du NIP avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil."</string>
    <string name="encryption_interstitial_message_pattern" msgid="2944051427890104942">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du motif avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil."</string>
    <string name="encryption_interstitial_message_password" msgid="1439296580879440802">"Pour améliorer la protection de cet appareil, vous pouvez exiger l\'entrée du mot de passe avant le démarrage. L\'appareil ne reçoit pas d\'appels, de messages ni de notifications, y compris les alertes, tant qu\'il n\'a pas démarré. \n\nCette fonctionnalité permet de protéger les données en cas de perte ou de vol de l\'appareil."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Exiger un NIP pour démarrer l\'appareil"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Exiger un motif pour démarrer l\'appareil"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Exiger un mot de passe pour démarrer l\'appareil"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Non, merci"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Non, merci"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Non, merci"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Exiger le NIP?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Exiger le motif?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Exiger le mot de passe?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="1890374082842868489">"Lorsque vous entrez votre NIP pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="4474332516537386384">"Lorsque vous entrez votre motif pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="8166099418487083927">"Lorsque vous entrez votre mot de passe pour démarrer cet appareil, les services d\'accessibilité comme <xliff:g id="SERVICE">%1$s</xliff:g> ne seront pas accessibles immédiatement."</string>
</resources>
