<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="202579285008794431">"octet(s)"</string>
    <string name="kilobyteShort" msgid="2214285521564195803">"Ko"</string>
    <string name="megabyteShort" msgid="6649361267635823443">"Mo"</string>
    <string name="gigabyteShort" msgid="7515809460261287991">"Go"</string>
    <string name="terabyteShort" msgid="1822367128583886496">"To"</string>
    <string name="petabyteShort" msgid="5651571254228534832">"Po"</string>
    <string name="fileSizeSuffix" msgid="4233671691980131257">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="3381766946944136678">"&lt;Sans nom&gt;"</string>
    <string name="emptyPhoneNumber" msgid="5812172618020360048">"(Aucun numéro de téléphone)"</string>
    <string name="unknownName" msgid="7078697621109055330">"Inconnu"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2190754495304236490">"Messagerie vocale"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2285034592902077488">"MSISDN1"</string>
    <string name="mmiError" msgid="2862759606579822246">"Problème de connexion ou code IHM non valide."</string>
    <string name="mmiFdnError" msgid="3975490266767565852">"Opération réservée aux numéros autorisés"</string>
    <string name="mmiErrorWhileRoaming" msgid="1204173664713870114">"Impossible de modifier les paramètres de transfert d\'appel depuis votre téléphone lorsque vous êtes en itinérance."</string>
    <string name="serviceEnabled" msgid="7549025003394765639">"Le service a été activé."</string>
    <string name="serviceEnabledFor" msgid="1463104778656711613">"Ce service a été activé pour :"</string>
    <string name="serviceDisabled" msgid="641878791205871379">"Ce service a été désactivé."</string>
    <string name="serviceRegistered" msgid="3856192211729577482">"Enregistrement réussi."</string>
    <string name="serviceErased" msgid="997354043770513494">"Effacement réussi."</string>
    <string name="passwordIncorrect" msgid="917087532676155877">"Le mot de passe est incorrect."</string>
    <string name="mmiComplete" msgid="6341884570892520140">"IHM terminée."</string>
    <string name="badPin" msgid="888372071306274355">"L\'ancien code PIN saisi est incorrect."</string>
    <string name="badPuk" msgid="4232069163733147376">"La clé PUK saisie est incorrecte."</string>
    <string name="mismatchPin" msgid="2929611853228707473">"Les codes PIN saisis ne correspondent pas."</string>
    <string name="invalidPin" msgid="7542498253319440408">"Le code PIN doit compter de 4 à 8 chiffres."</string>
    <string name="invalidPuk" msgid="8831151490931907083">"Saisissez un code PUK comportant au moins huit chiffres."</string>
    <string name="needPuk" msgid="7321876090152422918">"Votre carte SIM est verrouillée par clé PUK. Saisissez la clé PUK pour la déverrouiller."</string>
    <string name="needPuk2" msgid="7032612093451537186">"Saisissez la clé PUK2 pour débloquer la carte SIM."</string>
    <string name="enablePin" msgid="2543771964137091212">"Échec de l\'opération. Veuillez activer le verrouillage de la carte SIM/RUIM."</string>
    <plurals name="pinpuk_attempts" formatted="false" msgid="1619867269012213584">
      <item quantity="one">Il vous reste <xliff:g id="NUMBER_1">%d</xliff:g> tentative avant que votre carte SIM ne soit verrouillée.</item>
      <item quantity="other">Il vous reste <xliff:g id="NUMBER_1">%d</xliff:g> tentatives avant que votre carte SIM ne soit verrouillée.</item>
    </plurals>
    <string name="imei" msgid="2157082351232630390">"Code IMEI"</string>
    <string name="meid" msgid="3291227361605924674">"Code MEID"</string>
    <string name="ClipMmi" msgid="4110549342447630629">"Numéro de l\'appelant (entrant)"</string>
    <string name="ClirMmi" msgid="4702929460236547156">"Numéro de l\'appelant (sortant)"</string>
    <string name="ColpMmi" msgid="4736462893284419302">"Identifiant de la ligne connectée"</string>
    <string name="ColrMmi" msgid="5889782479745764278">"Restriction d\'identifiant de la ligne connectée"</string>
    <string name="CfMmi" msgid="8390012691099787178">"Transfert d\'appel"</string>
    <string name="CwMmi" msgid="3164609577675404761">"Appel en attente"</string>
    <string name="BaMmi" msgid="7205614070543372167">"Interdiction d\'appel"</string>
    <string name="PwdMmi" msgid="3360991257288638281">"Modification du mot de passe"</string>
    <string name="PinMmi" msgid="7133542099618330959">"Modification du code PIN"</string>
    <string name="CnipMmi" msgid="4897531155968151160">"Présentation du numéro d\'appelant"</string>
    <string name="CnirMmi" msgid="885292039284503036">"Numéro de l\'appelant masqué"</string>
    <string name="ThreeWCMmi" msgid="2436550866139999411">"Conférence téléphonique à trois"</string>
    <string name="RuacMmi" msgid="1876047385848991110">"Rejeter les appels indésirables"</string>
    <string name="CndMmi" msgid="185136449405618437">"Livraison du numéro d\'appel"</string>
    <string name="DndMmi" msgid="8797375819689129800">"Ne pas déranger"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="4511621022859867988">"Par défaut, les numéros des appelants ne sont pas restreints. Appel suivant : restreint"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="5036749051007098105">"Par défaut, les numéros des appelants ne sont pas restreints. Appel suivant : non restreint"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="1022781126694885017">"Par défaut, les numéros des appelants ne sont pas restreints. Appel suivant : restreint"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2491576172356463443">"Par défaut, les numéros des appelants ne sont pas restreints. Appel suivant : non restreint"</string>
    <string name="serviceNotProvisioned" msgid="8289333510236766193">"Ce service n\'est pas pris en charge."</string>
    <string name="CLIRPermanent" msgid="166443681876381118">"Impossible de modifier le paramètre relatif au numéro de l\'appelant."</string>
    <string name="RestrictedOnDataTitle" msgid="1500576417268169774">"Aucun service de données mobiles"</string>
    <string name="RestrictedOnEmergencyTitle" msgid="2852916906106191866">"Appels d\'urgence non disponibles"</string>
    <string name="RestrictedOnNormalTitle" msgid="7009474589746551737">"Aucun service vocal"</string>
    <string name="RestrictedOnAllVoiceTitle" msgid="3982069078579103087">"Aucun service vocal ni d\'appels d\'urgence"</string>
    <string name="RestrictedStateContent" msgid="7693575344608618926">"Service temporairement désactivé par votre opérateur"</string>
    <string name="RestrictedStateContentMsimTemplate" msgid="5228235722511044687">"Service temporairement désactivé par votre opérateur concernant la carte SIM <xliff:g id="SIMNUMBER">%d</xliff:g>"</string>
    <string name="NetworkPreferenceSwitchTitle" msgid="1008329951315753038">"Impossible d\'accéder au réseau mobile"</string>
    <string name="NetworkPreferenceSwitchSummary" msgid="2086506181486324860">"Essayez de changer le réseau préféré. Appuyez pour le modifier."</string>
    <string name="EmergencyCallWarningTitle" msgid="1615688002899152860">"Appels d\'urgence non disponibles"</string>
    <string name="EmergencyCallWarningSummary" msgid="1194185880092805497">"Impossible de passer des appels d\'urgence via le Wi-Fi"</string>
    <string name="notification_channel_network_alert" msgid="4788053066033851841">"Alertes"</string>
    <string name="notification_channel_call_forward" msgid="8230490317314272406">"Transfert d\'appel"</string>
    <string name="notification_channel_emergency_callback" msgid="54074839059123159">"Mode de rappel d\'urgence"</string>
    <string name="notification_channel_mobile_data_status" msgid="1941911162076442474">"État des données mobiles"</string>
    <string name="notification_channel_sms" msgid="1243384981025535724">"SMS"</string>
    <string name="notification_channel_voice_mail" msgid="8457433203106654172">"Messages vocaux"</string>
    <string name="notification_channel_wfc" msgid="9048240466765169038">"Appels Wi-Fi"</string>
    <string name="notification_channel_sim" msgid="5098802350325677490">"État de la carte SIM"</string>
    <string name="notification_channel_sim_high_prio" msgid="642361929452850928">"Notifications prioritaires de la carte SIM"</string>
    <string name="peerTtyModeFull" msgid="337553730440832160">"Mode TTY demandé par l\'interlocuteur : COMPLET"</string>
    <string name="peerTtyModeHco" msgid="5626377160840915617">"Mode TTY demandé par l\'interlocuteur : HCO"</string>
    <string name="peerTtyModeVco" msgid="572208600818270944">"Mode TTY demandé par l\'interlocuteur : VCO"</string>
    <string name="peerTtyModeOff" msgid="2420380956369226583">"Mode TTY demandé par l\'interlocuteur : DÉSACTIVÉ"</string>
    <string name="serviceClassVoice" msgid="2065556932043454987">"Voix"</string>
    <string name="serviceClassData" msgid="4148080018967300248">"Données"</string>
    <string name="serviceClassFAX" msgid="2561653371698904118">"Fax"</string>
    <string name="serviceClassSMS" msgid="1547664561704509004">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="2029856900898545984">"Asynchrones"</string>
    <string name="serviceClassDataSync" msgid="7895071363569133704">"Synchrones"</string>
    <string name="serviceClassPacket" msgid="1430642951399303804">"Paquet"</string>
    <string name="serviceClassPAD" msgid="6850244583416306321">"PAD"</string>
    <string name="roamingText0" msgid="7793257871609854208">"Indicateur d\'itinérance activé"</string>
    <string name="roamingText1" msgid="5073028598334616445">"Indicateur d\'itinérance désactivé"</string>
    <string name="roamingText2" msgid="2834048284153110598">"Indicateur d\'itinérance clignotant"</string>
    <string name="roamingText3" msgid="831690234035748988">"Hors zone"</string>
    <string name="roamingText4" msgid="2171252529065590728">"Hors du bâtiment"</string>
    <string name="roamingText5" msgid="4294671587635796641">"Itinérance - Système préféré"</string>
    <string name="roamingText6" msgid="5536156746637992029">"Itinérance - Système disponible"</string>
    <string name="roamingText7" msgid="1783303085512907706">"Itinérance - Partenaire Alliance"</string>
    <string name="roamingText8" msgid="7774800704373721973">"Itinérance - Partenaire Premium"</string>
    <string name="roamingText9" msgid="1933460020190244004">"Itinérance - Tous services disponibles"</string>
    <string name="roamingText10" msgid="7434767033595769499">"Itinérance - Services partiellement disponibles"</string>
    <string name="roamingText11" msgid="5245687407203281407">"Bannière d\'itinérance activée"</string>
    <string name="roamingText12" msgid="673537506362152640">"Bannière d\'itinérance désactivée"</string>
    <string name="roamingTextSearching" msgid="5323235489657753486">"Recherche des services disponibles"</string>
    <string name="wfcRegErrorTitle" msgid="3193072971584858020">"Impossible de configurer les appels Wi‑Fi"</string>
  <string-array name="wfcOperatorErrorAlertMessages">
    <item msgid="468830943567116703">"Pour passer des appels et envoyer des messages via le Wi-Fi, demandez d\'abord à votre opérateur de configurer ce service. Ensuite, réactivez les appels Wi-Fi dans les paramètres. (Code d\'erreur : <xliff:g id="CODE">%1$s</xliff:g>)"</item>
  </string-array>
  <string-array name="wfcOperatorErrorNotificationMessages">
    <item msgid="4795145070505729156">"Problème lors de l\'enregistrement des appels Wi‑Fi avec votre opérateur : <xliff:g id="CODE">%1$s</xliff:g>"</item>
  </string-array>
    <!-- no translation found for wfcSpnFormat_spn (2982505428519096311) -->
    <skip />
    <string name="wfcSpnFormat_spn_wifi_calling" msgid="3165949348000906194">"Appels Wi-Fi <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen" msgid="3836827895369365298">"Appels Wi-Fi <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wlan_call" msgid="4895315549916165700">"Appel WLAN"</string>
    <string name="wfcSpnFormat_spn_wlan_call" msgid="255919245825481510">"Appel WLAN <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_wifi" msgid="7232899594327126970">"Wi-Fi <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling_bar_spn" msgid="8383917598312067365">"Appels Wi-Fi | <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_spn_vowifi" msgid="6865214948822061486">"VoWiFi <xliff:g id="SPN">%s</xliff:g>"</string>
    <string name="wfcSpnFormat_wifi_calling" msgid="6178935388378661755">"Appels Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi" msgid="1376356951297043426">"Wi-Fi"</string>
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen" msgid="7178561009225028264">"Appels Wi-Fi"</string>
    <string name="wfcSpnFormat_vowifi" msgid="8371335230890725606">"VoWiFi"</string>
    <string name="wifi_calling_off_summary" msgid="5626710010766902560">"Désactivé"</string>
    <string name="wfc_mode_wifi_preferred_summary" msgid="1035175836270943089">"Appel via le Wi-Fi"</string>
    <string name="wfc_mode_cellular_preferred_summary" msgid="4958965609212575619">"Appel via le réseau mobile"</string>
    <string name="wfc_mode_wifi_only_summary" msgid="104951993894678665">"Wi-Fi uniquement"</string>
    <string name="cfTemplateNotForwarded" msgid="862202427794270501">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g> : non transféré"</string>
    <string name="cfTemplateForwarded" msgid="9132506315842157860">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g> : <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="735042369233323609">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g> : <xliff:g id="DIALING_NUMBER">{1}</xliff:g> au bout de <xliff:g id="TIME_DELAY">{2}</xliff:g> secondes"</string>
    <string name="cfTemplateRegistered" msgid="5619930473441550596">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g> : non transféré"</string>
    <string name="cfTemplateRegisteredTime" msgid="5222794399642525045">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g> : non transféré"</string>
    <string name="fcComplete" msgid="1080909484660507044">"Code de service terminé"</string>
    <string name="fcError" msgid="5325116502080221346">"Problème de connexion ou code de service non valide"</string>
    <string name="httpErrorOk" msgid="6206751415788256357">"OK"</string>
    <string name="httpError" msgid="3406003584150566720">"Une erreur réseau s\'est produite."</string>
    <string name="httpErrorLookup" msgid="3099834738227549349">"Impossible de trouver l\'URL."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="3976195595501606787">"Le modèle d\'authentification du site n\'est pas compatible."</string>
    <string name="httpErrorAuth" msgid="469553140922938968">"Impossible de procéder à l\'authentification."</string>
    <string name="httpErrorProxyAuth" msgid="7229662162030113406">"Échec de l\'authentification par un serveur proxy."</string>
    <string name="httpErrorConnect" msgid="3295081579893205617">"Impossible de se connecter au serveur."</string>
    <string name="httpErrorIO" msgid="3860318696166314490">"Impossible d\'établir une communication avec le serveur. Veuillez réessayer ultérieurement."</string>
    <string name="httpErrorTimeout" msgid="7446272815190334204">"Délai de connexion au serveur dépassé."</string>
    <string name="httpErrorRedirectLoop" msgid="8455757777509512098">"Cette page contient trop de redirections de serveurs."</string>
    <string name="httpErrorUnsupportedScheme" msgid="2664108769858966374">"Ce protocole n\'est pas compatible."</string>
    <string name="httpErrorFailedSslHandshake" msgid="546319061228876290">"Impossible d\'établir une connexion sécurisée."</string>
    <string name="httpErrorBadUrl" msgid="754447723314832538">"Impossible d\'ouvrir la page, car l\'URL n\'est pas valide."</string>
    <string name="httpErrorFile" msgid="3400658466057744084">"Impossible d\'accéder au fichier."</string>
    <string name="httpErrorFileNotFound" msgid="5191433324871147386">"Impossible de trouver le fichier demandé."</string>
    <string name="httpErrorTooManyRequests" msgid="2149677715552037198">"Trop de requêtes sont en cours de traitement. Veuillez réessayer ultérieurement."</string>
    <string name="notification_title" msgid="5783748077084481121">"Erreur de connexion au compte \"<xliff:g id="ACCOUNT">%1$s</xliff:g>\""</string>
    <string name="contentServiceSync" msgid="2341041749565687871">"Synchroniser"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="5766411446676388623">"Synchronisation impossible"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="4562226280528716090">"Vous avez dépassé le nombre limite de tentatives de suppression de ce type de contenu : <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" product="tablet" msgid="5557552311566179924">"La mémoire de la tablette est pleine. Supprimez des fichiers pour libérer de l\'espace."</string>
    <string name="low_memory" product="watch" msgid="3479447988234030194">"La mémoire de la montre est saturée. Veuillez supprimer des fichiers pour libérer de l\'espace."</string>
    <string name="low_memory" product="tv" msgid="6663680413790323318">"L\'espace de stockage de l\'appareil Android TV est saturé. Supprimez certains fichiers pour libérer de l\'espace."</string>
    <string name="low_memory" product="default" msgid="2539532364144025569">"La mémoire du téléphone est pleine. Veuillez supprimer des fichiers pour libérer de l\'espace."</string>
    <plurals name="ssl_ca_cert_warning" formatted="false" msgid="2288194355006173029">
      <item quantity="one">Autorité de certification installée</item>
      <item quantity="other">Autorités de certification installées</item>
    </plurals>
    <string name="ssl_ca_cert_noti_by_unknown" msgid="4961102218216815242">"Par un tiers inconnu"</string>
    <string name="ssl_ca_cert_noti_by_administrator" msgid="4564941950768783879">"Par l\'administrateur de votre profil professionnel"</string>
    <string name="ssl_ca_cert_noti_managed" msgid="217337232273211674">"Par <xliff:g id="MANAGING_DOMAIN">%s</xliff:g>"</string>
    <string name="work_profile_deleted" msgid="5891181538182009328">"Profil professionnel supprimé"</string>
    <string name="work_profile_deleted_details" msgid="3773706828364418016">"L\'application d\'administration du profil professionnel est manquante ou endommagée. Par conséquent, votre profil professionnel et toutes les données associées ont été supprimés. Pour obtenir de l\'aide, contactez l\'administrateur."</string>
    <string name="work_profile_deleted_description_dpm_wipe" msgid="2477244968924647232">"Votre profil professionnel n\'est plus disponible sur cet appareil"</string>
    <string name="work_profile_deleted_reason_maximum_password_failure" msgid="1080323158315663167">"Trop de tentatives de saisie du mot de passe"</string>
    <string name="device_ownership_relinquished" msgid="4080886992183195724">"L\'administrateur a mis l\'appareil à disposition pour un usage personnel"</string>
    <string name="network_logging_notification_title" msgid="554983187553845004">"L\'appareil est géré"</string>
    <string name="network_logging_notification_text" msgid="1327373071132562512">"Votre organisation gère cet appareil et peut surveiller le trafic réseau. Appuyez ici pour obtenir plus d\'informations."</string>
    <string name="location_changed_notification_title" msgid="3620158742816699316">"Des application peuvent accéder à votre position"</string>
    <string name="location_changed_notification_text" msgid="7158423339982706912">"Contactez l\'administrateur informatique pour en savoir plus"</string>
    <string name="country_detector" msgid="7023275114706088854">"Détecteur de pays"</string>
    <string name="location_service" msgid="2439187616018455546">"Service de localisation"</string>
    <string name="sensor_notification_service" msgid="7474531979178682676">"Service de notification du capteur"</string>
    <string name="twilight_service" msgid="8964898045693187224">"Service Twilight"</string>
    <string name="factory_reset_warning" msgid="6858705527798047809">"Les données de votre appareil vont être effacées"</string>
    <string name="factory_reset_message" msgid="2657049595153992213">"Impossible d\'utiliser l\'application d\'administration. Les données de votre appareil vont maintenant être effacées.\n\nSi vous avez des questions, contactez l\'administrateur de votre organisation."</string>
    <string name="printing_disabled_by" msgid="3517499806528864633">"Impression désactivée par <xliff:g id="OWNER_APP">%s</xliff:g>."</string>
    <string name="personal_apps_suspension_title" msgid="7561416677884286600">"Activez profil professionnel"</string>
    <string name="personal_apps_suspension_text" msgid="6115455688932935597">"Vos applications personnelles sont bloquées jusqu\'à ce que vous activiez votre profil professionnel"</string>
    <string name="personal_apps_suspension_tomorrow_text" msgid="6322541302153673994">"Vos applications personnelles seront bloquées demain"</string>
    <string name="personal_apps_suspended_turn_profile_on" msgid="4278188538997940785">"Activer le profil professionnel"</string>
    <string name="me" msgid="6207584824693813140">"Moi"</string>
    <string name="power_dialog" product="tablet" msgid="8333207765671417261">"Options de la tablette"</string>
    <string name="power_dialog" product="tv" msgid="7792839006640933763">"Options Android TV"</string>
    <string name="power_dialog" product="default" msgid="1107775420270203046">"Options du téléphone"</string>
    <string name="silent_mode" msgid="8796112363642579333">"Mode silencieux"</string>
    <string name="turn_on_radio" msgid="2961717788170634233">"Activer le mode sans fil"</string>
    <string name="turn_off_radio" msgid="7222573978109933360">"Désactiver le mode sans fil"</string>
    <string name="screen_lock" msgid="2072642720826409809">"Verrouillage de l\'écran"</string>
    <string name="power_off" msgid="4111692782492232778">"Éteindre"</string>
    <string name="silent_mode_silent" msgid="5079789070221150912">"Sonnerie désactivée"</string>
    <string name="silent_mode_vibrate" msgid="8821830448369552678">"Sonnerie en mode vibreur"</string>
    <string name="silent_mode_ring" msgid="6039011004781526678">"Sonnerie activée"</string>
    <string name="reboot_to_update_title" msgid="2125818841916373708">"Mise à jour du système Android"</string>
    <string name="reboot_to_update_prepare" msgid="6978842143587422365">"Préparation de la mise à jour en cours…"</string>
    <string name="reboot_to_update_package" msgid="4644104795527534811">"Traitement du package de mise à jour…"</string>
    <string name="reboot_to_update_reboot" msgid="4474726009984452312">"Redémarrage…"</string>
    <string name="reboot_to_reset_title" msgid="2226229680017882787">"Rétablir la configuration d\'usine"</string>
    <string name="reboot_to_reset_message" msgid="3347690497972074356">"Redémarrage…"</string>
    <string name="shutdown_progress" msgid="5017145516412657345">"Arrêt en cours..."</string>
    <string name="shutdown_confirm" product="tablet" msgid="2872769463279602432">"Votre tablette va s\'éteindre."</string>
    <string name="shutdown_confirm" product="tv" msgid="7975942887313518330">"Votre appareil Android TV va s\'éteindre."</string>
    <string name="shutdown_confirm" product="watch" msgid="2977299851200240146">"La montre va s\'éteindre."</string>
    <string name="shutdown_confirm" product="default" msgid="136816458966692315">"Votre téléphone va s\'éteindre."</string>
    <string name="shutdown_confirm_question" msgid="796151167261608447">"Voulez-vous éteindre l\'appareil ?"</string>
    <string name="reboot_safemode_title" msgid="5853949122655346734">"Redémarrer en mode sans échec"</string>
    <string name="reboot_safemode_confirm" msgid="1658357874737219624">"Voulez-vous redémarrer en mode sans échec ? Cette opération aura pour effet de désactiver toutes les applications tierces que vous avez installées. Elles seront réactivées au prochain redémarrage."</string>
    <string name="recent_tasks_title" msgid="8183172372995396653">"Récentes"</string>
    <string name="no_recent_tasks" msgid="9063946524312275906">"Aucune application récente"</string>
    <string name="global_actions" product="tablet" msgid="4412132498517933867">"Options de la tablette"</string>
    <string name="global_actions" product="tv" msgid="3871763739487450369">"Options Android TV"</string>
    <string name="global_actions" product="default" msgid="6410072189971495460">"Options du téléphone"</string>
    <string name="global_action_lock" msgid="6949357274257655383">"Verrouillage de l\'écran"</string>
    <string name="global_action_power_off" msgid="4404936470711393203">"Éteindre"</string>
    <string name="global_action_power_options" msgid="1185286119330160073">"Marche/Arrêt"</string>
    <string name="global_action_restart" msgid="4678451019561687074">"Redémarrer"</string>
    <string name="global_action_emergency" msgid="1387617624177105088">"Urgences"</string>
    <string name="global_action_bug_report" msgid="5127867163044170003">"Rapport de bug"</string>
    <string name="global_action_logout" msgid="6093581310002476511">"Fermer la session"</string>
    <string name="global_action_screenshot" msgid="2610053466156478564">"Capture d\'écran"</string>
    <string name="bugreport_title" msgid="8549990811777373050">"Rapport de bug"</string>
    <string name="bugreport_message" msgid="5212529146119624326">"Cela permet de recueillir des informations concernant l\'état actuel de votre appareil. Ces informations sont ensuite envoyées sous forme d\'e-mail. Merci de patienter pendant la préparation du rapport de bug. Cette opération peut prendre quelques instants."</string>
    <string name="bugreport_option_interactive_title" msgid="7968287837902871289">"Rapport interactif"</string>
    <string name="bugreport_option_interactive_summary" msgid="8493795476325339542">"Utilisez cette option dans la plupart des circonstances. Elle vous permet de suivre la progression du rapport, de saisir plus d\'informations sur le problème et d\'effectuer des captures d\'écran. Certaines sections moins utilisées et dont le remplissage demande beaucoup de temps peuvent être omises."</string>
    <string name="bugreport_option_full_title" msgid="7681035745950045690">"Rapport complet"</string>
    <string name="bugreport_option_full_summary" msgid="1975130009258435885">"Utilisez cette option pour qu\'il y ait le moins d\'interférences système possible lorsque votre appareil ne répond pas ou qu\'il est trop lent, ou lorsque vous avez besoin de toutes les sections du rapport de bug. Aucune capture d\'écran supplémentaire ne peut être prise, et vous ne pouvez saisir aucune autre information."</string>
    <plurals name="bugreport_countdown" formatted="false" msgid="3906120379260059206">
      <item quantity="one">Capture d\'écran pour le rapport de bug dans <xliff:g id="NUMBER_1">%d</xliff:g> seconde</item>
      <item quantity="other">Capture d\'écran pour le rapport de bug dans <xliff:g id="NUMBER_1">%d</xliff:g> secondes</item>
    </plurals>
    <string name="bugreport_screenshot_success_toast" msgid="7986095104151473745">"Capture d\'écran avec rapport de bug effectuée"</string>
    <string name="bugreport_screenshot_failure_toast" msgid="6736320861311294294">"Échec de la capture d\'écran avec le rapport de bug"</string>
    <string name="global_action_toggle_silent_mode" msgid="8464352592860372188">"Mode silencieux"</string>
    <string name="global_action_silent_mode_on_status" msgid="2371892537738632013">"Le son est désactivé."</string>
    <string name="global_action_silent_mode_off_status" msgid="6608006545950920042">"Le son est activé."</string>
    <string name="global_actions_toggle_airplane_mode" msgid="6911684460146916206">"Mode Avion"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="5508025516695361936">"Le mode Avion est activé."</string>
    <string name="global_actions_airplane_mode_off_status" msgid="8522219771500505475">"Le mode Avion est désactivé."</string>
    <string name="global_action_settings" msgid="4671878836947494217">"Paramètres"</string>
    <string name="global_action_assist" msgid="2517047220311505805">"Assistance"</string>
    <string name="global_action_voice_assist" msgid="6655788068555086695">"Assistance vocale"</string>
    <string name="global_action_lockdown" msgid="2475471405907902963">"Verrouillé"</string>
    <string name="status_bar_notification_info_overflow" msgid="3330152558746563475">"&gt;999"</string>
    <string name="notification_hidden_text" msgid="2835519769868187223">"Nouvelle notification"</string>
    <string name="notification_channel_virtual_keyboard" msgid="6465975799223304567">"Clavier virtuel"</string>
    <string name="notification_channel_physical_keyboard" msgid="5417306456125988096">"Clavier physique"</string>
    <string name="notification_channel_security" msgid="8516754650348238057">"Sécurité"</string>
    <string name="notification_channel_car_mode" msgid="2123919247040988436">"Mode Voiture"</string>
    <string name="notification_channel_account" msgid="6436294521740148173">"État du compte"</string>
    <string name="notification_channel_developer" msgid="1691059964407549150">"Messages relatifs aux développeurs"</string>
    <string name="notification_channel_developer_important" msgid="7197281908918789589">"Messages importants relatifs aux développeurs"</string>
    <string name="notification_channel_updates" msgid="7907863984825495278">"Mises à jour"</string>
    <string name="notification_channel_network_status" msgid="2127687368725272809">"État du réseau"</string>
    <string name="notification_channel_network_alerts" msgid="6312366315654526528">"Alertes réseau"</string>
    <string name="notification_channel_network_available" msgid="6083697929214165169">"Réseau disponible"</string>
    <string name="notification_channel_vpn" msgid="1628529026203808999">"État du VPN"</string>
    <string name="notification_channel_device_admin" msgid="6384932669406095506">"Alertes de votre administrateur informatique"</string>
    <string name="notification_channel_alerts" msgid="5070241039583668427">"Alertes"</string>
    <string name="notification_channel_retail_mode" msgid="3732239154256431213">"Démonstration en magasin"</string>
    <string name="notification_channel_usb" msgid="1528280969406244896">"Connexion USB"</string>
    <string name="notification_channel_heavy_weight_app" msgid="17455756500828043">"Application en cours d\'exécution"</string>
    <string name="notification_channel_foreground_service" msgid="7102189948158885178">"Applications utilisant la batterie"</string>
    <string name="foreground_service_app_in_background" msgid="1439289699671273555">"<xliff:g id="APP_NAME">%1$s</xliff:g> utilise la batterie"</string>
    <string name="foreground_service_apps_in_background" msgid="7340037176412387863">"<xliff:g id="NUMBER">%1$d</xliff:g> applications utilisent la batterie"</string>
    <string name="foreground_service_tap_for_details" msgid="9078123626015586751">"Appuyer pour obtenir des informations sur l\'utilisation de la batterie et des données"</string>
    <string name="foreground_service_multiple_separator" msgid="5002287361849863168">"<xliff:g id="LEFT_SIDE">%1$s</xliff:g>, <xliff:g id="RIGHT_SIDE">%2$s</xliff:g>"</string>
    <string name="safeMode" msgid="8974401416068943888">"Mode sécurisé"</string>
    <string name="android_system_label" msgid="5974767339591067210">"Système Android"</string>
    <string name="user_owner_label" msgid="8628726904184471211">"Passer au profil personnel"</string>
    <string name="managed_profile_label" msgid="7316778766973512382">"Passer au profil pro"</string>
    <string name="permgrouplab_contacts" msgid="4254143639307316920">"Contacts"</string>
    <string name="permgroupdesc_contacts" msgid="9163927941244182567">"accéder à vos contacts"</string>
    <string name="permgrouplab_location" msgid="1858277002233964394">"Localisation"</string>
    <string name="permgroupdesc_location" msgid="1995955142118450685">"accéder à la position de l\'appareil"</string>
    <string name="permgrouplab_calendar" msgid="6426860926123033230">"Agenda"</string>
    <string name="permgroupdesc_calendar" msgid="6762751063361489379">"accéder à votre agenda"</string>
    <string name="permgrouplab_sms" msgid="795737735126084874">"SMS"</string>
    <string name="permgroupdesc_sms" msgid="5726462398070064542">"envoyer et consulter des SMS"</string>
    <string name="permgrouplab_storage" msgid="1938416135375282333">"Fichiers et contenus multimédias"</string>
    <string name="permgroupdesc_storage" msgid="6351503740613026600">"accéder aux photos, contenus multimédias et fichiers sur votre appareil"</string>
    <string name="permgrouplab_microphone" msgid="2480597427667420076">"Microphone"</string>
    <string name="permgroupdesc_microphone" msgid="1047786732792487722">"enregistrer des fichiers audio"</string>
    <string name="permgrouplab_activityRecognition" msgid="3324466667921775766">"Activité physique"</string>
    <string name="permgroupdesc_activityRecognition" msgid="4725624819457670704">"accéder aux données d\'activité physique"</string>
    <string name="permgrouplab_camera" msgid="9090413408963547706">"Appareil photo"</string>
    <string name="permgroupdesc_camera" msgid="7585150538459320326">"prendre des photos et enregistrer des vidéos"</string>
    <string name="permgrouplab_calllog" msgid="7926834372073550288">"Journaux d\'appels"</string>
    <string name="permgroupdesc_calllog" msgid="2026996642917801803">"Consulter et modifier les journaux d\'appels du téléphone"</string>
    <string name="permgrouplab_phone" msgid="570318944091926620">"Téléphone"</string>
    <string name="permgroupdesc_phone" msgid="270048070781478204">"effectuer et gérer des appels téléphoniques"</string>
    <string name="permgrouplab_sensors" msgid="9134046949784064495">"Capteurs corporels"</string>
    <string name="permgroupdesc_sensors" msgid="2610631290633747752">"accéder aux données des capteurs relatives à vos signes vitaux"</string>
    <string name="capability_title_canRetrieveWindowContent" msgid="7554282892101587296">"Récupérer le contenu d\'une fenêtre"</string>
    <string name="capability_desc_canRetrieveWindowContent" msgid="6195610527625237661">"Inspecte le contenu d\'une fenêtre avec laquelle vous interagissez."</string>
    <string name="capability_title_canRequestTouchExploration" msgid="327598364696316213">"Activer la fonctionnalité Explorer au toucher"</string>
    <string name="capability_desc_canRequestTouchExploration" msgid="4394677060796752976">"Les éléments sélectionnés sont énoncés à voix haute. Vous pouvez explorer l\'écran à l\'aide de gestes."</string>
    <string name="capability_title_canRequestFilterKeyEvents" msgid="2772371671541753254">"Observer le texte que vous saisissez"</string>
    <string name="capability_desc_canRequestFilterKeyEvents" msgid="2381315802405773092">"Inclut des données personnelles telles que les numéros de cartes de paiement et les mots de passe."</string>
    <string name="capability_title_canControlMagnification" msgid="7701572187333415795">"Contrôler l\'agrandissement de l\'écran"</string>
    <string name="capability_desc_canControlMagnification" msgid="2206586716709254805">"Contrôle le niveau de zoom et le positionnement de l\'écran."</string>
    <string name="capability_title_canPerformGestures" msgid="9106545062106728987">"Effectuer des gestes"</string>
    <string name="capability_desc_canPerformGestures" msgid="6619457251067929726">"Permet d\'appuyer sur l\'écran, de le balayer, de le pincer et d\'effectuer d\'autres gestes."</string>
    <string name="capability_title_canCaptureFingerprintGestures" msgid="1189053104594608091">"Gestes avec l\'empreinte digitale"</string>
    <string name="capability_desc_canCaptureFingerprintGestures" msgid="6861869337457461274">"Peut enregistrer des gestes effectués sur le lecteur d\'empreinte digitale de l\'appareil."</string>
    <string name="capability_title_canTakeScreenshot" msgid="3895812893130071930">"Prendre une capture d\'écran"</string>
    <string name="capability_desc_canTakeScreenshot" msgid="7762297374317934052">"Peut prendre des captures d\'écran."</string>
    <string name="permlab_statusBar" msgid="8798267849526214017">"Désactivation ou modification de la barre d\'état"</string>
    <string name="permdesc_statusBar" msgid="5809162768651019642">"Permet à l\'application de désactiver la barre d\'état, ou d\'ajouter et de supprimer des icônes système."</string>
    <string name="permlab_statusBarService" msgid="2523421018081437981">"remplacer la barre d\'état"</string>
    <string name="permdesc_statusBarService" msgid="6652917399085712557">"Permet à l\'application de faire office de barre d\'état."</string>
    <string name="permlab_expandStatusBar" msgid="1184232794782141698">"Agrandir/réduire la barre d\'état"</string>
    <string name="permdesc_expandStatusBar" msgid="7180756900448498536">"Permet à l\'application de réduire ou de développer la barre d\'état."</string>
    <string name="permlab_install_shortcut" msgid="7451554307502256221">"Installer des raccourcis"</string>
    <string name="permdesc_install_shortcut" msgid="4476328467240212503">"Permettre à une application d\'ajouter des raccourcis à l\'écran d\'accueil sans l\'intervention de l\'utilisateur"</string>
    <string name="permlab_uninstall_shortcut" msgid="295263654781900390">"désinstaller des raccourcis"</string>
    <string name="permdesc_uninstall_shortcut" msgid="1924735350988629188">"Permettre à l\'application de supprimer des raccourcis de l\'écran d\'accueil sans l\'intervention de l\'utilisateur"</string>
    <string name="permlab_processOutgoingCalls" msgid="4075056020714266558">"transférer les appels sortants"</string>
    <string name="permdesc_processOutgoingCalls" msgid="7833149750590606334">"Permettre à l\'application de lire le numéro composé lors d\'un appel sortant, et lui donner la possibilité de rediriger l\'appel vers un autre numéro ou d\'abandonner l\'appel"</string>
    <string name="permlab_answerPhoneCalls" msgid="4131324833663725855">"répondre aux appels téléphoniques"</string>
    <string name="permdesc_answerPhoneCalls" msgid="894386681983116838">"Autorise l\'application à répondre à un appel téléphonique entrant."</string>
    <string name="permlab_receiveSms" msgid="505961632050451881">"recevoir des messages texte (SMS)"</string>
    <string name="permdesc_receiveSms" msgid="1797345626687832285">"Permet à l\'application de recevoir et de traiter les SMS. Cette autorisation lui donne la possibilité de surveiller ou supprimer les messages envoyés à votre appareil sans vous les montrer."</string>
    <string name="permlab_receiveMms" msgid="4000650116674380275">"recevoir des messages texte (MMS)"</string>
    <string name="permdesc_receiveMms" msgid="958102423732219710">"Permet à l\'application de recevoir et de traiter les MMS. Cette autorisation lui donne la possibilité de surveiller ou supprimer les messages envoyés à votre appareil sans vous les montrer."</string>
    <string name="permlab_bindCellBroadcastService" msgid="586746677002040651">"Transférer les messages reçus via un canal de diffusion cellulaire"</string>
    <string name="permdesc_bindCellBroadcastService" msgid="6540910200973641606">"Autorise l\'application à établir une connexion avec le module de diffusion cellulaire afin de transférer les messages reçus via un canal de diffusion cellulaire. Des alertes de diffusion cellulaire sont générées dans certaines régions afin de vous avertir de situations d\'urgence. Des applications malveillantes peuvent interférer avec les performances ou le fonctionnement de votre appareil lors de la réception d\'une alerte d\'urgence par diffusion cellulaire."</string>
    <string name="permlab_readCellBroadcasts" msgid="5869884450872137693">"lire les messages reçus via un canal de diffusion cellulaire"</string>
    <string name="permdesc_readCellBroadcasts" msgid="672513437331980168">"Permet à l\'application de lire les messages que votre appareil reçoit via un canal de diffusion cellulaire. Dans certaines zones géographiques, des alertes vous sont envoyées afin de vous prévenir en cas de situation d\'urgence. Les applications malveillantes peuvent venir perturber les performances ou le fonctionnement de votre appareil lorsqu\'un message est reçu via un canal de diffusion cellulaire."</string>
    <string name="permlab_subscribedFeedsRead" msgid="217624769238425461">"lire les flux auxquels vous êtes abonné"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="6911349196661811865">"Permet à l\'application d\'obtenir des informations sur les flux en cours de synchronisation."</string>
    <string name="permlab_sendSms" msgid="7757368721742014252">"envoyer et consulter des SMS"</string>
    <string name="permdesc_sendSms" msgid="6757089798435130769">"Permet à l\'application d\'envoyer des messages SMS. Cette autorisation peut entraîner des frais inattendus. Les applications malveillantes peuvent générer des frais en envoyant des messages sans votre consentement."</string>
    <string name="permlab_readSms" msgid="5164176626258800297">"voir les messages texte (SMS ou MMS)"</string>
    <string name="permdesc_readSms" product="tablet" msgid="7912990447198112829">"Cette application peut lire tous les SMS enregistrés sur votre tablette."</string>
    <string name="permdesc_readSms" product="tv" msgid="3054753345758011986">"Cette application peut lire tous les SMS stockés sur votre appareil Android TV."</string>
    <string name="permdesc_readSms" product="default" msgid="774753371111699782">"Cette application peut lire tous les SMS enregistrés sur votre téléphone."</string>
    <string name="permlab_receiveWapPush" msgid="4223747702856929056">"recevoir des messages texte (WAP)"</string>
    <string name="permdesc_receiveWapPush" msgid="1638677888301778457">"Permet à l\'application de recevoir et de traiter les messages WAP. Cette autorisation lui donne la possibilité de surveiller ou supprimer les messages envoyés à votre appareil sans vous les montrer."</string>
    <string name="permlab_getTasks" msgid="7460048811831750262">"récupérer les applications en cours d\'exécution"</string>
    <string name="permdesc_getTasks" msgid="7388138607018233726">"Permet à l\'application de récupérer des informations sur des tâches en cours d\'exécution et récemment exécutées. L\'application est ainsi susceptible d\'obtenir des informations sur les applications utilisées sur l\'appareil."</string>
    <string name="permlab_manageProfileAndDeviceOwners" msgid="639849495253987493">"gérer les propriétaires des profils et de l\'appareil"</string>
    <string name="permdesc_manageProfileAndDeviceOwners" msgid="7304240671781989283">"Autoriser les applications à définir les propriétaires des profils et celui de l\'appareil"</string>
    <string name="permlab_reorderTasks" msgid="7598562301992923804">"réorganiser les applications en cours d\'exécution"</string>
    <string name="permdesc_reorderTasks" msgid="8796089937352344183">"Permet à l\'application de déplacer les tâches au premier plan et en arrière-plan. L\'application peut procéder à ces opérations sans votre intervention."</string>
    <string name="permlab_enableCarMode" msgid="893019409519325311">"activer le mode voiture"</string>
    <string name="permdesc_enableCarMode" msgid="56419168820473508">"Permet à l\'application d\'activer le mode Voiture."</string>
    <string name="permlab_killBackgroundProcesses" msgid="6559320515561928348">"fermer les autres applications"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2357013583055434685">"Permet à l\'application de mettre fin aux processus d\'autres applications exécutés en arrière-plan. Cette autorisation peut interrompre l\'exécution d\'autres applications."</string>
    <string name="permlab_systemAlertWindow" msgid="5757218350944719065">"Cette application peut se superposer à d\'autres applications"</string>
    <string name="permdesc_systemAlertWindow" msgid="1145660714855738308">"Cette application peut se superposer à d\'autres applications ou à d\'autres parties de l\'écran. Cela peut altérer l\'utilisation normale des applications et modifier l\'apparence des autres applications."</string>
    <string name="permlab_runInBackground" msgid="541863968571682785">"s\'exécuter en arrière-plan"</string>
    <string name="permdesc_runInBackground" msgid="4344539472115495141">"Cette application peut s\'exécuter en arrière-plan, ce qui risque d\'épuiser la batterie plus rapidement."</string>
    <string name="permlab_useDataInBackground" msgid="783415807623038947">"consommer des données en arrière-plan"</string>
    <string name="permdesc_useDataInBackground" msgid="1230753883865891987">"Cette application peut utiliser des données en arrière-plan, ce qui risque d\'augmenter la consommation des données."</string>
    <string name="permlab_persistentActivity" msgid="464970041740567970">"exécuter l\'application en continu"</string>
    <string name="permdesc_persistentActivity" product="tablet" msgid="6055271149187369916">"Permet à l\'application de rendre certains de ces composants persistants dans la mémoire. Cette autorisation peut limiter la mémoire disponible pour d\'autres applications et ralentir la tablette."</string>
    <string name="permdesc_persistentActivity" product="tv" msgid="6800526387664131321">"Permet à l\'application de rendre certains de ses composants persistants dans la mémoire. Cette autorisation peut limiter la mémoire disponible pour d\'autres applications et ralentir votre appareil Android TV."</string>
    <string name="permdesc_persistentActivity" product="default" msgid="1914841924366562051">"Permet à l\'application de rendre certains de ces composants persistants dans la mémoire. Cette autorisation peut limiter la mémoire disponible pour d\'autres applications et ralentir le téléphone."</string>
    <string name="permlab_foregroundService" msgid="1768855976818467491">"exécuter un service de premier plan"</string>
    <string name="permdesc_foregroundService" msgid="8720071450020922795">"Autorise l\'application à utiliser des services de premier plan."</string>
    <string name="permlab_getPackageSize" msgid="375391550792886641">"évaluer l\'espace de stockage de l\'application"</string>
    <string name="permdesc_getPackageSize" msgid="742743530909966782">"Permet à l\'application de récupérer son code, ses données et la taille de sa mémoire cache."</string>
    <string name="permlab_writeSettings" msgid="8057285063719277394">"modifier les paramètres du système"</string>
    <string name="permdesc_writeSettings" msgid="8293047411196067188">"Permet à l\'application de modifier les paramètres du système. Des applications malveillantes peuvent exploiter cette fonctionnalité pour corrompre la configuration de votre système."</string>
    <string name="permlab_receiveBootCompleted" msgid="6643339400247325379">"s\'exécuter au démarrage"</string>
    <string name="permdesc_receiveBootCompleted" product="tablet" msgid="5565659082718177484">"Permet à l\'application de se lancer une fois le démarrage du système terminé. Elle peut rallonger le temps de démarrage de la tablette et ralentir son fonctionnement global en raison de son exécution continue."</string>
    <string name="permdesc_receiveBootCompleted" product="tv" msgid="4900842256047614307">"Permet à l\'application de se lancer une fois le démarrage du système terminé. Elle peut rallonger le temps de démarrage de votre appareil Android TV et ralentir son fonctionnement global en raison de son exécution continue."</string>
    <string name="permdesc_receiveBootCompleted" product="default" msgid="7912677044558690092">"Permet à l\'application de se lancer une fois le démarrage du système terminé. Elle peut rallonger le temps de démarrage du téléphone et ralentir son fonctionnement global en raison de son exécution continue."</string>
    <string name="permlab_broadcastSticky" msgid="4552241916400572230">"Envoi d\'une diffusion persistante"</string>
    <string name="permdesc_broadcastSticky" product="tablet" msgid="5058486069846384013">"Permet à l\'application d\'envoyer des intentions de diffusion \"persistantes\", qui perdurent une fois la diffusion terminée. Une utilisation excessive peut ralentir la tablette ou la rendre instable en l\'obligeant à utiliser trop de mémoire."</string>
    <string name="permdesc_broadcastSticky" product="tv" msgid="2338185920171000650">"Permet à l\'application d\'envoyer des diffusions \"persistantes\", qui perdurent une fois la diffusion effectuée. Une utilisation excessive peut ralentir votre appareil Android TV ou le rendre instable en l\'obligeant à utiliser trop de mémoire."</string>
    <string name="permdesc_broadcastSticky" product="default" msgid="134529339678913453">"Permet à l\'application d\'envoyer des intentions de diffusion \"persistantes\", qui perdurent une fois la diffusion terminée. Une utilisation excessive peut ralentir le téléphone ou le rendre instable en l\'obligeant à utiliser trop de mémoire."</string>
    <string name="permlab_readContacts" msgid="8776395111787429099">"Voir les contacts"</string>
    <string name="permdesc_readContacts" product="tablet" msgid="6430093481659992692">"Permet à l\'application de lire les données liées aux contacts stockés sur votre tablette. Les applications auront également accès aux comptes de votre tablette pour lesquels des contacts ont été créés. Cela peut inclure les comptes créés via des applications que vous avez installées. Cette autorisation permet aux applications d\'enregistrer les données liées à vos contacts. Des applications malveillantes peuvent exploiter cette fonctionnalité pour partager ces données à votre insu."</string>
    <string name="permdesc_readContacts" product="tv" msgid="8400138591135554789">"Permet à l\'application de lire les données liées aux contacts stockés sur votre appareil Android TV. Les applications auront également accès aux comptes de votre appareil Android TV pour lesquels des contacts ont été créés. Cela peut inclure les comptes créés via des applications que vous avez installées. Cette autorisation permet aux applications d\'enregistrer les données liées à vos contacts. Des applications malveillantes peuvent exploiter cette fonctionnalité pour partager ces données à votre insu."</string>
    <string name="permdesc_readContacts" product="default" msgid="4911989776203207644">"Permet à l\'application de lire les données liées aux contacts stockés sur votre téléphone. Les applications auront également accès aux comptes de votre téléphone pour lesquels des contacts ont été créés. Cela peut inclure les comptes créés via des applications que vous avez installées. Cette autorisation permet aux applications d\'enregistrer les données liées à vos contacts. Des applications malveillantes peuvent exploiter cette fonctionnalité pour partager ces données à votre insu."</string>
    <string name="permlab_writeContacts" msgid="8919430536404830430">"modifier les contacts"</string>
    <string name="permdesc_writeContacts" product="tablet" msgid="6422419281427826181">"Permet à l\'application de modifier les données liées aux contacts stockés sur votre tablette. Cette autorisation permet aux applications de supprimer ces données."</string>
    <string name="permdesc_writeContacts" product="tv" msgid="6488872735379978935">"Permet à l\'application de modifier les données liées aux contacts stockés sur votre appareil Android TV. Cette autorisation permet aux applications de supprimer ces données."</string>
    <string name="permdesc_writeContacts" product="default" msgid="8304795696237065281">"Permet à l\'application de modifier les données liées aux contacts stockés sur votre téléphone. Cette autorisation permet aux applications de supprimer ces données."</string>
    <string name="permlab_readCallLog" msgid="1739990210293505948">"lire le journal d\'appels"</string>
    <string name="permdesc_readCallLog" msgid="8964770895425873433">"Cette application peut lire l\'historique de vos appels."</string>
    <string name="permlab_writeCallLog" msgid="670292975137658895">"modifier le journal d\'appels"</string>
    <string name="permdesc_writeCallLog" product="tablet" msgid="2657525794731690397">"Permet à l\'application de lire le journal d\'appels de votre tablette, y compris les données relatives aux appels entrants et sortants. Des applications malveillantes peuvent utiliser cette fonctionnalité pour effacer ou modifier votre journal d\'appels."</string>
    <string name="permdesc_writeCallLog" product="tv" msgid="3934939195095317432">"Permet à l\'application de lire le journal d\'appels de votre appareil Android TV, y compris les données sur les appels entrants et sortants. Des applications malveillantes peuvent utiliser cette fonctionnalité pour effacer ou modifier votre journal d\'appels."</string>
    <string name="permdesc_writeCallLog" product="default" msgid="5903033505665134802">"Permet à l\'application de lire le journal d\'appels de votre téléphone, y compris les données relatives aux appels entrants et sortants. Des applications malveillantes peuvent utiliser cette fonctionnalité pour effacer ou modifier votre journal d\'appels."</string>
    <string name="permlab_bodySensors" msgid="3411035315357380862">"accéder capteurs corp. (ex : cardiofréquencemètres)"</string>
    <string name="permdesc_bodySensors" product="default" msgid="2365357960407973997">"Permet à l\'application d\'accéder aux données des capteurs qui contrôlent votre condition physique, comme votre rythme cardiaque."</string>
    <string name="permlab_readCalendar" msgid="6408654259475396200">"Lire les événements d\'agenda et les détails associés"</string>
    <string name="permdesc_readCalendar" product="tablet" msgid="515452384059803326">"Cette application peut lire tous les événements d\'agenda enregistrés sur votre tablette et partager ou enregistrer vos données d\'agenda."</string>
    <string name="permdesc_readCalendar" product="tv" msgid="5811726712981647628">"Cette application peut lire tous les événements de l\'agenda enregistrés sur votre appareil Android TV, et partager ou enregistrer les données de votre agenda."</string>
    <string name="permdesc_readCalendar" product="default" msgid="9118823807655829957">"Cette application peut lire tous les événements d\'agenda enregistrés sur votre téléphone et partager ou enregistrer vos données d\'agenda."</string>
    <string name="permlab_writeCalendar" msgid="6422137308329578076">"ajouter ou modifier des événements d\'agenda et envoyer des e-mails aux invités à l\'insu des propriétaires"</string>
    <string name="permdesc_writeCalendar" product="tablet" msgid="8722230940717092850">"Cette application peut ajouter, supprimer ou modifier les événements d\'agenda enregistrés sur votre tablette. Elle peut en outre envoyer des messages qui semblent provenir du propriétaire de l\'agenda, ou modifier des événements sans en informer leur propriétaire."</string>
    <string name="permdesc_writeCalendar" product="tv" msgid="951246749004952706">"Cette application peut ajouter, supprimer ou modifier les événements de l\'agenda enregistrés sur votre appareil Android TV. Elle peut en outre envoyer des messages qui semblent provenir du propriétaire de l\'agenda ou modifier des événements sans en informer leur propriétaire."</string>
    <string name="permdesc_writeCalendar" product="default" msgid="5416380074475634233">"Cette application peut ajouter, supprimer ou modifier les événements d\'agenda enregistrés sur votre téléphone. Elle peut en outre envoyer des messages qui semblent provenir du propriétaire de l\'agenda, ou modifier des événements sans en informer leur propriétaire."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="5162339812057983988">"Accès aux commandes de fournisseur de position géographique supplémentaires"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="355369611979907967">"Permet à l\'application d\'accéder à des commandes de localisation supplémentaires offertes par le fournisseur. Elle est ainsi susceptible d\'interférer avec le bon fonctionnement du GPS ou de toute autre source de localisation."</string>
    <string name="permlab_accessFineLocation" msgid="6426318438195622966">"accéder à la position exacte au premier plan uniquement"</string>
    <string name="permdesc_accessFineLocation" msgid="6732174080240016335">"Cette application peut accéder à votre position précise via les services de localisation lorsque vous l\'utilisez. Pour cela, vous devez activer les services de localisation sur votre appareil au préalable. Cela risque de solliciter davantage la batterie."</string>
    <string name="permlab_accessCoarseLocation" msgid="1561042925407799741">"accéder à la position approximative au premier plan uniquement"</string>
    <string name="permdesc_accessCoarseLocation" msgid="778521847873199160">"Cette application peut obtenir votre position approximative via les services de localisation lorsque vous l\'utilisez. Pour cela, vous devez activer les services de localisation sur votre appareil au préalable."</string>
    <string name="permlab_accessBackgroundLocation" msgid="1721164702777366138">"accéder à la position en arrière-plan"</string>
    <string name="permdesc_accessBackgroundLocation" msgid="8264885066095638105">"Cette application peut accéder à votre position à tout moment, y compris lorsque vous ne l\'utilisez pas."</string>
    <string name="permlab_modifyAudioSettings" msgid="6129039778010031815">"modifier vos paramètres audio"</string>
    <string name="permdesc_modifyAudioSettings" msgid="8687227609663124921">"Permet à l\'application de modifier les paramètres audio généraux, tels que le volume et la sortie audio utilisée."</string>
    <string name="permlab_recordAudio" msgid="1208457423054219147">"enregistrer des fichiers audio"</string>
    <string name="permdesc_recordAudio" msgid="3976213377904701093">"Cette application peut utiliser le micro pour enregistrer du contenu audio à tout moment."</string>
    <string name="permlab_sim_communication" msgid="176788115994050692">"envoyer des commandes à la carte SIM"</string>
    <string name="permdesc_sim_communication" msgid="4179799296415957960">"Autoriser l\'envoi de commandes à la carte SIM via l\'application. Cette fonctionnalité est très risquée."</string>
    <string name="permlab_activityRecognition" msgid="1782303296053990884">"reconnaître l\'activité physique"</string>
    <string name="permdesc_activityRecognition" msgid="8667484762991357519">"Cette application peut reconnaître votre activité physique."</string>
    <string name="permlab_camera" msgid="6320282492904119413">"prendre des photos et enregistrer des vidéos"</string>
    <string name="permdesc_camera" msgid="1354600178048761499">"Cette application peut utiliser l\'appareil photo pour prendre des photos et enregistrer des vidéos à tout moment."</string>
    <string name="permlab_systemCamera" msgid="3642917457796210580">"Autoriser une application ou un service à accéder aux caméras système pour prendre des photos et enregistrer des vidéos"</string>
    <string name="permdesc_systemCamera" msgid="5938360914419175986">"Cette application privilégiée ou système peut utiliser une caméra photo système pour prendre des photos et enregistrer des vidéos à tout moment. Pour cela, l\'application doit également disposer de l\'autorisation android.permission.CAMERA"</string>
    <string name="permlab_cameraOpenCloseListener" msgid="5548732769068109315">"Autoriser une application ou un service à recevoir des rappels liés à l\'ouverture ou à la fermeture de caméras"</string>
    <string name="permdesc_cameraOpenCloseListener" msgid="2002636131008772908">"Cette application peut recevoir des rappels lors de la fermeture ou de l\'ouverture d\'une caméra (par une application)."</string>
    <string name="permlab_vibrate" msgid="8596800035791962017">"contrôler le vibreur"</string>
    <string name="permdesc_vibrate" msgid="8733343234582083721">"Permet à l\'application de contrôler le vibreur."</string>
    <string name="permdesc_vibrator_state" msgid="7050024956594170724">"Permet à l\'application d\'accéder à l\'état du vibreur."</string>
    <string name="permlab_callPhone" msgid="1798582257194643320">"appeler directement les numéros de téléphone"</string>
    <string name="permdesc_callPhone" msgid="5439809516131609109">"Permet à l\'application d\'appeler des numéros de téléphone sans votre intervention. Cette autorisation peut entraîner des frais ou des appels imprévus et ne permet pas à l\'application d\'appeler des numéros d\'urgence. Les applications malveillantes peuvent générer des frais en passant des appels sans votre consentement."</string>
    <string name="permlab_accessImsCallService" msgid="442192920714863782">"accéder au service d\'appel IMS"</string>
    <string name="permdesc_accessImsCallService" msgid="6328551241649687162">"Permet à l\'application d\'utiliser le service IMS pour passer des appels sans votre intervention."</string>
    <string name="permlab_readPhoneState" msgid="8138526903259297969">"Voir l\'état et l\'identité du téléphone"</string>
    <string name="permdesc_readPhoneState" msgid="7229063553502788058">"Permet à l\'application d\'accéder aux fonctionnalités téléphoniques de l\'appareil. Cette autorisation permet à l\'application de déterminer le numéro de téléphone et les identifiants de l\'appareil, si un appel est actif et le numéro distant connecté par un appel."</string>
    <string name="permlab_manageOwnCalls" msgid="9033349060307561370">"acheminer les appels via le système"</string>
    <string name="permdesc_manageOwnCalls" msgid="4431178362202142574">"Autorise l\'application à acheminer les appels via le système afin d\'optimiser le confort d\'utilisation."</string>
    <string name="permlab_callCompanionApp" msgid="3654373653014126884">"voir et contrôler les appels via le système."</string>
    <string name="permdesc_callCompanionApp" msgid="8474168926184156261">"Permet à l\'application de voir et contrôler les appels en cours sur l\'appareil. Cela inclut des informations telles que les numéros associés aux appels et l\'état des appels."</string>
    <string name="permlab_exemptFromAudioRecordRestrictions" msgid="1164725468350759486">"Lever les restrictions portant sur l\'enregistrement audio"</string>
    <string name="permdesc_exemptFromAudioRecordRestrictions" msgid="2425117015896871976">"Exemptez l\'application des restrictions portant sur l\'enregistrement audio."</string>
    <string name="permlab_acceptHandover" msgid="2925523073573116523">"continuer un appel issu d\'une autre application"</string>
    <string name="permdesc_acceptHandovers" msgid="7129026180128626870">"Autorise l\'application à continuer un appel qui a été démarré dans une autre application."</string>
    <string name="permlab_readPhoneNumbers" msgid="5668704794723365628">"lire les numéros de téléphone"</string>
    <string name="permdesc_readPhoneNumbers" msgid="7368652482818338871">"Permet à l\'application d\'accéder aux numéros de téléphone de l\'appareil."</string>
    <string name="permlab_wakeLock" product="automotive" msgid="1904736682319375676">"laisser l\'écran de la voiture allumé"</string>
    <string name="permlab_wakeLock" product="tablet" msgid="1527660973931694000">"empêcher la tablette de passer en mode veille"</string>
    <string name="permlab_wakeLock" product="tv" msgid="2856941418123343518">"Empêcher votre appareil Android TV de passer en mode veille"</string>
    <string name="permlab_wakeLock" product="default" msgid="569409726861695115">"empêcher le téléphone de passer en mode veille"</string>
    <string name="permdesc_wakeLock" product="automotive" msgid="5995045369683254571">"Permet à l\'application de laisser l\'écran de la voiture allumé."</string>
    <string name="permdesc_wakeLock" product="tablet" msgid="2441742939101526277">"Permet à l\'application d\'empêcher la tablette de passer en mode veille."</string>
    <string name="permdesc_wakeLock" product="tv" msgid="2329298966735118796">"Permet à l\'application d\'empêcher votre appareil Android TV de passer en mode veille."</string>
    <string name="permdesc_wakeLock" product="default" msgid="3689523792074007163">"Permet à l\'application d\'empêcher le téléphone de passer en mode veille."</string>
    <string name="permlab_transmitIr" msgid="8077196086358004010">"transmettre des signaux infrarouges"</string>
    <string name="permdesc_transmitIr" product="tablet" msgid="5884738958581810253">"Permet à l\'application d\'utiliser l\'émetteur infrarouge de la tablette."</string>
    <string name="permdesc_transmitIr" product="tv" msgid="3278506969529173281">"Permet à l\'application d\'utiliser l\'émetteur infrarouge de votre appareil Android TV."</string>
    <string name="permdesc_transmitIr" product="default" msgid="8484193849295581808">"Permet à l\'application d\'utiliser l\'émetteur infrarouge du téléphone."</string>
    <string name="permlab_setWallpaper" msgid="6959514622698794511">"configurer le fond d\'écran"</string>
    <string name="permdesc_setWallpaper" msgid="2973996714129021397">"Permet à l\'application de définir le fond d\'écran du système."</string>
    <string name="permlab_setWallpaperHints" msgid="1153485176642032714">"modifier la taille du fond d\'écran"</string>
    <string name="permdesc_setWallpaperHints" msgid="6257053376990044668">"Permet à l\'application de définir les bulles d\'aide concernant la taille du fond d\'écran du système."</string>
    <string name="permlab_setTimeZone" msgid="7922618798611542432">"Sélection du fuseau horaire"</string>
    <string name="permdesc_setTimeZone" product="tablet" msgid="1788868809638682503">"Permet à l\'application de modifier le fuseau horaire de la tablette."</string>
    <string name="permdesc_setTimeZone" product="tv" msgid="9069045914174455938">"Permet à l\'application de modifier le fuseau horaire de votre appareil Android TV."</string>
    <string name="permdesc_setTimeZone" product="default" msgid="4611828585759488256">"Permet à l\'application de modifier le fuseau horaire du téléphone."</string>
    <string name="permlab_getAccounts" msgid="5304317160463582791">"rechercher des comptes sur l\'appareil"</string>
    <string name="permdesc_getAccounts" product="tablet" msgid="1784452755887604512">"Permet à l\'application d\'obtenir la liste des comptes connus par la tablette. Il peut s\'agir de n\'importe quel compte créé par les applications que vous avez installées."</string>
    <string name="permdesc_getAccounts" product="tv" msgid="437604680436540822">"Permet à l\'application d\'obtenir la liste des comptes connus de votre appareil Android TV. Il peut s\'agir de n\'importe quel compte créé par les applications que vous avez installées."</string>
    <string name="permdesc_getAccounts" product="default" msgid="2491273043569751867">"Permet à l\'application d\'obtenir la liste des comptes connus par le téléphone. Il peut s\'agir de n\'importe quel compte créé par les applications que vous avez installées."</string>
    <string name="permlab_accessNetworkState" msgid="2349126720783633918">"afficher les connexions réseau"</string>
    <string name="permdesc_accessNetworkState" msgid="4394564702881662849">"Permet à l\'application d\'accéder à des informations sur les connexions réseau, comme les réseaux existants et connectés."</string>
    <string name="permlab_createNetworkSockets" msgid="3224420491603590541">"bénéficier d\'un accès complet au réseau"</string>
    <string name="permdesc_createNetworkSockets" msgid="7722020828749535988">"Permet à l\'application de créer des sockets réseau et d\'utiliser des protocoles réseau personnalisés. Le navigateur et d\'autres applications permettent d\'envoyer des données sur Internet. Cette autorisation n\'est donc pas nécessaire pour envoyer des données sur Internet."</string>
    <string name="permlab_changeNetworkState" msgid="8945711637530425586">"modifier la connectivité réseau"</string>
    <string name="permdesc_changeNetworkState" msgid="649341947816898736">"Permet à l\'application de modifier l\'état de la connectivité du réseau."</string>
    <string name="permlab_changeTetherState" msgid="9079611809931863861">"changer la connectivité du partage de connexion"</string>
    <string name="permdesc_changeTetherState" msgid="3025129606422533085">"Permet à l\'application de modifier l\'état de la connectivité du partage de connexion."</string>
    <string name="permlab_accessWifiState" msgid="5552488500317911052">"afficher les connexions Wi-Fi"</string>
    <string name="permdesc_accessWifiState" msgid="6913641669259483363">"Permet à l\'application d\'accéder à des informations sur les réseaux Wi-Fi afin de savoir si une connexion Wi-Fi est activée et pour connaître le nom des appareils connectés au Wi-Fi, par exemple."</string>
    <string name="permlab_changeWifiState" msgid="7947824109713181554">"Activer/désactiver la connexion Wi-Fi"</string>
    <string name="permdesc_changeWifiState" msgid="7170350070554505384">"Permet à l\'application de se connecter à des points d\'accès Wi-Fi, de s\'en déconnecter et de modifier la configuration de l\'appareil pour les réseaux Wi-Fi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="285626875870754696">"autoriser la réception de données en Wi-Fi multidiffusion"</string>
    <string name="permdesc_changeWifiMulticastState" product="tablet" msgid="191079868596433554">"Permet à l\'application de recevoir des paquets envoyés à tous les appareils (et pas seulement à votre tablette) d\'un réseau Wi-Fi qui utilise des adresses de multidiffusion. Cette autorisation entraîne une consommation d\'énergie supérieure au mode de diffusion simple."</string>
    <string name="permdesc_changeWifiMulticastState" product="tv" msgid="1336952358450652595">"Permet à l\'application de recevoir des paquets envoyés à tous les appareils (et pas seulement à votre appareil Android TV) via un réseau Wi-Fi qui utilise des adresses de multidiffusion. Cette autorisation entraîne une consommation d\'énergie supérieure au mode de diffusion simple."</string>
    <string name="permdesc_changeWifiMulticastState" product="default" msgid="8296627590220222740">"Permet à l\'application de recevoir des paquets envoyés à tous les appareils (et pas seulement à votre téléphone) d\'un réseau Wi-Fi qui utilise des adresses de multidiffusion. Cette autorisation entraîne une consommation d\'énergie supérieure au mode de diffusion simple."</string>
    <string name="permlab_bluetoothAdmin" msgid="6490373569441946064">"Accéder aux paramètres Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" product="tablet" msgid="5370837055438574863">"Permet à l\'application de configurer la tablette Bluetooth locale, d\'identifier des appareils distants et de les associer à la tablette."</string>
    <string name="permdesc_bluetoothAdmin" product="tv" msgid="1623992984547014588">"Permet à l\'application de configurer le Bluetooth sur votre appareil Android TV, d\'identifier des appareils distants et de les associer à l\'appareil."</string>
    <string name="permdesc_bluetoothAdmin" product="default" msgid="7381341743021234863">"Permet à l\'application de configurer le téléphone Bluetooth local, d\'identifier des appareils distants et de les associer au téléphone."</string>
    <string name="permlab_accessWimaxState" msgid="7029563339012437434">"se connecter au réseau WiMAX et s\'en déconnecter"</string>
    <string name="permdesc_accessWimaxState" msgid="5372734776802067708">"Permet à l\'application de déterminer si le WiMAX est activé et d\'obtenir des informations sur tous les réseaux WiMAX connectés."</string>
    <string name="permlab_changeWimaxState" msgid="6223305780806267462">"modifier l\'état du WiMAX"</string>
    <string name="permdesc_changeWimaxState" product="tablet" msgid="4011097664859480108">"Permet à l\'application de connecter la tablette aux réseaux WiMAX et de l\'en déconnecter."</string>
    <string name="permdesc_changeWimaxState" product="tv" msgid="5373274458799425276">"Permet à l\'application de connecter votre appareil Android TV aux réseaux WiMAX et de les en déconnecter."</string>
    <string name="permdesc_changeWimaxState" product="default" msgid="1551666203780202101">"Permet à l\'application de connecter le téléphone aux réseaux WiMAX et de l\'en déconnecter."</string>
    <string name="permlab_bluetooth" msgid="586333280736937209">"Associer à appareils Bluetooth"</string>
    <string name="permdesc_bluetooth" product="tablet" msgid="3053222571491402635">"Permet à l\'application d\'accéder à la configuration du Bluetooth sur la tablette, et d\'établir et accepter des connexions avec les appareils associés."</string>
    <string name="permdesc_bluetooth" product="tv" msgid="8851534496561034998">"Permet à l\'application d\'afficher la configuration du Bluetooth sur votre appareil Android TV, de se connecter à des appareils associés et d\'accepter leur connexion."</string>
    <string name="permdesc_bluetooth" product="default" msgid="2779606714091276746">"Permet à l\'application d\'accéder à la configuration du Bluetooth sur le téléphone, et d\'établir et accepter des connexions avec les appareils associés."</string>
    <string name="permlab_preferredPaymentInfo" msgid="5274423844767445054">"Informations sur le service de paiement NFC préféré"</string>
    <string name="permdesc_preferredPaymentInfo" msgid="8583552469807294967">"Permet à l\'application d\'obtenir des informations sur le service de paiement NFC préféré, y compris les ID d\'applications et les destinations de routage enregistrés."</string>
    <string name="permlab_nfc" msgid="1904455246837674977">"contrôler la communication en champ proche"</string>
    <string name="permdesc_nfc" msgid="8352737680695296741">"Permet à l\'application de communiquer avec des tags, des cartes et des lecteurs compatibles avec la technologie NFC (communication en champ proche)."</string>
    <string name="permlab_disableKeyguard" msgid="3605253559020928505">"Désactiver le verrouillage de l\'écran"</string>
    <string name="permdesc_disableKeyguard" msgid="3223710003098573038">"Permet à l\'application de désactiver le verrouillage des touches et toute mesure de sécurité via mot de passe associée. Par exemple, votre téléphone désactive le verrouillage des touches lorsque vous recevez un appel, puis le réactive lorsque vous raccrochez."</string>
    <string name="permlab_requestPasswordComplexity" msgid="1808977190557794109">"demander la complexité du verrouillage de l\'écran"</string>
    <string name="permdesc_requestPasswordComplexity" msgid="1130556896836258567">"Permet à l\'application de connaître le niveau de complexité du verrouillage de l\'écran (élevé, moyen, faible ou aucun), qui indique les possibilités en matière de longueur du mot de passe et de type de verrouillage de l\'écran. L\'application peut également suggérer aux utilisateurs de modifier la complexité du verrouillage, mais ces derniers peuvent librement l\'ignorer. Remarque : Comme le verrouillage de l\'écran n\'est pas stocké au format texte brut, l\'application ne connaît pas le mot de passe exact."</string>
    <string name="permlab_useBiometric" msgid="6314741124749633786">"utiliser les composants biométriques"</string>
    <string name="permdesc_useBiometric" msgid="7502858732677143410">"Autoriser l\'application à utiliser les composants biométriques pour l\'authentification"</string>
    <string name="permlab_manageFingerprint" msgid="7432667156322821178">"Gérer le matériel d\'empreintes digitales"</string>
    <string name="permdesc_manageFingerprint" msgid="2025616816437339865">"Autoriser l\'application à invoquer des méthodes pour ajouter et supprimer des modèles d\'empreintes digitales"</string>
    <string name="permlab_useFingerprint" msgid="1001421069766751922">"Utiliser le matériel d\'empreintes digitales"</string>
    <string name="permdesc_useFingerprint" msgid="412463055059323742">"Autoriser l\'application à utiliser le matériel d\'empreintes digitales pour l\'authentification"</string>
    <string name="permlab_audioWrite" msgid="8501705294265669405">"modifier votre bibliothèque musicale"</string>
    <string name="permdesc_audioWrite" msgid="8057399517013412431">"Autorise l\'application à modifier votre bibliothèque musicale."</string>
    <string name="permlab_videoWrite" msgid="5940738769586451318">"modifier votre bibliothèque vidéo"</string>
    <string name="permdesc_videoWrite" msgid="6124731210613317051">"Autorise l\'application à modifier votre bibliothèque vidéo."</string>
    <string name="permlab_imagesWrite" msgid="1774555086984985578">"modifier votre bibliothèque photo"</string>
    <string name="permdesc_imagesWrite" msgid="5195054463269193317">"Autorise l\'application à modifier votre bibliothèque photo."</string>
    <string name="permlab_mediaLocation" msgid="7368098373378598066">"consulter des positions issues de votre bibliothèque multimédia"</string>
    <string name="permdesc_mediaLocation" msgid="597912899423578138">"Autorise l\'application à consulter des positions issues de votre bibliothèque multimédia."</string>
    <string name="biometric_dialog_default_title" msgid="5284880398508155088">"Confirmer votre identité"</string>
    <string name="biometric_error_hw_unavailable" msgid="2494077380540615216">"Matériel biométrique indisponible"</string>
    <string name="biometric_error_user_canceled" msgid="6732303949695293730">"Authentification annulée"</string>
    <string name="biometric_not_recognized" msgid="5106687642694635888">"Non reconnu"</string>
    <string name="biometric_error_canceled" msgid="8266582404844179778">"Authentification annulée"</string>
    <string name="biometric_error_device_not_secured" msgid="3129845065043995924">"Aucun code, schéma ni mot de passe n\'est défini"</string>
    <string name="fingerprint_acquired_partial" msgid="8532380671091299342">"Empreinte digitale partiellement détectée. Veuillez réessayer."</string>
    <string name="fingerprint_acquired_insufficient" msgid="2545149524031515411">"Impossible de reconnaître l\'empreinte digitale. Veuillez réessayer."</string>
    <string name="fingerprint_acquired_imager_dirty" msgid="4694800187151533990">"Le lecteur d\'empreinte digitale est sale. Veuillez le nettoyer, puis réessayer."</string>
    <string name="fingerprint_acquired_too_fast" msgid="5151661932298844352">"Vous avez déplacé votre doigt trop rapidement. Veuillez réessayer."</string>
    <string name="fingerprint_acquired_too_slow" msgid="6683510291554497580">"Vous avez déplacé votre doigt trop lentement. Veuillez réessayer."</string>
  <string-array name="fingerprint_acquired_vendor">
  </string-array>
    <string name="fingerprint_authenticated" msgid="2024862866860283100">"Empreinte digitale authentifiée"</string>
    <string name="face_authenticated_no_confirmation_required" msgid="8867889115112348167">"Visage authentifié"</string>
    <string name="face_authenticated_confirmation_required" msgid="6872632732508013755">"Visage authentifié, veuillez appuyer sur \"Confirmer\""</string>
    <string name="fingerprint_error_hw_not_available" msgid="4571700896929561202">"Matériel d\'empreinte digitale indisponible."</string>
    <string name="fingerprint_error_no_space" msgid="6126456006769817485">"Impossible d\'enregistrer l\'empreinte digitale. Veuillez en supprimer une autre."</string>
    <string name="fingerprint_error_timeout" msgid="2946635815726054226">"Délai de détection de l\'empreinte digitale expiré. Veuillez réessayer."</string>
    <string name="fingerprint_error_canceled" msgid="540026881380070750">"Opération d\'empreinte digitale annulée."</string>
    <string name="fingerprint_error_user_canceled" msgid="7685676229281231614">"Opération d\'authentification par empreinte digitale annulée par l\'utilisateur."</string>
    <string name="fingerprint_error_lockout" msgid="7853461265604738671">"Trop de tentatives. Veuillez réessayer plus tard."</string>
    <string name="fingerprint_error_lockout_permanent" msgid="3895478283943513746">"Trop de tentatives. Lecteur d\'empreinte digitale désactivé."</string>
    <string name="fingerprint_error_unable_to_process" msgid="1148553603490048742">"Veuillez réessayer."</string>
    <string name="fingerprint_error_no_fingerprints" msgid="8671811719699072411">"Aucune empreinte digitale enregistrée."</string>
    <string name="fingerprint_error_hw_not_present" msgid="578914350967423382">"Aucun lecteur d\'empreinte digitale n\'est installé sur cet appareil."</string>
    <string name="fingerprint_error_security_update_required" msgid="7750187320640856433">"Capteur temporairement désactivé."</string>
    <string name="fingerprint_name_template" msgid="8941662088160289778">"Doigt <xliff:g id="FINGERID">%d</xliff:g>"</string>
  <string-array name="fingerprint_error_vendor">
  </string-array>
    <string name="fingerprint_icon_content_description" msgid="4741068463175388817">"Icône d\'empreinte digitale"</string>
    <string name="permlab_manageFace" msgid="4569549381889283282">"gérer les composants de Face Unlock"</string>
    <string name="permdesc_manageFace" msgid="6204569688492710471">"Autorise l\'appli à invoquer des méthodes pour ajouter et supprimer des modèles de visages."</string>
    <string name="permlab_useFaceAuthentication" msgid="1011430526454859030">"utiliser les composants de Face Unlock"</string>
    <string name="permdesc_useFaceAuthentication" msgid="3115697017684668012">"Autorise l\'application à utiliser les composants de Face Unlock pour l\'authentification"</string>
    <string name="face_recalibrate_notification_name" msgid="6006095897989257026">"Face Unlock"</string>
    <string name="face_recalibrate_notification_title" msgid="5944930528030496897">"Enregistrer à nouveau votre visage"</string>
    <string name="face_recalibrate_notification_content" msgid="892757485125249962">"Pour améliorer la reconnaissance, veuillez enregistrer à nouveau votre visage"</string>
    <string name="face_acquired_insufficient" msgid="2150805835949162453">"Capture du visage impossible. Réessayez."</string>
    <string name="face_acquired_too_bright" msgid="8070756048978079164">"Trop lumineux. Essayez de baisser la lumière."</string>
    <string name="face_acquired_too_dark" msgid="252573548464426546">"Trop sombre. Essayez une éclairage plus lumineux."</string>
    <string name="face_acquired_too_close" msgid="1628767882971469833">"Éloignez le téléphone."</string>
    <string name="face_acquired_too_far" msgid="5098567726427173896">"Rapprochez le téléphone."</string>
    <string name="face_acquired_too_high" msgid="4868033653626081839">"Déplacez le téléphone vers le haut."</string>
    <string name="face_acquired_too_low" msgid="1512237819632165945">"Baissez le téléphone."</string>
    <string name="face_acquired_too_right" msgid="2513391513020932655">"Déplacez le téléphone vers la gauche."</string>
    <string name="face_acquired_too_left" msgid="8882499346502714350">"Déplacez le téléphone vers la droite."</string>
    <string name="face_acquired_poor_gaze" msgid="4427153558773628020">"Veuillez regarder plus directement l\'appareil."</string>
    <string name="face_acquired_not_detected" msgid="2945945257956443257">"Placez votre visage en face du téléphone."</string>
    <string name="face_acquired_too_much_motion" msgid="8199691445085189528">"Trop de mouvement. Ne bougez pas le téléphone."</string>
    <string name="face_acquired_recalibrate" msgid="8724013080976469746">"Veuillez enregistrer à nouveau votre visage."</string>
    <string name="face_acquired_too_different" msgid="4699657338753282542">"Impossible de reconnaître le visage. Réessayez."</string>
    <string name="face_acquired_too_similar" msgid="7684650785108399370">"Ressemble à un visage existant, changez de pose."</string>
    <string name="face_acquired_pan_too_extreme" msgid="7822191262299152527">"Tournez un peu moins la tête."</string>
    <string name="face_acquired_tilt_too_extreme" msgid="8119978324129248059">"Tournez un peu moins la tête."</string>
    <string name="face_acquired_roll_too_extreme" msgid="1442830503572636825">"Tournez un peu moins la tête."</string>
    <string name="face_acquired_obscured" msgid="4917643294953326639">"Retirez tout ce qui cache votre visage."</string>
    <string name="face_acquired_sensor_dirty" msgid="8968391891086721678">"Nettoyez la partie supérieure de l\'écran, y compris la barre noire"</string>
  <string-array name="face_acquired_vendor">
  </string-array>
    <string name="face_error_hw_not_available" msgid="5085202213036026288">"Imposs. valider visage. Matériel non disponible."</string>
    <string name="face_error_timeout" msgid="522924647742024699">"Réessayez d\'activer Face Unlock."</string>
    <string name="face_error_no_space" msgid="5649264057026021723">"Impossible stocker nouv. visages. Veuillez en supprimer un."</string>
    <string name="face_error_canceled" msgid="2164434737103802131">"Opération de reconnaissance faciale annulée."</string>
    <string name="face_error_user_canceled" msgid="8553045452825849843">"Face Unlock annulé par l\'utilisateur."</string>
    <string name="face_error_lockout" msgid="7864408714994529437">"Trop de tentatives. Réessayez plus tard."</string>
    <string name="face_error_lockout_permanent" msgid="8277853602168960343">"Tentatives trop nombreuses. Désactivation de Face Unlock."</string>
    <string name="face_error_unable_to_process" msgid="5723292697366130070">"Impossible de valider votre visage. Réessayez."</string>
    <string name="face_error_not_enrolled" msgid="7369928733504691611">"Face Unlock n\'est pas configuré."</string>
    <string name="face_error_hw_not_present" msgid="1070600921591729944">"Face Unlock n\'est pas compatible avec cet appareil."</string>
    <string name="face_error_security_update_required" msgid="5076017208528750161">"Capteur temporairement désactivé."</string>
    <string name="face_name_template" msgid="3877037340223318119">"Visage <xliff:g id="FACEID">%d</xliff:g>"</string>
  <string-array name="face_error_vendor">
  </string-array>
    <string name="face_icon_content_description" msgid="465030547475916280">"Icône visage"</string>
    <string name="permlab_readSyncSettings" msgid="6250532864893156277">"lire les paramètres de synchronisation"</string>
    <string name="permdesc_readSyncSettings" msgid="1325658466358779298">"Permet à l\'application d\'accéder aux paramètres de synchronisation d\'un compte. Par exemple, cette autorisation peut permettre de déterminer si l\'application Contacts est synchronisée avec un compte ou non."</string>
    <string name="permlab_writeSyncSettings" msgid="6583154300780427399">"activer/désactiver la synchronisation"</string>
    <string name="permdesc_writeSyncSettings" msgid="6029151549667182687">"Permet à une application de modifier les paramètres de synchronisation d\'un compte. Cette autorisation peut, par exemple, être utilisée pour activer la synchronisation de l\'application Contacts avec un compte."</string>
    <string name="permlab_readSyncStats" msgid="3747407238320105332">"Lecture des statistiques de synchronisation"</string>
    <string name="permdesc_readSyncStats" msgid="3867809926567379434">"Permet à une application d\'accéder aux statistiques de synchronisation d\'un compte, y compris l\'historique des événements de synchronisation et le volume de données synchronisées."</string>
    <string name="permlab_sdcardRead" msgid="5791467020950064920">"lire contenu mémoire de stockage partagée"</string>
    <string name="permdesc_sdcardRead" msgid="6872973242228240382">"Permet de lire le contenu mémoire de stockage partagée."</string>
    <string name="permlab_sdcardWrite" msgid="4863021819671416668">"modifier/supprimer contenu mémoire stockage partagée"</string>
    <string name="permdesc_sdcardWrite" msgid="8376047679331387102">"Permet de modifier le contenu mémoire de stockage partagée."</string>
    <string name="permlab_use_sip" msgid="8250774565189337477">"effectuer/recevoir des appels SIP"</string>
    <string name="permdesc_use_sip" msgid="3590270893253204451">"Autorise l\'application à effectuer et à recevoir des appels SIP."</string>
    <string name="permlab_register_sim_subscription" msgid="1653054249287576161">"enregistrer de nouvelles connexions SIM de télécommunication"</string>
    <string name="permdesc_register_sim_subscription" msgid="4183858662792232464">"Permettre à l\'application d\'enregistrer de nouvelles connexions SIM de télécommunication"</string>
    <string name="permlab_register_call_provider" msgid="6135073566140050702">"enregistrer de nouvelles connexions de télécommunication"</string>
    <string name="permdesc_register_call_provider" msgid="4201429251459068613">"Permettre à l\'application d\'enregistrer de nouvelles connexions de télécommunication"</string>
    <string name="permlab_connection_manager" msgid="3179365584691166915">"gérer les connexions de télécommunication"</string>
    <string name="permdesc_connection_manager" msgid="1426093604238937733">"Permettre à l\'application de gérer les connexions de télécommunication"</string>
    <string name="permlab_bind_incall_service" msgid="5990625112603493016">"contrôler l\'écran d\'appel"</string>
    <string name="permdesc_bind_incall_service" msgid="4124917526967765162">"Permet à l\'application de contrôler quand et comment l\'écran d\'appel s\'affiche."</string>
    <string name="permlab_bind_connection_service" msgid="5409268245525024736">"interagir avec des services de téléphonie"</string>
    <string name="permdesc_bind_connection_service" msgid="6261796725253264518">"Permet à l\'application d\'interagir avec des services de téléphonie pour effectuer et recevoir des appels."</string>
    <string name="permlab_control_incall_experience" msgid="6436863486094352987">"fournir une expérience utilisateur pendant l\'appel"</string>
    <string name="permdesc_control_incall_experience" msgid="5896723643771737534">"Permet à l\'application de fournir une expérience utilisateur pendant l\'appel."</string>
    <string name="permlab_readNetworkUsageHistory" msgid="8470402862501573795">"lire l\'historique d\'utilisation du réseau"</string>
    <string name="permdesc_readNetworkUsageHistory" msgid="1112962304941637102">"Permet à l\'application de lire l\'historique d\'utilisation de réseaux et d\'applications spécifiques."</string>
    <string name="permlab_manageNetworkPolicy" msgid="6872549423152175378">"gérer les règles du réseau"</string>
    <string name="permdesc_manageNetworkPolicy" msgid="1865663268764673296">"Permet à l\'application de gérer les stratégies du réseau et de définir celles qui sont spécifiques à l\'application."</string>
    <string name="permlab_modifyNetworkAccounting" msgid="7448790834938749041">"modifier le système de comptabilisation de l\'utilisation du réseau"</string>
    <string name="permdesc_modifyNetworkAccounting" msgid="5076042642247205390">"Permet à l\'application de modifier l\'utilisation du réseau par les autres applications. Les applications standards ne doivent pas utiliser cette fonctionnalité."</string>
    <string name="permlab_accessNotifications" msgid="7130360248191984741">"accéder aux notifications"</string>
    <string name="permdesc_accessNotifications" msgid="761730149268789668">"Permet aux applications de récupérer, d\'examiner et d\'autoriser les notifications, y compris celles envoyées par d\'autres applications."</string>
    <string name="permlab_bindNotificationListenerService" msgid="5848096702733262458">"s\'associer à l\'interface de niveau supérieur d\'un service d\'écoute des notifications"</string>
    <string name="permdesc_bindNotificationListenerService" msgid="4970553694467137126">"Permet à l\'application de s\'associer à l\'interface de niveau supérieur d\'un service d\'écoute des notifications. Ne devrait jamais être nécessaire pour les applications normales."</string>
    <string name="permlab_bindConditionProviderService" msgid="5245421224814878483">"s\'associer à un service de fournisseur de conditions"</string>
    <string name="permdesc_bindConditionProviderService" msgid="6106018791256120258">"Permet à l\'application de s\'associer à l\'interface de niveau supérieur d\'un service de fournisseur de conditions. Ne devrait pas être nécessaire pour les applications standards."</string>
    <string name="permlab_bindDreamService" msgid="4776175992848982706">"associer à un service d\'écran de veille interactif"</string>
    <string name="permdesc_bindDreamService" msgid="9129615743300572973">"Permet à l\'application autorisée de s\'associer à l\'interface de plus haut niveau d\'un service d\'écran de veille interactif. Cette autorisation ne devrait jamais être nécessaire pour les applications standards."</string>
    <string name="permlab_invokeCarrierSetup" msgid="5098810760209818140">"faire appel à l\'application de configuration fournie par l\'opérateur"</string>
    <string name="permdesc_invokeCarrierSetup" msgid="4790845896063237887">"Permet à l\'application autorisée de faire appel à l\'application de configuration fournie par l\'opérateur. Cette fonctionnalité ne devrait pas être nécessaire pour les applications standards."</string>
    <string name="permlab_accessNetworkConditions" msgid="1270732533356286514">"détecter des observations sur les conditions du réseau"</string>
    <string name="permdesc_accessNetworkConditions" msgid="2959269186741956109">"Permet à une application de détecter des observations sur les conditions du réseau. Les applications standards ne devraient pas nécessiter cette autorisation."</string>
    <string name="permlab_setInputCalibration" msgid="932069700285223434">"modifier le calibrage du périphérique d\'entrée"</string>
    <string name="permdesc_setInputCalibration" msgid="2937872391426631726">"Permettre à l\'application de modifier les paramètres de calibrage de l\'écran tactile. Ne devrait jamais être nécessaire pour les applications standards."</string>
    <string name="permlab_accessDrmCertificates" msgid="6473765454472436597">"accéder aux certificats DRM"</string>
    <string name="permdesc_accessDrmCertificates" msgid="6983139753493781941">"Permet à une application de fournir et d\'utiliser des certificats DRM. Ne devrait jamais être nécessaire pour les applications standards."</string>
    <string name="permlab_handoverStatus" msgid="7620438488137057281">"recevoir des informations sur l\'état du transfert Android Beam"</string>
    <string name="permdesc_handoverStatus" msgid="3842269451732571070">"Autoriser cette application à recevoir des informations sur les transferts Android Beam en cours"</string>
    <string name="permlab_removeDrmCertificates" msgid="710576248717404416">"supprimer les certificats DRM"</string>
    <string name="permdesc_removeDrmCertificates" msgid="4068445390318355716">"Permet à une application de supprimer les certificats DRM. Ne devrait jamais être nécessaire pour les applications standards."</string>
    <string name="permlab_bindCarrierMessagingService" msgid="3363450860593096967">"s\'associer au service SMS/MMS d\'un opérateur"</string>
    <string name="permdesc_bindCarrierMessagingService" msgid="6316457028173478345">"Permettre à l\'application de s\'associer à l\'interface de niveau supérieur du service SMS/MMS d\'un opérateur. Ne devrait jamais être nécessaire pour les applications standards."</string>
    <string name="permlab_bindCarrierServices" msgid="2395596978626237474">"associer aux services de l\'opérateur"</string>
    <string name="permdesc_bindCarrierServices" msgid="9185614481967262900">"Permet à l\'application autorisée de s\'associer aux services d\'un opérateur. Ne devrait pas être nécessaire pour les applications standards."</string>
    <string name="permlab_access_notification_policy" msgid="5524112842876975537">"accéder au mode Ne pas déranger"</string>
    <string name="permdesc_access_notification_policy" msgid="8538374112403845013">"Permet à l\'application de consulter et de modifier la configuration du mode Ne pas déranger."</string>
    <string name="permlab_startViewPermissionUsage" msgid="1504564328641112341">"activer l\'utilisation de l\'autorisation d\'affichage"</string>
    <string name="permdesc_startViewPermissionUsage" msgid="2820325605959586538">"Permet à l\'application autorisée d\'activer l\'utilisation de l\'autorisation pour une application. Cette fonctionnalité ne devrait pas être nécessaire pour les applications standards."</string>
    <string name="policylab_limitPassword" msgid="4851829918814422199">"Définir les règles du mot de passe"</string>
    <string name="policydesc_limitPassword" msgid="4105491021115793793">"Gérer le nombre et le type de caractères autorisés dans les mots de passe et les codes d\'accès de verrouillage de l\'écran"</string>
    <string name="policylab_watchLogin" msgid="7599669460083719504">"Gérer les tentatives de déverrouillage de l\'écran"</string>
    <string name="policydesc_watchLogin" product="tablet" msgid="2388436408621909298">"Contrôler le nombre de mots de passe incorrects saisis pour le déverrouillage de l\'écran, puis verrouiller la tablette ou effacer toutes ses données si le nombre maximal de tentatives de saisie du mot de passe est atteint"</string>
    <string name="policydesc_watchLogin" product="tv" msgid="2140588224468517507">"Contrôle le nombre de fois qu\'un mot de passe incorrect est saisi lors du déverrouillage de l\'écran, et verrouille votre appareil Android TV ou en efface toutes les données si le nombre maximal de mots de passe incorrects autorisé est dépassé."</string>
    <string name="policydesc_watchLogin" product="default" msgid="4885030206253600299">"Contrôler le nombre de mots de passe incorrects saisis pour le déverrouillage de l\'écran, puis verrouiller le téléphone ou effacer toutes ses données si le nombre maximal de tentatives de saisie du mot de passe est atteint"</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet" msgid="2049038943004297474">"Contrôlez le nombre de fois qu\'un mot de passe incorrect est saisi lors du déverrouillage de l\'écran, et verrouillez la tablette ou effacez toutes les informations sur l\'utilisateur si le nombre maximal de mots de passe incorrects autorisés est dépassé."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tv" msgid="8965224107449407052">"Contrôle le nombre de fois qu\'un mot de passe incorrect est saisi lors du déverrouillage de l\'écran, et verrouille votre appareil Android TV ou efface toutes les données de cet utilisateur si le nombre maximal de mots de passe incorrects autorisé est dépassé."</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default" msgid="9177645136475155924">"Contrôlez le nombre de fois qu\'un mot de passe incorrect est saisi lors du déverrouillage de l\'écran, et verrouillez le téléphone ou effacez toutes les informations sur l\'utilisateur si le nombre maximal de mots de passe incorrects autorisés est dépassé."</string>
    <string name="policylab_resetPassword" msgid="214556238645096520">"Modifier le verrouillage de l\'écran"</string>
    <string name="policydesc_resetPassword" msgid="4626419138439341851">"Modifier le verrouillage de l\'écran"</string>
    <string name="policylab_forceLock" msgid="7360335502968476434">"Verrouiller l\'écran"</string>
    <string name="policydesc_forceLock" msgid="1008844760853899693">"Gérer la méthode et les conditions de verrouillage de l\'écran"</string>
    <string name="policylab_wipeData" msgid="1359485247727537311">"Effacer toutes les données"</string>
    <string name="policydesc_wipeData" product="tablet" msgid="7245372676261947507">"Effacer les données de la tablette sans avertissement, en rétablissant la configuration d\'usine"</string>
    <string name="policydesc_wipeData" product="tv" msgid="513862488950801261">"Efface les données de votre appareil Android TV sans avertissement en rétablissant la configuration d\'usine."</string>
    <string name="policydesc_wipeData" product="default" msgid="8036084184768379022">"Effacer les données du téléphone sans avertissement, en rétablissant la configuration d\'usine"</string>
    <string name="policylab_wipeData_secondaryUser" msgid="413813645323433166">"Effacer les informations sur l\'utilisateur"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tablet" msgid="2336676480090926470">"Effacer les informations sur cet utilisateur de cette tablette sans avertissement"</string>
    <string name="policydesc_wipeData_secondaryUser" product="tv" msgid="2293713284515865200">"Efface les données concernant cet utilisateur de cet appareil Android TV sans avertissement."</string>
    <string name="policydesc_wipeData_secondaryUser" product="default" msgid="2788325512167208654">"Effacer les informations sur cet utilisateur de ce téléphone sans avertissement"</string>
    <string name="policylab_setGlobalProxy" msgid="215332221188670221">"Définir le proxy global du mobile"</string>
    <string name="policydesc_setGlobalProxy" msgid="7149665222705519604">"Indiquer le proxy global à utiliser pour l\'appareil lorsque la règle est activée. Seul le propriétaire de l\'appareil peut définir le proxy global."</string>
    <string name="policylab_expirePassword" msgid="6015404400532459169">"Définir l\'expiration du mot de passe de verrouillage d\'écran"</string>
    <string name="policydesc_expirePassword" msgid="9136524319325960675">"Modifier la fréquence de modification du mot de passe, du code d\'accès ou du schéma de verrouillage de l\'écran"</string>
    <string name="policylab_encryptedStorage" msgid="9012936958126670110">"Définir chiffrement du stockage"</string>
    <string name="policydesc_encryptedStorage" msgid="1102516950740375617">"Exiger le chiffrement des données d\'application stockées"</string>
    <string name="policylab_disableCamera" msgid="5749486347810162018">"Désactiver les appareils photo"</string>
    <string name="policydesc_disableCamera" msgid="3204405908799676104">"Empêcher l\'utilisation de tous les appareils photos"</string>
    <string name="policylab_disableKeyguardFeatures" msgid="5071855750149949741">"Désactiver les options de verrouillage de l\'écran"</string>
    <string name="policydesc_disableKeyguardFeatures" msgid="6641673177041195957">"Empêcher l\'utilisation de certaines fonctionnalités du verrouillage de l\'écran"</string>
  <string-array name="phoneTypes">
    <item msgid="8996339953292723951">"Domicile"</item>
    <item msgid="7740243458912727194">"Mobile"</item>
    <item msgid="8526146065496663766">"Bureau"</item>
    <item msgid="8150904584178569699">"Fax travail"</item>
    <item msgid="4537253139152229577">"Fax domicile"</item>
    <item msgid="6751245029698664340">"Bipeur"</item>
    <item msgid="1692790665884224905">"Autre"</item>
    <item msgid="6216981255272016212">"Personnalisé"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="7786349763648997741">"Domicile"</item>
    <item msgid="435564470865989199">"Bureau"</item>
    <item msgid="4199433197875490373">"Autre"</item>
    <item msgid="3233938986670468328">"Personnalisée"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="3861463339764243038">"Domicile"</item>
    <item msgid="5472578890164979109">"Bureau"</item>
    <item msgid="5718921296646594739">"Autre"</item>
    <item msgid="5523122236731783179">"Personnalisée"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="588088543406993772">"Domicile"</item>
    <item msgid="5503060422020476757">"Bureau"</item>
    <item msgid="2530391194653760297">"Autre"</item>
    <item msgid="7640927178025203330">"Personnalisé"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="6144047813304847762">"Bureau"</item>
    <item msgid="7402720230065674193">"Autre"</item>
    <item msgid="808230403067569648">"Personnalisée"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="7535761744432206400">"AIM"</item>
    <item msgid="2236558491789293993">"Windows Live"</item>
    <item msgid="4925858989398000295">"Yahoo"</item>
    <item msgid="5203383604393320577">"Skype"</item>
    <item msgid="6142060795155127001">"QQ"</item>
    <item msgid="8831467252725610081">"Google Talk"</item>
    <item msgid="4717545739447438044">"ICQ"</item>
    <item msgid="8293711853624033835">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="5120365721260686814">"Personnalisé"</string>
    <string name="phoneTypeHome" msgid="3880132427643623588">"Domicile"</string>
    <string name="phoneTypeMobile" msgid="1178852541462086735">"Mobile"</string>
    <string name="phoneTypeWork" msgid="6604967163358864607">"Bureau"</string>
    <string name="phoneTypeFaxWork" msgid="6757519896109439123">"Fax travail"</string>
    <string name="phoneTypeFaxHome" msgid="6678559953115904345">"Fax domicile"</string>
    <string name="phoneTypePager" msgid="576402072263522767">"Bipeur"</string>
    <string name="phoneTypeOther" msgid="6918196243648754715">"Autre"</string>
    <string name="phoneTypeCallback" msgid="3455781500844157767">"Rappel"</string>
    <string name="phoneTypeCar" msgid="4604775148963129195">"Voiture"</string>
    <string name="phoneTypeCompanyMain" msgid="4482773154536455441">"Entreprise (principal)"</string>
    <string name="phoneTypeIsdn" msgid="2496238954533998512">"RNIS"</string>
    <string name="phoneTypeMain" msgid="5199722006991000111">"Principal"</string>
    <string name="phoneTypeOtherFax" msgid="3037145630364770357">"Autre fax"</string>
    <string name="phoneTypeRadio" msgid="2637819130239264771">"Radio"</string>
    <string name="phoneTypeTelex" msgid="2558783611711876562">"Télex"</string>
    <string name="phoneTypeTtyTdd" msgid="532038552105328779">"TTY/TTD"</string>
    <string name="phoneTypeWorkMobile" msgid="7522314392003565121">"Mobile pro"</string>
    <string name="phoneTypeWorkPager" msgid="3748332310638505234">"Bipeur pro"</string>
    <string name="phoneTypeAssistant" msgid="757550783842231039">"Assistant"</string>
    <string name="phoneTypeMms" msgid="1799747455131365989">"MMS"</string>
    <string name="eventTypeCustom" msgid="3257367158986466481">"Personnalisé"</string>
    <string name="eventTypeBirthday" msgid="7770026752793912283">"Anniversaire"</string>
    <string name="eventTypeAnniversary" msgid="4684702412407916888">"Fête"</string>
    <string name="eventTypeOther" msgid="530671238533887997">"Autre"</string>
    <string name="emailTypeCustom" msgid="1809435350482181786">"Personnalisé"</string>
    <string name="emailTypeHome" msgid="1597116303154775999">"Domicile"</string>
    <string name="emailTypeWork" msgid="2020095414401882111">"Bureau"</string>
    <string name="emailTypeOther" msgid="5131130857030897465">"Autre"</string>
    <string name="emailTypeMobile" msgid="787155077375364230">"Mobile"</string>
    <string name="postalTypeCustom" msgid="5645590470242939129">"Personnalisé"</string>
    <string name="postalTypeHome" msgid="7562272480949727912">"Domicile"</string>
    <string name="postalTypeWork" msgid="8553425424652012826">"Bureau"</string>
    <string name="postalTypeOther" msgid="7094245413678857420">"Autre"</string>
    <string name="imTypeCustom" msgid="5653384545085765570">"Personnalisé"</string>
    <string name="imTypeHome" msgid="6996507981044278216">"Domicile"</string>
    <string name="imTypeWork" msgid="2099668940169903123">"Bureau"</string>
    <string name="imTypeOther" msgid="8068447383276219810">"Autre"</string>
    <string name="imProtocolCustom" msgid="4437878287653764692">"Personnalisé"</string>
    <string name="imProtocolAim" msgid="4050198236506604378">"AIM"</string>
    <string name="imProtocolMsn" msgid="2257148557766499232">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="5373338758093392231">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="1486297589164830043">"Skype"</string>
    <string name="imProtocolQq" msgid="7254708777029006592">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="9194016024343166782">"Hangouts"</string>
    <string name="imProtocolIcq" msgid="2410325380427389521">"ICQ"</string>
    <string name="imProtocolJabber" msgid="7919269388889582015">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="4985002408136148256">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="8684458700669564172">"Bureau"</string>
    <string name="orgTypeOther" msgid="5450675258408005553">"Autre"</string>
    <string name="orgTypeCustom" msgid="1126322047677329218">"Personnalisé"</string>
    <string name="relationTypeCustom" msgid="282938315217441351">"Personnalisée"</string>
    <string name="relationTypeAssistant" msgid="4057605157116589315">"Assistant"</string>
    <string name="relationTypeBrother" msgid="7141662427379247820">"Frère"</string>
    <string name="relationTypeChild" msgid="9076258911292693601">"Enfant"</string>
    <string name="relationTypeDomesticPartner" msgid="7825306887697559238">"Concubin"</string>
    <string name="relationTypeFather" msgid="3856225062864790596">"Père"</string>
    <string name="relationTypeFriend" msgid="3192092625893980574">"Ami(e)"</string>
    <string name="relationTypeManager" msgid="2272860813153171857">"Responsable"</string>
    <string name="relationTypeMother" msgid="2331762740982699460">"Mère"</string>
    <string name="relationTypeParent" msgid="4177920938333039882">"Parent(e)"</string>
    <string name="relationTypePartner" msgid="4018017075116766194">"Conjoint(e)"</string>
    <string name="relationTypeReferredBy" msgid="5285082289602849400">"Parrain(ne)"</string>
    <string name="relationTypeRelative" msgid="3396498519818009134">"Proche"</string>
    <string name="relationTypeSister" msgid="3721676005094140671">"Sœur"</string>
    <string name="relationTypeSpouse" msgid="6916682664436031703">"Époux(se)"</string>
    <string name="sipAddressTypeCustom" msgid="6283889809842649336">"Personnalisée"</string>
    <string name="sipAddressTypeHome" msgid="5918441930656878367">"Domicile"</string>
    <string name="sipAddressTypeWork" msgid="7873967986701216770">"Professionnelle"</string>
    <string name="sipAddressTypeOther" msgid="6317012577345187275">"Autre"</string>
    <string name="quick_contacts_not_available" msgid="1262709196045052223">"Aucune application permettant d\'afficher ce contact n\'a été trouvée."</string>
    <string name="keyguard_password_enter_pin_code" msgid="6401406801060956153">"Saisissez le code PIN."</string>
    <string name="keyguard_password_enter_puk_code" msgid="3112256684547584093">"Saisissez la clé PUK et le nouveau code PIN."</string>
    <string name="keyguard_password_enter_puk_prompt" msgid="2825313071899938305">"Code PUK"</string>
    <string name="keyguard_password_enter_pin_prompt" msgid="5505434724229581207">"Nouveau code PIN"</string>
    <string name="keyguard_password_entry_touch_hint" msgid="4032288032993261520"><font size="17">"Appuyer pour saisir mot passe"</font></string>
    <string name="keyguard_password_enter_password_code" msgid="2751130557661643482">"Saisissez le mot de passe pour déverrouiller le clavier."</string>
    <string name="keyguard_password_enter_pin_password_code" msgid="7792964196473964340">"Saisissez le code PIN pour déverrouiller le clavier."</string>
    <string name="keyguard_password_wrong_pin_code" msgid="8583732939138432793">"Le code PIN est erroné."</string>
    <string name="keyguard_label_text" msgid="3841953694564168384">"Pour déverrouiller le clavier, appuyez sur \"Menu\" puis sur 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="2978165477085612673">"Numéro d\'urgence"</string>
    <string name="lockscreen_carrier_default" msgid="6192313772955399160">"Aucun service"</string>
    <string name="lockscreen_screen_locked" msgid="7364905540516041817">"Écran verrouillé"</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="7982445492532123308">"Appuyez sur \"Menu\" pour déverrouiller le téléphone ou appeler un numéro d\'urgence"</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="7434061749374801753">"Appuyez sur \"Menu\" pour déverrouiller le téléphone."</string>
    <string name="lockscreen_pattern_instructions" msgid="3169991838169244941">"Dessinez un schéma pour déverrouiller le téléphone"</string>
    <string name="lockscreen_emergency_call" msgid="7500692654885445299">"Urgences"</string>
    <string name="lockscreen_return_to_call" msgid="3156883574692006382">"Retour à l\'appel"</string>
    <string name="lockscreen_pattern_correct" msgid="8050630103651508582">"Combinaison correcte !"</string>
    <string name="lockscreen_pattern_wrong" msgid="2940138714468358458">"Veuillez réessayer."</string>
    <string name="lockscreen_password_wrong" msgid="8605355913868947490">"Veuillez réessayer."</string>
    <string name="lockscreen_storage_locked" msgid="634993789186443380">"Déverr. pour autres fonctionnalités et données"</string>
    <string name="faceunlock_multiple_failures" msgid="681991538434031708">"Nombre maximal autorisé de tentatives Face Unlock atteint."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="1248431165144893792">"Pas de carte SIM"</string>
    <string name="lockscreen_missing_sim_message" product="tablet" msgid="8596805728510570760">"Aucune carte SIM n\'est insérée dans la tablette."</string>
    <string name="lockscreen_missing_sim_message" product="tv" msgid="2582768023352171073">"Aucune carte SIM n\'est installée dans votre appareil Android TV."</string>
    <string name="lockscreen_missing_sim_message" product="default" msgid="1408695081255172556">"Aucune carte SIM n\'est insérée dans le téléphone."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8473601862688263903">"Insérez une carte SIM."</string>
    <string name="lockscreen_missing_sim_instructions_long" msgid="3664999892038416334">"Carte SIM absente ou illisible. Insérez une carte SIM."</string>
    <string name="lockscreen_permanent_disabled_sim_message_short" msgid="3812893366715730539">"Carte SIM inutilisable."</string>
    <string name="lockscreen_permanent_disabled_sim_instructions" msgid="4358929052509450807">"Votre carte SIM a été définitivement désactivée.\n Veuillez contacter votre opérateur de téléphonie mobile pour en obtenir une autre."</string>
    <string name="lockscreen_transport_prev_description" msgid="2879469521751181478">"Piste précédente"</string>
    <string name="lockscreen_transport_next_description" msgid="2931509904881099919">"Piste suivante"</string>
    <string name="lockscreen_transport_pause_description" msgid="6705284702135372494">"Interrompre"</string>
    <string name="lockscreen_transport_play_description" msgid="106868788691652733">"Lire"</string>
    <string name="lockscreen_transport_stop_description" msgid="1449552232598355348">"Arrêter"</string>
    <string name="lockscreen_transport_rew_description" msgid="7680106856221622779">"Retour arrière"</string>
    <string name="lockscreen_transport_ffw_description" msgid="4763794746640196772">"Avance rapide"</string>
    <string name="emergency_calls_only" msgid="3057351206678279851">"Urgences seulement"</string>
    <string name="lockscreen_network_locked_message" msgid="2814046965899249635">"Réseau verrouillé"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="6618356415831082174">"La carte SIM est verrouillée par clé PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="5307979043730860995">"Veuillez consulter le guide de l\'utilisateur ou contacter le service client."</string>
    <string name="lockscreen_sim_locked_message" msgid="3160196135801185938">"La carte SIM est verrouillée."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="2286497117428409709">"Déblocage de la carte SIM..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="6458790975898594240">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises.\n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message" msgid="3118353451602377380">"Vous avez saisi un mot de passe incorrect <xliff:g id="NUMBER_0">%1$d</xliff:g> fois. \n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message" msgid="2874278239714821984">"Vous avez saisi un code PIN incorrect <xliff:g id="NUMBER_0">%1$d</xliff:g> fois. \n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet" msgid="3069635524964070596">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Au bout de <xliff:g id="NUMBER_1">%2$d</xliff:g> échecs supplémentaires, vous devrez déverrouiller votre tablette à l\'aide de votre identifiant Google.\n\nVeuillez réessayer dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv" msgid="6399092175942158529">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, vous devrez déverrouiller votre appareil Android TV en vous connectant à votre compte Google.\n\n Réessayez dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" product="default" msgid="5691623136957148335">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Au bout de <xliff:g id="NUMBER_1">%2$d</xliff:g> échecs supplémentaires, vous devrez déverrouiller votre téléphone à l\'aide de votre identifiant Google.\n\nVeuillez réessayer dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet" msgid="7914445759242151426">"Vous avez tenté de déverrouiller la tablette de façon incorrecte à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv" msgid="4275591249631864248">"Vous avez tenté de déverrouiller votre appareil Android TV à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default" msgid="1166532464798446579">"Vous avez tenté de déverrouiller le téléphone de façon incorrecte à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet" msgid="8682445539263683414">"Vous avez tenté de déverrouiller la tablette de façon incorrecte à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va être rétablie."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="tv" msgid="2205435033340091883">"Vous avez tenté de déverrouiller votre appareil Android TV à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va maintenant être rétablie."</string>
    <string name="lockscreen_failed_attempts_now_wiping" product="default" msgid="2203704707679895487">"Vous avez tenté de déverrouiller le téléphone de façon incorrecte à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va être rétablie."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6807200118164539589">"Réessayez dans <xliff:g id="NUMBER">%d</xliff:g> secondes."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="8362442730606839031">"Schéma oublié ?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="9218940117797602518">"Déverrouillage du compte"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="3775904917743034195">"Trop de tentatives"</string>
    <string name="lockscreen_glogin_instructions" msgid="4695162942525531700">"Pour déverrouiller le téléphone, veuillez vous connecter avec votre compte Google."</string>
    <string name="lockscreen_glogin_username_hint" msgid="6916101478673157045">"Nom d\'utilisateur (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="3031027901286812848">"Mot de passe"</string>
    <string name="lockscreen_glogin_submit_button" msgid="3590556636347843733">"Se connecter"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="4369219936865697679">"Nom d\'utilisateur ou mot de passe incorrect."</string>
    <string name="lockscreen_glogin_account_recovery_hint" msgid="1683405808525090649">"Vous avez oublié votre nom d\'utilisateur ou votre mot de passe ?\nAccédez à la page "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="lockscreen_glogin_checking_password" msgid="2607271802803381645">"Vérification en cours…"</string>
    <string name="lockscreen_unlock_label" msgid="4648257878373307582">"Déverrouiller"</string>
    <string name="lockscreen_sound_on_label" msgid="1660281470535492430">"Son activé"</string>
    <string name="lockscreen_sound_off_label" msgid="2331496559245450053">"Son désactivé"</string>
    <string name="lockscreen_access_pattern_start" msgid="3778502525702613399">"Schéma commencé."</string>
    <string name="lockscreen_access_pattern_cleared" msgid="7493849102641167049">"Schéma effacé."</string>
    <string name="lockscreen_access_pattern_cell_added" msgid="6746676335293144163">"Cellule ajoutée."</string>
    <string name="lockscreen_access_pattern_cell_added_verbose" msgid="2931364927622563465">"Le point <xliff:g id="CELL_INDEX">%1$s</xliff:g> a bien été ajouté."</string>
    <string name="lockscreen_access_pattern_detected" msgid="3931150554035194012">"Schéma terminé."</string>
    <string name="lockscreen_access_pattern_area" msgid="1288780416685002841">"Zone du schéma"</string>
    <string name="keyguard_accessibility_widget_changed" msgid="7298011259508200234">"%1$s. Widget %2$d sur %3$d."</string>
    <string name="keyguard_accessibility_add_widget" msgid="8245795023551343672">"Ajouter un widget"</string>
    <string name="keyguard_accessibility_widget_empty_slot" msgid="544239307077644480">"Vide"</string>
    <string name="keyguard_accessibility_unlock_area_expanded" msgid="7768634718706488951">"Zone de déverrouillage développée."</string>
    <string name="keyguard_accessibility_unlock_area_collapsed" msgid="4729922043778400434">"Zone de déverrouillage réduite."</string>
    <string name="keyguard_accessibility_widget" msgid="6776892679715699875">"Widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g>"</string>
    <string name="keyguard_accessibility_user_selector" msgid="1466067610235696600">"Sélecteur d\'utilisateur"</string>
    <string name="keyguard_accessibility_status" msgid="6792745049712397237">"État"</string>
    <string name="keyguard_accessibility_camera" msgid="7862557559464986528">"Caméra"</string>
    <string name="keygaurd_accessibility_media_controls" msgid="2267379779900620614">"Commandes multimédias"</string>
    <string name="keyguard_accessibility_widget_reorder_start" msgid="7066213328912939191">"Début de la réorganisation des widgets"</string>
    <string name="keyguard_accessibility_widget_reorder_end" msgid="1083806817600593490">"Réorganisation des widgets terminée."</string>
    <string name="keyguard_accessibility_widget_deleted" msgid="1509738950119878705">"Le widget <xliff:g id="WIDGET_INDEX">%1$s</xliff:g> a été supprimé."</string>
    <string name="keyguard_accessibility_expand_lock_area" msgid="4215280881346033434">"Développer la zone de déverrouillage"</string>
    <string name="keyguard_accessibility_slide_unlock" msgid="2968195219692413046">"Déverrouillage en faisant glisser votre doigt sur l\'écran"</string>
    <string name="keyguard_accessibility_pattern_unlock" msgid="8669128146589233293">"Déverrouillage par schéma"</string>
    <string name="keyguard_accessibility_face_unlock" msgid="632407612842329815">"Déverrouillage par reconnaissance faciale"</string>
    <string name="keyguard_accessibility_pin_unlock" msgid="4020864007967340068">"Déverrouillage par code PIN"</string>
    <string name="keyguard_accessibility_sim_pin_unlock" msgid="4895939120871890557">"Déverrouillage de la carte SIM à l\'aide d\'un code."</string>
    <string name="keyguard_accessibility_sim_puk_unlock" msgid="3459003464041899101">"Déverrouillage de la carte SIM à l\'aide d\'une clé PUK."</string>
    <string name="keyguard_accessibility_password_unlock" msgid="6130186108581153265">"Déverrouillage par mot de passe"</string>
    <string name="keyguard_accessibility_pattern_area" msgid="1419570880512350689">"Zone du schéma"</string>
    <string name="keyguard_accessibility_slide_area" msgid="4331399051142520176">"Zone où faire glisser votre doigt sur l\'écran"</string>
    <string name="password_keyboard_label_symbol_key" msgid="2716255580853511949">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="5294837425652726684">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="8528261816395508841">"ALT"</string>
    <string name="granularity_label_character" msgid="8903387663153706317">"caractère"</string>
    <string name="granularity_label_word" msgid="3686589158760620518">"mot"</string>
    <string name="granularity_label_link" msgid="9007852307112046526">"lien"</string>
    <string name="granularity_label_line" msgid="376204904280620221">"ligne"</string>
    <string name="factorytest_failed" msgid="3190979160945298006">"Échec du test usine"</string>
    <string name="factorytest_not_system" msgid="5658160199925519869">"L\'action FACTORY_TEST est uniquement prise en charge pour les paquets de données installés dans in/system/app."</string>
    <string name="factorytest_no_action" msgid="339252838115675515">"Impossible de trouver un paquet proposant l\'action FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="2050147445567257365">"Redémarrer"</string>
    <string name="js_dialog_title" msgid="7464775045615023241">"La page \"<xliff:g id="TITLE">%s</xliff:g>\" indique :"</string>
    <string name="js_dialog_title_default" msgid="3769524569903332476">"JavaScript"</string>
    <string name="js_dialog_before_unload_title" msgid="7012587995876771246">"Quitter la page"</string>
    <string name="js_dialog_before_unload_positive_button" msgid="4274257182303565509">"Quitter cette page"</string>
    <string name="js_dialog_before_unload_negative_button" msgid="3873765747622415310">"Rester sur cette page"</string>
    <string name="js_dialog_before_unload" msgid="7213364985774778744">"<xliff:g id="MESSAGE">%s</xliff:g>\n\nVoulez-vous vraiment quitter cette page ?"</string>
    <string name="save_password_label" msgid="9161712335355510035">"Confirmer"</string>
    <string name="double_tap_toast" msgid="7065519579174882778">"Conseil : Appuyez deux fois pour faire un zoom avant ou arrière."</string>
    <string name="autofill_this_form" msgid="3187132440451621492">"Saisie auto"</string>
    <string name="setup_autofill" msgid="5431369130866618567">"Conf. saisie auto"</string>
    <string name="autofill_window_title" msgid="4379134104008111961">"Saisie automatique avec <xliff:g id="SERVICENAME">%1$s</xliff:g>"</string>
    <string name="autofill_address_name_separator" msgid="8190155636149596125">" "</string>
    <string name="autofill_address_summary_name_format" msgid="3402882515222673691">"$1$2$3"</string>
    <string name="autofill_address_summary_separator" msgid="760522655085707045">", "</string>
    <string name="autofill_address_summary_format" msgid="8417010069362125194">"$1$2$3"</string>
    <string name="autofill_province" msgid="3676846437741893159">"Province"</string>
    <string name="autofill_postal_code" msgid="7034789388968295591">"Code postal"</string>
    <string name="autofill_state" msgid="3341725337190434069">"État"</string>
    <string name="autofill_zip_code" msgid="1315503730274962450">"Code postal"</string>
    <string name="autofill_county" msgid="7781382735643492173">"Comté"</string>
    <string name="autofill_island" msgid="5367139008536593734">"Île"</string>
    <string name="autofill_district" msgid="6428712062213557327">"District"</string>
    <string name="autofill_department" msgid="9047276226873531529">"Département"</string>
    <string name="autofill_prefecture" msgid="7267397763720241872">"Préfecture"</string>
    <string name="autofill_parish" msgid="6847960518334530198">"Commune"</string>
    <string name="autofill_area" msgid="8289022370678448983">"Région"</string>
    <string name="autofill_emirate" msgid="2544082046790551168">"Émirat"</string>
    <string name="permlab_readHistoryBookmarks" msgid="9102293913842539697">"voir l\'historique et les favoris Web"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="2323799501008967852">"Permet à l\'application d\'accéder à l\'historique de toutes les URL auxquelles le navigateur a accédé, ainsi qu\'à l\'ensemble des favoris du navigateur. Remarque : il est possible que cette autorisation ne soit pas appliquée par les navigateurs tiers ni par d\'autres applications permettant de naviguer sur le Web."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="6090259925187986937">"modifier l\'historique et les favoris Web"</string>
    <string name="permdesc_writeHistoryBookmarks" product="tablet" msgid="573341025292489065">"Permet à l\'application de modifier l\'historique du navigateur ou les favoris enregistrés sur votre tablette. Cette autorisation peut lui permettre d\'effacer ou de modifier les données du navigateur. Remarque : il est possible que cette autorisation ne soit pas appliquée par les navigateurs tiers ni par d\'autres applications permettant de naviguer sur le Web."</string>
    <string name="permdesc_writeHistoryBookmarks" product="tv" msgid="88642768580408561">"Permet à l\'application de modifier l\'historique du navigateur ou les favoris stockés sur votre appareil Android TV. Cette autorisation peut permettre à l\'application d\'effacer ou de modifier les données du navigateur. Remarque : cette autorisation n\'est pas toujours appliquée par les navigateurs tiers ou par les autres applications dotées de fonctionnalités de navigation Web."</string>
    <string name="permdesc_writeHistoryBookmarks" product="default" msgid="2245203087160913652">"Permet à l\'application de modifier l\'historique du navigateur ou les favoris enregistrés sur votre téléphone. Cette autorisation peut lui permettre d\'effacer ou de modifier les données du navigateur. Remarque : il est possible que cette autorisation ne soit pas appliquée par les navigateurs tiers ni par d\'autres applications permettant de naviguer sur le Web."</string>
    <string name="permlab_setAlarm" msgid="1158001610254173567">"définir une alarme"</string>
    <string name="permdesc_setAlarm" msgid="2185033720060109640">"Permet à l\'application de régler la sonnerie d\'un réveil installé. Cette fonctionnalité n\'est pas disponible sur tous les réveils."</string>
    <string name="permlab_addVoicemail" msgid="4770245808840814471">"ajouter un message vocal"</string>
    <string name="permdesc_addVoicemail" msgid="5470312139820074324">"Permet à l\'application d\'ajouter des messages à votre messagerie vocale."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="8605631647492879449">"modifier les autorisations de géolocalisation du navigateur"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="5817346421222227772">"Permet à l\'application de modifier les autorisations de géolocalisation du navigateur. Des applications malveillantes peuvent exploiter cette fonctionnalité pour permettre l\'envoi de données de localisation à des sites Web arbitraires."</string>
    <string name="save_password_message" msgid="2146409467245462965">"Voulez-vous que le navigateur se souvienne de ce mot de passe ?"</string>
    <string name="save_password_notnow" msgid="2878327088951240061">"Pas maintenant"</string>
    <string name="save_password_remember" msgid="6490888932657708341">"Mémoriser"</string>
    <string name="save_password_never" msgid="6776808375903410659">"Jamais"</string>
    <string name="open_permission_deny" msgid="5136793905306987251">"Vous n\'êtes pas autorisé à ouvrir cette page."</string>
    <string name="text_copied" msgid="2531420577879738860">"Le texte a été copié dans le presse-papier."</string>
    <string name="copied" msgid="4675902854553014676">"Copie effectuée"</string>
    <string name="more_item_label" msgid="7419249600215749115">"Plus"</string>
    <string name="prepend_shortcut_label" msgid="1743716737502867951">"Menu+"</string>
    <string name="menu_meta_shortcut_label" msgid="1623390163674762478">"Méta+"</string>
    <string name="menu_ctrl_shortcut_label" msgid="131911133027196485">"Ctrl+"</string>
    <string name="menu_alt_shortcut_label" msgid="343761069945250991">"Alt+"</string>
    <string name="menu_shift_shortcut_label" msgid="5443936876111232346">"Maj+"</string>
    <string name="menu_sym_shortcut_label" msgid="4037566049061218776">"Sym+"</string>
    <string name="menu_function_shortcut_label" msgid="2367112760987662566">"Fonction+"</string>
    <string name="menu_space_shortcut_label" msgid="5949311515646872071">"espace"</string>
    <string name="menu_enter_shortcut_label" msgid="6709499510082897320">"entrée"</string>
    <string name="menu_delete_shortcut_label" msgid="4365787714477739080">"supprimer"</string>
    <string name="search_go" msgid="2141477624421347086">"Rechercher"</string>
    <string name="search_hint" msgid="455364685740251925">"Rechercher…"</string>
    <string name="searchview_description_search" msgid="1045552007537359343">"Rechercher"</string>
    <string name="searchview_description_query" msgid="7430242366971716338">"Requête de recherche"</string>
    <string name="searchview_description_clear" msgid="1989371719192982900">"Effacer la requête"</string>
    <string name="searchview_description_submit" msgid="6771060386117334686">"Envoyer la requête"</string>
    <string name="searchview_description_voice" msgid="42360159504884679">"Recherche vocale"</string>
    <string name="enable_explore_by_touch_warning_title" msgid="5095399706284943314">"Activer \"Explorer au toucher\" ?"</string>
    <string name="enable_explore_by_touch_warning_message" product="tablet" msgid="1037295476738940824">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> souhaite activer la fonctionnalité \"Explorer au toucher\". Lorsque celle-ci est activée, vous pouvez entendre ou voir les descriptions des éléments que vous sélectionnez, ou bien interagir avec la tablette en effectuant certains gestes."</string>
    <string name="enable_explore_by_touch_warning_message" product="default" msgid="4312979647356179250">"<xliff:g id="ACCESSIBILITY_SERVICE_NAME">%1$s</xliff:g> souhaite activer la fonctionnalité \"Explorer au toucher\". Lorsque celle-ci est activée, vous pouvez entendre ou voir les descriptions des éléments que vous sélectionnez, ou bien interagir avec le téléphone en effectuant certains gestes."</string>
    <string name="oneMonthDurationPast" msgid="4538030857114635777">"Il y a 1 mois"</string>
    <string name="beforeOneMonthDurationPast" msgid="8315149541372065392">"Il y a plus d\'un mois"</string>
    <plurals name="last_num_days" formatted="false" msgid="687443109145393632">
      <item quantity="one">Le dernier jour (<xliff:g id="COUNT_1">%d</xliff:g>)</item>
      <item quantity="other">Les <xliff:g id="COUNT_1">%d</xliff:g> derniers jours</item>
    </plurals>
    <string name="last_month" msgid="1528906781083518683">"Le mois dernier"</string>
    <string name="older" msgid="1645159827884647400">"Préc."</string>
    <string name="preposition_for_date" msgid="2780767868832729599">"le <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="4336835286453822053">"à <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="3149809685340130039">"en <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8394717255950176156">"jour"</string>
    <string name="days" msgid="4570879797423034973">"jours"</string>
    <string name="hour" msgid="7796325297097314653">"heure"</string>
    <string name="hours" msgid="8517014849629200683">"heures"</string>
    <string name="minute" msgid="8369209540986467610">"min"</string>
    <string name="minutes" msgid="3456532942641808971">"min"</string>
    <string name="second" msgid="9210875257112211713">"s"</string>
    <string name="seconds" msgid="2175052687727971048">"s"</string>
    <string name="week" msgid="907127093960923779">"semaine"</string>
    <string name="weeks" msgid="3516247214269821391">"semaines"</string>
    <string name="year" msgid="5182610307741238982">"année"</string>
    <string name="years" msgid="5797714729103773425">"années"</string>
    <string name="now_string_shortest" msgid="3684914126941650330">"mainten."</string>
    <plurals name="duration_minutes_shortest" formatted="false" msgid="7519574894537185135">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> m</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> m</item>
    </plurals>
    <plurals name="duration_hours_shortest" formatted="false" msgid="2838655994500499651">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> h</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> h</item>
    </plurals>
    <plurals name="duration_days_shortest" formatted="false" msgid="3686058472983158496">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> j</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> j</item>
    </plurals>
    <plurals name="duration_years_shortest" formatted="false" msgid="8299112348723640338">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> a</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> a</item>
    </plurals>
    <plurals name="duration_minutes_shortest_future" formatted="false" msgid="849196137176399440">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> m</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> m</item>
    </plurals>
    <plurals name="duration_hours_shortest_future" formatted="false" msgid="5386373597343170388">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> h</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> h</item>
    </plurals>
    <plurals name="duration_days_shortest_future" formatted="false" msgid="814754627092787227">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> j</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> j</item>
    </plurals>
    <plurals name="duration_years_shortest_future" formatted="false" msgid="7683731800140202145">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> a</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> a</item>
    </plurals>
    <plurals name="duration_minutes_relative" formatted="false" msgid="6569851308583028344">
      <item quantity="one">il y a <xliff:g id="COUNT_1">%d</xliff:g> minute</item>
      <item quantity="other">il y a <xliff:g id="COUNT_1">%d</xliff:g> minutes</item>
    </plurals>
    <plurals name="duration_hours_relative" formatted="false" msgid="420434788589102019">
      <item quantity="one">il y a <xliff:g id="COUNT_1">%d</xliff:g> heure</item>
      <item quantity="other">il y a <xliff:g id="COUNT_1">%d</xliff:g> heures</item>
    </plurals>
    <plurals name="duration_days_relative" formatted="false" msgid="6056425878237482431">
      <item quantity="one">il y a <xliff:g id="COUNT_1">%d</xliff:g> jour</item>
      <item quantity="other">il y a <xliff:g id="COUNT_1">%d</xliff:g> jours</item>
    </plurals>
    <plurals name="duration_years_relative" formatted="false" msgid="2179998228861172159">
      <item quantity="one">il y a <xliff:g id="COUNT_1">%d</xliff:g> an</item>
      <item quantity="other">il y a <xliff:g id="COUNT_1">%d</xliff:g> ans</item>
    </plurals>
    <plurals name="duration_minutes_relative_future" formatted="false" msgid="5759885720917567723">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> minute</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> minutes</item>
    </plurals>
    <plurals name="duration_hours_relative_future" formatted="false" msgid="8963511608507707959">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> heure</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> heures</item>
    </plurals>
    <plurals name="duration_days_relative_future" formatted="false" msgid="1964709470979250702">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> jour</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> jours</item>
    </plurals>
    <plurals name="duration_years_relative_future" formatted="false" msgid="3985129025134896371">
      <item quantity="one">dans <xliff:g id="COUNT_1">%d</xliff:g> an</item>
      <item quantity="other">dans <xliff:g id="COUNT_1">%d</xliff:g> ans</item>
    </plurals>
    <string name="VideoView_error_title" msgid="5750686717225068016">"Problème vidéo"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="3782449246085134720">"Impossible de lire cette vidéo en streaming sur cet appareil."</string>
    <string name="VideoView_error_text_unknown" msgid="7658683339707607138">"Impossible de lire la vidéo."</string>
    <string name="VideoView_error_button" msgid="5138809446603764272">"OK"</string>
    <string name="relative_time" msgid="8572030016028033243">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="8365974533050605886">"midi"</string>
    <string name="Noon" msgid="6902418443846838189">"Midi"</string>
    <string name="midnight" msgid="3646671134282785114">"minuit"</string>
    <string name="Midnight" msgid="8176019203622191377">"Minuit"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="8689459651807876423">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="2302144714803345056">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="1532369154488982046">"Tout sélectionner"</string>
    <string name="cut" msgid="2561199725874745819">"Couper"</string>
    <string name="copy" msgid="5472512047143665218">"Copier"</string>
    <string name="failed_to_copy_to_clipboard" msgid="725919885138539875">"Échec de la copie dans le presse-papiers"</string>
    <string name="paste" msgid="461843306215520225">"Coller"</string>
    <string name="paste_as_plain_text" msgid="7664800665823182587">"Coller au format texte brut"</string>
    <string name="replace" msgid="7842675434546657444">"Remplacer..."</string>
    <string name="delete" msgid="1514113991712129054">"Supprimer"</string>
    <string name="copyUrl" msgid="6229645005987260230">"Copier l\'URL"</string>
    <string name="selectTextMode" msgid="3225108910999318778">"Sélectionner texte"</string>
    <string name="undo" msgid="3175318090002654673">"Annuler"</string>
    <string name="redo" msgid="7231448494008532233">"Rétablir"</string>
    <string name="autofill" msgid="511224882647795296">"Saisie automatique"</string>
    <string name="textSelectionCABTitle" msgid="5151441579532476940">"Sélection de texte"</string>
    <string name="addToDictionary" msgid="8041821113480950096">"Ajouter au dictionnaire"</string>
    <string name="deleteText" msgid="4200807474529938112">"Supprimer"</string>
    <string name="inputMethod" msgid="1784759500516314751">"Mode de saisie"</string>
    <string name="editTextMenuTitle" msgid="857666911134482176">"Actions sur le texte"</string>
    <string name="low_internal_storage_view_title" msgid="9024241779284783414">"Espace de stockage bientôt saturé"</string>
    <string name="low_internal_storage_view_text" msgid="8172166728369697835">"Il est possible que certaines fonctionnalités du système ne soient pas opérationnelles."</string>
    <string name="low_internal_storage_view_text_no_boot" msgid="7368968163411251788">"Espace de stockage insuffisant pour le système. Assurez-vous de disposer de 250 Mo d\'espace libre, puis redémarrez."</string>
    <string name="app_running_notification_title" msgid="8985999749231486569">"<xliff:g id="APP_NAME">%1$s</xliff:g> en cours d\'exécution"</string>
    <string name="app_running_notification_text" msgid="5120815883400228566">"Appuyez ici pour en savoir plus ou pour arrêter l\'application."</string>
    <string name="ok" msgid="2646370155170753815">"OK"</string>
    <string name="cancel" msgid="6908697720451760115">"Annuler"</string>
    <string name="yes" msgid="9069828999585032361">"OK"</string>
    <string name="no" msgid="5122037903299899715">"Annuler"</string>
    <string name="dialog_alert_title" msgid="651856561974090712">"Attention"</string>
    <string name="loading" msgid="3138021523725055037">"Chargement…"</string>
    <string name="capital_on" msgid="2770685323900821829">"OUI"</string>
    <string name="capital_off" msgid="7443704171014626777">"NON"</string>
    <string name="checked" msgid="9179896827054513119">"activé"</string>
    <string name="not_checked" msgid="7972320087569023342">"désactivé"</string>
    <string name="whichApplication" msgid="5432266899591255759">"Continuer avec"</string>
    <string name="whichApplicationNamed" msgid="6969946041713975681">"Terminer l\'action avec %1$s"</string>
    <string name="whichApplicationLabel" msgid="7852182961472531728">"Terminer l\'action"</string>
    <string name="whichViewApplication" msgid="5733194231473132945">"Ouvrir avec"</string>
    <string name="whichViewApplicationNamed" msgid="415164730629690105">"Ouvrir avec %1$s"</string>
    <string name="whichViewApplicationLabel" msgid="7367556735684742409">"Ouvrir"</string>
    <string name="whichOpenHostLinksWith" msgid="7645631470199397485">"Ouvrir les liens <xliff:g id="HOST">%1$s</xliff:g> avec"</string>
    <string name="whichOpenLinksWith" msgid="1120936181362907258">"Ouvrir les liens avec"</string>
    <string name="whichOpenLinksWithApp" msgid="6917864367861910086">"Ouvrir les liens avec <xliff:g id="APPLICATION">%1$s</xliff:g>"</string>
    <string name="whichOpenHostLinksWithApp" msgid="2401668560768463004">"Ouvrir les liens <xliff:g id="HOST">%1$s</xliff:g> avec <xliff:g id="APPLICATION">%2$s</xliff:g>"</string>
    <string name="whichGiveAccessToApplicationLabel" msgid="7805857277166106236">"Accorder l\'accès"</string>
    <string name="whichEditApplication" msgid="6191568491456092812">"Modifier avec"</string>
    <string name="whichEditApplicationNamed" msgid="8096494987978521514">"Modifier avec %1$s"</string>
    <string name="whichEditApplicationLabel" msgid="1463288652070140285">"Modifier"</string>
    <string name="whichSendApplication" msgid="4143847974460792029">"Partager"</string>
    <string name="whichSendApplicationNamed" msgid="4470386782693183461">"Partager avec %1$s"</string>
    <string name="whichSendApplicationLabel" msgid="7467813004769188515">"Partager"</string>
    <string name="whichSendToApplication" msgid="77101541959464018">"Envoyer avec"</string>
    <string name="whichSendToApplicationNamed" msgid="3385686512014670003">"Envoyer avec %1$s"</string>
    <string name="whichSendToApplicationLabel" msgid="3543240188816513303">"Envoyer"</string>
    <string name="whichHomeApplication" msgid="8276350727038396616">"Sélectionner une application de l\'écran d\'accueil"</string>
    <string name="whichHomeApplicationNamed" msgid="5855990024847433794">"Utiliser %1$s comme écran d\'accueil"</string>
    <string name="whichHomeApplicationLabel" msgid="8907334282202933959">"Capturer une image"</string>
    <string name="whichImageCaptureApplication" msgid="2737413019463215284">"Capturer une image avec"</string>
    <string name="whichImageCaptureApplicationNamed" msgid="8820702441847612202">"Capturer une image avec %1$s"</string>
    <string name="whichImageCaptureApplicationLabel" msgid="6505433734824988277">"Capturer une image"</string>
    <string name="alwaysUse" msgid="3153558199076112903">"Utiliser cette application par défaut pour cette action"</string>
    <string name="use_a_different_app" msgid="4987790276170972776">"Utiliser une autre application"</string>
    <string name="clearDefaultHintMsg" msgid="1325866337702524936">"Pour supprimer les valeurs par défaut, accédez à Paramètres système &gt; Applications &gt; Téléchargements."</string>
    <string name="chooseActivity" msgid="8563390197659779956">"Sélectionnez une action"</string>
    <string name="chooseUsbActivity" msgid="2096269989990986612">"Sélectionnez une application pour le périphérique de stockage USB"</string>
    <string name="noApplications" msgid="1186909265235544019">"Aucune application ne peut effectuer cette action."</string>
    <string name="aerr_application" msgid="4090916809370389109">"<xliff:g id="APPLICATION">%1$s</xliff:g> a cessé de fonctionner."</string>
    <string name="aerr_process" msgid="4268018696970966407">"Le processus <xliff:g id="PROCESS">%1$s</xliff:g> a cessé de fonctionner."</string>
    <string name="aerr_application_repeated" msgid="7804378743218496566">"<xliff:g id="APPLICATION">%1$s</xliff:g> s\'arrête systématiquement"</string>
    <string name="aerr_process_repeated" msgid="1153152413537954974">"Le processus \"<xliff:g id="PROCESS">%1$s</xliff:g>\" ne cesse de s\'arrêter."</string>
    <string name="aerr_restart" msgid="2789618625210505419">"Rouvrir l\'application"</string>
    <string name="aerr_report" msgid="3095644466849299308">"Envoyer des commentaires"</string>
    <string name="aerr_close" msgid="3398336821267021852">"Fermer"</string>
    <string name="aerr_mute" msgid="2304972923480211376">"Ignorer jusqu\'au redémarrage de l\'appareil"</string>
    <string name="aerr_wait" msgid="3198677780474548217">"Attendre"</string>
    <string name="aerr_close_app" msgid="8318883106083050970">"Fermer l\'application"</string>
    <string name="anr_title" msgid="7290329487067300120"></string>
    <string name="anr_activity_application" msgid="8121716632960340680">"<xliff:g id="APPLICATION">%2$s</xliff:g> ne répond pas."</string>
    <string name="anr_activity_process" msgid="3477362583767128667">"L\'activité \"<xliff:g id="ACTIVITY">%1$s</xliff:g>\" ne répond pas."</string>
    <string name="anr_application_process" msgid="4978772139461676184">"<xliff:g id="APPLICATION">%1$s</xliff:g> ne répond pas."</string>
    <string name="anr_process" msgid="1664277165911816067">"Le processus \"<xliff:g id="PROCESS">%1$s</xliff:g>\" ne répond pas."</string>
    <string name="force_close" msgid="9035203496368973803">"OK"</string>
    <string name="report" msgid="2149194372340349521">"Rapport"</string>
    <string name="wait" msgid="7765985809494033348">"Attendre"</string>
    <string name="webpage_unresponsive" msgid="7850879412195273433">"La page ne répond pas.\n \nVoulez-vous quitter ?"</string>
    <string name="launch_warning_title" msgid="6725456009564953595">"Application redirigée"</string>
    <string name="launch_warning_replace" msgid="3073392976283203402">"<xliff:g id="APP_NAME">%1$s</xliff:g> est maintenant lancée."</string>
    <string name="launch_warning_original" msgid="3332206576800169626">"Application lancée initialement : <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="screen_compat_mode_scale" msgid="8627359598437527726">"Mise à l\'échelle"</string>
    <string name="screen_compat_mode_show" msgid="5080361367584709857">"Toujours afficher"</string>
    <string name="screen_compat_mode_hint" msgid="4032272159093750908">"Réactivez ce mode en accédant à Paramètres système &gt; Applications &gt; Téléchargements"</string>
    <string name="unsupported_display_size_message" msgid="7265211375269394699">"<xliff:g id="APP_NAME">%1$s</xliff:g> n\'est pas compatible avec le paramètre de taille d\'affichage actuel et peut présenter un comportement inattendu."</string>
    <string name="unsupported_display_size_show" msgid="980129850974919375">"Toujours afficher"</string>
    <string name="unsupported_compile_sdk_message" msgid="7326293500707890537">"L\'application <xliff:g id="APP_NAME">%1$s</xliff:g> a été conçue pour une version incompatible du système Android et peut présenter un comportement inattendu. Il est possible qu\'une version mise à jour de l\'application soit disponible."</string>
    <string name="unsupported_compile_sdk_show" msgid="1601210057960312248">"Toujours afficher"</string>
    <string name="unsupported_compile_sdk_check_update" msgid="1103639989147664456">"Rechercher les mises à jour"</string>
    <string name="smv_application" msgid="3775183542777792638">"L\'application <xliff:g id="APPLICATION">%1$s</xliff:g> (du processus <xliff:g id="PROCESS">%2$s</xliff:g>) a enfreint ses propres règles du mode strict."</string>
    <string name="smv_process" msgid="1398801497130695446">"Le processus <xliff:g id="PROCESS">%1$s</xliff:g> a enfreint ses propres règles du mode strict."</string>
    <string name="android_upgrading_title" product="default" msgid="7279077384220829683">"Mise à jour du téléphone…"</string>
    <string name="android_upgrading_title" product="tablet" msgid="4268417249079938805">"Mise à jour de la tablette…"</string>
    <string name="android_upgrading_title" product="device" msgid="6774767702998149762">"Mise à jour de l\'appareil…"</string>
    <string name="android_start_title" product="default" msgid="4036708252778757652">"Démarrage du téléphone…"</string>
    <string name="android_start_title" product="automotive" msgid="7917984412828168079">"Démarrage d\'Android en cours"</string>
    <string name="android_start_title" product="tablet" msgid="4429767260263190344">"Démarrage de la tablette…"</string>
    <string name="android_start_title" product="device" msgid="6967413819673299309">"Démarrage de l\'appareil…"</string>
    <string name="android_upgrading_fstrim" msgid="3259087575528515329">"Optimisation du stockage en cours…"</string>
    <string name="android_upgrading_notification_title" product="default" msgid="3509927005342279257">"Finalisation de la mise à jour du système…"</string>
    <string name="app_upgrading_toast" msgid="1016267296049455585">"Mise à jour de l\'application <xliff:g id="APPLICATION">%1$s</xliff:g>…"</string>
    <string name="android_upgrading_apk" msgid="1339564803894466737">"Optimisation de l\'application <xliff:g id="NUMBER_0">%1$d</xliff:g> sur <xliff:g id="NUMBER_1">%2$d</xliff:g>…"</string>
    <string name="android_preparing_apk" msgid="589736917792300956">"Préparation de <xliff:g id="APPNAME">%1$s</xliff:g> en cours…"</string>
    <string name="android_upgrading_starting_apps" msgid="6206161195076057075">"Lancement des applications…"</string>
    <string name="android_upgrading_complete" msgid="409800058018374746">"Finalisation de la mise à jour."</string>
    <string name="heavy_weight_notification" msgid="8382784283600329576">"<xliff:g id="APP">%1$s</xliff:g> en cours d\'exécution"</string>
    <string name="heavy_weight_notification_detail" msgid="6802247239468404078">"Appuyez pour revenir au jeu"</string>
    <string name="heavy_weight_switcher_title" msgid="3861984210040100886">"Choisir un jeu"</string>
    <string name="heavy_weight_switcher_text" msgid="6814316627367160126">"Pour des performances optimales, un seul de ces jeux peut être ouvert à la fois."</string>
    <string name="old_app_action" msgid="725331621042848590">"Revenir à <xliff:g id="OLD_APP">%1$s</xliff:g>"</string>
    <string name="new_app_action" msgid="547772182913269801">"Ouvrir <xliff:g id="NEW_APP">%1$s</xliff:g>"</string>
    <string name="new_app_description" msgid="1958903080400806644">"<xliff:g id="OLD_APP">%1$s</xliff:g> va se fermer sans enregistrer les données"</string>
    <string name="dump_heap_notification" msgid="5316644945404825032">"Le processus \"<xliff:g id="PROC">%1$s</xliff:g>\" a dépassé la limite de mémoire"</string>
    <string name="dump_heap_ready_notification" msgid="2302452262927390268">"Empreinte de la mémoire du processus \"<xliff:g id="PROC">%1$s</xliff:g>\" prête"</string>
    <string name="dump_heap_notification_detail" msgid="8431586843001054050">"Une empreinte de la mémoire a bien été générée. Appuyez pour partager."</string>
    <string name="dump_heap_title" msgid="4367128917229233901">"Partager l\'empreinte de la mémoire ?"</string>
    <string name="dump_heap_text" msgid="1692649033835719336">"Le processus \"<xliff:g id="PROC">%1$s</xliff:g>\" a dépassé sa limite de mémoire fixée à <xliff:g id="SIZE">%2$s</xliff:g>. Une empreinte de la mémoire est disponible pour que vous la communiquiez à son développeur. Attention : celle-ci peut contenir des informations personnelles auxquelles l\'application a accès."</string>
    <string name="dump_heap_system_text" msgid="6805155514925350849">"Le processus \"<xliff:g id="PROC">%1$s</xliff:g>\" a dépassé sa limite de mémoire fixée à <xliff:g id="SIZE">%2$s</xliff:g>. Une empreinte de la mémoire est disponible pour que vous la communiquiez à qui de droit. Attention : Celle-ci peut contenir des informations personnelles sensibles auxquelles le processus a accès, y compris des informations que vous avez saisies."</string>
    <string name="dump_heap_ready_text" msgid="5849618132123045516">"Une empreinte de la mémoire du processus \"<xliff:g id="PROC">%1$s</xliff:g>\" est disponible et peut être partagée. Attention : Celle-ci peut contenir des informations personnelles sensibles auxquelles le processus a accès, y compris des informations que vous avez saisies."</string>
    <string name="sendText" msgid="493003724401350724">"Sélectionner une action pour le texte"</string>
    <string name="volume_ringtone" msgid="134784084629229029">"Volume de la sonnerie"</string>
    <string name="volume_music" msgid="7727274216734955095">"Volume"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="2614142915948898228">"Lecture via le Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="1514829655029062233">"Sonnerie silencieuse sélectionnée"</string>
    <string name="volume_call" msgid="7625321655265747433">"Volume des appels entrants"</string>
    <string name="volume_bluetooth_call" msgid="2930204618610115061">"Volume d\'appels entrants sur le Bluetooth"</string>
    <string name="volume_alarm" msgid="4486241060751798448">"Volume"</string>
    <string name="volume_notification" msgid="6864412249031660057">"Volume des notifications"</string>
    <string name="volume_unknown" msgid="4041914008166576293">"Volume"</string>
    <string name="volume_icon_description_bluetooth" msgid="7540388479345558400">"Volume Bluetooth"</string>
    <string name="volume_icon_description_ringer" msgid="2187800636867423459">"Volume de la sonnerie"</string>
    <string name="volume_icon_description_incall" msgid="4491255105381227919">"Volume d\'appel"</string>
    <string name="volume_icon_description_media" msgid="4997633254078171233">"Volume"</string>
    <string name="volume_icon_description_notification" msgid="579091344110747279">"Volume des notifications"</string>
    <string name="ringtone_default" msgid="9118299121288174597">"Sonnerie par défaut"</string>
    <string name="ringtone_default_with_actual" msgid="2709686194556159773">"Sonnerie par défaut (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="397111123930141876">"Aucun(e)"</string>
    <string name="ringtone_picker_title" msgid="667342618626068253">"Sonneries"</string>
    <string name="ringtone_picker_title_alarm" msgid="7438934548339024767">"Sons de l\'alarme"</string>
    <string name="ringtone_picker_title_notification" msgid="6387191794719608122">"Sons de notification"</string>
    <string name="ringtone_unknown" msgid="5059495249862816475">"Inconnue"</string>
    <string name="wifi_available_sign_in" msgid="381054692557675237">"Connectez-vous au réseau Wi-Fi"</string>
    <string name="network_available_sign_in" msgid="1520342291829283114">"Se connecter au réseau"</string>
    <!-- no translation found for network_available_sign_in_detailed (7520423801613396556) -->
    <skip />
    <string name="wifi_no_internet" msgid="1386911698276448061">"Aucune connexion à Internet pour <xliff:g id="NETWORK_SSID">%1$s</xliff:g>"</string>
    <string name="wifi_no_internet_detailed" msgid="634938444133558942">"Appuyez ici pour afficher des options."</string>
    <string name="mobile_no_internet" msgid="4014455157529909781">"Le réseau mobile ne dispose d\'aucun accès à Internet"</string>
    <string name="other_networks_no_internet" msgid="6698711684200067033">"Le réseau ne dispose d\'aucun accès à Internet"</string>
    <string name="private_dns_broken_detailed" msgid="3709388271074611847">"Impossible d\'accéder au serveur DNS privé"</string>
    <string name="network_partial_connectivity" msgid="4791024923851432291">"La connectivité de <xliff:g id="NETWORK_SSID">%1$s</xliff:g> est limitée"</string>
    <string name="network_partial_connectivity_detailed" msgid="5741329444564575840">"Appuyer pour se connecter quand même"</string>
    <string name="network_switch_metered" msgid="1531869544142283384">"Nouveau réseau : <xliff:g id="NETWORK_TYPE">%1$s</xliff:g>"</string>
    <string name="network_switch_metered_detail" msgid="1358296010128405906">"L\'appareil utilise <xliff:g id="NEW_NETWORK">%1$s</xliff:g> lorsque <xliff:g id="PREVIOUS_NETWORK">%2$s</xliff:g> n\'a pas de connexion Internet. Des frais peuvent s\'appliquer."</string>
    <string name="network_switch_metered_toast" msgid="501662047275723743">"Ancien réseau : <xliff:g id="PREVIOUS_NETWORK">%1$s</xliff:g>. Nouveau réseau : <xliff:g id="NEW_NETWORK">%2$s</xliff:g>"</string>
  <string-array name="network_switch_type_name">
    <item msgid="2255670471736226365">"données mobiles"</item>
    <item msgid="5520925862115353992">"Wi-Fi"</item>
    <item msgid="1055487873974272842">"Bluetooth"</item>
    <item msgid="1616528372438698248">"Ethernet"</item>
    <item msgid="9177085807664964627">"VPN"</item>
  </string-array>
    <string name="network_switch_type_name_unknown" msgid="3665696841646851068">"type de réseau inconnu"</string>
    <string name="accept" msgid="5447154347815825107">"Accepter"</string>
    <string name="decline" msgid="6490507610282145874">"Refuser"</string>
    <string name="select_character" msgid="3352797107930786979">"Insérer un caractère"</string>
    <string name="sms_control_title" msgid="4748684259903148341">"Envoi de messages SMS"</string>
    <string name="sms_control_message" msgid="6574313876316388239">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; envoie un grand nombre de SMS. Autorisez-vous cette application à poursuivre l\'envoi des messages ?"</string>
    <string name="sms_control_yes" msgid="4858845109269524622">"Autoriser"</string>
    <string name="sms_control_no" msgid="4845717880040355570">"Refuser"</string>
    <string name="sms_short_code_confirm_message" msgid="1385416688897538724">"&lt;b&gt;<xliff:g id="APP_NAME">%1$s</xliff:g>&lt;/b&gt; souhaite envoyer un message à &lt;b&gt;<xliff:g id="DEST_ADDRESS">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="sms_short_code_details" msgid="2723725738333388351">"Ceci "<b>"peut entraîner des frais"</b>" sur votre compte de téléphonie mobile."</string>
    <string name="sms_premium_short_code_details" msgid="1400296309866638111"><b>"Ceci entraînera des frais sur votre compte de téléphonie mobile."</b></string>
    <string name="sms_short_code_confirm_allow" msgid="920477594325526691">"Envoyer"</string>
    <string name="sms_short_code_confirm_deny" msgid="1356917469323768230">"Annuler"</string>
    <string name="sms_short_code_remember_choice" msgid="1374526438647744862">"Mémoriser mon choix"</string>
    <string name="sms_short_code_remember_undo_instruction" msgid="2620984439143080410">"Pour modifier : Paramètres &gt; Applications"</string>
    <string name="sms_short_code_confirm_always_allow" msgid="2223014893129755950">"Toujours autoriser"</string>
    <string name="sms_short_code_confirm_never_allow" msgid="2688828813521652079">"Ne jamais autoriser"</string>
    <string name="sim_removed_title" msgid="5387212933992546283">"Carte SIM retirée"</string>
    <string name="sim_removed_message" msgid="9051174064474904617">"Le réseau mobile ne sera pas disponible avant le redémarrage avec une carte SIM valide insérée."</string>
    <string name="sim_done_button" msgid="6464250841528410598">"OK"</string>
    <string name="sim_added_title" msgid="7930779986759414595">"Carte SIM ajoutée."</string>
    <string name="sim_added_message" msgid="6602906609509958680">"Redémarrez votre appareil pour accéder au réseau mobile."</string>
    <string name="sim_restart_button" msgid="8481803851341190038">"Redémarrer"</string>
    <string name="install_carrier_app_notification_title" msgid="5712723402213090102">"Activer le service de données mobiles"</string>
    <string name="install_carrier_app_notification_text" msgid="2781317581274192728">"Téléchargez l\'application de l\'opérateur pour activer votre nouvelle carte SIM"</string>
    <string name="install_carrier_app_notification_text_app_name" msgid="4086877327264106484">"Téléchargez l\'application <xliff:g id="APP_NAME">%1$s</xliff:g> pour activer votre nouvelle carte SIM"</string>
    <string name="install_carrier_app_notification_button" msgid="6257740533102594290">"Télécharger l\'application"</string>
    <string name="carrier_app_notification_title" msgid="5815477368072060250">"Nouvelle carte SIM insérée"</string>
    <string name="carrier_app_notification_text" msgid="6567057546341958637">"Appuyez ici pour effectuer la configuration."</string>
    <string name="time_picker_dialog_title" msgid="9053376764985220821">"Définir l\'heure"</string>
    <string name="date_picker_dialog_title" msgid="5030520449243071926">"Définir la date"</string>
    <string name="date_time_set" msgid="4603445265164486816">"Définir"</string>
    <string name="date_time_done" msgid="8363155889402873463">"OK"</string>
    <string name="perms_new_perm_prefix" msgid="6984556020395757087"><font size="12" fgcolor="#ff33b5e5">"NOUVEAU"</font>" :"</string>
    <string name="perms_description_app" msgid="2747752389870161996">"Fourni par <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_permissions" msgid="5729199278862516390">"Aucune autorisation requise"</string>
    <string name="perm_costs_money" msgid="749054595022779685">"Cela peut engendrer des frais"</string>
    <string name="dlg_ok" msgid="5103447663504839312">"OK"</string>
    <string name="usb_charging_notification_title" msgid="1674124518282666955">"Appareil en charge via USB"</string>
    <string name="usb_supplying_notification_title" msgid="5378546632408101811">"Recharge via USB de l\'appareil connecté"</string>
    <string name="usb_mtp_notification_title" msgid="1065989144124499810">"Transfert de fichiers via USB activé"</string>
    <string name="usb_ptp_notification_title" msgid="5043437571863443281">"PTP via USB activé"</string>
    <string name="usb_tether_notification_title" msgid="8828527870612663771">"Partage de connexion via USB activé"</string>
    <string name="usb_midi_notification_title" msgid="7404506788950595557">"MIDI via USB activé"</string>
    <string name="usb_accessory_notification_title" msgid="1385394660861956980">"Accessoire USB connecté"</string>
    <string name="usb_notification_message" msgid="4715163067192110676">"Appuyez ici pour plus d\'options."</string>
    <string name="usb_power_notification_message" msgid="7284765627437897702">"Recharge de l\'appareil connecté. Appuyez ici pour plus d\'options."</string>
    <string name="usb_unsupported_audio_accessory_title" msgid="2335775548086533065">"Accessoire audio analogique détecté"</string>
    <string name="usb_unsupported_audio_accessory_message" msgid="1300168007129796621">"L\'appareil connecté n\'est pas compatible avec ce téléphone. Appuyez ici pour en savoir plus."</string>
    <string name="adb_active_notification_title" msgid="408390247354560331">"Débogage USB activé"</string>
    <string name="adb_active_notification_message" msgid="5617264033476778211">"Appuyez pour désactiver le débogage USB"</string>
    <string name="adb_active_notification_message" product="tv" msgid="6624498401272780855">"Sélectionnez cette option pour désactiver le débogage USB."</string>
    <string name="adbwifi_active_notification_title" msgid="6147343659168302473">"Débogage sans fil connecté"</string>
    <string name="adbwifi_active_notification_message" msgid="930987922852867972">"Appuyez pour désactiver le débogage sans fil"</string>
    <string name="adbwifi_active_notification_message" product="tv" msgid="8633421848366915478">"Sélectionnez cette option pour désactiver le débogage sans fil."</string>
    <string name="test_harness_mode_notification_title" msgid="2282785860014142511">"Mode Atelier de test activé"</string>
    <string name="test_harness_mode_notification_message" msgid="3039123743127958420">"Rétablissez la configuration d\'usine pour désactiver le mode Atelier de test."</string>
    <string name="console_running_notification_title" msgid="6087888939261635904">"Console série activée"</string>
    <string name="console_running_notification_message" msgid="7892751888125174039">"Les performances sont affectées. Pour désactiver la console série, vérifiez le bootloader."</string>
    <string name="usb_contaminant_detected_title" msgid="4359048603069159678">"Présence de liquide ou de saletés dans le port USB"</string>
    <string name="usb_contaminant_detected_message" msgid="7346100585390795743">"Le port USB est désactivé automatiquement. Appuyez sur cette notification pour en savoir plus."</string>
    <string name="usb_contaminant_not_detected_title" msgid="2651167729563264053">"Le port USB peut être utilisé"</string>
    <string name="usb_contaminant_not_detected_message" msgid="892863190942660462">"Aucun liquide ni corps étranger à signaler"</string>
    <string name="taking_remote_bugreport_notification_title" msgid="1582531382166919850">"Création du rapport de bug…"</string>
    <string name="share_remote_bugreport_notification_title" msgid="6708897723753334999">"Partager le rapport de bug ?"</string>
    <string name="sharing_remote_bugreport_notification_title" msgid="3077385149217638550">"Partage du rapport de bug…"</string>
    <string name="share_remote_bugreport_notification_message_finished" msgid="7325635795739260135">"Votre administrateur a demandé un rapport de bug pour l\'aider à résoudre le problème lié à cet appareil. Il est possible que des applications et des données soient partagées."</string>
    <string name="share_remote_bugreport_action" msgid="7630880678785123682">"PARTAGER"</string>
    <string name="decline_remote_bugreport_action" msgid="4040894777519784346">"REFUSER"</string>
    <string name="select_input_method" msgid="3971267998568587025">"Sélectionnez le mode de saisie"</string>
    <string name="show_ime" msgid="6406112007347443383">"Afficher le clavier virtuel même lorsque le clavier physique est actif"</string>
    <string name="hardware" msgid="1800597768237606953">"Afficher le clavier virtuel"</string>
    <string name="select_keyboard_layout_notification_title" msgid="4427643867639774118">"Configurer le clavier physique"</string>
    <string name="select_keyboard_layout_notification_message" msgid="8835158247369158154">"Appuyer pour sélectionner la langue et la disposition"</string>
    <string name="fast_scroll_alphabet" msgid="8854435958703888376">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="2529539945421557329">" 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
    <string name="alert_windows_notification_channel_group_name" msgid="6063891141815714246">"Afficher par-dessus les autres applications"</string>
    <string name="alert_windows_notification_channel_name" msgid="3437528564303192620">"<xliff:g id="NAME">%s</xliff:g> est affichée sur les autres applications"</string>
    <string name="alert_windows_notification_title" msgid="6331662751095228536">"<xliff:g id="NAME">%s</xliff:g> se superpose aux autres applis"</string>
    <string name="alert_windows_notification_message" msgid="6538171456970725333">"Si vous ne voulez pas que l\'application <xliff:g id="NAME">%s</xliff:g> utilise cette fonctionnalité, appuyez ici pour ouvrir les paramètres et la désactiver."</string>
    <string name="alert_windows_notification_turn_off_action" msgid="7805857234839123780">"Désactiver"</string>
    <string name="ext_media_checking_notification_title" msgid="8299199995416510094">"Vérification de \"<xliff:g id="NAME">%s</xliff:g>\"…"</string>
    <string name="ext_media_checking_notification_message" msgid="2231566971425375542">"Vérification du contenu actuel"</string>
    <string name="ext_media_new_notification_title" msgid="3517407571407687677">"Nouveau périphérique : <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_new_notification_message" msgid="6095403121990786986">"Appuyer pour configurer"</string>
    <string name="ext_media_new_notification_message" product="automotive" msgid="8488046026389025694"></string>
    <string name="ext_media_ready_notification_message" msgid="777258143284919261">"Pour transférer photos et fichiers"</string>
    <string name="ext_media_unmountable_notification_title" msgid="4895444667278979910">"Problème avec : <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_unmountable_notification_message" msgid="3256290114063126205">"Appuyez sur la notification pour résoudre le problème"</string>
    <string name="ext_media_unmountable_notification_message" product="tv" msgid="3003611129979934633">"La <xliff:g id="NAME">%s</xliff:g> est corrompue. Sélectionnez cette option pour résoudre le problème."</string>
    <string name="ext_media_unmountable_notification_message" product="automotive" msgid="5622514265490819212"></string>
    <string name="ext_media_unsupported_notification_title" msgid="4358280700537030333">"<xliff:g id="NAME">%s</xliff:g> non compatible"</string>
    <string name="ext_media_unsupported_notification_message" msgid="917738524888367560">"Cet appareil n\'est pas compatible avec le support \"<xliff:g id="NAME">%s</xliff:g>\". Appuyez ici pour le configurer dans un format accepté."</string>
    <string name="ext_media_unsupported_notification_message" product="tv" msgid="7744945987775645685">"Cet appareil n\'est pas compatible avec cette <xliff:g id="NAME">%s</xliff:g>. Sélectionnez cette option pour la configurer dans un format accepté."</string>
    <string name="ext_media_unsupported_notification_message" product="automotive" msgid="7657357085538772913">"Cet appareil n\'est pas compatible avec le support \"<xliff:g id="NAME">%s</xliff:g>\"."</string>
    <string name="ext_media_badremoval_notification_title" msgid="4114625551266196872">"Retrait inattendu de mémoire \"<xliff:g id="NAME">%s</xliff:g>\""</string>
    <string name="ext_media_badremoval_notification_message" msgid="1986514704499809244">"Éjectez le périphérique externe avant de le retirer pour éviter toute perte de contenu"</string>
    <string name="ext_media_nomedia_notification_title" msgid="742671636376975890">"<xliff:g id="NAME">%s</xliff:g> supprimé"</string>
    <string name="ext_media_nomedia_notification_message" msgid="2832724384636625852">"Certaines fonctionnalités risquent de ne pas s\'exécuter correctement. Insérez un nouveau périphérique de stockage externe."</string>
    <string name="ext_media_unmounting_notification_title" msgid="4147986383917892162">"Éjection de \"<xliff:g id="NAME">%s</xliff:g>\""</string>
    <string name="ext_media_unmounting_notification_message" msgid="5717036261538754203">"Ne retirez pas le périphérique"</string>
    <string name="ext_media_init_action" msgid="2312974060585056709">"Configurer"</string>
    <string name="ext_media_unmount_action" msgid="966992232088442745">"Éjecter"</string>
    <string name="ext_media_browse_action" msgid="344865351947079139">"Parcourir"</string>
    <string name="ext_media_seamless_action" msgid="8837030226009268080">"Changer de sortie"</string>
    <string name="ext_media_missing_title" msgid="3209472091220515046">"Mémoire de stockage \"<xliff:g id="NAME">%s</xliff:g>\" manquante"</string>
    <string name="ext_media_missing_message" msgid="4408988706227922909">"Insérez le périphérique"</string>
    <string name="ext_media_move_specific_title" msgid="8492118544775964250">"Transfert de l\'application <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_title" msgid="2682741525619033637">"Déplacement des données en cours"</string>
    <string name="ext_media_move_success_title" msgid="4901763082647316767">"Le contenu a bien été déplacé"</string>
    <string name="ext_media_move_success_message" msgid="9159542002276982979">"Contenu déplacé vers : <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="ext_media_move_failure_title" msgid="3184577479181333665">"Impossible de déplacer le contenu"</string>
    <string name="ext_media_move_failure_message" msgid="4197306718121869335">"Nouvelle tentative de déplacement du contenu"</string>
    <string name="ext_media_status_removed" msgid="241223931135751691">"Supprimé"</string>
    <string name="ext_media_status_unmounted" msgid="8145812017295835941">"Éjecté"</string>
    <string name="ext_media_status_checking" msgid="159013362442090347">"Vérification en cours…"</string>
    <string name="ext_media_status_mounted" msgid="3459448555811203459">"Prêt"</string>
    <string name="ext_media_status_mounted_ro" msgid="1974809199760086956">"Lecture seule"</string>
    <string name="ext_media_status_bad_removal" msgid="508448566481406245">"Retrait risqué"</string>
    <string name="ext_media_status_unmountable" msgid="7043574843541087748">"Corrompu"</string>
    <string name="ext_media_status_unsupported" msgid="5460509911660539317">"Non compatible"</string>
    <string name="ext_media_status_ejecting" msgid="7532403368044013797">"Éjection en cours…"</string>
    <string name="ext_media_status_formatting" msgid="774148701503179906">"Formatage en cours…"</string>
    <string name="ext_media_status_missing" msgid="6520746443048867314">"Non inséré"</string>
    <string name="activity_list_empty" msgid="4219430010716034252">"Aucune activité correspondante trouvée."</string>
    <string name="permlab_route_media_output" msgid="8048124531439513118">"diriger la sortie multimédia"</string>
    <string name="permdesc_route_media_output" msgid="1759683269387729675">"Permet à une application de diriger la sortie multimédia vers d\'autres appareils externes."</string>
    <string name="permlab_readInstallSessions" msgid="7279049337895583621">"accéder aux sessions d\'installation"</string>
    <string name="permdesc_readInstallSessions" msgid="4012608316610763473">"Permet à une application d\'accéder aux sessions d\'installation. Cela lui permet de consulter les détails relatifs à l\'installation des packages actifs."</string>
    <string name="permlab_requestInstallPackages" msgid="7600020863445351154">"demander l\'installation de packages"</string>
    <string name="permdesc_requestInstallPackages" msgid="3969369278325313067">"Permet à une application de demander l\'installation de packages."</string>
    <string name="permlab_requestDeletePackages" msgid="2541172829260106795">"demander la suppression de packages"</string>
    <string name="permdesc_requestDeletePackages" msgid="6133633516423860381">"Permet à une application de demander la suppression de packages."</string>
    <string name="permlab_requestIgnoreBatteryOptimizations" msgid="7646611326036631439">"demander à ignorer les optimisations de batterie"</string>
    <string name="permdesc_requestIgnoreBatteryOptimizations" msgid="634260656917874356">"Autorise une application à demander l\'autorisation d\'ignorer les optimisations de batterie pour cette application."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1842872462124648678">"Appuyer deux fois pour régler le zoom"</string>
    <string name="gadget_host_error_inflating" msgid="2449961590495198720">"Impossible d\'ajouter le widget."</string>
    <string name="ime_action_go" msgid="5536744546326495436">"OK"</string>
    <string name="ime_action_search" msgid="4501435960587287668">"Rechercher"</string>
    <string name="ime_action_send" msgid="8456843745664334138">"Envoyer"</string>
    <string name="ime_action_next" msgid="4169702997635728543">"Suivant"</string>
    <string name="ime_action_done" msgid="6299921014822891569">"OK"</string>
    <string name="ime_action_previous" msgid="6548799326860401611">"Préc."</string>
    <string name="ime_action_default" msgid="8265027027659800121">"Exécuter"</string>
    <string name="dial_number_using" msgid="6060769078933953531">"Composer le numéro\nen utilisant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="create_contact_using" msgid="6200708808003692594">"Ajouter un contact\nen utilisant <xliff:g id="NUMBER">%s</xliff:g>"</string>
    <string name="grant_credentials_permission_message_header" msgid="5365733888842570481">"Les applications suivantes demandent l\'autorisation d\'accéder à votre compte à partir de maintenant."</string>
    <string name="grant_credentials_permission_message_footer" msgid="1886710210516246461">"Voulez-vous autoriser cette demande ?"</string>
    <string name="grant_permissions_header_text" msgid="3420736827804657201">"Demande d\'accès"</string>
    <string name="allow" msgid="6195617008611933762">"Autoriser"</string>
    <string name="deny" msgid="6632259981847676572">"Refuser"</string>
    <string name="permission_request_notification_title" msgid="1810025922441048273">"Autorisation demandée"</string>
    <string name="permission_request_notification_with_subtitle" msgid="3743417870360129298">"Autorisation demandée\npour le compte \"<xliff:g id="ACCOUNT">%s</xliff:g>\""</string>
    <string name="forward_intent_to_owner" msgid="4620359037192871015">"Vous utilisez cette application en dehors de votre profil professionnel."</string>
    <string name="forward_intent_to_work" msgid="3620262405636021151">"Vous utilisez cette application dans votre profil professionnel."</string>
    <string name="input_method_binding_label" msgid="1166731601721983656">"Mode de saisie"</string>
    <string name="sync_binding_label" msgid="469249309424662147">"Synchronisation"</string>
    <string name="accessibility_binding_label" msgid="1974602776545801715">"Accessibilité"</string>
    <string name="wallpaper_binding_label" msgid="1197440498000786738">"Fond d\'écran"</string>
    <string name="chooser_wallpaper" msgid="3082405680079923708">"Changer de fond d\'écran"</string>
    <string name="notification_listener_binding_label" msgid="2702165274471499713">"Outil d\'écoute des notifications"</string>
    <string name="vr_listener_binding_label" msgid="8013112996671206429">"Écouteur de réalité virtuelle"</string>
    <string name="condition_provider_service_binding_label" msgid="8490641013951857673">"Fournisseur de conditions"</string>
    <string name="notification_ranker_binding_label" msgid="432708245635563763">"Service de classement des notifications"</string>
    <string name="vpn_title" msgid="5906991595291514182">"VPN activé"</string>
    <string name="vpn_title_long" msgid="6834144390504619998">"VPN activé par <xliff:g id="APP">%s</xliff:g>"</string>
    <string name="vpn_text" msgid="2275388920267251078">"Appuyez ici pour gérer le réseau."</string>
    <string name="vpn_text_long" msgid="278540576806169831">"Connecté à <xliff:g id="SESSION">%s</xliff:g>. Appuyez ici pour gérer le réseau."</string>
    <string name="vpn_lockdown_connecting" msgid="6096725311950342607">"VPN permanent en cours de connexion…"</string>
    <string name="vpn_lockdown_connected" msgid="2853127976590658469">"VPN permanent connecté"</string>
    <string name="vpn_lockdown_disconnected" msgid="5573611651300764955">"Déconnecté du VPN permanent"</string>
    <string name="vpn_lockdown_error" msgid="4453048646854247947">"Impossible de se connecter au VPN permanent"</string>
    <string name="vpn_lockdown_config" msgid="8331697329868252169">"Modifier les paramètres réseau ou VPN"</string>
    <string name="upload_file" msgid="8651942222301634271">"Sélectionner un fichier"</string>
    <string name="no_file_chosen" msgid="4146295695162318057">"Aucun fichier sélectionné"</string>
    <string name="reset" msgid="3865826612628171429">"Réinitialiser"</string>
    <string name="submit" msgid="862795280643405865">"Envoyer"</string>
    <string name="car_mode_disable_notification_title" msgid="8450693275833142896">"L\'application de conduite est en cours d\'exécution"</string>
    <string name="car_mode_disable_notification_message" msgid="8954550232288567515">"Appuyez ici pour quitter l\'application de conduite."</string>
    <string name="back_button_label" msgid="4078224038025043387">"Retour"</string>
    <string name="next_button_label" msgid="6040209156399907780">"Suivant"</string>
    <string name="skip_button_label" msgid="3566599811326688389">"Ignorer"</string>
    <string name="no_matches" msgid="6472699895759164599">"Aucune correspondance"</string>
    <string name="find_on_page" msgid="5400537367077438198">"Rechercher sur la page"</string>
    <plurals name="matches_found" formatted="false" msgid="1101758718194295554">
      <item quantity="one"><xliff:g id="INDEX">%d</xliff:g> sur <xliff:g id="TOTAL">%d</xliff:g></item>
      <item quantity="other"><xliff:g id="INDEX">%d</xliff:g> sur <xliff:g id="TOTAL">%d</xliff:g></item>
    </plurals>
    <string name="action_mode_done" msgid="2536182504764803222">"OK"</string>
    <string name="progress_erasing" msgid="6891435992721028004">"Suppression de l\'espace de stockage partagé…"</string>
    <string name="share" msgid="4157615043345227321">"Partager"</string>
    <string name="find" msgid="5015737188624767706">"Rechercher"</string>
    <string name="websearch" msgid="5624340204512793290">"Recherche Web"</string>
    <string name="find_next" msgid="5341217051549648153">"Rechercher suivant"</string>
    <string name="find_previous" msgid="4405898398141275532">"Rechercher précédent"</string>
    <string name="gpsNotifTicker" msgid="3207361857637620780">"Demande de position de la part de <xliff:g id="NAME">%s</xliff:g>"</string>
    <string name="gpsNotifTitle" msgid="1590033371665669570">"Demande de position"</string>
    <string name="gpsNotifMessage" msgid="7346649122793758032">"Demande de <xliff:g id="NAME">%1$s</xliff:g> (<xliff:g id="SERVICE">%2$s</xliff:g>)"</string>
    <string name="gpsVerifYes" msgid="3719843080744112940">"Oui"</string>
    <string name="gpsVerifNo" msgid="1671201856091564741">"Non"</string>
    <string name="gnss_nfw_notification_title" msgid="5004493772059563423">"Accès à la localisation d\'urgence"</string>
    <string name="gnss_nfw_notification_message_oem" msgid="3683958907027107969">"Le fabricant de votre appareil a accédé à votre position récemment lors d\'une situation d\'urgence"</string>
    <string name="gnss_nfw_notification_message_carrier" msgid="815888995791562151">"Votre opérateur a accédé à votre position récemment lors d\'une situation d\'urgence"</string>
    <string name="sync_too_many_deletes" msgid="6999440774578705300">"Le nombre maximal de suppressions a été atteint."</string>
    <string name="sync_too_many_deletes_desc" msgid="7409327940303504440">"<xliff:g id="NUMBER_OF_DELETED_ITEMS">%1$d</xliff:g> éléments vont être supprimés lors de la synchronisation <xliff:g id="TYPE_OF_SYNC">%2$s</xliff:g> pour le compte <xliff:g id="ACCOUNT_NAME">%3$s</xliff:g>. Que voulez-vous faire ?"</string>
    <string name="sync_really_delete" msgid="5657871730315579051">"Supprimer les éléments"</string>
    <string name="sync_undo_deletes" msgid="5786033331266418896">"Annuler les suppressions"</string>
    <string name="sync_do_nothing" msgid="4528734662446469646">"Ne rien faire pour l\'instant"</string>
    <string name="choose_account_label" msgid="5557833752759831548">"Sélectionnez un compte"</string>
    <string name="add_account_label" msgid="4067610644298737417">"Ajouter un compte"</string>
    <string name="add_account_button_label" msgid="322390749416414097">"Ajouter un compte"</string>
    <string name="number_picker_increment_button" msgid="7621013714795186298">"Augmenter"</string>
    <string name="number_picker_decrement_button" msgid="5116948444762708204">"Diminuer"</string>
    <string name="number_picker_increment_scroll_mode" msgid="8403893549806805985">"<xliff:g id="VALUE">%s</xliff:g> appuyez de manière prolongée."</string>
    <string name="number_picker_increment_scroll_action" msgid="8310191318914268271">"Faites glisser vers le haut pour augmenter et vers le bas pour diminuer."</string>
    <string name="time_picker_increment_minute_button" msgid="7195870222945784300">"Minute suivante"</string>
    <string name="time_picker_decrement_minute_button" msgid="230925389943411490">"Minute précédente"</string>
    <string name="time_picker_increment_hour_button" msgid="3063572723197178242">"Heure suivante"</string>
    <string name="time_picker_decrement_hour_button" msgid="584101766855054412">"Heure précédente"</string>
    <string name="time_picker_increment_set_pm_button" msgid="5889149366900376419">"Définir la valeur PM"</string>
    <string name="time_picker_decrement_set_am_button" msgid="1422608001541064087">"Définir la valeur AM"</string>
    <string name="date_picker_increment_month_button" msgid="3447263316096060309">"Mois suivant"</string>
    <string name="date_picker_decrement_month_button" msgid="6531888937036883014">"Mois précédent"</string>
    <string name="date_picker_increment_day_button" msgid="4349336637188534259">"Jour suivant"</string>
    <string name="date_picker_decrement_day_button" msgid="6840253837656637248">"Jour précédent"</string>
    <string name="date_picker_increment_year_button" msgid="7608128783435372594">"Année suivante"</string>
    <string name="date_picker_decrement_year_button" msgid="4102586521754172684">"Année précédente"</string>
    <string name="date_picker_prev_month_button" msgid="3418694374017868369">"Mois précédent"</string>
    <string name="date_picker_next_month_button" msgid="4858207337779144840">"Mois suivant"</string>
    <string name="keyboardview_keycode_alt" msgid="8997420058584292385">"Alt"</string>
    <string name="keyboardview_keycode_cancel" msgid="2134624484115716975">"Annuler"</string>
    <string name="keyboardview_keycode_delete" msgid="2661117313730098650">"Supprimer"</string>
    <string name="keyboardview_keycode_done" msgid="2524518019001653851">"Terminé"</string>
    <string name="keyboardview_keycode_mode_change" msgid="2743735349997999020">"Changement de mode"</string>
    <string name="keyboardview_keycode_shift" msgid="3026509237043975573">"Maj"</string>
    <string name="keyboardview_keycode_enter" msgid="168054869339091055">"Entrée"</string>
    <string name="activitychooserview_choose_application" msgid="3500574466367891463">"Sélectionnez une application"</string>
    <string name="activitychooserview_choose_application_error" msgid="6937782107559241734">"Impossible de lancer l\'application <xliff:g id="APPLICATION_NAME">%s</xliff:g>."</string>
    <string name="shareactionprovider_share_with" msgid="2753089758467748982">"Partager avec"</string>
    <string name="shareactionprovider_share_with_application" msgid="4902832247173666973">"Partager avec <xliff:g id="APPLICATION_NAME">%s</xliff:g>"</string>
    <string name="content_description_sliding_handle" msgid="982510275422590757">"Poignée coulissante. Appuyez de manière prolongée."</string>
    <string name="description_target_unlock_tablet" msgid="7431571180065859551">"Faites glisser votre doigt pour déverrouiller l\'appareil."</string>
    <string name="action_bar_home_description" msgid="1501655419158631974">"Retour à l\'accueil"</string>
    <string name="action_bar_up_description" msgid="6611579697195026932">"Parcourir vers le haut"</string>
    <string name="action_menu_overflow_description" msgid="4579536843510088170">"Plus d\'options"</string>
    <string name="action_bar_home_description_format" msgid="5087107531331621803">"%1$s, %2$s"</string>
    <string name="action_bar_home_subtitle_description_format" msgid="4346835454749569826">"%1$s, %2$s, %3$s"</string>
    <string name="storage_internal" msgid="8490227947584914460">"Espace de stockage interne partagé"</string>
    <string name="storage_sd_card" msgid="3404740277075331881">"Carte SD"</string>
    <string name="storage_sd_card_label" msgid="7526153141147470509">"Carte SD <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb_drive" msgid="448030813201444573">"Clé USB"</string>
    <string name="storage_usb_drive_label" msgid="6631740655876540521">"Clé USB <xliff:g id="MANUFACTURER">%s</xliff:g>"</string>
    <string name="storage_usb" msgid="2391213347883616886">"Mémoire de stockage USB"</string>
    <string name="extract_edit_menu_button" msgid="63954536535863040">"Modifier"</string>
    <string name="data_usage_warning_title" msgid="9034893717078325845">"Avertissement de consommation de données"</string>
    <string name="data_usage_warning_body" msgid="1669325367188029454">"Vous avez utilisé <xliff:g id="APP">%s</xliff:g> de données"</string>
    <string name="data_usage_mobile_limit_title" msgid="3911447354393775241">"Limite données mobiles atteinte"</string>
    <string name="data_usage_wifi_limit_title" msgid="2069698056520812232">"Limite données Wi-Fi atteinte"</string>
    <string name="data_usage_limit_body" msgid="3567699582000085710">"Données suspendues jusqu\'à la fin du cycle"</string>
    <string name="data_usage_mobile_limit_snoozed_title" msgid="101888478915677895">"Limite données mobiles dépassée"</string>
    <string name="data_usage_wifi_limit_snoozed_title" msgid="1622359254521960508">"Limite de données Wi-Fi dépassée"</string>
    <string name="data_usage_limit_snoozed_body" msgid="545146591766765678">"Vous avez dépassé votre limite définie de <xliff:g id="SIZE">%s</xliff:g>"</string>
    <string name="data_usage_restricted_title" msgid="126711424380051268">"Données en arrière-plan limitées"</string>
    <string name="data_usage_restricted_body" msgid="5338694433686077733">"Appuyez pour suppr. restriction."</string>
    <string name="data_usage_rapid_title" msgid="2950192123248740375">"Conso données mobiles élevée"</string>
    <string name="data_usage_rapid_body" msgid="3886676853263693432">"Vos applications ont utilisé plus de données que d\'habitude"</string>
    <string name="data_usage_rapid_app_body" msgid="5425779218506513861">"<xliff:g id="APP">%s</xliff:g> a utilisé plus de données que d\'habitude"</string>
    <string name="ssl_certificate" msgid="5690020361307261997">"Certificat de sécurité"</string>
    <string name="ssl_certificate_is_valid" msgid="7293675884598527081">"Ce certificat est valide."</string>
    <string name="issued_to" msgid="5975877665505297662">"Délivré à :"</string>
    <string name="common_name" msgid="1486334593631798443">"Nom commun :"</string>
    <string name="org_name" msgid="7526331696464255245">"Organisation :"</string>
    <string name="org_unit" msgid="995934486977223076">"Unité organisationnelle :"</string>
    <string name="issued_by" msgid="7872459822431585684">"Émis par :"</string>
    <string name="validity_period" msgid="1717724283033175968">"Validité :"</string>
    <string name="issued_on" msgid="5855489688152497307">"Date d\'émission :"</string>
    <string name="expires_on" msgid="1623640879705103121">"Date d\'expiration :"</string>
    <string name="serial_number" msgid="3479576915806623429">"Numéro de série :"</string>
    <string name="fingerprints" msgid="148690767172613723">"Empreintes :"</string>
    <string name="sha256_fingerprint" msgid="7103976380961964600">"Empreinte SHA-256 :"</string>
    <string name="sha1_fingerprint" msgid="2339915142825390774">"Empreinte SHA-1 :"</string>
    <string name="activity_chooser_view_see_all" msgid="3917045206812726099">"Tout afficher"</string>
    <string name="activity_chooser_view_dialog_title_default" msgid="8880731437191978314">"Sélectionnez une activité"</string>
    <string name="share_action_provider_share_with" msgid="1904096863622941880">"Partager avec"</string>
    <string name="sending" msgid="206925243621664438">"Envoi en cours…"</string>
    <string name="launchBrowserDefault" msgid="6328349989932924119">"Lancer le navigateur ?"</string>
    <string name="SetupCallDefault" msgid="5581740063237175247">"Prendre l\'appel ?"</string>
    <string name="activity_resolver_use_always" msgid="5575222334666843269">"Toujours"</string>
    <string name="activity_resolver_set_always" msgid="4142825808921411476">"Toujours ouvrir avec cette application"</string>
    <string name="activity_resolver_use_once" msgid="948462794469672658">"Une seule fois"</string>
    <string name="activity_resolver_app_settings" msgid="6758823206817748026">"Paramètres"</string>
    <string name="activity_resolver_work_profiles_support" msgid="4071345609235361269">"%1$s n\'est pas compatible avec le profil professionnel."</string>
    <string name="default_audio_route_name" product="tablet" msgid="367936735632195517">"Tablette"</string>
    <string name="default_audio_route_name" product="tv" msgid="4908971385068087367">"Téléviseur"</string>
    <string name="default_audio_route_name" product="default" msgid="9213546147739983977">"Téléphone"</string>
    <string name="default_audio_route_name_dock_speakers" msgid="1551166029093995289">"Haut-parleurs de la station d\'accueil"</string>
    <string name="default_audio_route_name_hdmi" msgid="5474470558160717850">"HDMI"</string>
    <string name="default_audio_route_name_headphones" msgid="6954070994792640762">"Écouteurs"</string>
    <string name="default_audio_route_name_usb" msgid="895668743163316932">"USB"</string>
    <string name="default_audio_route_category_name" msgid="5241740395748134483">"Système"</string>
    <string name="bluetooth_a2dp_audio_route_name" msgid="4214648773120426288">"Audio Bluetooth"</string>
    <string name="wireless_display_route_description" msgid="8297563323032966831">"Affichage sans fil"</string>
    <string name="media_route_button_content_description" msgid="2299223698196869956">"Caster"</string>
    <string name="media_route_chooser_title" msgid="6646594924991269208">"Connexion à l\'appareil"</string>
    <string name="media_route_chooser_title_for_remote_display" msgid="3105906508794326446">"Caster l\'écran sur l\'appareil"</string>
    <string name="media_route_chooser_searching" msgid="6119673534251329535">"Recherche d\'appareils…"</string>
    <string name="media_route_chooser_extended_settings" msgid="2506352159381327741">"Paramètres"</string>
    <string name="media_route_controller_disconnect" msgid="7362617572732576959">"Déconnecter"</string>
    <string name="media_route_status_scanning" msgid="8045156315309594482">"Analyse en cours..."</string>
    <string name="media_route_status_connecting" msgid="5845597961412010540">"Connexion en cours..."</string>
    <string name="media_route_status_available" msgid="1477537663492007608">"Disponible"</string>
    <string name="media_route_status_not_available" msgid="480912417977515261">"Indisponible"</string>
    <string name="media_route_status_in_use" msgid="6684112905244944724">"En cours d\'utilisation"</string>
    <string name="display_manager_built_in_display_name" msgid="1015775198829722440">"Écran intégré"</string>
    <string name="display_manager_hdmi_display_name" msgid="1022758026251534975">"Écran HDMI"</string>
    <string name="display_manager_overlay_display_name" msgid="5306088205181005861">"Superposition n° <xliff:g id="ID">%1$d</xliff:g>"</string>
    <string name="display_manager_overlay_display_title" msgid="1480158037150469170">"<xliff:g id="NAME">%1$s</xliff:g> : <xliff:g id="WIDTH">%2$d</xliff:g> x <xliff:g id="HEIGHT">%3$d</xliff:g>, <xliff:g id="DPI">%4$d</xliff:g> dpi"</string>
    <string name="display_manager_overlay_display_secure_suffix" msgid="2810034719482834679">", sécurisé"</string>
    <string name="kg_forgot_pattern_button_text" msgid="406145459223122537">"J\'ai oublié le schéma"</string>
    <string name="kg_wrong_pattern" msgid="1342812634464179931">"Schéma incorrect."</string>
    <string name="kg_wrong_password" msgid="2384677900494439426">"Mot de passe incorrect."</string>
    <string name="kg_wrong_pin" msgid="3680925703673166482">"Code PIN incorrect."</string>
    <plurals name="kg_too_many_failed_attempts_countdown" formatted="false" msgid="236717428673283568">
      <item quantity="one">Réessayez dans <xliff:g id="NUMBER">%d</xliff:g> seconde.</item>
      <item quantity="other">Réessayez dans <xliff:g id="NUMBER">%d</xliff:g> secondes.</item>
    </plurals>
    <string name="kg_pattern_instructions" msgid="8366024510502517748">"Dessinez votre schéma."</string>
    <string name="kg_sim_pin_instructions" msgid="6479401489471690359">"Saisissez le code PIN de la carte SIM."</string>
    <string name="kg_pin_instructions" msgid="7355933174673539021">"Saisissez le code PIN."</string>
    <string name="kg_password_instructions" msgid="7179782578809398050">"Saisissez votre mot de passe."</string>
    <string name="kg_puk_enter_puk_hint" msgid="6696187482616360994">"La carte SIM est maintenant désactivée. Saisissez le code PUK pour continuer. Contactez votre opérateur pour en savoir plus."</string>
    <string name="kg_puk_enter_pin_hint" msgid="8190982314659429770">"Saisir le code PIN souhaité"</string>
    <string name="kg_enter_confirm_pin_hint" msgid="6372557107414074580">"Confirmer le code PIN souhaité"</string>
    <string name="kg_sim_unlock_progress_dialog_message" msgid="8871937892678885545">"Déblocage de la carte SIM en cours…"</string>
    <string name="kg_password_wrong_pin_code" msgid="9013856346870572451">"Le code PIN est erroné."</string>
    <string name="kg_invalid_sim_pin_hint" msgid="4821601451222564077">"Veuillez saisir un code PIN comprenant entre quatre et huit chiffres."</string>
    <string name="kg_invalid_sim_puk_hint" msgid="2539364558870734339">"La clé PUK doit contenir 8 chiffres."</string>
    <string name="kg_invalid_puk" msgid="4809502818518963344">"Veuillez saisir de nouveau le code PUK correct. Des tentatives répétées désactivent définitivement la carte SIM."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="4705368340409816254">"Les codes PIN ne correspondent pas."</string>
    <string name="kg_login_too_many_attempts" msgid="699292728290654121">"Trop de tentatives."</string>
    <string name="kg_login_instructions" msgid="3619844310339066827">"Pour déverrouiller le téléphone, veuillez vous connecter avec votre compte Google."</string>
    <string name="kg_login_username_hint" msgid="1765453775467133251">"Nom d\'utilisateur (e-mail)"</string>
    <string name="kg_login_password_hint" msgid="3330530727273164402">"Mot de passe"</string>
    <string name="kg_login_submit_button" msgid="893611277617096870">"Connexion"</string>
    <string name="kg_login_invalid_input" msgid="8292367491901220210">"Nom d\'utilisateur ou mot de passe non valide."</string>
    <string name="kg_login_account_recovery_hint" msgid="4892466171043541248">"Vous avez oublié votre nom d\'utilisateur ou votre mot de passe ?\nRendez-vous sur la page "<b>"google.com/accounts/recovery"</b>"."</string>
    <string name="kg_login_checking_password" msgid="4676010303243317253">"Vérification du compte en cours…"</string>
    <string name="kg_too_many_failed_pin_attempts_dialog_message" msgid="23741434207544038">"Vous avez saisi un code PIN incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. \n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="kg_too_many_failed_password_attempts_dialog_message" msgid="3328686432962224215">"Vous avez saisi un mot de passe incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. \n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message" msgid="7357404233979139075">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises.\n\nVeuillez réessayer dans <xliff:g id="NUMBER_1">%2$d</xliff:g> secondes."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="3479940221343361587">"Vous avez tenté de déverrouiller la tablette de façon incorrecte à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tv" msgid="9064457748587850217">"Vous avez tenté de déverrouiller votre appareil Android TV à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="5955398963754432548">"Vous avez tenté de déverrouiller le téléphone de façon incorrecte à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, sa configuration d\'usine sera rétablie, et toutes les données utilisateur seront perdues."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="2299099385175083308">"Vous avez tenté de déverrouiller la tablette de façon incorrecte à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va être rétablie."</string>
    <string name="kg_failed_attempts_now_wiping" product="tv" msgid="5045460916106267585">"Vous avez tenté de déverrouiller votre appareil Android TV à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va maintenant être rétablie."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="5043730590446071189">"Vous avez tenté de déverrouiller le téléphone de façon incorrecte à <xliff:g id="NUMBER">%d</xliff:g> reprises. Sa configuration d\'usine va être rétablie."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="7086799295109717623">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, vous devrez déverrouiller votre tablette à l\'aide d\'un compte de messagerie électronique.\n\n Veuillez réessayer dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tv" msgid="4670840383567106114">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, vous devrez déverrouiller votre appareil Android TV à l\'aide d\'un compte de messagerie électronique.\n\n Réessayez dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="5270861875006378092">"Vous avez dessiné un schéma de déverrouillage incorrect à <xliff:g id="NUMBER_0">%1$d</xliff:g> reprises. Si vous échouez encore <xliff:g id="NUMBER_1">%2$d</xliff:g> fois, vous devrez déverrouiller votre téléphone à l\'aide d\'un compte de messagerie électronique.\n\n Veuillez réessayer dans <xliff:g id="NUMBER_2">%3$d</xliff:g> secondes."</string>
    <string name="kg_text_message_separator" product="default" msgid="4503708889934976866">" — "</string>
    <string name="kg_reordering_delete_drop_target_text" msgid="2034358143731750914">"Supprimer"</string>
    <string name="allow_while_in_use_permission_in_fgs" msgid="4101339676785053656">"Le service de premier plan qui a démarré en arrière-plan et provenant de <xliff:g id="PACKAGENAME">%1$s</xliff:g> ne disposera pas de l\'autorisation \"pendant l\'utilisation\" dans les futurs builds R. Veuillez accéder à go/r-bg-fgs-restriction et envoyer un rapport de bug."</string>
    <string name="safe_media_volume_warning" product="default" msgid="3751676824423049994">"Augmenter le volume au dessus du niveau recommandé ?\n\nL\'écoute prolongée à un volume élevé peut endommager vos facultés auditives."</string>
    <string name="accessibility_shortcut_warning_dialog_title" msgid="4017995837692622933">"Utiliser le raccourci d\'accessibilité ?"</string>
    <string name="accessibility_shortcut_toogle_warning" msgid="4161716521310929544">"Quand le raccourci est activé, appuyez sur les deux boutons de volume pendant trois secondes pour démarrer une fonctionnalité d\'accessibilité."</string>
    <string name="accessibility_shortcut_multiple_service_warning_title" msgid="8417489297036013065">"Activer les fonctionnalités d\'accessibilité ?"</string>
    <string name="accessibility_shortcut_multiple_service_warning" msgid="3740723309483706911">"Si vous appuyez sur les deux touches de volume pendant quelques secondes, vous activez des fonctionnalités d\'accessibilité. Cela peut affecter le fonctionnement de votre appareil.\n\nFonctionnalités actuellement utilisées :\n<xliff:g id="SERVICE">%1$s</xliff:g>\nPour les modifier, accédez à Paramètres &gt; Accessibilité."</string>
    <string name="accessibility_shortcut_multiple_service_list" msgid="6935581470716541531">"	• <xliff:g id="SERVICE">%1$s</xliff:g>\n"</string>
    <string name="accessibility_shortcut_talkback_warning_title" msgid="3410100187167382427">"Activer TalkBack ?"</string>
    <string name="accessibility_shortcut_talkback_warning" msgid="8412954203626349109">"Si vous appuyez sur les deux touches de volume pendant quelques secondes, vous activez TalkBack, un lecteur d\'écran très pratique pour les personnes aveugles ou malvoyantes. TalkBack change complètement le fonctionnement de votre appareil.\n\nPour attribuer ce raccourci à une autre fonctionnalité, accédez à Paramètres &gt; Accessibilité."</string>
    <string name="accessibility_shortcut_single_service_warning_title" msgid="2819109500943271385">"Activer <xliff:g id="SERVICE">%1$s</xliff:g> ?"</string>
    <string name="accessibility_shortcut_single_service_warning" msgid="6363127705112844257">"Si vous appuyez sur les deux touches de volume pendant quelques secondes, vous activez la fonctionnalité d\'accessibilité <xliff:g id="SERVICE">%1$s</xliff:g>. Cela peut affecter le fonctionnement de votre appareil.\n\nPour attribuer ce raccourci à une autre fonctionnalité, accédez à Paramètres &gt; Accessibilité."</string>
    <string name="accessibility_shortcut_on" msgid="5463618449556111344">"Activer"</string>
    <string name="accessibility_shortcut_off" msgid="3651336255403648739">"Ne pas activer"</string>
    <string name="accessibility_shortcut_menu_item_status_on" msgid="6608392117189732543">"ACTIVÉE"</string>
    <string name="accessibility_shortcut_menu_item_status_off" msgid="5531598275559472393">"DÉSACTIVÉE"</string>
    <string name="accessibility_enable_service_title" msgid="3931558336268541484">"Accorder le contrôle total de votre appareil au service <xliff:g id="SERVICE">%1$s</xliff:g> ?"</string>
    <string name="accessibility_enable_service_encryption_warning" msgid="8603532708618236909">"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="accessibility_service_warning_description" msgid="291674995220940133">"Le contrôle total convient aux applications qui répondent à vos besoins d\'accessibilité. Il ne convient pas à la plupart des applications."</string>
    <string name="accessibility_service_screen_control_title" msgid="190017412626919776">"Afficher et contrôler l\'écran"</string>
    <string name="accessibility_service_screen_control_description" msgid="6946315917771791525">"Cette fonctionnalité peut lire l\'intégralité du contenu à l\'écran et afficher du contenu par-dessus d\'autres applications."</string>
    <string name="accessibility_service_action_perform_title" msgid="779670378951658160">"Afficher et effectuer des actions"</string>
    <string name="accessibility_service_action_perform_description" msgid="2718852014003170558">"Cette fonctionnalité peut effectuer le suivi de vos interactions avec une application ou un capteur matériel, et interagir avec les applications en votre nom."</string>
    <string name="accessibility_dialog_button_allow" msgid="2092558122987144530">"Autoriser"</string>
    <string name="accessibility_dialog_button_deny" msgid="4129575637812472671">"Refuser"</string>
    <string name="accessibility_select_shortcut_menu_title" msgid="6002726538854613272">"Appuyez sur une fonctionnalité pour commencer à l\'utiliser :"</string>
    <string name="accessibility_edit_shortcut_menu_button_title" msgid="239446795930436325">"Choisir les fonctionnalités à utiliser avec le bouton Accessibilité"</string>
    <string name="accessibility_edit_shortcut_menu_volume_title" msgid="1077294237378645981">"Choisir les fonctionnalités à utiliser avec le raccourci des touches de volume"</string>
    <string name="accessibility_uncheck_legacy_item_warning" msgid="8047830891064817447">"Le service <xliff:g id="SERVICE_NAME">%s</xliff:g> a été désactivé"</string>
    <string name="edit_accessibility_shortcut_menu_button" msgid="8885752738733772935">"Modifier les raccourcis"</string>
    <string name="done_accessibility_shortcut_menu_button" msgid="3668407723770815708">"OK"</string>
    <string name="disable_accessibility_shortcut" msgid="5806091378745232383">"Désactiver le raccourci"</string>
    <string name="leave_accessibility_shortcut_on" msgid="6543362062336990814">"Utiliser le raccourci"</string>
    <string name="color_inversion_feature_name" msgid="326050048927789012">"Inversion des couleurs"</string>
    <string name="color_correction_feature_name" msgid="3655077237805422597">"Correction des couleurs"</string>
    <string name="accessibility_shortcut_enabling_service" msgid="5473495203759847687">"Touches de volume appuyées de manière prolongée. Service <xliff:g id="SERVICE_NAME">%1$s</xliff:g> activé."</string>
    <string name="accessibility_shortcut_disabling_service" msgid="8675244165062700619">"Touches de volume appuyées de manière prolongée. Service <xliff:g id="SERVICE_NAME">%1$s</xliff:g> désactivé."</string>
    <string name="accessibility_shortcut_spoken_feedback" msgid="4228997042855695090">"Appuyez de manière prolongée sur les deux touches de volume pendant trois secondes pour utiliser <xliff:g id="SERVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_button_prompt_text" msgid="8343213623338605305">"Choisissez une fonctionnalité à utiliser lorsque vous appuyez sur le bouton Accessibilité :"</string>
    <string name="accessibility_gesture_prompt_text" msgid="8742535972130563952">"Choisissez une fonctionnalité à utiliser avec le geste d\'accessibilité (balayez l\'écran de bas en haut avec deux doigts) :"</string>
    <string name="accessibility_gesture_3finger_prompt_text" msgid="5211827854510660203">"Choisissez une fonctionnalité à utiliser avec le geste d\'accessibilité (balayer l\'écran de bas en haut avec trois doigts) :"</string>
    <string name="accessibility_button_instructional_text" msgid="8853928358872550500">"Pour changer de fonctionnalité, appuyez de manière prolongée sur le bouton Accessibilité."</string>
    <string name="accessibility_gesture_instructional_text" msgid="9196230728837090497">"Pour changer de fonctionnement, balayez l\'écran vers le haut avec deux doigts et appuyez de manière prolongée."</string>
    <string name="accessibility_gesture_3finger_instructional_text" msgid="3425123684990193765">"Pour changer de fonctionnalité, balayez l\'écran vers le haut avec trois doigts et appuyez de manière prolongée."</string>
    <string name="accessibility_magnification_chooser_text" msgid="1502075582164931596">"Agrandissement"</string>
    <string name="user_switched" msgid="7249833311585228097">"Utilisateur actuel : <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="user_switching_message" msgid="1912993630661332336">"Chargement du profil de <xliff:g id="NAME">%1$s</xliff:g>..."</string>
    <string name="user_logging_out_message" msgid="7216437629179710359">"Déconnexion de <xliff:g id="NAME">%1$s</xliff:g>…"</string>
    <string name="owner_name" msgid="8713560351570795743">"Propriétaire"</string>
    <string name="error_message_title" msgid="4082495589294631966">"Erreur"</string>
    <string name="error_message_change_not_allowed" msgid="843159705042381454">"Votre administrateur n\'autorise pas cette modification"</string>
    <string name="app_not_found" msgid="3429506115332341800">"Aucune application trouvée pour gérer cette action."</string>
    <string name="revoke" msgid="5526857743819590458">"Révoquer"</string>
    <string name="mediasize_iso_a0" msgid="7039061159929977973">"ISO A0"</string>
    <string name="mediasize_iso_a1" msgid="4063589931031977223">"ISO A1"</string>
    <string name="mediasize_iso_a2" msgid="2779860175680233980">"ISO A2"</string>
    <string name="mediasize_iso_a3" msgid="3683469257246970630">"ISO A3"</string>
    <string name="mediasize_iso_a4" msgid="752903572302658845">"ISO A4"</string>
    <string name="mediasize_iso_a5" msgid="3020439171949376572">"ISO A5"</string>
    <string name="mediasize_iso_a6" msgid="6503671662530738180">"ISO A6"</string>
    <string name="mediasize_iso_a7" msgid="8488649018955763878">"ISO A7"</string>
    <string name="mediasize_iso_a8" msgid="3380506944389571030">"ISO A8"</string>
    <string name="mediasize_iso_a9" msgid="7000627318995334730">"ISO A9"</string>
    <string name="mediasize_iso_a10" msgid="4091511972200388310">"ISO A10"</string>
    <string name="mediasize_iso_b0" msgid="2057859571254103889">"ISO B0"</string>
    <string name="mediasize_iso_b1" msgid="4931975244795236924">"ISO B1"</string>
    <string name="mediasize_iso_b2" msgid="4701978611340339483">"ISO B2"</string>
    <string name="mediasize_iso_b3" msgid="3509735449039761603">"ISO B3"</string>
    <string name="mediasize_iso_b4" msgid="486628178454656526">"ISO B4"</string>
    <string name="mediasize_iso_b5" msgid="2507554073053511267">"ISO B5"</string>
    <string name="mediasize_iso_b6" msgid="344189428571954711">"ISO B6"</string>
    <string name="mediasize_iso_b7" msgid="7266158663658064799">"ISO B7"</string>
    <string name="mediasize_iso_b8" msgid="5229204010533786299">"ISO B8"</string>
    <string name="mediasize_iso_b9" msgid="2925910409602493256">"ISO B9"</string>
    <string name="mediasize_iso_b10" msgid="8590530019536996218">"ISO B10"</string>
    <string name="mediasize_iso_c0" msgid="6504734131385460314">"ISO C0"</string>
    <string name="mediasize_iso_c1" msgid="1751671704929443684">"ISO C1"</string>
    <string name="mediasize_iso_c2" msgid="2935473413647925667">"ISO C2"</string>
    <string name="mediasize_iso_c3" msgid="6835637985527663396">"ISO C3"</string>
    <string name="mediasize_iso_c4" msgid="3000965043023118958">"ISO C4"</string>
    <string name="mediasize_iso_c5" msgid="3846339505379333795">"ISO C5"</string>
    <string name="mediasize_iso_c6" msgid="8663097559661858303">"ISO C6"</string>
    <string name="mediasize_iso_c7" msgid="4469290754678239705">"ISO C7"</string>
    <string name="mediasize_iso_c8" msgid="1949330679635319183">"ISO C8"</string>
    <string name="mediasize_iso_c9" msgid="3716843356839880581">"ISO C9"</string>
    <string name="mediasize_iso_c10" msgid="2113667674722450076">"ISO C10"</string>
    <string name="mediasize_na_letter" msgid="1947253006814499213">"Letter"</string>
    <string name="mediasize_na_gvrnmt_letter" msgid="4056220626420245955">"Government Letter"</string>
    <string name="mediasize_na_legal" msgid="8356233803828931150">"Legal"</string>
    <string name="mediasize_na_junior_legal" msgid="3398084874757748531">"Junior Legal"</string>
    <string name="mediasize_na_ledger" msgid="1819497882853940248">"Ledger"</string>
    <string name="mediasize_na_tabloid" msgid="6792611672983574375">"Tabloïd"</string>
    <string name="mediasize_na_index_3x5" msgid="990821038991491710">"Index Card 3x5"</string>
    <string name="mediasize_na_index_4x6" msgid="4414381976602032401">"Index Card 4x6"</string>
    <string name="mediasize_na_index_5x8" msgid="4499341583361946948">"Index Card 5x8"</string>
    <string name="mediasize_na_monarch" msgid="4396943937986136896">"Monarch"</string>
    <string name="mediasize_na_quarto" msgid="2119101847712239885">"Quarto"</string>
    <string name="mediasize_na_foolscap" msgid="5011612828564394648">"Foolscap"</string>
    <string name="mediasize_chinese_roc_8k" msgid="411670106572707544">"ROC 8K"</string>
    <string name="mediasize_chinese_roc_16k" msgid="7496706798725321898">"ROC 16K"</string>
    <string name="mediasize_chinese_prc_1" msgid="946949835711037253">"PRC 1"</string>
    <string name="mediasize_chinese_prc_2" msgid="4704308592895046237">"PRC 2"</string>
    <string name="mediasize_chinese_prc_3" msgid="1082996050478581675">"PRC 3"</string>
    <string name="mediasize_chinese_prc_4" msgid="7865122849174932948">"PRC 4"</string>
    <string name="mediasize_chinese_prc_5" msgid="852020506971633186">"PRC 5"</string>
    <string name="mediasize_chinese_prc_6" msgid="3399567254628077606">"PRC 6"</string>
    <string name="mediasize_chinese_prc_7" msgid="2804330751361491000">"PRC 7"</string>
    <string name="mediasize_chinese_prc_8" msgid="7988760621340084314">"PRC 8"</string>
    <string name="mediasize_chinese_prc_9" msgid="90266288020939533">"PRC 9"</string>
    <string name="mediasize_chinese_prc_10" msgid="7721316829399772162">"PRC 10"</string>
    <string name="mediasize_chinese_prc_16k" msgid="7471455177845043180">"PRC 16K"</string>
    <string name="mediasize_chinese_om_pa_kai" msgid="6305242012782587594">"Pa Kai"</string>
    <string name="mediasize_chinese_om_dai_pa_kai" msgid="8133982147973309032">"Dai Pa Kai"</string>
    <string name="mediasize_chinese_om_jurro_ku_kai" msgid="5888548906612445289">"Jurro Ku Kai"</string>
    <string name="mediasize_japanese_jis_b10" msgid="6761433476186549691">"JIS B10"</string>
    <string name="mediasize_japanese_jis_b9" msgid="6011047111717561836">"JIS B9"</string>
    <string name="mediasize_japanese_jis_b8" msgid="1541865115368043069">"JIS B8"</string>
    <string name="mediasize_japanese_jis_b7" msgid="8300341273885698803">"JIS B7"</string>
    <string name="mediasize_japanese_jis_b6" msgid="4329528623016980657">"JIS B6"</string>
    <string name="mediasize_japanese_jis_b5" msgid="7340334955358311979">"JIS B5"</string>
    <string name="mediasize_japanese_jis_b4" msgid="7403538361394953235">"JIS B4"</string>
    <string name="mediasize_japanese_jis_b3" msgid="9024287678505132047">"JIS B3"</string>
    <string name="mediasize_japanese_jis_b2" msgid="5151340021154579154">"JIS B2"</string>
    <string name="mediasize_japanese_jis_b1" msgid="2709589944170908250">"JIS B1"</string>
    <string name="mediasize_japanese_jis_b0" msgid="1209735840926222618">"JIS B0"</string>
    <string name="mediasize_japanese_jis_exec" msgid="2137738196058117115">"JIS Exec"</string>
    <string name="mediasize_japanese_chou4" msgid="2533204016634398713">"Chou4"</string>
    <string name="mediasize_japanese_chou3" msgid="5976745918096025459">"Chou3"</string>
    <string name="mediasize_japanese_chou2" msgid="6841260581434101675">"Chou2"</string>
    <string name="mediasize_japanese_hagaki" msgid="2112968853810337326">"Hagaki"</string>
    <string name="mediasize_japanese_oufuku" msgid="1575013107082530108">"Oufuku"</string>
    <string name="mediasize_japanese_kahu" msgid="7290232592648122042">"Kahu"</string>
    <string name="mediasize_japanese_kaku2" msgid="7477551750461028312">"Kaku2"</string>
    <string name="mediasize_japanese_you4" msgid="5552111912684384833">"You4"</string>
    <string name="mediasize_unknown_portrait" msgid="3817016220446495613">"Taille inconnue au format portrait"</string>
    <string name="mediasize_unknown_landscape" msgid="1584741567225095325">"Taille inconnue au format paysage"</string>
    <string name="write_fail_reason_cancelled" msgid="2344081488493969190">"Tâche annulée."</string>
    <string name="write_fail_reason_cannot_write" msgid="432118118378451508">"Erreur lors de la modification du contenu."</string>
    <string name="reason_unknown" msgid="5599739807581133337">"inconnu"</string>
    <string name="reason_service_unavailable" msgid="5288405248063804713">"Service d\'impression désactivé."</string>
    <string name="print_service_installed_title" msgid="6134880817336942482">"Service \"<xliff:g id="NAME">%s</xliff:g>\" installé"</string>
    <string name="print_service_installed_message" msgid="7005672469916968131">"Appuyer pour activer"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1199419462726962697">"Saisir le code administrateur"</string>
    <string name="restr_pin_enter_pin" msgid="373139384161304555">"Saisir le code PIN"</string>
    <string name="restr_pin_incorrect" msgid="3861383632940852496">"Incorrect."</string>
    <string name="restr_pin_enter_old_pin" msgid="7537079094090650967">"Code PIN actuel"</string>
    <string name="restr_pin_enter_new_pin" msgid="3267614461844565431">"Nouveau code PIN"</string>
    <string name="restr_pin_confirm_pin" msgid="7143161971614944989">"Confirmer le nouveau code PIN"</string>
    <string name="restr_pin_create_pin" msgid="917067613896366033">"Créer un code pour modifier les restrictions"</string>
    <string name="restr_pin_error_doesnt_match" msgid="7063392698489280556">"Les codes PIN ne correspondent pas. Veuillez réessayer."</string>
    <string name="restr_pin_error_too_short" msgid="1547007808237941065">"Le code PIN est trop court. Il doit comporter au moins 4 chiffres."</string>
    <plurals name="restr_pin_countdown" formatted="false" msgid="4427486903285216153">
      <item quantity="one">Réessayer dans <xliff:g id="COUNT">%d</xliff:g> seconde</item>
      <item quantity="other">Réessayer dans <xliff:g id="COUNT">%d</xliff:g> secondes</item>
    </plurals>
    <string name="restr_pin_try_later" msgid="5897719962541636727">"Veuillez réessayer ultérieurement."</string>
    <string name="immersive_cling_title" msgid="2307034298721541791">"Affichage en plein écran"</string>
    <string name="immersive_cling_description" msgid="7092737175345204832">"Pour quitter, balayez l\'écran du haut vers le bas."</string>
    <string name="immersive_cling_positive" msgid="7047498036346489883">"OK"</string>
    <string name="done_label" msgid="7283767013231718521">"OK"</string>
    <string name="hour_picker_description" msgid="5153757582093524635">"Curseur circulaire des heures"</string>
    <string name="minute_picker_description" msgid="9029797023621927294">"Curseur circulaire des minutes"</string>
    <string name="select_hours" msgid="5982889657313147347">"Sélectionner une heure"</string>
    <string name="select_minutes" msgid="9157401137441014032">"Sélectionner des minutes"</string>
    <string name="select_day" msgid="2060371240117403147">"Sélectionner un mois et un jour"</string>
    <string name="select_year" msgid="1868350712095595393">"Sélectionner une année"</string>
    <string name="deleted_key" msgid="9130083334943364001">"\"<xliff:g id="KEY">%1$s</xliff:g>\" supprimé"</string>
    <string name="managed_profile_label_badge" msgid="6762559569999499495">"<xliff:g id="LABEL">%1$s</xliff:g> (travail)"</string>
    <string name="managed_profile_label_badge_2" msgid="5673187309555352550">"2e <xliff:g id="LABEL">%1$s</xliff:g> professionnelle"</string>
    <string name="managed_profile_label_badge_3" msgid="6882151970556391957">"3e <xliff:g id="LABEL">%1$s</xliff:g> professionnelle"</string>
    <string name="lock_to_app_unlock_pin" msgid="3890940811866290782">"Demander le code avant d\'annuler l\'épinglage"</string>
    <string name="lock_to_app_unlock_pattern" msgid="2694204070499712503">"Demander le schéma de déverrouillage avant d\'annuler l\'épinglage"</string>
    <string name="lock_to_app_unlock_password" msgid="9126722403506560473">"Demander le mot de passe avant d\'annuler l\'épinglage"</string>
    <string name="package_installed_device_owner" msgid="7035926868974878525">"Installé par votre administrateur"</string>
    <string name="package_updated_device_owner" msgid="7560272363805506941">"Mis à jour par votre administrateur"</string>
    <string name="package_deleted_device_owner" msgid="2292335928930293023">"Supprimé par votre administrateur"</string>
    <string name="confirm_battery_saver" msgid="5247976246208245754">"OK"</string>
    <string name="battery_saver_description_with_learn_more" msgid="5997766757551917769">"Pour prolonger l\'autonomie de la batterie, l\'économiseur de batterie :\n\n· active le thème sombre ;\n· désactive ou restreint les activités en arrière-plan, certains effets visuels et d\'autres fonctionnalités, comme \"Ok Google\".\n\n"<annotation id="url">"En savoir plus"</annotation></string>
    <string name="battery_saver_description" msgid="8587408568232177204">"Pour prolonger l\'autonomie de la batterie, l\'économiseur de batterie :\n\n· active le thème sombre ;·\n désactive ou restreint les activités en arrière-plan, certains effets visuels et d\'autres fonctionnalités, comme \"Ok Google\"."</string>
    <string name="data_saver_description" msgid="4995164271550590517">"Pour réduire la consommation de données, l\'économiseur de données empêche certaines applications d\'envoyer ou de recevoir des données en arrière-plan. Ainsi, les applications que vous utilisez peuvent toujours accéder aux données, mais pas en permanence. Par exemple, il se peut que les images ne s\'affichent pas tant que vous n\'appuyez pas dessus."</string>
    <string name="data_saver_enable_title" msgid="7080620065745260137">"Activer l\'économiseur de données ?"</string>
    <string name="data_saver_enable_button" msgid="4399405762586419726">"Activer"</string>
    <plurals name="zen_mode_duration_minutes_summary" formatted="false" msgid="2877101784123058273">
      <item quantity="one">Pendant %1$d minute (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pendant %1$d minutes (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_summary_short" formatted="false" msgid="4230730310318858312">
      <item quantity="one">Pendant %1$d min (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pendant %1$d min (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary" formatted="false" msgid="7725354244196466758">
      <item quantity="one">Pendant %1$d heure (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pendant %1$d heures (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_summary_short" formatted="false" msgid="588719069121765642">
      <item quantity="one">Pendant %1$d h (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Pendant %1$d h (jusqu\'à <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes" formatted="false" msgid="1148568456958944998">
      <item quantity="one">Pendant %d minute</item>
      <item quantity="other">Pendant %d minutes</item>
    </plurals>
    <plurals name="zen_mode_duration_minutes_short" formatted="false" msgid="2742377799995454859">
      <item quantity="one">Pendant %d min</item>
      <item quantity="other">Pendant %d min</item>
    </plurals>
    <plurals name="zen_mode_duration_hours" formatted="false" msgid="525401855645490022">
      <item quantity="one">Pendant %d heure</item>
      <item quantity="other">Pendant %d heures</item>
    </plurals>
    <plurals name="zen_mode_duration_hours_short" formatted="false" msgid="7644653189680911640">
      <item quantity="one">Pendant %d h</item>
      <item quantity="other">Pendant %d h</item>
    </plurals>
    <string name="zen_mode_until" msgid="2250286190237669079">"Jusqu\'à <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_alarm" msgid="7046911727540499275">"Jusqu\'à <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> (alarme suivante)"</string>
    <string name="zen_mode_forever" msgid="740585666364912448">"Jusqu\'à la désactivation"</string>
    <string name="zen_mode_forever_dnd" msgid="3423201955704180067">"Jusqu\'à ce que vous désactiviez la fonctionnalité \"Ne pas déranger\""</string>
    <string name="zen_mode_rule_name_combination" msgid="7174598364351313725">"<xliff:g id="FIRST">%1$s</xliff:g>/<xliff:g id="REST">%2$s</xliff:g>"</string>
    <string name="toolbar_collapse_description" msgid="8009920446193610996">"Réduire"</string>
    <string name="zen_mode_feature_name" msgid="3785547207263754500">"Ne pas déranger"</string>
    <string name="zen_mode_downtime_feature_name" msgid="5886005761431427128">"Temps d\'arrêt"</string>
    <string name="zen_mode_default_weeknights_name" msgid="7902108149994062847">"Soirée de semaine"</string>
    <string name="zen_mode_default_weekends_name" msgid="4707200272709377930">"Week-end"</string>
    <string name="zen_mode_default_events_name" msgid="2280682960128512257">"Événement"</string>
    <string name="zen_mode_default_every_night_name" msgid="1467765312174275823">"Sommeil"</string>
    <string name="muted_by" msgid="91464083490094950">"<xliff:g id="THIRD_PARTY">%1$s</xliff:g> coupe certains sons"</string>
    <string name="system_error_wipe_data" msgid="5910572292172208493">"Un problème interne lié à votre appareil est survenu. Ce dernier risque d\'être instable jusqu\'à ce que vous rétablissiez la configuration d\'usine."</string>
    <string name="system_error_manufacturer" msgid="703545241070116315">"Un problème interne lié à votre appareil est survenu. Veuillez contacter le fabricant pour en savoir plus."</string>
    <string name="stk_cc_ussd_to_dial" msgid="3139884150741157610">"Requête USSD transformée en appel standard"</string>
    <string name="stk_cc_ussd_to_ss" msgid="4826846653052609738">"Requête USSD transformée en requête SS"</string>
    <string name="stk_cc_ussd_to_ussd" msgid="8343001461299302472">"Remplacement par une nouvelle requête USSD"</string>
    <string name="stk_cc_ussd_to_dial_video" msgid="429118590323618623">"Requête USSD transformée en appel vidéo"</string>
    <string name="stk_cc_ss_to_dial" msgid="4087396658768717077">"Requête SS transformée en appel standard"</string>
    <string name="stk_cc_ss_to_dial_video" msgid="1324194624384312664">"Requête SS transformée en appel vidéo"</string>
    <string name="stk_cc_ss_to_ussd" msgid="8417905193112944760">"Requête SS transformée en requête USSD"</string>
    <string name="stk_cc_ss_to_ss" msgid="132040645206514450">"Remplacement par une nouvelle requête SS"</string>
    <string name="notification_work_profile_content_description" msgid="5296477955677725799">"Profil professionnel"</string>
    <string name="notification_alerted_content_description" msgid="6139691253611265992">"Alerte envoyée"</string>
    <string name="expand_button_content_description_collapsed" msgid="3873368935659010279">"Développer"</string>
    <string name="expand_button_content_description_expanded" msgid="7484217944948667489">"Réduire"</string>
    <string name="expand_action_accessibility" msgid="1947657036871746627">"activer/désactiver le développement"</string>
    <string name="usb_midi_peripheral_name" msgid="490523464968655741">"Port du périphérique USB Android"</string>
    <string name="usb_midi_peripheral_manufacturer_name" msgid="7557148557088787741">"Android"</string>
    <string name="usb_midi_peripheral_product_name" msgid="2836276258480904434">"Port du périphérique USB"</string>
    <string name="floating_toolbar_open_overflow_description" msgid="2260297653578167367">"Plus d\'options"</string>
    <string name="floating_toolbar_close_overflow_description" msgid="3949818077708138098">"Fermer la barre d\'outils en superposition"</string>
    <string name="maximize_button_text" msgid="4258922519914732645">"Agrandir"</string>
    <string name="close_button_text" msgid="10603510034455258">"Fermer"</string>
    <string name="notification_messaging_title_template" msgid="772857526770251989">"<xliff:g id="CONVERSATION_TITLE">%1$s</xliff:g> : <xliff:g id="SENDER_NAME">%2$s</xliff:g>"</string>
    <plurals name="selected_count" formatted="false" msgid="3946212171128200491">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> élément sélectionné</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> éléments sélectionnés</item>
    </plurals>
    <string name="default_notification_channel_label" msgid="3697928973567217330">"Sans catégorie"</string>
    <string name="importance_from_user" msgid="2782756722448800447">"Vous définissez l\'importance de ces notifications."</string>
    <string name="importance_from_person" msgid="4235804979664465383">"Ces notifications sont importantes en raison des participants."</string>
    <string name="notification_history_title_placeholder" msgid="7748630986182249599">"Notification d\'application personnalisée"</string>
    <string name="user_creation_account_exists" msgid="2239146360099708035">"Autoriser <xliff:g id="APP">%1$s</xliff:g> à créer un profil utilisateur avec le compte <xliff:g id="ACCOUNT">%2$s</xliff:g> (un utilisateur associé à ce compte existe déjà) ?"</string>
    <string name="user_creation_adding" msgid="7305185499667958364">"Autoriser <xliff:g id="APP">%1$s</xliff:g> à créer un profil utilisateur avec le compte <xliff:g id="ACCOUNT">%2$s</xliff:g> ?"</string>
    <string name="language_selection_title" msgid="52674936078683285">"Ajouter une langue"</string>
    <string name="country_selection_title" msgid="5221495687299014379">"Préférences régionales"</string>
    <string name="search_language_hint" msgid="7004225294308793583">"Saisissez la langue"</string>
    <string name="language_picker_section_suggested" msgid="6556199184638990447">"Suggestions"</string>
    <string name="language_picker_section_all" msgid="1985809075777564284">"Toutes les langues"</string>
    <string name="region_picker_section_all" msgid="756441309928774155">"Toutes les régions"</string>
    <string name="locale_search_menu" msgid="6258090710176422934">"Rechercher"</string>
    <string name="app_suspended_title" msgid="888873445010322650">"Application indisponible"</string>
    <string name="app_suspended_default_message" msgid="6451215678552004172">"L\'application <xliff:g id="APP_NAME_0">%1$s</xliff:g> n\'est pas disponible pour le moment. Cette suspension est gérée par l\'application <xliff:g id="APP_NAME_1">%2$s</xliff:g>."</string>
    <string name="app_suspended_more_details" msgid="211260942831587014">"En savoir plus"</string>
    <string name="app_suspended_unsuspend_message" msgid="1665438589450555459">"Débloquer l\'application"</string>
    <string name="work_mode_off_title" msgid="5503291976647976560">"Activer profil professionnel ?"</string>
    <string name="work_mode_off_message" msgid="8417484421098563803">"Vos applications professionnelles, notifications, données et d\'autres fonctionnalités de votre profil professionnel seront activées"</string>
    <string name="work_mode_turn_on" msgid="3662561662475962285">"Activer"</string>
    <string name="app_blocked_title" msgid="7353262160455028160">"Application non disponible"</string>
    <string name="app_blocked_message" msgid="542972921087873023">"<xliff:g id="APP_NAME">%1$s</xliff:g> n\'est pas disponible pour le moment."</string>
    <string name="deprecated_target_sdk_message" msgid="5203207875657579953">"Cette application a été conçue pour une ancienne version d\'Android et risque de ne pas fonctionner correctement. Recherchez des mises à jour ou contactez le développeur."</string>
    <string name="deprecated_target_sdk_app_store" msgid="8456784048558808909">"Rechercher une mise à jour"</string>
    <string name="new_sms_notification_title" msgid="6528758221319927107">"Vous avez de nouveaux messages"</string>
    <string name="new_sms_notification_content" msgid="3197949934153460639">"Ouvrir l\'application de SMS pour afficher le message"</string>
    <string name="profile_encrypted_title" msgid="9001208667521266472">"Des fonctions peuvent être limitées"</string>
    <string name="profile_encrypted_detail" msgid="5279730442756849055">"Profil professionnel verrouillé"</string>
    <string name="profile_encrypted_message" msgid="1128512616293157802">"Appuyez pour déverrouiller profil pro"</string>
    <string name="usb_mtp_launch_notification_title" msgid="774319638256707227">"Connecté à <xliff:g id="PRODUCT_NAME">%1$s</xliff:g>"</string>
    <string name="usb_mtp_launch_notification_description" msgid="6942535713629852684">"Appuyez ici pour voir les fichiers."</string>
    <string name="pin_target" msgid="8036028973110156895">"Épingler"</string>
    <string name="pin_specific_target" msgid="7824671240625957415">"Épingler <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="unpin_target" msgid="3963318576590204447">"Retirer"</string>
    <string name="unpin_specific_target" msgid="3859828252160908146">"Retirer <xliff:g id="LABEL">%1$s</xliff:g>"</string>
    <string name="app_info" msgid="6113278084877079851">"Infos sur l\'appli"</string>
    <string name="negative_duration" msgid="1938335096972945232">"− <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="demo_starting_message" msgid="6577581216125805905">"Lancement de la démo…"</string>
    <string name="demo_restarting_message" msgid="1160053183701746766">"Réinitialisation…"</string>
    <string name="suspended_widget_accessibility" msgid="6331451091851326101">"Élément \"<xliff:g id="LABEL">%1$s</xliff:g>\" désactivé"</string>
    <string name="conference_call" msgid="5731633152336490471">"Conférence téléphonique"</string>
    <string name="tooltip_popup_title" msgid="7863719020269945722">"Info-bulle"</string>
    <string name="app_category_game" msgid="4534216074910244790">"Jeux"</string>
    <string name="app_category_audio" msgid="8296029904794676222">"Musique et audio"</string>
    <string name="app_category_video" msgid="2590183854839565814">"Films et vidéos"</string>
    <string name="app_category_image" msgid="7307840291864213007">"Photos et images"</string>
    <string name="app_category_social" msgid="2278269325488344054">"Réseaux sociaux et communication"</string>
    <string name="app_category_news" msgid="1172762719574964544">"Actualités et magazines"</string>
    <string name="app_category_maps" msgid="6395725487922533156">"Plans et navigation"</string>
    <string name="app_category_productivity" msgid="1844422703029557883">"Productivité"</string>
    <string name="device_storage_monitor_notification_channel" msgid="5164244565844470758">"Mémoire de l\'appareil"</string>
    <string name="adb_debugging_notification_channel_tv" msgid="4764046459631031496">"Débogage USB"</string>
    <string name="time_picker_hour_label" msgid="4208590187662336864">"heures"</string>
    <string name="time_picker_minute_label" msgid="8307452311269824553">"minutes"</string>
    <string name="time_picker_header_text" msgid="9073802285051516688">"Définir l\'heure"</string>
    <string name="time_picker_input_error" msgid="8386271930742451034">"Veuillez indiquer une heure valide"</string>
    <string name="time_picker_prompt_label" msgid="303588544656363889">"Indiquez l\'heure"</string>
    <string name="time_picker_text_input_mode_description" msgid="4761160667516611576">"Passer en mode saisie de texte pour la saisie de l\'heure."</string>
    <string name="time_picker_radial_mode_description" msgid="1222342577115016953">"Passer en mode horloge pour la saisie de l\'heure."</string>
    <string name="autofill_picker_accessibility_title" msgid="4425806874792196599">"Options de saisie automatique"</string>
    <string name="autofill_save_accessibility_title" msgid="1523225776218450005">"Enregistrer pour la saisie automatique"</string>
    <string name="autofill_error_cannot_autofill" msgid="6528827648643138596">"Le contenu ne peut pas être saisi automatiquement"</string>
    <string name="autofill_picker_no_suggestions" msgid="1076022650427481509">"Aucune suggestion de saisie automatique"</string>
    <plurals name="autofill_picker_some_suggestions" formatted="false" msgid="6651883186966959978">
      <item quantity="one"><xliff:g id="COUNT">%1$s</xliff:g> suggestion de saisie automatique</item>
      <item quantity="other"><xliff:g id="COUNT">%1$s</xliff:g> suggestions de saisie automatique</item>
    </plurals>
    <string name="autofill_save_title" msgid="7719802414283739775">"Enregistrer dans "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_save_title_with_type" msgid="3002460014579799605">"Enregistrer <xliff:g id="TYPE">%1$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_save_title_with_2types" msgid="3783270967447869241">"Enregistrer <xliff:g id="TYPE_0">%1$s</xliff:g> et <xliff:g id="TYPE_1">%2$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_save_title_with_3types" msgid="6598228952100102578">"Enregistrer <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> et <xliff:g id="TYPE_2">%3$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_update_title" msgid="3630695947047069136">"Mettre à jour cet élément dans "<b>"<xliff:g id="LABEL">%1$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_update_title_with_type" msgid="5264152633488495704">"Mettre à jour <xliff:g id="TYPE">%1$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%2$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_update_title_with_2types" msgid="1797514386321086273">"Mettre à jour <xliff:g id="TYPE_0">%1$s</xliff:g> et <xliff:g id="TYPE_1">%2$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%3$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_update_title_with_3types" msgid="1312232153076212291">"Mettre à jour les éléments <xliff:g id="TYPE_0">%1$s</xliff:g>, <xliff:g id="TYPE_1">%2$s</xliff:g> et <xliff:g id="TYPE_2">%3$s</xliff:g> dans "<b>"<xliff:g id="LABEL">%4$s</xliff:g>"</b>" ?"</string>
    <string name="autofill_save_yes" msgid="8035743017382012850">"Enregistrer"</string>
    <string name="autofill_save_no" msgid="9212826374207023544">"Non, merci"</string>
    <string name="autofill_save_notnow" msgid="2853932672029024195">"Pas maintenant"</string>
    <string name="autofill_save_never" msgid="6821841919831402526">"Jamais"</string>
    <string name="autofill_update_yes" msgid="4608662968996874445">"Mettre à jour"</string>
    <string name="autofill_continue_yes" msgid="7914985605534510385">"Continuer"</string>
    <string name="autofill_save_type_password" msgid="5624528786144539944">"mot de passe"</string>
    <string name="autofill_save_type_address" msgid="3111006395818252885">"adresse"</string>
    <string name="autofill_save_type_credit_card" msgid="3583795235862046693">"carte de paiement"</string>
    <string name="autofill_save_type_debit_card" msgid="3169397504133097468">"carte de débit"</string>
    <string name="autofill_save_type_payment_card" msgid="6555012156728690856">"carte de paiement"</string>
    <string name="autofill_save_type_generic_card" msgid="1019367283921448608">"carte"</string>
    <string name="autofill_save_type_username" msgid="1018816929884640882">"nom d\'utilisateur"</string>
    <string name="autofill_save_type_email_address" msgid="1303262336895591924">"adresse e-mail"</string>
    <string name="etws_primary_default_message_earthquake" msgid="8401079517718280669">"Restez calme et cherchez un abri à proximité."</string>
    <string name="etws_primary_default_message_tsunami" msgid="5828171463387976279">"Évacuez immédiatement les zones côtières et les berges des fleuves, et réfugiez-vous dans un endroit plus sûr, comme un terrain surélevé."</string>
    <string name="etws_primary_default_message_earthquake_and_tsunami" msgid="4888224011071875068">"Restez calme et cherchez un abri à proximité."</string>
    <string name="etws_primary_default_message_test" msgid="4583367373909549421">"Test de messages d\'urgence"</string>
    <string name="notification_reply_button_accessibility" msgid="5235776156579456126">"Répondre"</string>
    <string name="etws_primary_default_message_others" msgid="7958161706019130739"></string>
    <string name="mmcc_authentication_reject" msgid="4891965994643876369">"Carte SIM non autorisée pour les commandes vocales"</string>
    <string name="mmcc_imsi_unknown_in_hlr" msgid="227760698553988751">"Carte SIM non provisionnée pour les commandes vocales"</string>
    <string name="mmcc_illegal_ms" msgid="7509650265233909445">"Carte SIM non autorisée pour les commandes vocales"</string>
    <string name="mmcc_illegal_me" msgid="6505557881889904915">"Téléphone non autorisé pour les commandes vocales"</string>
    <string name="mmcc_authentication_reject_msim_template" msgid="4480853038909922153">"Carte SIM <xliff:g id="SIMNUMBER">%d</xliff:g> non autorisée"</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template" msgid="3688508325248599657">"Carte SIM <xliff:g id="SIMNUMBER">%d</xliff:g> non provisionnée"</string>
    <string name="mmcc_illegal_ms_msim_template" msgid="832644375774599327">"Carte SIM <xliff:g id="SIMNUMBER">%d</xliff:g> non autorisée"</string>
    <string name="mmcc_illegal_me_msim_template" msgid="4802735138861422802">"Carte SIM <xliff:g id="SIMNUMBER">%d</xliff:g> non autorisée"</string>
    <string name="popup_window_default_title" msgid="6907717596694826919">"Fenêtre pop-up"</string>
    <string name="slice_more_content" msgid="3377367737876888459">"+ <xliff:g id="NUMBER">%1$d</xliff:g>"</string>
    <string name="shortcut_restored_on_lower_version" msgid="9206301954024286063">"La version de l\'application est revenue à une version antérieure ou n\'est pas compatible avec cet raccourci"</string>
    <string name="shortcut_restore_not_supported" msgid="4763198938588468400">"Le raccourci ne peut pas être restauré car l\'application n\'accepte pas la sauvegarde et la restauration"</string>
    <string name="shortcut_restore_signature_mismatch" msgid="579345304221605479">"Le raccourci ne peut pas être restauré car la signature de l\'application est différente"</string>
    <string name="shortcut_restore_unknown_issue" msgid="2478146134395982154">"Impossible de restaurer le raccourci"</string>
    <string name="shortcut_disabled_reason_unknown" msgid="753074793553599166">"Le raccourci est désactivé"</string>
    <string name="harmful_app_warning_uninstall" msgid="6472912975664191772">"DÉSINSTALLER"</string>
    <string name="harmful_app_warning_open_anyway" msgid="5963657791740211807">"OUVRIR QUAND MÊME"</string>
    <string name="harmful_app_warning_title" msgid="8794823880881113856">"Application dangereuse détectée"</string>
    <string name="slices_permission_request" msgid="3677129866636153406">"<xliff:g id="APP_0">%1$s</xliff:g> souhaite afficher des éléments de <xliff:g id="APP_2">%2$s</xliff:g>"</string>
    <string name="screenshot_edit" msgid="7408934887203689207">"Modifier"</string>
    <string name="volume_dialog_ringer_guidance_vibrate" msgid="2055927873175228519">"Vibreur pour les appels et les notifications"</string>
    <string name="volume_dialog_ringer_guidance_silent" msgid="1011246774949993783">"Sonnerie désactivée pour les appels et les notifications"</string>
    <string name="notification_channel_system_changes" msgid="2462010596920209678">"Modifications du système"</string>
    <string name="notification_channel_do_not_disturb" msgid="7832584281883687653">"Ne pas déranger"</string>
    <string name="zen_upgrade_notification_visd_title" msgid="2001148984371968620">"Nouveau : Le mode Ne pas déranger masque les notifications"</string>
    <string name="zen_upgrade_notification_visd_content" msgid="3683314609114134946">"Appuyez pour en savoir plus et pour modifier les paramètres."</string>
    <string name="zen_upgrade_notification_title" msgid="8198167698095298717">"Le mode Ne pas déranger a été modifié"</string>
    <string name="zen_upgrade_notification_content" msgid="5228458567180124005">"Appuyez pour vérifier les contenus bloqués."</string>
    <string name="notification_app_name_system" msgid="3045196791746735601">"Système"</string>
    <string name="notification_app_name_settings" msgid="9088548800899952531">"Paramètres"</string>
    <string name="notification_appops_camera_active" msgid="8177643089272352083">"Caméra"</string>
    <string name="notification_appops_microphone_active" msgid="581333393214739332">"Micro"</string>
    <string name="notification_appops_overlay_active" msgid="5571732753262836481">"se superpose aux autres applications sur l\'écran"</string>
    <string name="dynamic_mode_notification_channel_name" msgid="2986926422100223328">"Notification d\'information du mode Routine"</string>
    <string name="dynamic_mode_notification_title" msgid="9205715501274608016">"Vous risquez d\'être à court de batterie plus tôt que prévu"</string>
    <string name="dynamic_mode_notification_summary" msgid="4141614604437372157">"Économiseur de batterie activé pour prolonger l\'autonomie"</string>
    <string name="battery_saver_notification_channel_name" msgid="3918243458067916913">"Économiseur de batterie"</string>
    <string name="battery_saver_off_notification_title" msgid="7637255960468032515">"Économiseur de batterie désactivé"</string>
    <string name="battery_saver_charged_notification_summary" product="default" msgid="5544457317418624367">"Téléphone suffisamment chargé. Les fonctionnalités ne sont plus restreintes."</string>
    <string name="battery_saver_charged_notification_summary" product="tablet" msgid="4426317048139996888">"Tablette suffisamment chargée. Les fonctionnalités ne sont plus restreintes."</string>
    <string name="battery_saver_charged_notification_summary" product="device" msgid="1031562417867646649">"Appareil suffisamment chargé. Les fonctionnalités ne sont plus restreintes."</string>
    <string name="mime_type_folder" msgid="2203536499348787650">"Dossier"</string>
    <string name="mime_type_apk" msgid="3168784749499623902">"Application Android"</string>
    <string name="mime_type_generic" msgid="4606589110116560228">"Fichier"</string>
    <string name="mime_type_generic_ext" msgid="9220220924380909486">"Fichier <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_audio" msgid="4933450584432509875">"Audio"</string>
    <string name="mime_type_audio_ext" msgid="2615491023840514797">"Audio <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_video" msgid="7071965726609428150">"Vidéo"</string>
    <string name="mime_type_video_ext" msgid="185438149044230136">"Vidéo <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_image" msgid="2134307276151645257">"Image"</string>
    <string name="mime_type_image_ext" msgid="5743552697560999471">"Image <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_compressed" msgid="8737300936080662063">"Archive"</string>
    <string name="mime_type_compressed_ext" msgid="4775627287994475737">"Archive <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_document" msgid="3737256839487088554">"Document"</string>
    <string name="mime_type_document_ext" msgid="2398002765046677311">"Document <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_spreadsheet" msgid="8188407519131275838">"Feuille de calcul"</string>
    <string name="mime_type_spreadsheet_ext" msgid="8720173181137254414">"Feuille de calcul <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="mime_type_presentation" msgid="1145384236788242075">"Présentation"</string>
    <string name="mime_type_presentation_ext" msgid="8761049335564371468">"Présentation <xliff:g id="EXTENSION">%1$s</xliff:g>"</string>
    <string name="bluetooth_airplane_mode_toast" msgid="2066399056595768554">"Le Bluetooth restera activé en mode Avion"</string>
    <string name="car_loading_profile" msgid="8219978381196748070">"Chargement…"</string>
    <plurals name="file_count" formatted="false" msgid="7063513834724389247">
      <item quantity="one"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> fichier</item>
      <item quantity="other"><xliff:g id="FILE_NAME_2">%s</xliff:g> + <xliff:g id="COUNT_3">%d</xliff:g> fichiers</item>
    </plurals>
    <string name="chooser_no_direct_share_targets" msgid="1511722103987329028">"Aucune recommandation de personnes avec lesquelles effectuer un partage"</string>
    <string name="chooser_all_apps_button_label" msgid="3230427756238666328">"Liste des applications"</string>
    <string name="usb_device_resolve_prompt_warn" msgid="325871329788064199">"Cette application n\'a pas reçu l\'autorisation d\'enregistrer des contenus audio, mais peut le faire via ce périphérique USB."</string>
    <string name="accessibility_system_action_home_label" msgid="3234748160850301870">"Accueil"</string>
    <string name="accessibility_system_action_back_label" msgid="4205361367345537608">"Retour"</string>
    <string name="accessibility_system_action_recents_label" msgid="4782875610281649728">"Applications récentes"</string>
    <string name="accessibility_system_action_notifications_label" msgid="6083767351772162010">"Notifications"</string>
    <string name="accessibility_system_action_quick_settings_label" msgid="4583900123506773783">"Configuration rapide"</string>
    <string name="accessibility_system_action_power_dialog_label" msgid="8095341821683910781">"Boîte de dialogue Marche/Arrêt"</string>
    <string name="accessibility_system_action_lock_screen_label" msgid="5484190691945563838">"Verrouiller l\'écran"</string>
    <string name="accessibility_system_action_screenshot_label" msgid="3581566515062741676">"Capture d\'écran"</string>
    <string name="accessibility_system_action_accessibility_button_label" msgid="5941347017132886642">"Raccourci d\'accessibilité à l\'écran"</string>
    <string name="accessibility_system_action_accessibility_button_chooser_label" msgid="6973618519666227981">"Outil de sélection des raccourcis d\'accessibilité à l\'écran"</string>
    <string name="accessibility_freeform_caption" msgid="8377519323496290122">"Barre de légende de l\'application <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="as_app_forced_to_restricted_bucket" msgid="8233871289353898964">"<xliff:g id="PACKAGE_NAME">%1$s</xliff:g> a été placé dans le bucket RESTRICTED"</string>
    <string name="conversation_single_line_name_display" msgid="8958948312915255999">"<xliff:g id="SENDER_NAME">%1$s</xliff:g> :"</string>
    <string name="conversation_single_line_image_placeholder" msgid="6983271082911936900">"a envoyé une image"</string>
    <string name="conversation_title_fallback_one_to_one" msgid="1980753619726908614">"Conversation"</string>
    <string name="conversation_title_fallback_group_chat" msgid="456073374993104303">"Conversation de groupe"</string>
    <string name="unread_convo_overflow" msgid="920517615597353833">"<xliff:g id="MAX_UNREAD_COUNT">%1$d</xliff:g> ou +"</string>
    <string name="resolver_personal_tab" msgid="2051260504014442073">"Personnel"</string>
    <string name="resolver_work_tab" msgid="2690019516263167035">"Professionnel"</string>
    <string name="resolver_personal_tab_accessibility" msgid="5739524949153091224">"Vue personnelle"</string>
    <string name="resolver_work_tab_accessibility" msgid="4753168230363802734">"Vue professionnelle"</string>
    <string name="resolver_cant_share_with_work_apps" msgid="637686613606502219">"Impossible de partager ce contenu avec les applications professionnelles"</string>
    <string name="resolver_cant_share_with_work_apps_explanation" msgid="3332302070341130545">"Votre administrateur informatique ne vous autorise pas à partager ce contenu avec les applications de votre profil professionnel"</string>
    <string name="resolver_cant_access_work_apps" msgid="2455757966397563223">"Impossible d\'ouvrir ce contenu avec les applications professionnelles"</string>
    <string name="resolver_cant_access_work_apps_explanation" msgid="3626983885525445790">"Votre administrateur informatique ne vous autorise pas à ouvrir ce contenu avec les applications de votre profil professionnel"</string>
    <string name="resolver_cant_share_with_personal_apps" msgid="3079139799233316203">"Impossible de partager ce contenu avec les applications personnelles"</string>
    <string name="resolver_cant_share_with_personal_apps_explanation" msgid="2959282422751315171">"Votre administrateur informatique ne vous autorise pas à partager ce contenu avec les applications de votre profil personnel"</string>
    <string name="resolver_cant_access_personal_apps" msgid="648291604475669395">"Impossible d\'ouvrir ce contenu avec les applications personnelles"</string>
    <string name="resolver_cant_access_personal_apps_explanation" msgid="2298773629302296519">"Votre administrateur informatique ne vous autorise pas à ouvrir ce contenu avec les applications de votre profil personnel"</string>
    <string name="resolver_turn_on_work_apps" msgid="884910835250037247">"Profil professionnel en pause"</string>
    <string name="resolver_switch_on_work" msgid="2873009160846966379">"Activer"</string>
    <string name="resolver_no_work_apps_available_share" msgid="7933949011797699505">"Aucune application professionnelle ne prend en charge ce contenu"</string>
    <string name="resolver_no_work_apps_available_resolve" msgid="1244844292366099399">"Aucune application professionnelle ne peut ouvrir ce contenu"</string>
    <string name="resolver_no_personal_apps_available_share" msgid="5639102815174748732">"Aucune application personnelle ne prend en charge ce contenu"</string>
    <string name="resolver_no_personal_apps_available_resolve" msgid="5120671970531446978">"Aucune application personnelle ne peut ouvrir ce contenu"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ENTRY" msgid="8050953231914637819">"Code PIN de déblocage du réseau SIM"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ENTRY" msgid="7164399703751688214">"Code PIN de déblocage du sous-ensemble du réseau SIM"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ENTRY" msgid="4447629474818217364">"Code PIN de déblocage de la carte SIM d\'entreprise"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ENTRY" msgid="973059024670737358">"Code PIN de déblocage de la carte SIM du fournisseur de services."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ENTRY" msgid="4487435301206073787">"Code de déblocage de la carte SIM"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ENTRY" msgid="768060297218652809">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ENTRY" msgid="7129527319490548930">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ENTRY" msgid="2876126640607573252">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="8952595089930109282">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ENTRY" msgid="3013902515773728996">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ENTRY" msgid="2974411408893410289">"Code PIN de déblocage de la carte RUIM Network1"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ENTRY" msgid="687618528751880721">"Code PIN de déblocage de la carte RUIM Network2"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ENTRY" msgid="6810596579655575381">"Code PIN de déblocage de la carte RUIM HRPD"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ENTRY" msgid="2715929642540980259">"Code PIN de déblocage de la carte RUIM d\'entreprise"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ENTRY" msgid="8557791623303951590">"Code PIN de déblocage de la carte RUIM du fournisseur de services"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ENTRY" msgid="7382468767274580323">"Code PIN de déblocage de la carte RUIM"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ENTRY" msgid="6730880791104286987">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ENTRY" msgid="6432126539782267026">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ENTRY" msgid="1730510161529488920">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ENTRY" msgid="3369885925003346830">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ENTRY" msgid="9129139686191167829">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ENTRY" msgid="2869929685874615358">"Saisir la clé PUK"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ENTRY" msgid="1238663472392741771">"Code PIN de déblocage SPN"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ENTRY" msgid="3988705848553894358">"Code PIN de déblocage SP EHPLMN"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ENTRY" msgid="6186770686690993200">"Code de déblocage ICCID"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ENTRY" msgid="7043865376145617024">"Code PIN de déblocage IMPI"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ENTRY" msgid="6144227308185112176">"Code PIN de déblocage du sous-réseau du fournisseur de services."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_IN_PROGRESS" msgid="4233355366318061180">"Demande de déblocage du réseau SIM…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_IN_PROGRESS" msgid="6742563947637715645">"Demande de déblocage du sous-ensemble du réseau SIM…"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="2033399698172403560">"Demande de déblocage de la carte SIM du fournisseur de services…"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_IN_PROGRESS" msgid="4795977251920732254">"Demande de déblocage de la carte SIM d\'entreprise…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_IN_PROGRESS" msgid="1090425878157254446">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_IN_PROGRESS" msgid="6476898876518094438">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_IN_PROGRESS" msgid="6006806734293747731">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="6546680489620881893">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_IN_PROGRESS" msgid="3506845511000727015">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_SIM_IN_PROGRESS" msgid="6709169861932992750">"Demande de déblocage de la carte SIM…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_IN_PROGRESS" msgid="4013870911606478520">"Demande de déblocage de la carte RUIM Network1…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_IN_PROGRESS" msgid="9032651188219523434">"Demande de déblocage de la carte RUIM Network2…"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_IN_PROGRESS" msgid="6584576506344491207">"Demande de déblocage de la carte RUIM HRPD…"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_IN_PROGRESS" msgid="830981927724888114">"Demande de déblocage de la carte RUIM…"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_IN_PROGRESS" msgid="7851790973098894802">"Demande de déblocage de la carte RUIM d\'entreprise…"</string>
    <string name="PERSOSUBSTATE_SIM_SPN_IN_PROGRESS" msgid="1149560739586960121">"Demande de déblocage SPN…"</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_IN_PROGRESS" msgid="5708964693522116025">"Demande de déblocage SP EHPLMN…"</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_IN_PROGRESS" msgid="7288103122966483455">"Demande de déblocage ICCID…"</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_IN_PROGRESS" msgid="4036752174056147753">"Demande de déblocage IMPI…"</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_IN_PROGRESS" msgid="5089536274515338566">"Demande de déblocage du sous-réseau du fournisseur de services…"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_IN_PROGRESS" msgid="6737197986936251958">"Demande de déblocage de la carte RUIM…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_IN_PROGRESS" msgid="5658767775619998623">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_IN_PROGRESS" msgid="665978313257653727">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_IN_PROGRESS" msgid="3857142652251836850">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_IN_PROGRESS" msgid="2695664012344346788">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_IN_PROGRESS" msgid="2695678959963807782">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_IN_PROGRESS" msgid="1230605365926493599">"Demande de déblocage avec la clé PUK…"</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_ERROR" msgid="1924844017037151535">"Échec de la demande de déblocage du réseau SIM."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_ERROR" msgid="3372797822292089708">"Échec de la demande de déblocage du sous-ensemble du réseau SIM."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_ERROR" msgid="1878443146720411381">"Échec de la demande de déblocage de la carte SIM du fournisseur de services."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_ERROR" msgid="7664778312218023192">"Échec de la demande de déblocage de la carte SIM d\'entreprise."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_ERROR" msgid="2472944311643350302">"Échec de la demande de déblocage de la carte SIM."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_ERROR" msgid="828089694480999120">"Échec de la demande de déblocage de la carte RUIM Network1."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_ERROR" msgid="17619001007092511">"Échec de la demande de déblocage de la carte RUIM Network2."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_ERROR" msgid="807214229604353614">"Échec de la demande de déblocage de la carte RUIM HRPD."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_ERROR" msgid="8644184447744175747">"Échec de la demande de déblocage de la carte RUIM d\'entreprise."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_ERROR" msgid="3801002648649640407">"Échec de la demande de déblocage de la carte RUIM du fournisseur de services."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_ERROR" msgid="707397021218680753">"Échec de la demande de déblocage de la carte RUIM."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_ERROR" msgid="894358680773257820">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_ERROR" msgid="352466878146726991">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_ERROR" msgid="7353389721907138671">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_ERROR" msgid="2655263155490857920">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_ERROR" msgid="6903740900892931310">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_ERROR" msgid="5165901670447518687">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_ERROR" msgid="2856763216589267623">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_ERROR" msgid="817542684437829139">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_ERROR" msgid="5178635064113393143">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_ERROR" msgid="5391587926974531008">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_ERROR" msgid="4895494864493315868">"Échec du déblocage avec la clé PUK."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_ERROR" msgid="9017576601595353649">"Échec de la demande de déblocage SPN."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_ERROR" msgid="1116993930995545742">"Échec de la demande de déblocage SP EHPLMN."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_ERROR" msgid="7559167306794441462">"Échec de la demande de déblocage ICCID."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_ERROR" msgid="2782926139511136588">"Échec de la demande de déblocage IMPI."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_ERROR" msgid="1890493954453456758">"Échec de la demande de déblocage du sous-réseau du fournisseur de services."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUCCESS" msgid="4886243367747126325">"Déblocage du réseau SIM effectué."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_SUCCESS" msgid="4053809277733513987">"Déblocage du sous-ensemble du réseau SIM effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_SUCCESS" msgid="8249342930499801740">"Déblocage de la carte SIM du fournisseur de services effectué."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_SUCCESS" msgid="2339794542560381270">"Déblocage de la carte SIM d\'entreprise effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_SUCCESS" msgid="6975608174152828954">"Déblocage de la carte SIM effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_SUCCESS" msgid="2846699261330463192">"Déblocage de la carte RUIM Network1 effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_SUCCESS" msgid="5335414726057102801">"Déblocage de la carte RUIM Network2 effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_SUCCESS" msgid="8868100318474971969">"Déblocage de la carte RUIM HRPD effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_SUCCESS" msgid="6020936629725666932">"Déblocage de la carte RUIM du fournisseur de services effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_SUCCESS" msgid="6944873647584595489">"Déblocage de la carte RUIM d\'entreprise effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_SUCCESS" msgid="2526483514124121988">"Déblocage de la carte RUIM effectué."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_PUK_SUCCESS" msgid="7662200333621664621">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK_SUCCESS" msgid="2861223407953766632">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_SIM_CORPORATE_PUK_SUCCESS" msgid="5345648571175243272">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="3725278343103422466">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SIM_PUK_SUCCESS" msgid="6998502547560297983">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK1_PUK_SUCCESS" msgid="8555433771162560361">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_NETWORK2_PUK_SUCCESS" msgid="3555767296933606232">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_HRPD_PUK_SUCCESS" msgid="6778051818199974237">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_CORPORATE_PUK_SUCCESS" msgid="4080108758498911429">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK_SUCCESS" msgid="7873675303000794343">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_RUIM_RUIM_PUK_SUCCESS" msgid="1763198215069819523">"Déblocage avec la clé PUK effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SPN_SUCCESS" msgid="2053891977727320532">"Déblocage SPN effectué."</string>
    <string name="PERSOSUBSTATE_SIM_SP_EHPLMN_SUCCESS" msgid="8146602361895007345">"Déblocage SP EHPLMN effectué."</string>
    <string name="PERSOSUBSTATE_SIM_ICCID_SUCCESS" msgid="8058678548991999545">"Déblocage ICCID effectué."</string>
    <string name="PERSOSUBSTATE_SIM_IMPI_SUCCESS" msgid="2545608067978550571">"Déblocage IMPI effectué."</string>
    <string name="PERSOSUBSTATE_SIM_NS_SP_SUCCESS" msgid="4352382949744625007">"Déblocage du sous-réseau du fournisseur de services effectué."</string>
</resources>
