<?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">
    <!-- The name of the Android Camera application. [CHAR LIMIT=16] -->
    <string name="app_name">Camera</string>
    <!-- The label for the Video Camera activity. [CHAR LIMIT=16] -->
    <string name="video_camera_label">Camcorder</string>
    <!-- Used to format short video duration in Details dialog. minutes:seconds e.g. 00:30 -->
    <string name="details_ms">%1$02d:%2$02d</string>
    <!-- Used to format video duration in Details dialog. hours:minutes:seconds e.g. 0:21:30 -->
    <string name="details_hms">%1$d:%2$02d:%3$02d</string>

    <!-- Displayed in the title of the dialog for things to do with a picture
             that is to be "set as" (e.g. set as contact photo or set as wallpaper) -->
    <string name="set_image">Set picture as</string>

    <!-- Details dialog "OK" button. Dismisses dialog. -->
    <string name="delete">Delete</string>
    <string name="share">Share</string>
    <string name="share_panorama">Share panorama</string>
    <string name="share_as_photo">Share as photo</string>

    <!-- The label shown after an image is deleted [CHAR LIMIT=16] -->
    <string name="deleted">Deleted</string>

    <!-- The label on the button which when clicked will undo a deletion of image [CHAR LIMIT=16]-->
    <string name="undo">UNDO</string>

    <string name="details">Details</string>
    <string name="close">Close</string>

    <!-- String indicating timestamp of photo or video -->
    <string name="show_on_map">Show on map</string>
    <string name="rotate_left">Rotate left</string>
    <string name="rotate_right">Rotate right</string>

    <!-- String used as a menu label. The user can choose to edit the image
         [CHAR_LIMIT=20]-->
    <string name="edit">Edit</string>

    <!-- The title of the menu item to let user crop the image. [CHAR LIMIT=15] -->
    <string name="crop_action">Crop</string>
    <!-- The title of the menu item to let user trim the video. [CHAR LIMIT=15] -->
    <string name="trim_action">Trim</string>
    <!-- The title of the menu item to let user set the image as background etc. [CHAR LIMIT=15] -->
    <string name="set_as">Set as</string>

    <!-- String indicating an error when playing the video. [CHAR LIMIT=30] -->
    <string name="video_err">Can\'t play video.</string>

    <!-- Text indicating the title of a media item in details window [CHAR LIMIT=14] -->
    <string name="title">Title</string>
    <!-- Text indicating the description of a media item in details window [CHAR LIMIT=14] -->
    <string name="description">Description</string>
    <!-- Text indicating the creation time of a media item in details window [CHAR LIMIT=14] -->
    <string name="time">Time</string>
    <!-- Text indicating the location of a media item in details window [CHAR LIMIT=14] -->
    <string name="location">Location</string>
    <!-- Text indicating the path of a media item in details window [CHAR LIMIT=14] -->
    <string name="path">Path</string>
    <!-- Text indicating the width of a media item in details window [CHAR LIMIT=14] -->
    <string name="width">Width</string>
    <!-- Text indicating the height of a media item in details window [CHAR LIMIT=14] -->
    <string name="height">Height</string>
    <!-- Text indicating the orientation of a media item in details window [CHAR LIMIT=14] -->
    <string name="orientation">Orientation</string>
    <!-- Text indicating the duration of a video item in details window [CHAR LIMIT=18] -->
    <string name="duration">Duration</string>
    <!-- Text indicating the mime type of a media item in details window [CHAR LIMIT=14] -->
    <string name="mimetype">MIME type</string>
    <!-- Text indicating the file size of a media item in details window [CHAR LIMIT=14] -->
    <string name="file_size">File size</string>
    <!-- Text indicating the maker of a media item in details window [CHAR LIMIT=14] -->
    <string name="maker">Maker</string>
    <!-- Text indicating the model of a media item in details window [CHAR LIMIT=14] -->
    <string name="model">Model</string>
    <!-- Text indicating flash info of a media item in details window [CHAR LIMIT=14] -->
    <string name="flash">Flash</string>
    <!-- Text indicating aperture of a media item in details window [CHAR LIMIT=14] -->
    <string name="aperture">Aperture</string>
    <!-- Text indicating the focal length of a media item in details window [CHAR LIMIT=14] -->
    <string name="focal_length">Focal Length</string>
    <!-- Text indicating the white balance of a media item in details window [CHAR LIMIT=18] -->
    <string name="white_balance">White balance</string>
    <!-- Text indicating the exposure time of a media item in details window [CHAR LIMIT=14] -->
    <string name="exposure_time">Exposure time</string>
    <!-- Text indicating the ISO speed rating of a media item in details window [CHAR LIMIT=14] -->
    <string name="iso">ISO</string>
    <!-- String indicating the time units in seconds. [CHAR LIMIT=8] -->
    <!-- String indicating the length units in milli-meters. [CHAR LIMIT=8] -->
    <string name="unit_mm">mm</string>
    <!-- String indicating how camera shooting feature is used. [CHAR LIMIT=12] -->
    <string name="manual">Manual</string>
    <!-- String indicating how camera shooting feature is used. [CHAR LIMIT=12 -->
    <string name="auto">Auto</string>
    <!-- String indicating camera flash is fired. [CHAR LIMIT=14] -->
    <string name="flash_on">Flash fired</string>
    <!-- String indicating camera flash is not used. [CHAR LIMIT=14] -->
    <string name="flash_off">No flash</string>

    <!-- String indicating image width or height is unknown. [CHAR LIMIT=14] -->
    <string name="unknown">Unknown</string>

    <!-- Toast message shown after we try to make a local album available offline
         [CHAR LIMIT=150] -->
    <string name="try_to_set_local_album_available_offline">
        This item is stored locally and available offline.</string>


    <!-- The content of a dialog showing trimming in progress. [CHAR LIMIT=30] -->
    <string name="please_wait">Please wait</string>

    <!-- 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="error_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="error_camera_disabled">Camera has been disabled because of security policies.</string>

    <!-- message for the dialog showing that the user's photo could not be saved [CHAR LIMIT=NONE] -->
    <string name="error_media_storage_failure">There was a problem saving your photo or video.</string>

    <!-- message for the dialog showing that the app does not have sufficient permissions [CHAR LIMIT=NONE] -->
    <string name="error_permissions">The app does not have critical permissions needed to run. Please check your permissions settings.</string>

    <!-- Reason used for session failure which is visible in UI [CHAR LIMIT=NONE] -->
    <string name="reason_storage_failure">Photo storage failure.</string>

    <!-- alert to the user to wait for some operation to complete -->
    <string name="wait">Please wait\u2026</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 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 SD card. -->
    <string name="access_sd_fail" product="default">Couldn\'t access SD card.</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>

    <!-- Default feedback that is entered in the Feedback textview for issues related to camera access. [CHAR LIMIT=NONE] -->
    <string name="feedback_description_camera_access">The app couldn\'t connect to the camera</string>

    <!-- Default feedback that is entered in the Feedback textview for issues related to saving photos. [CHAR LIMIT=NONE] -->
    <string name="feedback_description_save_photo">Photo or video did not save to the device.</string>

    <!-- Screen display message during image capture to indicate that the capture is in progress, like during HDR+. [CHAR LIMIT=20] -->
    <string name="capturing">Capturing</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>

    <!-- Named indexes into the array of camera facing entries -->
    <string name="pref_camera_id_index_back" translatable="false">0</string>
    <string name="pref_camera_id_index_front" translatable="false">1</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>

    <!-- In select camera setting, back facing camera value. [CHAR LIMIT=14] -->
    <string name="pref_camera_id_entry_back_value" translatable="false">0</string>
    <!-- In select camera setting, front-facing camera value. [CHAR LIMIT=14] -->
    <string name="pref_camera_id_entry_front_value" translatable="false">1</string>

    <!-- Settings screen, location setting text. [CHAR LIMIT=20]-->
    <string name="pref_camera_save_location_title">Save location</string>

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

    <!--  Label for record location preference [CHAR LIMIT=50] -->
    <string name="pref_camera_location_label">LOCATION</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>
    <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=24]-->
    <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 value of a camera preference indicating the setting is none. -->
    <string name="setting_none_value" translatable="false">none</string>

    <!-- The Video quality settings in preference [CHAR LIMIT=21] -->
    <string name="pref_video_quality_title">Video quality</string>

    <!-- The value of a camera preference indicating the video quality is 'large'. -->
    <string name="pref_video_quality_large" translatable="false">large</string>
    <!-- The value of a camera preference indicating the video quality is 'medium'. -->
    <string name="pref_video_quality_medium" translatable="false">medium</string>
    <!-- The value of a camera preference indicating the video quality is 'small'. -->
    <string name="pref_video_quality_small" translatable="false">small</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 "large" picture size [CHAR LIMIT=20] -->
    <string name="pref_camera_picturesize_entry_large">Large</string>
    <!-- Settings screen, dialog choice for "medium" picture size [CHAR LIMIT=20] -->
    <string name="pref_camera_picturesize_entry_medium">Medium</string>
    <!-- Settings screen, dialog choice for "small" picture size [CHAR LIMIT=20] -->
    <string name="pref_camera_picturesize_entry_small">Small</string>

    <!-- The default photo resolution value. -->
    <string name="pref_camera_picturesize_default" translatable="false">large</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>
    <!-- A setting that lets the camera focus into infinity. [CHAR LIMIT=20] -->
    <string name="pref_camera_focusmode_entry_infinity">Infinity</string>
    <!-- A setting that lets the camera operate in macro focus mode for nearby objects. [CHAR LIMIT=20] -->
    <string name="pref_camera_focusmode_entry_macro">Macro</string>

    <!-- Menu, focus mode labels [CHAR LIMIT=50] -->
    <string name="pref_camera_focusmode_label_auto">AUTO</string>
    <string name="pref_camera_focusmode_label_infinity">INFINITY</string>
    <string name="pref_camera_focusmode_label_macro">MACRO</string>

    <!-- HDR support mode setting. -->
    <string name="pref_camera_hdr_supportmode_none" translatable="false">no_hdr</string>
    <string name="pref_camera_hdr_supportmode_hdr" translatable="false">hdr</string>
    <string name="pref_camera_hdr_supportmode_hdr_plus" translatable="false">hdr_plus</string>

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

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

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

    <!-- Default HDR+ flash mode setting. -->
    <string name="pref_camera_hdr_plus_flashmode_default" translatable="false">off</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>
        <!-- flash label [CHAR LIMIT=50] -->
    <string name="pref_camera_flashmode_label">FLASH MODE</string>

    <!-- Settings screen, Flash mode 'auto'. [CHAR LIMIT=12] -->
    <string name="pref_camera_flashmode_entry_auto">Auto</string>
    <!-- Settings screen, Flash mode 'alway on'. [CHAR LIMIT=12] -->
    <string name="pref_camera_flashmode_entry_on">On</string>
    <!-- Settings screen, Flash mode 'always off'. [CHAR LIMIT=12] -->
    <string name="pref_camera_flashmode_entry_off">Off</string>

    <!-- Menu, flash mode labels [CHAR LIMIT=50] -->
    <string name="pref_camera_flashmode_label_auto">FLASH AUTO</string>
    <string name="pref_camera_flashmode_label_on">FLASH ON</string>
    <string name="pref_camera_flashmode_label_off">FLASH 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>
    <!-- Menu, white balance label -->
    <string name="pref_camera_whitebalance_label">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>

    <!-- Menu, White balance labels [CHAR LIMIT=50] -->
    <string name="pref_camera_whitebalance_label_auto">AUTO</string>
    <string name="pref_camera_whitebalance_label_incandescent">INCANDESCENT</string>
    <string name="pref_camera_whitebalance_label_daylight">DAYLIGHT</string>
    <string name="pref_camera_whitebalance_label_fluorescent">FLUORESCENT</string>
    <string name="pref_camera_whitebalance_label_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 plus (better HDR) [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_hdr_plus">HDR+</string>
    <!-- Scene mode that uses HDR (high dynamic range) [CHAR LIMIT=16] -->
    <string name="pref_camera_scenemode_entry_hdr">HDR</string>
    <!-- Scene mode to turn on HDR (better high dynamic range) [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_entry_turn_hdr_plus_on">HDR+ ON</string>
    <!-- Scene mode to turn off HDR (better high dynamic range) [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_entry_turn_hdr_plus_off">HDR+ OFF</string>
    <!-- Scene mode to turn on HDR (high dynamic range) [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_entry_turn_hdr_on">HDR ON</string>
    <!-- Scene mode to turn off HDR (high dynamic range) [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_entry_turn_hdr_off">HDR OFF</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>

    <!-- Settings menu, scene mode labels [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_label_auto">NONE</string>
    <!-- Scene mode that takes an image quickly with little motion blur. [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_label_action">ACTION</string>
    <!-- Scene mode that takes long exposures to capture night scenes without flash. [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_label_night">NIGHT</string>
    <!-- Scene mode optimized for taking images in the sunset. [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_label_sunset">SUNSET</string>
    <!-- Scene mode optimized for taking indoor low-lights pictures. [CHAR LIMIT=50] -->
    <string name="pref_camera_scenemode_label_party">PARTY</string>

    <!-- Settings menu countdown timer off [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label_off">TIMER OFF</string>
    <!-- Settings menu countdown timer 1 second [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label_one">1 SECOND</string>
    <!-- Settings menu countdown timer 3 seconds [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label_three">3 SECONDS</string>
    <!-- Settings menu countdown timer 10 seconds [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label_ten">10 SECONDS</string>
    <!-- Settings menu countdown timer 15 seconds [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label_fifteen">15 SECONDS</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>
    <!--  menu label exposure compensation [CHAR LIMIT=50] -->
    <string name="pref_exposure_label">EXPOSURE</string>

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

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

    <!-- HDR label ON [CHAR LIMIT=60] -->
    <string name="pref_camera_hdr_label">HDR</string>

    <!-- switch camera label back [CHAR LIMIT=60] -->
    <string name="pref_camera_id_label_back">FRONT CAMERA</string>
    <!-- switch camera label front [CHAR LIMIT=60] -->
    <string name="pref_camera_id_label_front">BACK CAMERA</string>

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

    <!-- Dialog "Report" button. Opens Google Feedback screen [CHAR LIMIT=12] -->
    <string name="dialog_report">Report</string>
    <!-- Dialog "Dismiss" button. Closes the dialog [CHAR LIMIT=12]-->
    <string name="dialog_dismiss">Dismiss</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=16] -->
    <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=16] -->
    <string name="effect_backdropper_sunset">Sunset</string>
    <!-- Effect setting item that replaces background with video from gallery. [CHAR LIMIT=16] -->
    <string name="effect_backdropper_gallery">Your video</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>

    <!-- 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</string>
    <!-- The cancel button. Used to cancel an in progress shot [CHAR LIMIT=NONE] -->
    <string name="accessibility_cancel_button">Cancel</string>
    <!-- The menu button. [CHAR LIMIT=NONE] -->
    <string name="accessibility_menu_button">Menu button</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 the Photo Sphere mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_switch_to_photo_sphere">Switch to Photo Sphere</string>
    <!-- The button to switch to the high quality mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_switch_to_gcam">Switch to high quality</string>
    <!-- The button to switch to the Re-Focus mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_switch_to_refocus">Switch to Refocus</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>
    <!-- The button that opens up mode options, shown as '...' on screen [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_options">Options</string>
    <!-- Announcement when the mode list becomes hidden off screen [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_list_hidden">Mode list closed</string>
    <!-- Announcement when the mode list becomes shown on screen [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_list_shown">Mode list open</string>
    <!-- Announcement when a general media capture is performed, and visually the capture 'peeks' from right screen [CHAR LIMIT=NONE] -->
    <string name="media_accessibility_peek">Capture taken</string>
    <!-- Announcement when a video capture is performed, and visually the capture 'peeks' from right screen [CHAR LIMIT=NONE] -->
    <string name="photo_accessibility_peek">Photo taken</string>
    <!-- Announcement when a video capture is performed, and visually the capture 'peeks' from right screen [CHAR LIMIT=NONE] -->
    <string name="video_accessibility_peek">Video taken</string>

    <!-- Description for the lock icon in Secure Camera filmstrip that when clicked, brings user to lock screen then full Camera [CHAR LIMIT=NONE] -->
    <string name="accessibility_unlock_to_camera">Unlock to Camera</string>

    <!-- Content description for general media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="media_date_content_description">Media taken on %s</string>
    <!-- Content description for photo media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="photo_date_content_description">Photo taken on %s</string>
    <!-- Content description for video media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="video_date_content_description">Video taken on %s</string>
    <!-- Content description for panorama media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="panorama_date_content_description">Panorama taken on %s</string>
    <!-- Content description for photosphere media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="photosphere_date_content_description">Photo Sphere taken on %s</string>
    <!-- Content description for refocus media items in filmstrip based on modified date, template will read a file modified date and time [CHAR LIMIT=NONE] -->
    <string name="refocus_date_content_description">Lens blur taken on %s</string>

    <!-- Content description for media items in filmstrip which are still in the middle of processing [CHAR LIMIT=NONE] -->
    <string name="media_processing_content_description">Media processing</string>

    <!-- Content description of the button that toggles the on screen list of camera mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_list_toggle">Toggle mode list</string>

    <!-- Text on the button that toggles the on screen list of camera mode. [CHAR LIMIT=20] -->
    <string name="btn_mode_list_toggle">Mode list</string>

    <!-- Content description of the button that toggles the filmstrip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_filmstrip_toggle">Toggle filmstrip</string>

    <!-- Text on the button that toggles the filmstrip. [CHAR LIMIT=20] -->
    <string name="btn_filmstrip_toggle">Filmstrip</string>

    <!-- Content description of the button that zooms in. [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_zoom_plus">Zoom in</string>

    <!-- Text on the button that zooms in [CHAR LIMIT=20] -->
    <string name="btn_zoom_plus">Z+</string>

    <!-- Content description of the button that zooms out. [CHAR LIMIT=NONE] -->
    <string name="accessibility_mode_zoom_minus">Zoom out</string>

    <!-- Text on the button that zooms out [CHAR LIMIT=20] -->
    <string name="btn_zoom_minus">Z-</string>

    <!-- Accessibility message spoken by TalkBack informing user of the current zoom value [CHAR LIMIT=NONE] -->
    <string name="accessibility_zoom_announcement">Zoom value is %.1f</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>

    <!-- Describes button on top of a video in filmstrip that is a play icon, pressing starts external video player [CHAR LIMIT=NONE] -->
    <string name="video_control_play">Play Video</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>
    <!-- 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\'re taken.</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>

    <!-- Camera menu labels -->
    <!-- more options label [CHAR LIMIT=50] -->
    <string name="camera_menu_more_label">MORE OPTIONS</string>
    <!-- settings label [CHAR LIMIT=50] -->
    <string name="camera_menu_settings_label">SETTINGS</string>

    <!--  Tiny Planet -->
    <!-- Button to press for creating a tiny planet image. [CHAR LIMIT=30] -->
    <string name="create_tiny_planet">Create Tiny Planet</string>
    <!-- Message shown while a tiny planet image is being saved. [CHAR LIMIT=30] -->
    <string name="saving_tiny_planet">Saving Tiny Planet …</string>
    <!-- Label above a slider that let's the user set the zoom of a tiny planet image. [CHAR LIMIT=15] -->
    <string name="tiny_planet_zoom">Zoom</string>
    <!-- Label above a slider that let's the user set the rotation of a tiny planet image. [CHAR LIMIT=15] -->
    <string name="tiny_planet_rotate">Rotate</string>
    <!-- Label for menu item that starts a photo editor. [CHAR LIMIT=30] -->
    <string name="photo_editor">Photo Editor</string>

    <!-- Crop -->
    <!-- Label for the save button in the crop activity action bar [CHAR LIMIT=20] -->
    <string name="crop_save">Save</string>
    <!--  String shown when we cannot load the image when starting the activity [CHAR LIMIT=NONE] -->
    <string name="cannot_load_image">Cannot load the image!</string>
    <!-- Label for album filmstrip button -->
    <string name="switch_photo_filmstrip">Filmstrip view</string>

    <!--  String shown when setting the homepage wallpaper in the background [CHAR LIMIT=NONE] -->
    <string name="setting_wallpaper">Setting wallpaper</string>

    <!-- Camera settings. [CHAR LIMIT=25] -->
    <string name="mode_settings">Settings</string>
    <!-- Text shown in the camera mode options list for normal camera mode [CHAR LIMIT=25] -->
    <string name="mode_camera">Camera</string>
    <!-- Text shown in the camera mode options list for putting camera in video recording mode [CHAR LIMIT=25] -->
    <string name="mode_video">Video</string>
    <!-- Text shown in the camera mode options list for putting camera in photo sphere mode. 'Photo sphere' is a product name. [CHAR LIMIT=25] -->
    <string name="mode_photosphere">Photo Sphere</string>
    <!-- Text shown in the camera mode options list for putting camera in time lapse mode [CHAR LIMIT=25] -->
    <string name="mode_timelapse">Time Lapse</string>
    <!-- Text shown in the camera mode options list for putting camera in wide angle panorama mode [CHAR LIMIT=25] -->
    <string name="mode_wideangle">Wide Angle</string>
    <!-- Text shown in the camera mode options list for putting camera in panorama mode [CHAR LIMIT=25] -->
    <string name="mode_panorama">Panorama</string>
    <!-- Text shown in the camera mode options list for putting camera in refocus mode [CHAR LIMIT=25] -->
    <string name="mode_refocus">Lens Blur</string>

    <!-- Accessibility text for switching to normal camera mode [CHAR_LIMIT=NONE] -->
    <string name="mode_camera_desc">Switch to Camera Mode</string>
    <!-- Accessibility text for switching to video mode [CHAR_LIMIT=NONE] -->
    <string name="mode_video_desc">Switch to Video Camera</string>
    <!-- Accessibility text for switching to photo sphere mode. 'Photo sphere' is a product name. [CHAR_LIMIT=NONE] -->
    <string name="mode_photosphere_desc">Switch to Photo Sphere Mode</string>
    <!-- Accessibility text for switching to panorama mode [CHAR_LIMIT=NONE] -->
    <string name="mode_panorama_desc">Switch to Panorama Mode</string>
    <!-- Accessibility text for switching to refocus mode [CHAR_LIMIT=NONE] -->
    <string name="mode_refocus_desc">Switch to Lens Blur Mode</string>

    <!-- Accessibility text for settings toggle button states [CHAR_LIMIT=NONE] -->
    <string name="settings_open_desc">Open settings</string>
    <string name="settings_close_desc">Close settings</string>

    <!-- Accessibility text for HDR+ toggle button states [CHAR_LIMIT=NONE] -->
    <string name="hdr_plus_off_desc">HDR Plus off</string>
    <string name="hdr_plus_on_desc">HDR Plus on</string>

    <!-- Accessibility text for HDR toggle button states [CHAR_LIMIT=NONE] -->
    <string name="hdr_off_desc">HDR off</string>
    <string name="hdr_on_desc">HDR on</string>

    <!-- Accessibility text for camera flash toggle button states [CHAR_LIMIT=NONE] -->
    <string name="flash_off_desc">Flash off</string>
    <string name="flash_auto_desc">Flash auto</string>
    <string name="flash_on_desc">Flash on</string>

    <!-- Accessibility text for HDR+ flash toggle button states [CHAR_LIMIT=NONE] -->
    <string name="hdr_plus_flash_off_desc">HDR+ flash off</string>
    <string name="hdr_plus_flash_auto_desc">HDR+ flash auto</string>
    <string name="hdr_plus_flash_on_desc">HDR+ flash on</string>

    <!-- Accessibility text for vide torch (flash) toggle button states [CHAR_LIMIT=NONE] -->
    <string name="torch_on_desc">Torch on</string>
    <string name="torch_off_desc">Torch off</string>

    <!-- Accessibility text for camera switch toggle button states [CHAR_LIMIT=NONE] -->
    <string name="camera_id_back_desc">Back camera</string>
    <string name="camera_id_front_desc">Front camera</string>

    <!-- Accessibility text for grid lines toggle button states [CHAR_LIMIT=NONE] -->
    <string name="grid_lines_off_desc">Grid lines off</string>
    <string name="grid_lines_on_desc">Grid lines on</string>

    <!-- Accessibility text for countdown timer toggle button states [CHAR_LIMIT=NONE] -->
    <string name="countdown_timer_off">Countdown timer is off</string>
    <string name="countdown_timer_duration_3s">Countdown timer duration is set to 3 seconds</string>
    <string name="countdown_timer_duration_10s">Countdown timer duration is set to 10 seconds</string>

    <!-- Accessibility text for More Options button [CHAR_LIMIT=NONE] -->
    <string name="more_options_desc">More Options</string>

    <!-- Accessibility text for cancel button [CHAR_LIMIT=NONE] -->
    <string name="cancel_button_description">Cancel</string>
    <!-- Accessibility text for done button [CHAR_LIMIT=NONE] -->
    <string name="done_button_description">Done</string>
    <!-- Accessibility text for retake button [CHAR_LIMIT=NONE] -->
    <string name="retake_button_description">Retake</string>
    <!-- Accessibility text for video review button [CHAR_LIMIT=NONE] -->
    <string name="review_button_description">Review</string>

    <!-- Accessibility text for filmstrip share button [CHAR_LIMIT=NONE] -->
    <string name="share_button_description">Share</string>
    <!-- Accessibility text for filmstrip view button used to open special image viewers, like 3d photosphere [CHAR_LIMIT=NONE] -->
    <string name="view_button_description">View</string>
    <!-- Accessibility text for filmstrip edit button [CHAR_LIMIT=NONE] -->
    <string name="edit_button_description">Edit</string>
    <!-- Accessibility text for filmstrip delete button [CHAR_LIMIT=NONE] -->
    <string name="delete_button_description">Delete</string>

    <!-- Accessibility text for manual exposure compensation button [CHAR_LIMIT=NONE] -->
    <string name="manual_exposure_compensation_desc">Manual Exposure Compensation</string>
    <!-- Accessibility text for exposure compensation -2 button [CHAR_LIMIT=NONE] -->
    <string name="exposure_compensation_desc_n2">Exposure Compensation -2</string>
    <!-- Accessibility text for exposure compensation -1 button [CHAR_LIMIT=NONE] -->
    <string name="exposure_compensation_desc_n1">Exposure Compensation -1</string>
    <!-- Accessibility text for exposure compensation 0 button [CHAR_LIMIT=NONE] -->
    <string name="exposure_compensation_desc_0">Exposure Compensation 0</string>
    <!-- Accessibility text for exposure compensation +1 button [CHAR_LIMIT=NONE] -->
    <string name="exposure_compensation_desc_p1">Exposure Compensation +1</string>
    <!-- Accessibility text for exposure compensation +2 button [CHAR_LIMIT=NONE] -->
    <string name="exposure_compensation_desc_p2">Exposure Compensation +2</string>

    <!-- Accessibility announcement when option button changes on screen after tap, e.g. from flash auto to flash off [CHAR_LIMIT=NONE] -->
    <string name="button_change_announcement">Button is now %s</string>

    <!-- Text shown in camera settings list for toggling photo location on or off [CHAR LIMIT=25] -->
    <string name="setting_location">Location</string>

    <!-- Camera settings title for back camera photo resolution. [CHAR LIMIT=25] -->
    <string name="setting_back_camera_photo">Back camera photo</string>
    <!-- Camera settings title for back camera video resolution. [CHAR LIMIT=25] -->
    <string name="setting_back_camera_video">Back camera video</string>
    <!-- Camera settings title for front camera photo resolution. [CHAR LIMIT=25] -->
    <string name="setting_front_camera_photo">Front camera photo</string>
    <!-- Camera settings title for front camera video resolution. [CHAR LIMIT=25] -->
    <string name="setting_front_camera_video">Front camera video</string>

    <!-- Text shown in camera settings list for selecting the camera mode that will be used by default when the app starts [CHAR LIMIT=25] -->
    <string name="setting_default_camera">Default Camera</string>

    <!-- Text shown in camera settings list for launching Google Help [CHAR LIMIT=25] -->
    <string name="setting_google_help_and_feedback">Help &amp; feedback</string>

    <!-- TODO: don't ship with these. -->
    <string name="focus_ring_toggle" translatable="false">FR</string>
    <string name="immediate_capture_toggle" translatable="false">IMM</string>

    <!-- camera jpeg quality settings -->
    <string name="pref_camera_jpeg_quality_normal" translatable="false">normal</string>
    <string name="pref_camera_jpeg_quality_fine" translatable="false">fine</string>
    <string name="pref_camera_jpeg_quality_superfine" translatable="false">superfine</string>

    <!-- Default for camera startup module index -->
    <string name="pref_camera_startup_index_default" translatable="false">0</string>

    <!-- Default number of times to play shimmy. -->
    <string name="pref_shimmy_play_times" translatable="false">10</string>

    <!-- A message shown to the user, indicating that an HDR+ photo is being processed. [CHAR LIMIT=25] -->
    <string name="processing_hdr_plus">Processing HDR+ &#8230;</string>

    <string name="pano_orientation_horizontal" translatable="false">pano_horizontal</string>
    <string name="pano_orientation_vertical" translatable="false">pano_vertical</string>
    <string name="pano_orientation_wide" translatable="false">pano_wide</string>
    <string name="pano_orientation_fisheye" translatable="false">pano_fisheye</string>

    <string name="tag_enabled_id" translatable="false">enabled_id</string>

    <!-- Title of a dialog showing open source licenses used in the app. [CHAR LIMIT=30] -->
    <string name="open_source_licenses">Open source licenses</string>

    <!-- Default number of times to play peek animation. -->
    <string name="pref_filmstrip_peek_anim_play_times" translatable="false">20</string>

    <!--  Title of a preference group which contains general settings. [CHAR LIMIT=30]  -->
    <string name="pref_category_general">General Settings</string>

    <!--  Title of a preference group which contains settings for changing capture resolution and quality. [CHAR LIMIT=30]  -->
    <string name="pref_category_resolution_quality">Resolution &amp; quality</string>

    <!--  Title of a preference group which contains information about the app. [CHAR LIMIT=30]  -->
    <string name="pref_category_about">About</string>

    <!--  Title of a preference which shows the build version of the app. [CHAR LIMIT=30]  -->
    <string name="pref_title_build_version">Build version</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>
    <!-- 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 quarter CIF quality. Details on CIF: http://goo.gl/3jDK [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_qcif">QCIF</string>
    <!-- Video quality setting entry. Videos will be recorded in CIF quality. Details on CIF: http://goo.gl/3jDK [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_cif">CIF</string>
    <!-- Video quality setting entry. Videos will be recorded in 480p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_480p">SD 480p</string>
    <!-- Video quality setting entry. Videos will be recorded in 720p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_720p">HD 720p</string>
    <!-- Video quality setting entry. Videos will be recorded in 1080p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_1080p">HD 1080p</string>
    <!-- Video quality setting entry. Videos will be recorded in quarter VGA quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_qvga">QVGA</string>
    <!-- Video quality setting entry. Videos will be recorded in 2160p quality. [CHAR LIMIT=24] -->
    <string name="pref_video_quality_entry_2160p">UHD 4K</string>

    <!--  The strings below will not be translated. We're using them until the above translations are sane. -->
    <string name="pref_video_quality_entry_qcif_notrans" translatable="false">QCIF</string>
    <string name="pref_video_quality_entry_cif_notrans" translatable="false">CIF</string>
    <string name="pref_video_quality_entry_480p_notrans" translatable="false">SD 480p</string>
    <string name="pref_video_quality_entry_720p_notrans" translatable="false">HD 720p</string>
    <string name="pref_video_quality_entry_1080p_notrans" translatable="false">HD 1080p</string>
    <string name="pref_video_quality_entry_qvga_notrans" translatable="false">QVGA</string>
    <string name="pref_video_quality_entry_2160p_notrans" translatable="false">UHD 4K</string>

    <!-- Message shown in the settings summary for how many megapixels have been selected. [CHAR LIMIT=24]-->
    <string name="setting_summary_x_megapixels">%1$s megapixels</string>

    <!-- Message shown in the settings summary that includes the the aspect ratio of the selected resolution i.e. (4:3) and the size of the selected resolution in megapixels. [CHAR LIMIT=24]-->
    <string name="setting_summary_aspect_ratio_and_megapixels">(%1$d:%2$d) %3$s megapixels</string>

    <!-- Text shown above the button that opens to editor for images created from lens blur mode. [CHAR LIMIT=60] -->
    <string name="cling_text_for_refocus_editor_button">To refocus, touch here</string>

    <!-- Title of a preference group for advanced preferences. [CHAR LIMIT=30] -->
    <string name="pref_category_advanced">Advanced</string>
    <!-- Title of a preference for enabling manual exposure compensation. [CHAR LIMIT=20] -->
    <string name="pref_camera_exposure_compensation">Manual exposure</string>

    <!-- Text shown next to the settings button to explain what is in settings menu. [CHAR LIMIT=120] !-->
    <string name="settings_cling_text">In Settings, change resolution and quality, or try advanced features.</string>

    <!-- Title on the startup screen that lets user select photo aspect ratio. [CHAR LIMIT=40]-->
    <string name="photo_size_selection_title">Choose photo size</string>

    <!-- Text on the photo aspect ratio selection screen. [CHAR LIMIT=120] -->
    <string name="photo_aspect_ratio_selection_content">You can change this later in Settings.</string>

    <!-- Shown above the intent chooser when the user is about to share an item. [CHAR LIMIT=20] -->
    <string name="share_to">Share to</string>
    <!-- Shown above the intent chooser when the user is about to edit an item. [CHAR LIMIT=20] -->
    <string name="edit_with">Edit with</string>

    <!-- Text on the button to take user to the next page of the on-screen instructions. [CHAR LIMIT=20] -->
    <string name="startup_dialog_button_next">NEXT</string>

    <!-- Text on the button to confirm that user understands the on-screen instructions. [CHAR LIMIT=20] -->
    <string name="confirm_button_text">OK, GOT IT</string>

    <!-- Selection for a 4:3 picture size where the sensor provides 4:3 so the result is not cropped. [CHAR LIMIT=30] -->
    <string name="full_sensor_4x3_aspect_ratio">Full sensor \n(4:3)</string>

    <!-- Selection for a 16:9 picture size where the sensor provides 4:3 so the result will be cropped. [CHAR LIMIT=30] -->
    <string name="cropped_sensor_16x9_aspect_ratio">Cropped sensor \n(16:9)</string>

    <!-- String representation of boolean false, allows for integer conversion. -->
    <string name="pref_boolean_false">0</string>
    <!-- String representation of boolean true, allows for integer conversion. -->
    <string name="pref_boolean_true">1</string>

    <!-- Shown to the user while an image/video is being saved to disk. -->
    <string name="session_saving_image">Saving\u2026</string>
 </resources>
