<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2009 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="sharedUserLabel" msgid="8024311725474286801">"Applications de base Android"</string>
    <string name="app_label" msgid="3389954322874982620">"Liste des contacts"</string>
    <string name="provider_label" msgid="6012150850819899907">"Contacts"</string>
    <string name="upgrade_out_of_memory_notification_ticker" msgid="7638747231223520477">"La mise à jour des contacts requiert plus de mémoire."</string>
    <string name="upgrade_out_of_memory_notification_title" msgid="8888171924684998531">"Mise à jour du stockage des contacts"</string>
    <string name="upgrade_out_of_memory_notification_text" msgid="8438179450336437626">"Appuyez pour terminer la mise à jour."</string>
    <string name="default_directory" msgid="93961630309570294">"Contacts"</string>
    <string name="local_invisible_directory" msgid="705244318477396120">"Autre"</string>
    <string name="voicemail_from_column" msgid="435732568832121444">"Message vocal de "</string>
    <string name="debug_dump_title" msgid="4916885724165570279">"Copier la base de données de contacts"</string>
    <string name="debug_dump_database_message" msgid="406438635002392290">"Vous êtes sur le point de 1) faire une copie de votre base de données (qui inclut toutes les données relatives aux contacts et l\'intégralité du journal d\'appels) dans la mémoire de stockage interne, puis de 2) l\'envoyer par courriel. N\'oubliez pas de supprimer la copie une fois qu\'elle a été dupliquée ou dès que le courriel a été reçu."</string>
    <string name="debug_dump_delete_button" msgid="7832879421132026435">"Supprimer maintenant"</string>
    <string name="debug_dump_start_button" msgid="2837506913757600001">"Démarrer"</string>
    <string name="debug_dump_email_sender_picker" msgid="3534420908672176460">"Choisissez un programme pour envoyer vos fichiers"</string>
    <string name="debug_dump_email_subject" msgid="108188398416385976">"Base de données de contacts ci-jointe"</string>
    <string name="debug_dump_email_body" msgid="4577749800871444318">"Veuillez trouver ci-joint ma base de données de contacts incluant toutes les coordonnées de mes contacts. Merci de la traiter avec précaution."</string>
</resources>
