<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2016 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:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- The name of the app. [CHAR_LIMIT=30] -->
    <string name="app_label">Emergency information</string>
    <!-- The title of the medical information preferences category -->
    <string name="medical_info_title">Medical information</string>
    <!-- The title of the action to add the medical information preferences -->
    <string name="add_medical_info">Add information</string>
    <!-- The description of the pencil icon, for talkback. [CHAR_LIMIT=NONE] -->
    <string name="edit_info">Edit emergency information</string>
    <!-- The title of the emergency info tab. [CHAR_LIMIT=15] -->
    <string name="tab_title_info">Info</string>
    <!-- The title of the emergency contacts tab. [CHAR_LIMIT=15] -->
    <string name="tab_title_contacts">Contacts</string>
    <!-- The title of the name preference. [CHAR_LIMIT=40] -->
    <string name="name">Name</string>
    <!-- The default preference subtitle text to show when the name is unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_name">Unknown</string>
    <!-- The title of the address preference. [CHAR_LIMIT=40] -->
    <string name="address">Address</string>
    <!-- The default preference subtitle text to show when the address is unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_address">Unknown</string>
    <!-- The title of the date of birth preference. [CHAR_LIMIT=40] -->
    <string name="date_of_birth">Date of birth</string>
    <!-- The default preference subtitle text to show when the date of birth is unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_date_of_birth">Unknown</string>
    <!-- Parenthesis around the date of birth of a user. [CHAR_LIMIT=40] -->
    <string name="dob">
        (<xliff:g id="date_of_birth" example="3 feb 1987">%1$s</xliff:g>)
    </string>
    <!-- The age of the user. [CHAR_LIMIT=20] -->
    <string name="age">
        Age: <xliff:g id="numerical_age" example="29">%1$d</xliff:g>
    </string>
    <!-- The description of the remove date of birth icon, for talkback. [CHAR_LIMIT=NONE] -->
    <string name="remove_dob_icon_text">Remove date of birth</string>
    <!-- The title of the blood type preference. [CHAR_LIMIT=40] -->
    <string name="blood_type">Blood type</string>
    <!-- The default preference subtitle text to show when the blood type is unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_blood_type">Unknown</string>
    <!-- Blood type O+. [CHAR_LIMIT=10] -->
    <string name="oplus">O+</string>
    <!-- Blood type O-. [CHAR_LIMIT=10] -->
    <string name="ominus">O-</string>
    <!-- Blood type A+. [CHAR_LIMIT=10] -->
    <string name="aplus">A+</string>
    <!-- Blood type A-. [CHAR_LIMIT=10] -->
    <string name="aminus">A-</string>
    <!-- Blood type B+. [CHAR_LIMIT=10] -->
    <string name="bplus">B+</string>
    <!-- Blood type B-. [CHAR_LIMIT=10] -->
    <string name="bminus">B-</string>
    <!-- Blood type AB+. [CHAR_LIMIT=10] -->
    <string name="abplus">AB+</string>
    <!-- Blood type AB-. [CHAR_LIMIT=10] -->
    <string name="abminus">AB-</string>
    <!-- Blood type H/H. [CHAR_LIMIT=10] -->
    <string name="hh">H/H</string>
    <string-array name="blood_type_entries">
        <item>@string/oplus</item>
        <item>@string/ominus</item>
        <item>@string/aplus</item>
        <item>@string/aminus</item>
        <item>@string/bplus</item>
        <item>@string/bminus</item>
        <item>@string/abplus</item>
        <item>@string/abminus</item>
        <item>@string/hh</item>
        <item>@string/unknown_blood_type</item>
    </string-array>
    <!-- Blood type values. Do not translate -->
    <string-array name="blood_type_values">
        <!-- Do not translate -->
        <item>0+</item>
        <!-- Do not translate -->
        <item>O-</item>
        <!-- Do not translate -->
        <item>A+</item>
        <!-- Do not translate -->
        <item>A-</item>
        <!-- Do not translate -->
        <item>B+</item>
        <!-- Do not translate -->
        <item>B-</item>
        <!-- Do not translate -->
        <item>AB+</item>
        <!-- Do not translate -->
        <item>AB-</item>
        <!-- Do not translate -->
        <item>H/H</item>
        <item></item>
    </string-array>
    <!-- [DO NOT TRANSLATE] Empty text for setting injection [CHAR_LIMIT=NONE] -->
    <string name="injection_summary_empty" translatable="false"></string>
    <!-- Content descriptions for the blood types, used for talkback. -->
    <string-array name="blood_type_content_description">
        <item>@string/o_positive</item>
        <item>@string/o_negative</item>
        <item>@string/a_positive</item>
        <item>@string/a_negative</item>
        <item>@string/b_positive</item>
        <item>@string/b_negative</item>
        <item>@string/ab_positive</item>
        <item>@string/ab_negative</item>
        <item>@string/h_h</item>
        <item>@string/unknown_blood_type</item>
    </string-array>
    <!-- Content descriptions for blood type O+, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="o_positive">O positive</string>
    <!-- Content descriptions for blood type O-, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="o_negative">O negative</string>
    <!-- Content descriptions for blood type A+, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="a_positive">A, positive</string>
    <!-- Content descriptions for blood type A-, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="a_negative">A, negative</string>
    <!-- Content descriptions for blood type B+, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="b_positive">B positive</string>
    <!-- Content descriptions for blood type B-, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="b_negative">B negative</string>
    <!-- Content descriptions for blood type AB+, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="ab_positive">A B positive</string>
    <!-- Content descriptions for blood type AB-, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="ab_negative">A B negative</string>
    <!-- Content descriptions for blood type H/H, used for talkback. [CHAR_LIMIT=NONE] -->
    <string name="h_h">H H</string>

    <!-- The title of the allergies preference. [CHAR_LIMIT=40] -->
    <string name="allergies">Allergies</string>
    <!-- The default preference subtitle text to show when the allergies are unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_allergies">Unknown</string>
    <!-- Hint to show in the edit text of the allergies. [CHAR_LIMIT=30] -->
    <string name="allergies_hint">For example, peanuts</string>
    <!-- The title of the medications preference. [CHAR_LIMIT=40] -->
    <string name="medications">Medications</string>
    <!-- The default preference subtitle text to show when the medications are unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_medications">Unknown</string>
    <!-- Hint to show in the edit text of the medications. [CHAR_LIMIT=30] -->
    <string name="medications_hint">For example, aspirin</string>
    <!-- The title of the medical conditions preference. [CHAR_LIMIT=40] -->
    <string name="medical_conditions">Medical notes</string>
    <!-- The default preference subtitle text to show when the medical conditions are unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_medical_conditions">Unknown</string>
    <!-- Hint to show in the edit text of the medical conditions. [CHAR_LIMIT=30] -->
    <string name="medical_conditions_hint">For example, asthma</string>
    <!-- The title of the organ donor preference. [CHAR_LIMIT=40] -->
    <string name="organ_donor">Organ donor</string>
    <!-- The default preference subtitle text to show when the organ donor choice is unknown. [CHAR_LIMIT=40] -->
    <string name="unknown_organ_donor">Unknown</string>
    <!-- Affirmative. [CHAR_LIMIT=10] -->
    <string name="yes">Yes</string>
    <!-- Negative. [CHAR_LIMIT=10] -->
    <string name="no">No</string>
    <string-array name="organ_donor_entries">
        <item>@string/yes</item>
        <item>@string/no</item>
        <item>@string/unknown_organ_donor</item>
    </string-array>
    <!-- Organ donor values. Do not translate -->
    <string-array name="organ_donor_values">
        <!-- Do not translate -->
        <item>Yes</item>
        <!-- Do not translate -->
        <item>No</item>
        <item></item>
    </string-array>
    <!-- The title of the emergency contacts preference. [CHAR_LIMIT=40] -->
    <string name="emergency_contacts_title">Emergency contacts</string>
    <!-- The title of the add emergency contacts preference. [CHAR_LIMIT=40] -->
    <string name="add_emergency_contact">Add contact</string>
    <!-- The text shown in a Toast when no contact picker activity could be loaded [CHAR_LIMIT=NONE] -->
    <string name="fail_load_contact_picker">Couldn\'t find a contact picker</string>
    <!-- The text shown in a Toast when the contact can't be displayed [CHAR_LIMIT=NONE] -->
    <string name="fail_display_contact">Can\'t display the contact</string>
    <!-- The message of the dialog shown when removing a contact. [CHAR_LIMIT=140] -->
    <string name="remove_contact">
        Remove <xliff:g id="contact_name" example="John Doe">%1$s</xliff:g> from emergency contacts?
    </string>
    <!-- The description of the remove an emergency contact, for talkback. [CHAR_LIMIT=NONE] -->
    <string name="remove_contact_icon_text">Remove contact</string>
    <!-- The text shown in a Toast when a contact couldn't be added [CHAR_LIMIT=NONE] -->
    <string name="fail_add_contact">Unable to read contact information properly</string>
    <!-- Button text for removing a contact. [CHAR_LIMIT=15] -->
    <string name="remove">Remove</string>
    <!-- Button text for canceling an operation. [CHAR_LIMIT=15] -->
    <string name="cancel">Cancel</string>
    <!-- Button text for accepting an operation. [CHAR_LIMIT=15] -->
    <string name="ok">OK</string>
    <!-- Subtitle for an emergency contact. [CHAR_LIMIT=NONE] -->
    <string name="phone_type_and_phone_number">
        <xliff:g id="phone_type" example="Mobile">%1$s</xliff:g> • <xliff:g id="phone_number" example="333-444-5566">%2$s</xliff:g>
    </string>
    <!-- Message shown when no emergency information has been provided by the user [CHAR LIMIT=NONE] -->
    <string name="no_info_provided">No information about the phone\'s owner</string>
    <!-- Extra message to indicate to the user that they can add emergency information [CHAR LIMIT=NONE] -->
    <string name="tap_pencil">With your phone unlocked, tap the pencil icon to add information that will be displayed here in case of emergency</string>
    <!-- Label for action item on the menu of the editing screen [CHAR LIMIT=15] -->
    <string name="clear_all">Clear all</string>
    <!-- Label for button of dialog shown to clear all information and contacts [CHAR LIMIT=15] -->
    <string name="clear">Clear</string>
    <!-- Message of dialog shown to clear all information and contacts [CHAR LIMIT=NONE] -->
    <string name="clear_all_message">Clear all information and contacts?</string>
    <!-- Information footer describing the use of emergency information. [CHAR LIMIT=NONE] -->
    <string name="emergency_info_footer">Adding medical information and emergency contacts can help first responders in an emergency.\n\nAnyone can read this information from your lock screen, and dial your contacts by tapping their names, without unlocking your phone.</string>
    <!-- Title for a suggestion to a user to set up their emergency information [CHAR_LIMIT=46] -->
    <string name="settings_suggestion_title">Add emergency information</string>
    <!-- Explanatory text for a suggestion to a user to set up their emergency information [CHAR_LIMIT=55] -->
    <string name="settings_suggestion_body">Let first responders see your information</string>

    <!-- An option in a photo selection dialog to take a new photo [CHAR LIMIT=50] -->
    <string name="user_image_take_photo">Take a photo</string>
    <!-- An option in a photo selection dialog to choose a pre-existing image [CHAR LIMIT=50] -->
    <string name="user_image_choose_photo">Choose an image</string>
    <!-- Accessibility message for the photo selector which is a button/popup with the current photo [CHAR LIMIT=50] -->
    <string name="user_image_photo_selector">Select photo</string>
    <!-- Title for the preference to enter the nickname of the user to display in the user switcher [CHAR LIMIT=25]-->
    <string name="user_nickname">Nickname</string>
</resources>
