<?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">Cannot connect to 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>

    <!-- label for the folder that contains Camera pictures in the gallery -->
    <string name="gallery_camera_bucket_name">Camera pictures</string>

    <!-- label for the folder that contains Camera videos in the gallery -->
    <string name="gallery_camera_videos_bucket_name">Camera videos</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">Please 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">Please insert an SD card before using the camera.</string>

    <!-- alert to the user that the USB storage is too full to complete the operation [CHAR LIMIT=NONE] -->
    <string name="not_enough_space" product="nosdcard">Your USB storage is full.</string>
    <!-- alert to the user that the SD card is too full to complete the operation -->
    <string name="not_enough_space" product="default">Your SD card is full.</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>

    <!-- Confirmation dialog when restoring settings -->
    <string name="confirm_restore_title">Restore defaults</string>
    <string name="confirm_restore_message">Camera settings will be restored to defaults.</string>

    <!-- button in review mode indicating that the video just taken should be played [CHAR LIMIT=10] -->
    <string name="review_play">Play</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">OK</string>

    <!-- button in review mode indicate the user want to retake another photo/video for attachment [CHAR LIMIT=10] -->
    <string name="review_retake">RETAKE</string>

    <!-- Button indicating to go to the image gallery -->
    <string name="camera_gallery_photos_text">Gallery</string>

    <!-- Button indicating to switch to another camera -->
    <string name="switch_camera_id">Switch Camera</string>

    <!-- A lable 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">Select 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>

    <!-- Settings screen, Record location dialog choices -->
    <string name="pref_camera_recordlocation_entry_off">Off</string>
    <string name="pref_camera_recordlocation_entry_on">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</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</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</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 interval</string>
    <string name="pref_video_time_lapse_frame_interval_default" translatable="false">0</string>
    <!-- The time interval between frame capture for time lapse recording -->
    <string name="pref_video_time_lapse_frame_interval_entry_1000" translatable="false">1s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_1500" translatable="false">1.5s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_2000" translatable="false">2s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_2500" translatable="false">2.5s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_3000" translatable="false">3s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_5000" translatable="false">5s</string>
    <string name="pref_video_time_lapse_frame_interval_entry_10000" translatable="false">10s</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, Picture size dialog radio button choices -->
    <string name="pref_camera_picturesize_entry_2592x1936">5M Pixels</string>
    <string name="pref_camera_picturesize_entry_2048x1536">3M Pixels</string>
    <string name="pref_camera_picturesize_entry_1600x1200">2M Pixels</string>
    <string name="pref_camera_picturesize_entry_1280x960">1.3M Pixels</string>
    <string name="pref_camera_picturesize_entry_1024x768">1M Pixels</string>
    <string name="pref_camera_picturesize_entry_640x480">VGA</string>
    <string name="pref_camera_picturesize_entry_320x240">QVGA</string>

    <!-- Default focus mode setting.-->
    <string name="pref_camera_focusmode_default" translatable="false">continuous-picture</string>

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

    <!-- Settings screen, Focue 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 -->
    <string name="pref_camera_scenemode_entry_auto">Auto</string>
    <!-- Scene mode that takes an image quickly with little motion blur. -->
    <string name="pref_camera_scenemode_entry_action">Action</string>
    <!-- Scene mode that takes long exposures to capture night scenes without flash. -->
    <string name="pref_camera_scenemode_entry_night">Night</string>
    <!-- Scene mode optimized for taking images in the sunset. -->
    <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">This is not selectable in scene mode</string>

    <!-- Restore settings item in preference -->
    <string name="pref_restore_title">Camera settings</string>
    <string name="pref_restore_detail">Restore defaults</string>

    <!-- Exposure settings in preference -->
    <string name="pref_exposure_title">Exposure</string>
    <string name="pref_exposure_default" translatable="false">0</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 messsage shown when video record reaches size limit. -->
    <string name="video_reach_size_limit">Size limit reached.</string>

    <!-- The text of menu item to switch the mode to Camera. [CHAR LIMIT=NONE] -->
    <string name="switch_to_camera_label">Switch to camera</string>

    <!-- The text of menu item to switch the mode to Video. [CHAR LIMIT=NONE] -->
    <string name="switch_to_video_label">Switch to video</string>

    <!-- The text of menu item to switch the mode to Panorama. [CHAR LIMIT=NONE] -->
    <string name="switch_to_panorama_label">Switch to panorama</string>

    <string name="setting_increment" translatable="false">&gt;</string>
    <string name="setting_decrement" translatable="false">&lt;</string>

    <!-- Title of the dialog showing a list of applications that can share the captured picture. [CHAR LIMIT=30] -->
    <string name="share_picture_via">Share picture via</string>

    <!-- Title of the dialog showing a list of applications that can share the captured video. [CHAR LIMIT=30] -->
    <string name="share_video_via">Share video via</string>

    <!-- Toast saying that there is no picture to share. [CHAR LIMIT=30] -->
    <string name="no_picture_to_share">No picture to share</string>

    <!-- Toast saying that there is no video to share. [CHAR LIMIT=30] -->
    <string name="no_video_to_share">No video to share</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">Failed to 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 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...</string>

    <!-- Toast telling users tapping on the viewfinder will trigger autofocus [CHAR LIMIT=28] -->
    <string name="tap_to_focus">Tap 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 a disco effect. [CHAR LIMIT=14] -->
    <string name="effect_backdropper_disco">Disco</string>
    <!-- Effect setting item that replaces background with video from gallery. [CHAR LIMIT=14] -->
    <string name="effect_backdropper_gallery">Pick your own</string>

    <!-- Message displayed in overlay during background replacement training [CHAR LIMIT=180]-->
    <string name="bg_replacement_message">Place your device on a steady surface and be sure there\'s no movement behind you.\n\nThen step out of the camera\'s view.</string>

    <!-- Toast after trying to select a setting that is not allowed to change in effect [CHAR LIMIT=50] -->
    <string name="not_selectable_in_effect">This is not selectable when the effect is on.</string>

    <!-- Toast telling users tapping on the viewfinder will take a picture [CHAR LIMIT=65] -->
    <string name="video_snapshot_hint">Take a photo during video recording by tapping on the preview screen.</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 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 on/off switch in camera settings, such as store location. [CHAR LIMIT = NONE] -->
    <string name="accessibility_switch">%1$s switch</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>
</resources>
