<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2011 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">

    <!-- The name of the Cell Broadcast Receiver app. [CHAR LIMIT=NONE] -->
    <string name="app_label">Cell Broadcasts</string>

    <!-- Label for settings screen. [CHAR LIMIT=NONE] -->
    <string name="sms_cb_settings">Cell Broadcast settings</string>

    <!-- Text for dismiss button in broadcast message view dialog. [CHAR LIMIT=25] -->
    <string name="button_dismiss">OK</string>

    <!-- Text for list view when empty (no broadcasts). [CHAR LIMIT=200] -->
    <string name="no_cell_broadcasts">There are no active alerts in your area. You can change the Alert settings using the Settings menu option.</string>

    <!-- Menu item for accessing application settings. [CHAR LIMIT=30] -->
    <string name="menu_preferences">Settings</string>
    <!-- Menu item for deleting all broadcasts. [CHAR LIMIT=30] -->
    <string name="menu_delete_all">Delete broadcasts</string>

    <!-- Header for context menu on an individual broadcast. [CHAR LIMIT=30] -->
    <string name="message_options">Message options</string>
    <!-- Context menu item for viewing broadcast details such as time and date. [CHAR LIMIT=30] -->
    <string name="menu_view_details">View details</string>
    <!-- Context menu item to delete a previously received broadcast. [CHAR LIMIT=30] -->
    <string name="menu_delete">Delete broadcast</string>

    <!-- Title of "View details" dialog -->
    <string name="view_details_title">Alert details</string>

    <!-- Confirm Delete -->
    <!-- Delete broadcast confirmation dialog message. [CHAR LIMIT=NONE] -->
    <string name="confirm_delete_broadcast">Delete this broadcast?</string>
    <!-- Delete all broadcasts confirmation dialog message. [CHAR LIMIT=NONE] -->
    <string name="confirm_delete_all_broadcasts">Delete all received broadcast messages?</string>
    <!-- Delete button text for delete broadcast dialog. [CHAR LIMIT=25] -->
    <string name="button_delete">Delete</string>
    <!-- Cancel button text for delete broadcast dialog. [CHAR LIMIT=25] -->
    <string name="button_cancel">Cancel</string>

    <!-- ETWS dialog title for Earthquake Warning. [CHAR LIMIT=50] -->
    <string name="etws_earthquake_warning">Earthquake warning</string>
    <!-- ETWS dialog title for Tsunami Warning. [CHAR LIMIT=50] -->
    <string name="etws_tsunami_warning">Tsunami warning</string>
    <!-- ETWS dialog title for Earthquake and Tsunami Warning. [CHAR LIMIT=50] -->
    <string name="etws_earthquake_and_tsunami_warning">Earthquake and tsunami warning</string>
    <!-- ETWS dialog title for test message. [CHAR LIMIT=50] -->
    <string name="etws_test_message">ETWS test message</string>
    <!-- ETWS dialog title for other emergency type. [CHAR LIMIT=50] -->
    <string name="etws_other_emergency_type">Emergency warning</string>
    <!-- CMAS dialog title for presidential level alert. [CHAR LIMIT=50] -->
    <string name="cmas_presidential_level_alert">Presidential alert</string>
    <!-- CMAS dialog title for extreme alert. [CHAR LIMIT=50] -->
    <string name="cmas_extreme_alert">Emergency alert: Extreme</string>
    <!-- CMAS dialog title for severe alert. [CHAR LIMIT=50] -->
    <string name="cmas_severe_alert">Emergency alert: Severe</string>
    <!-- CMAS dialog title for child abduction emergency (Amber Alert). [CHAR LIMIT=50] -->
    <string name="cmas_amber_alert">Child abduction (Amber alert)</string>
    <!-- CMAS dialog title for required monthly test. [CHAR LIMIT=50] -->
    <string name="cmas_required_monthly_test">Emergency alert monthly test</string>
    <!-- CMAS dialog title for CMAS Exercise. [CHAR LIMIT=50] -->
    <string name="cmas_exercise_alert">Emergency alert (exercise)</string>
    <!-- CMAS dialog title for operator defined use. [CHAR LIMIT=50] -->
    <string name="cmas_operator_defined_alert">Emergency alert (operator)</string>
    <!-- Dialog title for all other message identifiers in the PWS range. [CHAR LIMIT=50] -->
    <string name="pws_other_message_identifiers">Emergency alert</string>
    <!-- Dialog title for all non-emergency cell broadcasts. [CHAR LIMIT=50] -->
    <string name="cb_other_message_identifiers">Cell broadcast</string>

    <!-- Preference category title for emergency alert settings. [CHAR LIMIT=50] -->
    <string name="emergency_alert_settings_title">Emergency alert settings</string>
    <!-- Preference title for enable emergency alerts checkbox. [CHAR LIMIT=30] -->
    <string name="enable_emergency_alerts_title">Turn on notifications</string>
    <!-- Preference summary for enable notifications checkbox. [CHAR LIMIT=50] -->
    <string name="enable_emergency_alerts_summary">Display emergency alert broadcasts</string>
    <!-- Preference title for alert sound duration list. [CHAR LIMIT=30] -->
    <string name="alert_sound_duration_title">Alert sound duration</string>
    <!-- Do not translate. Empty summary for alert duration (set by CellBroadcastSettings). -->
    <string name="alert_sound_duration_summary"></string>
    <!-- Preference title for enable text-to-speech checkbox. [CHAR LIMIT=30] -->
    <string name="enable_alert_speech_title">Speak alert message</string>
    <!-- Preference summary for enable text-to-speech checkbox. [CHAR LIMIT=100] -->
    <string name="enable_alert_speech_summary">Use text-to-speech to speak emergency alert messages</string>

    <!-- Preference category title for ETWS settings. [CHAR LIMIT=50] -->
    <string name="category_etws_settings_title">ETWS settings</string>
    <!-- Preference title for enable ETWS test alerts checkbox. [CHAR LIMIT=30] -->
    <string name="enable_etws_test_alerts_title">Show ETWS test broadcasts</string>
    <!-- Preference summary for enable ETWS test alerts checkbox. [CHAR LIMIT=100] -->
    <string name="enable_etws_test_alerts_summary">Display test broadcasts for Earthquake Tsunami Warning System</string>

    <!-- Preference title for enable CMAS extreme threat alerts checkbox. [CHAR LIMIT=30] -->
    <string name="enable_cmas_extreme_threat_alerts_title">Show extreme threats</string>
    <!-- Preference summary for enable CMAS extreme threat alerts checkbox. [CHAR LIMIT=100] -->
    <string name="enable_cmas_extreme_threat_alerts_summary">Display alerts for extreme threats to life and property</string>
    <!-- Preference title for enable CMAS severe threat alerts checkbox. [CHAR LIMIT=30] -->
    <string name="enable_cmas_severe_threat_alerts_title">Show severe threats</string>
    <!-- Preference summary for enable CMAS severe threat alerts checkbox. [CHAR LIMIT=100] -->
    <string name="enable_cmas_severe_threat_alerts_summary">Display alerts for severe threats to life and property</string>
    <!-- Preference title for enable CMAS amber alerts checkbox. [CHAR LIMIT=50] -->
    <string name="enable_cmas_amber_alerts_title">Show AMBER alerts</string>
    <!-- Preference summary for enable CMAS amber alerts checkbox. [CHAR LIMIT=100] -->
    <string name="enable_cmas_amber_alerts_summary">Display child abduction emergency bulletins (AMBER alert)</string>

    <!-- Preference title for enable CMAS test alerts checkbox. [CHAR LIMIT=30] -->
    <string name="enable_cmas_test_alerts_title">Show CMAS test broadcasts</string>
    <!-- Preference summary for enable CMAS test alerts checkbox. [CHAR LIMIT=100] -->
    <string name="enable_cmas_test_alerts_summary">Display test broadcasts for Commercial Mobile Alert System</string>

    <!-- Preference title for CMAS vibration on/off. [CHAR LIMIT=30] -->
    <string name="enable_alert_vibrate_title">Vibrate</string>
    <!-- Preference summary for CMAS vibration on/off. [CHAR LIMIT=60] -->
    <string name="enable_alert_vibrate_summary">Vibrate on alert</string>

    <!-- Preference category title for Brazil settings. [CHAR LIMIT=50] -->
    <string name="category_brazil_settings_title">Settings for Brazil</string>
    <!-- Preference title for enable channel 50 alerts (Brazil only). [CHAR LIMIT=30] -->
    <string name="enable_channel_50_alerts_title">Show channel 50 broadcasts</string>
    <!-- Preference summary for enable channel 50 alerts (Brazil only). [CHAR LIMIT=100] -->
    <string name="enable_channel_50_alerts_summary">Channel 50 is used in Brazil for area update information</string>

    <!-- Preference category title for developer settings. [CHAR LIMIT=50] -->
    <string name="category_dev_settings_title">Developer options</string>

    <!-- CMAS alert category heading (including colon). [CHAR LIMIT=30] -->
    <string name="cmas_category_heading">Alert Category:</string>
    <!-- CMAS category for geophysical alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_geo">Geophysical</string>
    <!-- CMAS category for meteorological alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_met">Meteorological</string>
    <!-- CMAS category for general emergency and public safety alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_safety">Safety</string>
    <!-- CMAS category for security alerts (law enforcement, military, etc.). [CHAR LIMIT=50] -->
    <string name="cmas_category_security">Security</string>
    <!-- CMAS category for rescue and recovery alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_rescue">Rescue</string>
    <!-- CMAS category for fire suppression and rescue alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_fire">Fire</string>
    <!-- CMAS category for medical and public health alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_health">Health</string>
    <!-- CMAS category for pollution and other environmental alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_env">Environmental</string>
    <!-- CMAS category for transportation alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_transport">Transportation</string>
    <!-- CMAS category for utility, telecommunication, and other infrastructure alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_infra">Infrastructure</string>
    <!-- CMAS category for chemical, biological, radiological, nuclear alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_cbrne">Chemical/Biological/Nuclear/Explosive</string>
    <!-- CMAS category for other alerts. [CHAR LIMIT=50] -->
    <string name="cmas_category_other">Other</string>

    <!-- CMAS response type heading (including colon). [CHAR LIMIT=30] -->
    <string name="cmas_response_heading">Response Type:</string>
    <!-- CMAS response type: take shelter in place. [CHAR LIMIT=50] -->
    <string name="cmas_response_shelter">Shelter</string>
    <!-- CMAS response type: evacuate (relocate). [CHAR LIMIT=50] -->
    <string name="cmas_response_evacuate">Evacuate</string>
    <!-- CMAS response type: make preparations. [CHAR LIMIT=50] -->
    <string name="cmas_response_prepare">Prepare</string>
    <!-- CMAS response type: execute a pre-planned activity. [CHAR LIMIT=50] -->
    <string name="cmas_response_execute">Execute</string>
    <!-- CMAS response type: monitor information sources. [CHAR LIMIT=50] -->
    <string name="cmas_response_monitor">Monitor</string>
    <!-- CMAS response type: avoid hazard. [CHAR LIMIT=50] -->
    <string name="cmas_response_avoid">Avoid</string>
    <!-- CMAS response type: evaluate the information in this message. [CHAR LIMIT=50] -->
    <string name="cmas_response_assess">Assess</string>
    <!-- CMAS response type: no action recommended. [CHAR LIMIT=50] -->
    <string name="cmas_response_none">None</string>

    <!-- CMAS severity heading (including colon). [CHAR LIMIT=30] -->
    <string name="cmas_severity_heading">Severity:</string>
    <!-- CMAS severity type: extreme. [CHAR LIMIT=30] -->
    <string name="cmas_severity_extreme">Extreme</string>
    <!-- CMAS severity type: severe. [CHAR LIMIT=30] -->
    <string name="cmas_severity_severe">Severe</string>

    <!-- CMAS urgency heading (including colon). [CHAR LIMIT=30] -->
    <string name="cmas_urgency_heading">Urgency:</string>
    <!-- CMAS urgency type: take responsive action immediately. [CHAR LIMIT=30] -->
    <string name="cmas_urgency_immediate">Immediate</string>
    <!-- CMAS severity type: severe. [CHAR LIMIT=30] -->
    <string name="cmas_urgency_expected">Expected</string>

    <!-- CMAS certainty heading (including colon). [CHAR LIMIT=30] -->
    <string name="cmas_certainty_heading">Certainty:</string>
    <!-- CMAS certainty type: observed. [CHAR LIMIT=30] -->
    <string name="cmas_certainty_observed">Observed</string>
    <!-- CMAS severity type: severe. [CHAR LIMIT=30] -->
    <string name="cmas_certainty_likely">Likely</string>

    <!-- Message delivery time (including colon). [CHAR LIMIT=30] -->
    <string name="delivery_time_heading">Received:</string>

    <!-- Non-emergency broadcast notification description for multiple unread alerts. -->
    <string name="notification_multiple"><xliff:g id="count">%s</xliff:g> unread alerts.</string>
    <!-- Non-emergency broadcast notification title for multiple unread alerts. -->
    <string name="notification_multiple_title">New alerts</string>

    <!-- Show CMAS opt-out dialog on first non-Presidential alert. [CHAR LIMIT=100] -->
    <string name="show_cmas_opt_out_summary">Show an opt-out dialog after displaying the first CMAS alert (other than Presidential Alert).</string>
    <!-- Show CMAS opt-out dialog on first non-Presidential alert. [CHAR LIMIT=40] -->
    <string name="show_cmas_opt_out_title">Show opt-out dialog</string>

    <!-- CMAS opt-out dialog message. [CHAR LIMIT=160] -->
    <string name="cmas_opt_out_dialog_text">You are currently receiving Emergency Alerts. Would you like to continue receiving Emergency Alerts?</string>
    <!-- Text for positive button in CMAS opt-out dialog. [CHAR LIMIT=25] -->
    <string name="cmas_opt_out_button_yes">Yes</string>
    <!-- Text for negative button in CMAS opt-out dialog. [CHAR LIMIT=25] -->
    <string name="cmas_opt_out_button_no">No</string>

    <!-- Entries listed in the ListPreference for allowed alert durations. [CHAR LIMIT=30] -->
    <string-array name="alert_sound_duration_entries">
      <item>2 seconds</item>
      <item>4 seconds</item>
      <item>6 seconds</item>
      <item>8 seconds</item>
      <item>10 seconds</item>
    </string-array>

    <!-- Do not translate. Values that are retrieved from the ListPreference.
         These must match the alert_sound_duration_entries above. -->
    <string-array name="alert_sound_duration_values">
      <item>2</item>
      <item>4</item>
      <item>6</item>
      <item>8</item>
      <item>10</item>
    </string-array>
</resources>
