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

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

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

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- General strings -->

    <!-- title for the dialog showing the error of camera hardware -->
    <string name="camera_error_title">Camera error</string>

    <!-- message for the dialog showing the error of camera hardware -->
    <string name="cannot_connect_camera">Can\'t connect to the camera.</string>

    <!-- message for the dialog showing the camera is disabled because of security policies. Camera cannot be used. -->
    <string name="camera_disabled">Camera has been disabled because of security policies.</string>

    <!-- label for the icon meaning 'show me all the images that were taken with the camera' -->
    <string name="camera_label">Camera</string>

    <!-- label for the 'video recording application shown in the top level 'all applications' -->
    <string name="video_camera_label">Camcorder</string>

    <!-- alert to the user to wait for some operation to complete -->
    <string name="wait">Please wait\u2026</string>

    <!-- alert to the user that USB storage must be available before using the camera [CHAR LIMIT=NONE] -->
    <string name="no_storage" product="nosdcard">Mount USB storage before using the camera.</string>
    <!-- alert to the user that an SD card must be installed before using the camera -->
    <string name="no_storage" product="default">Insert an SD card before using the camera.</string>

    <!-- alert to the user that the USB storage is being disk-checked [CHAR LIMIT=30] -->
    <string name="preparing_sd" product="nosdcard">Preparing USB storage\u2026</string>
    <!-- alert to the user that the SD card is being disk-checked -->
    <string name="preparing_sd" product="default">Preparing SD card\u2026</string>

    <!-- alert to the user that the camera fails to read or write the USB storage. [CHAR LIMIT=NONE] -->
    <string name="access_sd_fail" product="nosdcard">Couldn\'t access USB storage.</string>
    <!-- alert to the user that the camera fails to read or write the SD card. -->
    <string name="access_sd_fail" product="default">Couldn\'t access SD card.</string>

    <!-- button in review mode indicating that the photo taking, video recording, and panorama saving session should be canceled [CHAR LIMIT=10] -->
    <string name="review_cancel">CANCEL</string>

    <!-- button in review mode indicating that the taken photo/video is OK to be attached/uploaded [CHAR LIMIT=10] -->
    <string name="review_ok">DONE</string>

    <!-- A label that overlays on top of the preview frame to indicate the camcorder is in time lapse mode [CHAR LIMIT=35] -->
    <string name="time_lapse_title">Time lapse recording</string>

    <!-- Settings screen, camera selection dialog title. Users can select a camera from the phone (front-facing or back-facing). [CHAR LIMIT=20] -->
    <string name="pref_camera_id_title">Choose camera</string>

    <string name="pref_camera_id_default" translatable="false">0</string>

    <!-- In select camera setting, back facing camera. [CHAR LIMIT=14] -->
    <string name="pref_camera_id_entry_back">Back</string>
    <!-- In select camera setting, front-facing camera. [CHAR LIMIT=14] -->
    <string name="pref_camera_id_entry_front">Front</string>

    <!-- Settings screen, setting title text -->
    <string name="pref_camera_recordlocation_title">Store location</string>

    <string name="pref_camera_recordlocation_default" translatable="false">none</string>

    <!-- Title for countdown timer on camera settings screen [CHAR LIMIT=30]-->
    <string name="pref_camera_timer_title">Countdown timer</string>

    <string name="pref_camera_timer_default" translatable="false">0</string>
    <!-- Entry for countdown timer setting. e.g. 1 second, 10 seconds, etc. [CHAR LIMIT=30]-->
    <plurals name="pref_camera_timer_entry">
        <item quantity="one">1 second</item>
        <item quantity="other">%d seconds</item>
    </plurals>
    <string name="pref_camera_timer_sound_default">@string/setting_on_value</string>
    <!-- Text followed by a checkbox to turn on/off sound effects during the countdown. [CHAR LIMIT = 16]-->
    <string name="pref_camera_timer_sound_title">Beep during countdown</string>

    <!-- Entry of a on/off setting. The setting is turned off. [CHAR LIMIT=15] -->
    <string name="setting_off">Off</string>
    <!-- Entry of a on/off setting. The setting is turned on. [CHAR LIMIT=15] -->
    <string name="setting_on">On</string>

    <!-- The value of a camera preference indicating the setting is off. -->
    <string name="setting_off_value" translatable="false">off</string>
    <!-- The value of a camera preference indicating the setting is on. -->
    <string name="setting_on_value" translatable="false">on</string>

    <!-- The Video quality settings in preference [CHAR LIMIT=21] -->
    <string name="pref_video_quality_title">Video quality</string>
    <!-- The default quality value is 5 (720p) -->
    <string name="pref_video_quality_default" translatable="false">5</string>
    <!-- Video quality setting entry. Videos will be recorded in 1080p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_1080p" translatable="false">HD 1080p</string>
    <!-- Video quality setting entry. Videos will be recorded in 720p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_720p" translatable="false">HD 720p</string>
    <!-- Video quality setting entry. Videos will be recorded in 480p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_480p" translatable="false">SD 480p</string>
    <!-- Video quality setting entry. Videos will be recorded in the highest quality available on the device. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_high">High</string>
    <!-- Video quality setting entry. Videos will be recorded in the lowest quality available on the device. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_low">Low</string>

    <!-- Describes the preference dialog for choosing interval between frame capture for
    time lapse recording. Appears at top of the dialog. [CHAR LIMIT=30] -->
    <string name="pref_video_time_lapse_frame_interval_title">Time lapse</string>
    <string name="pref_video_time_lapse_frame_interval_default" translatable="false">0</string>

    <!-- Settings screen, Camera setting category title -->
    <string name="pref_camera_settings_category">Camera settings</string>

    <!-- Settings screen, Camcorder setting category title -->
    <string name="pref_camcorder_settings_category">Camcorder settings</string>

    <!-- Settings screen, Picture size title -->
    <string name="pref_camera_picturesize_title">Picture size</string>

    <!-- Settings screen, dialog choice for 8 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_8mp">8M pixels</string>
    <!-- Settings screen, dialog choice for 5 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_5mp">5M pixels</string>
    <!-- Settings screen, dialog choice for 3 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_3mp">3M pixels</string>
    <!-- Settings screen, dialog choice for 2 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_2mp">2M pixels</string>
    <!-- Settings screen, dialog choice for 1.3 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_1_3mp">1.3M pixels</string>
    <!-- Settings screen, dialog choice for 1 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_1mp">1M pixels</string>
    <!-- Settings screen, dialog choice for VGA picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_vga">VGA</string>
    <!-- Settings screen, dialog choice for QVGA picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_qvga">QVGA</string>

    <!-- Settings screen, Focus mode title -->
    <string name="pref_camera_focusmode_title">Focus mode</string>

    <!-- Settings screen, Focus mode dialog radio button choices -->
    <string name="pref_camera_focusmode_entry_auto">Auto</string>
    <string name="pref_camera_focusmode_entry_infinity">Infinity</string>
    <string name="pref_camera_focusmode_entry_macro">Macro</string>

    <!-- Default flash mode setting.-->
    <string name="pref_camera_flashmode_default" translatable="false">auto</string>

    <!-- Value for flash off setting-->
    <string name="pref_camera_flashmode_no_flash" translatable="false">no_flash</string>

    <!-- Settings screen, Flash mode title -->
    <string name="pref_camera_flashmode_title">Flash mode</string>

    <!-- Settings screen, Flash mode dialog radio button choices -->
    <string name="pref_camera_flashmode_entry_auto">Auto</string>
    <string name="pref_camera_flashmode_entry_on">On</string>
    <string name="pref_camera_flashmode_entry_off">Off</string>

    <!-- Default videocamera flash mode setting.-->
    <string name="pref_camera_video_flashmode_default" translatable="false">off</string>

    <!-- Default white balance setting. -->
    <string name="pref_camera_whitebalance_default" translatable="false">auto</string>

    <!-- Settings screen, white balance title -->
    <string name="pref_camera_whitebalance_title">White balance</string>

    <!-- Settings screen, White balance dialog radio button choices -->
    <string name="pref_camera_whitebalance_entry_auto">Auto</string>
    <string name="pref_camera_whitebalance_entry_incandescent">Incandescent</string>
    <string name="pref_camera_whitebalance_entry_daylight">Daylight</string>
    <string name="pref_camera_whitebalance_entry_fluorescent">Fluorescent</string>
    <string name="pref_camera_whitebalance_entry_cloudy">Cloudy</string>

    <!-- Default scene mode setting. -->
    <string name="pref_camera_scenemode_default" translatable="false">auto</string>

    <!-- Settings screen, Select Scene mode -->
    <string name="pref_camera_scenemode_title">Scene mode</string>

    <!-- Settings menu, scene mode choices [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_auto">Auto</string>
    <!-- Scene mode that uses HDR (high dynamic range) [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_hdr">HDR</string>
    <!-- Scene mode that takes an image quickly with little motion blur. [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_action">Action</string>
    <!-- Scene mode that takes long exposures to capture night scenes without flash. [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_night">Night</string>
    <!-- Scene mode optimized for taking images in the sunset. [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_sunset">Sunset</string>
    <!-- Scene mode optimized for taking indoor low-lights pictures. [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_party">Party</string>

    <!-- Toast after trying to select a setting that is not allowed to change in scene mode [CHAR LIMIT=NONE] -->
    <string name="not_selectable_in_scene_mode">Not selectable in scene mode.</string>

    <!-- Exposure settings in preference -->
    <string name="pref_exposure_title">Exposure</string>
    <string name="pref_exposure_default" translatable="false">0</string>

    <!-- Default HDR entry value -->
    <string name="pref_camera_hdr_default">@string/setting_off_value</string>

    <!-- Dialog "OK" button. Dismisses dialog. -->
    <string name="dialog_ok">OK</string>

    <!-- Low-memory dialog message [CHAR LIMT=NONE] -->
    <string name="spaceIsLow_content" product="nosdcard">Your USB storage is running out of space. Change the quality setting or delete some images or other files.</string>
    <!-- Low-memory dialog message [CHAR LIMIT=NONE] -->
    <string name="spaceIsLow_content" product="default">Your SD card is running out of space. Change the quality setting or delete some images or other files.</string>

    <!-- Camera format string for new image files. Passed to java.text.SimpleDateFormat. -->
    <string name="image_file_name_format" translatable="false">"'IMG'_yyyyMMdd_HHmmss"</string>

    <!-- Video Camera format string for new video files. Passed to java.text.SimpleDateFormat. -->
    <string name="video_file_name_format" translatable="false">"'VID'_yyyyMMdd_HHmmss"</string>

    <!-- Filename prefix for panorama output. -->
    <string name="pano_file_name_format" translatable="false">"'PANO'_yyyyMMdd_HHmmss"</string>

    <!-- The message shown when video record reaches size limit. -->
    <string name="video_reach_size_limit">Size limit reached.</string>

    <!-- The text shown when the panorama panning speed is to fast [CHAR LIMIT=12] -->
    <string name="pano_too_fast_prompt">Too fast</string>

    <!-- The text shown in the progress dialog when panorama preview is generating in the background [CHAR LIMIT=30] -->
    <string name="pano_dialog_prepare_preview">Preparing panorama</string>

    <!-- The text shown in the dialog when panorama saving failed [CHAR LIMIT=40] -->
    <string name="pano_dialog_panorama_failed">Couldn\'t save panorama.</string>

    <!-- The text shown on the dialog title in the dialogs for Panorama [CHAR LIMIT=12] -->
    <string name="pano_dialog_title">Panorama</string>

    <!-- The text shown on the top-left corner of the screen to indicate the capturing is on going [CHAR LIMIT=27] -->
    <string name="pano_capture_indication">Capturing panorama</string>

    <!-- The text shown in the progress dialog when waiting for previous panorama finishing [CHAR LIMIT=40] -->
    <string name="pano_dialog_waiting_previous">Waiting for previous panorama</string>

    <!-- The text shown on the bottom-left corner of the screen to indicate that the saving is in process [CHAR LIMIT=13] -->
    <string name="pano_review_saving_indication_str">Saving\u2026</string>

    <!-- The text shown on the screen to indicate that the panorama is rendering [CHAR LIMIT=27] -->
    <string name="pano_review_rendering">Rendering panorama</string>

    <!-- Toast telling users tapping on the viewfinder will trigger autofocus [CHAR LIMIT=28] -->
    <string name="tap_to_focus">Touch to focus.</string>

    <!-- Default effect setting that clears the effect. -->
    <string name="pref_video_effect_default" translatable="false">none</string>

    <!-- Title of video effect setting popup window -->
    <string name="pref_video_effect_title">Effects</string>

    <!-- Effect setting item that clear the effect. [CHAR LIMIT=14] -->
    <string name="effect_none">None</string>
    <!-- Effect setting item that squeezes the face. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_squeeze">Squeeze</string>
    <!-- Effect setting item that makes eyes big. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_big_eyes">Big eyes</string>
    <!-- Effect setting item that makes mouth big. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_big_mouth">Big mouth</string>
    <!-- Effect setting item that makes mouth small. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_small_mouth">Small mouth</string>
    <!-- Effect setting item that makes nose big. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_big_nose">Big nose</string>
    <!-- Effect setting item that makes eyes small. [CHAR LIMIT=14] -->
    <string name="effect_goofy_face_small_eyes">Small eyes</string>
    <!-- Effect setting item that replaces background with Android in Space. [CHAR LIMIT=14] -->
    <string name="effect_backdropper_space">In space</string>
    <!-- Effect setting item that replaces background with a sunset. [CHAR LIMIT=14] -->
    <string name="effect_backdropper_sunset">Sunset</string>
    <!-- Effect setting item that replaces background with video from gallery. [CHAR LIMIT=14] -->
    <string name="effect_backdropper_gallery">Your video</string>

    <!-- Message displayed in overlay during background replacement training [CHAR LIMIT=180]-->
    <string name="bg_replacement_message">Set your device down.\nStep out of view for a moment.</string>


    <!-- Toast telling users tapping on the viewfinder will take a picture [CHAR LIMIT=54] -->
    <string name="video_snapshot_hint">Touch to take photo while recording.</string>

    <!-- Announcement telling users video recording has just started [CHAR LIMIT=NONE] -->
    <string name="video_recording_started">Video recording has started.</string>
    <!-- Announcement telling users video recording has just stopped [CHAR LIMIT=NONE] -->
    <string name="video_recording_stopped">Video recording has stopped.</string>

    <!-- Toast telling users video snapshot is disabled when the effects are on and a user tries to tap on the viewfinder [CHAR LIMIT=65] -->
    <string name="disable_video_snapshot_hint">Video snapshot is disabled when special effects are on.</string>

    <!-- A button in effect setting popup to clear the effect. [CHAR LIMIT=26] -->
    <string name="clear_effects">Clear effects</string>

    <!-- Title of category for silly face effects. [CHAR LIMIT=26] -->
    <string name="effect_silly_faces">SILLY FACES</string>

    <!-- Title of category for background replacement effects. [CHAR LIMIT=26] -->
    <string name="effect_background">BACKGROUND</string>

    <!-- The shutter button. [CHAR LIMIT = NONE] -->
    <string name="accessibility_shutter_button">Shutter button</string>
    <!-- The menu button. [CHAR LIMIT = NONE] -->
    <string name="accessibility_menu_button">Menu button</string>
    <!-- The button to review the thumbnail. [CHAR LIMIT = NONE] -->
    <string name="accessibility_review_thumbnail">Most recent photo</string>
    <!-- The front/back camera switch. [CHAR LIMIT = NONE] -->
    <string name="accessibility_camera_picker">Front and back camera switch</string>
    <!-- The mode picker to switch between camera, video and panorama. [CHAR LIMIT = NONE] -->
    <string name="accessibility_mode_picker">Camera, video, or panorama selector</string>
    <!-- The button to switch to the second-level indicators of the camera settings. [CHAR LIMIT = NONE] -->
    <string name="accessibility_second_level_indicators">More setting controls</string>
    <!-- The button to back to the first-level indicators of the camera settings. [CHAR LIMIT = NONE] -->
    <string name="accessibility_back_to_first_level">Close setting controls</string>
    <!-- The zoom control button. [CHAR LIMIT = NONE] -->
    <string name="accessibility_zoom_control">Zoom control</string>
    <!-- The decrement button in camera preference such as exposure, picture size. [CHAR LIMIT = NONE] -->
    <string name="accessibility_decrement">Decrease %1$s</string>
    <!-- The increment button in camera preference such as exposure, picture size. [CHAR LIMIT = NONE] -->
    <string name="accessibility_increment">Increase %1$s</string>
    <!-- The check box in camera settings, such as store location. [CHAR LIMIT = NONE] -->
    <string name="accessibility_check_box">%1$s check box</string>
    <!-- The button to switch to Camera mode. [CHAR LIMIT = NONE] -->
    <string name="accessibility_switch_to_camera">Switch to photo</string>
    <!-- The button to switch to Video mode. [CHAR LIMIT = NONE] -->
    <string name="accessibility_switch_to_video">Switch to video</string>
    <!-- The button to switch to Panorama mode. [CHAR LIMIT = NONE] -->
    <string name="accessibility_switch_to_panorama">Switch to panorama</string>
    <!-- The button to switch to new Panorama mode. [CHAR LIMIT = NONE] -->
    <string name="accessibility_switch_to_new_panorama">Switch to new panorama</string>
    <!-- The button in review mode indicating that the photo taking, video recording, and panorama saving session should be canceled [CHAR LIMIT = NONE] -->
    <string name="accessibility_review_cancel">Review cancel</string>
    <!-- The button in review mode indicating that the taken photo/video is OK to be attached/uploaded [CHAR LIMIT = NONE] -->
    <string name="accessibility_review_ok">Review done</string>
    <!-- button in review mode indicate the user want to retake another photo/video for attachment [
CHAR LIMIT = NONE] -->
    <string name="accessibility_review_retake">Review retake</string>
    <!-- TODO: remove the string as it is a work-around solution to bypass the default speak of the element type. -->
    <string name="empty" translatable="false">" "</string>

    <!-- Default text for a button that can be toggled on and off. -->
    <string name="capital_on">ON</string>
    <!-- Default text for a button that can be toggled on and off. -->
    <string name="capital_off">OFF</string>

    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_off">Off</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_500">0.5 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_1000">1 second</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_1500">1.5 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_2000">2 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_2500">2.5 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_3000">3 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_4000">4 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_5000">5 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_6000">6 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_10000">10 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_12000">12 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_15000">15 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_24000">24 seconds</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_30000">0.5 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_60000">1 minute</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_90000">1.5 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_120000">2 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_150000">2.5 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_180000">3 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_240000">4 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_300000">5 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_360000">6 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_600000">10 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_720000">12 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_900000">15 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_1440000">24 minutes</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_1800000">0.5 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_3600000">1 hour</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_5400000">1.5 hour</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_7200000">2 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_9000000">2.5 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_10800000">3 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_14400000">4 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_18000000">5 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_21600000">6 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_36000000">10 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_43200000">12 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_54000000">15 hours</string>
    <!-- Text to indicate time lapse recording frame interval [CHAR LIMIT = 30] -->
    <string name="pref_video_time_lapse_frame_interval_86400000">24 hours</string>

    <!-- Seconds: a unit of time for time lapse intervals. [CHAR LIMIT = 20] -->
    <string name="time_lapse_seconds">seconds</string>
    <!-- Minutes: a unit of time for time lapse intervals. [CHAR LIMIT = 20] -->
    <string name="time_lapse_minutes">minutes</string>
    <!-- Hours: a unit of time for time lapse intervals. [CHAR LIMIT = 20] -->
    <string name="time_lapse_hours">hours</string>

    <!-- The button to confirm time-lapse setting changes. [CHAR LIMIT = 20] -->
    <string name="time_lapse_interval_set">Done</string>
    <!-- Title in time interval picker for setting time interval. [CHAR LIMIT = 30]-->
    <string name="set_time_interval">Set Time Interval</string>
    <!-- Help text that is shown when the time lapse feature is turned off. [CHAR LIMIT = 180]-->
    <string name="set_time_interval_help">Time lapse feature is off. Turn it on to set time interval.</string>
    <!-- Help text that is shown when the countdown timer is turned off. [CHAR LIMIT = 180]-->
    <string name="set_timer_help">Countdown timer is off. Turn it on to count down before taking a picture.</string>
    <!-- Title in timer setting for setting the duration for the countdown timer. [CHAR LIMIT = 50]-->
    <string name="set_duration">Set duration in seconds</string>
    <!-- On-screen hint during timer countdown for taking a photo. [CHAR LIMIT = 60]-->
    <string name="count_down_title_text">Counting down to take a photo</string>

    <!-- Title for first run dialog asking if the user wants to remember photo locations [CHAR LIMIT = 50] -->
    <string name="remember_location_title">Remember photo locations?</string>
    <!-- Message for first run dialog asking if the user wants to remember photo locations [CHAR LIMIT = None] -->
    <string name="remember_location_prompt">Tag your photos and videos with the locations where they are taken.\n\nOther apps can access this information along with your saved images.</string>
    <!-- Negative answer for first run dialog asking if the user wants to remember photo locations [CHAR LIMIT = 20] -->
    <string name="remember_location_no">No thanks</string>
    <!-- Positive answer for first run dialog asking if the user wants to remember photo locations [CHAR LIMIT = 20] -->
    <string name="remember_location_yes">Yes</string>

</resources>
