<?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">
    <string name="app_name">Gallery</string>
    <!-- Title for picture frame gadget to show in list of all available gadgets -->
    <string name="gadget_title">Picture frame</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>
    <!-- Activity label. This might show up in the activity-picker -->
    <string name="movie_view_label">Video player</string>
    <!-- shown in the video player view while the video is being loaded, before it starts playing -->
    <string name="loading_video">Loading video\u2026</string>
    <string name="loading_image">Loading image\u2026</string>

    <!-- Message shown on the progress dialog to indicate we're loading the
            account info [CHAR LIMIT=30] -->
    <string name="loading_account">Loading account\u2026</string>

    <!-- Movie View Resume Playing dialog title -->
    <string name="resume_playing_title">Resume video</string>

    <!-- Movie View Start Playing dialog title -->
    <string name="resume_playing_message">Resume playing from %s ?</string>
    <!-- Movie View Start Playing button "Resume from bookmark" -->
    <string name="resume_playing_resume">Resume playing</string>

    <!-- Displayed in the title of those albums that are being loaded -->
    <string name="loading">Loading\u2026</string>

    <!-- Displayed in the title of those pictures that fails to be loaded
         [CHAR LIMIT=50]-->
    <string name="fail_to_load">Couldn\'t load</string>

    <!-- Used in a toast message when an image fails to be loaded
         [CHAR LIMIT=50]-->
    <string name="fail_to_load_image">Couldn\'t load the image</string>

    <!-- Displayed in place of the picture when we fail to get the thumbnail of it.
         [CHAR LIMIT=50]-->
    <string name="no_thumbnail">No thumbnail</string>

    <!-- Movie View Start Playing button "Beginning" -->
    <string name="resume_playing_restart">Start over</string>

    <!-- Title of a menu item to indicate performing the image crop operation
         [CHAR LIMIT=20] -->
    <string name="crop_save_text">OK</string>
    <!-- Title of a menu item to indicate performing the image crop operation
         [CHAR LIMIT=20] -->
    <string name="ok">OK</string>
    <!-- Button indicating that the cropped image should be reverted back to the original -->
    <!-- Hint that appears when cropping an image with more than one face -->
    <string name="multiface_crop_help">Touch a face to begin.</string>
    <!-- Toast/alert that the image is being saved to the SD card -->
    <string name="saving_image">Saving picture\u2026</string>

    <!-- Toast/alert that the image is being saved after editing in filtershow [CHAR LIMIT=40]-->
    <string name="filtershow_saving_image">Saving picture to <xliff:g id="album_name">%1$s</xliff:g> \u2026</string>

    <!-- Eorror toast message that the image cannot be saved [CHAR LIMIT=40]-->
    <string name="save_error">Couldn\'t save cropped image.</string>

    <!-- menu pick: crop the currently selected image [CHAR LIMIT=30]-->
    <string name="crop_label">Crop picture</string>
    <!-- menu pick: trim the currently selected video [CHAR LIMIT=30]-->
    <string name="trim_label">Trim video</string>

    <!-- Toast/alert that the face detection is being run -->

    <!-- Title prompted for user to choose a photo item [CHAR LIMIT=20] -->
    <string name="select_image">Select photo</string>
    <!-- Title prompted for user to choose a video item [CHAR LIMIT=20] -->
    <string name="select_video">Select video</string>
    <!-- Title prompted for user to choose a media object [CHAR LIMIT=20] -->
    <string name="select_item">Select item</string>
    <!-- Title prompted for user to choose an album [CHAR LIMIT=20] -->
    <string name="select_album">Select album</string>
    <!-- Title prompted for user to choose a group [CHAR LIMIT=20] -->
    <string name="select_group">Select group</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>
    <!-- Activity title for cropping picture and setting it as wallpaper [CHAR LIMIT=20] -->
    <string name="set_wallpaper">Set wallpaper</string>
    <!-- Toast/alert after saving wallpaper -->
    <string name="wallpaper">Setting wallpaper\u2026</string>
    <string name="camera_setas_wallpaper">Wallpaper</string>

    <!-- Details dialog "OK" button. Dismisses dialog. -->
    <string name="delete">Delete</string>
    <!-- String Delete the selected media item(s) [CHAR LIMIT=50] -->
    <plurals name="delete_selection">
        <item quantity="one">Delete selected item?</item>
        <item quantity="other">Delete selected items?</item>
    </plurals>
    <string name="confirm">Confirm</string>
    <string name="cancel">Cancel</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 indicating more actions are available -->
    <string name="select_all">Select all</string>
    <string name="deselect_all">Deselect all</string>
    <string name="slideshow">Slideshow</string>

    <string name="details">Details</string>
    <string name="details_title">%1$d of %2$d items:</string>
    <string name="close">Close</string>

    <!-- Title of a menu item to switch from Gallery to Camera app [CHAR LIMIT=30] -->
    <string name="switch_to_camera">Switch to Camera</string>

    <!-- String indicating how many media item(s) is(are) selected
            eg. 1 selected [CHAR LIMIT=30] -->
    <plurals name="number_of_items_selected">
        <item quantity="zero">%1$d selected</item>
        <item quantity="one">%1$d selected</item>
        <item quantity="other">%1$d selected</item>
    </plurals>

    <!-- String indicating how many media album(s) is(are) selected
            eg. 1 selected [CHAR LIMIT=30] -->
    <plurals name="number_of_albums_selected">
        <item quantity="zero">%1$d selected</item>
        <item quantity="one">%1$d selected</item>
        <item quantity="other">%1$d selected</item>
    </plurals>

    <!-- String indicating how many media group(s) is(are) selected
            eg. 1 selected [CHAR LIMIT=30] -->
    <plurals name="number_of_groups_selected">
        <item quantity="zero">%1$d selected</item>
        <item quantity="one">%1$d selected</item>
        <item quantity="other">%1$d selected</item>
    </plurals>

    <!-- 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>

    <!-- Toast message prompted when the specified item is not found [CHAR LIMIT=40]-->
    <string name="no_such_item">Couldn\'t find item.</string>

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

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

    <!-- String used as a title of a progress dialog. The user can
         choose to cache some Picasa picture albums on device, so it can
         be viewed offline. This string is shown when the request is being
         processed. [CHAR LIMIT=50] -->
    <string name="process_caching_requests">Processing caching requests</string>

    <!-- String used as a small notification label above a Picasa album.
         It means the pictures of the Picasa album is currently being
         transferred to local storage, so the pictures can later be viewed
         offline. [CHAR LIMIT=15] -->
    <string name="caching_label">Caching\u2026</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 mute the video. [CHAR LIMIT=15] -->
    <string name="mute_action">Mute</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 muting the video. [CHAR LIMIT=30] -->
    <string name="video_mute_err">Can\'t mute video.</string>
    <!-- String indicating an error when playing the video. [CHAR LIMIT=30] -->
    <string name="video_err">Can\'t play video.</string>

    <!-- Strings for grouping operations in the menu. The photos can be grouped
         by their location, taken time, or tags. -->
    <!-- The title of the menu item to let user choose the grouping rule, when
         pressed, a submenu will shown and user can choose one grouping rule
         from the submenu. -->

    <!-- Title of a menu item to group photo by location [CHAR LIMIT=30] -->
    <string name="group_by_location">By location</string>

    <!-- Title of a menu tiem to group photo by taken date [CHAR LIMIT=30]-->
    <string name="group_by_time">By time</string>

    <!-- Title of a menu item to group photo by tags [CHAR LIMIT=30]-->
    <string name="group_by_tags">By tags</string>

    <!-- Title of a menu item to group photo by faces [CHAR LIMIT=30]-->
    <string name="group_by_faces">By people</string>

    <!-- Title of a menu item to group photo by albums [CHAR LIMIT=30]-->
    <string name="group_by_album">By album</string>

    <!-- Title of a menu item to group photo by size [CHAR LIMIT=30]-->
    <string name="group_by_size">By size</string>

    <!-- When grouping photos by tags, the label used for photos without tags
         [CHAR LIMIT=20]-->
    <string name="untagged">Untagged</string>

    <!-- When grouping photos by locations, the label used for photos that don't
         have location information in them [CHAR LIMIT=20]-->
    <string name="no_location">No location</string>

    <!-- This toast message is shown when network connection is lost while doing clustering -->
    <string name="no_connectivity">Some locations couldn\'t be identified due to network problems.</string>

    <!-- This toast message is shown when failed to load the album data. [CHAR LIMIT=NONE] -->
    <string name="sync_album_error">Couldn\'t download the photos in this album. Retry later.</string>

    <!-- The title of the menu item to let user choose the which portion of
         the media items the user wants to see. When pressed, a submenu will
         appear and user can choose one of "show images only",
         "show videos only", or "show all" from the submenu. -->

    <!-- Title of a menu item to show images only [CHAR LIMIT=30]-->
    <string name="show_images_only">Images only</string>

    <!-- Title of a menu item to show videos only [CHAR LIMIT=30]-->
    <string name="show_videos_only">Videos only</string>

    <!-- Title of a menu item to show all (both images and videos) [CHAR LIMIT=30]-->
    <string name="show_all">Images &amp; videos</string>

    <!-- Title of the StackView AppWidget -->
    <string name="appwidget_title">Photo Gallery</string>

    <!-- Text for the empty state of the StackView AppWidget [CHAR LIMIT=30] -->
    <string name="appwidget_empty_text">No photos.</string>

    <!-- Toast message shown when the cropped image has been saved in the
         %s folder (string: folder_download) [CHAR LIMIT=50]-->
    <string name="crop_saved">
        Cropped image saved to <xliff:g id="folder_name">%s</xliff:g>.</string>

    <!-- Toast message shown when there is no albums available [CHAR LIMIT=50]-->
    <string name="no_albums_alert">No albums available.</string>

    <!-- Toast message shown when we close the AlbumPage because it is empty
            [CHAR LIMIT=50] -->
    <string name="empty_album">O images/videos available.</string>

    <!-- Album label used to indicate the collection of PWA Buzz/Post photos -->
    <string name="picasa_posts">Posts</string>

    <!-- A label describing that the current screen is for the user to pick
         some albums to be viewable offline [CHAR LIMIT=30] -->
    <string name="make_available_offline">Make available offline</string>

    <!-- A label of a menu item for user to sync the content [CHAR LIMIT=30] -->
    <string name="sync_picasa_albums">Refresh</string>

    <!-- A label on a button. The user clicks this button after he has
         finished selection. [CHAR LIMIT=15] -->
    <string name="done">Done</string>

    <!-- String indicating the sequence of currently selected item in the
            media set eg. 3 of 5 items [CHAR LIMIT=30] -->
    <string name="sequence_in_set">%1$d of %2$d items:</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=14] -->
    <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=14] -->
    <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=8] -->
    <string name="manual">Manual</string>
    <!-- String indicating how camera shooting feature is used. [CHAR LIMIT=8] -->
    <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>

    <!-- String for the empty not filtered image [CHAR LIMIT=10] -->
    <string name="ffx_original">Original</string>
    <!-- String for brown-colored old-fashion looking filter (filtershow_fx_0000_vintage) [CHAR LIMIT=10] -->
    <string name="ffx_vintage">Vintage</string>
    <!-- String for filter that brightens colors (filtershow_fx_0001_instant) [CHAR LIMIT=10] -->
    <string name="ffx_instant">Instant</string>
    <!-- String for filter that washes out colors (filtershow_fx_0002_bleach) [CHAR LIMIT=10] -->
    <string name="ffx_bleach">Bleach</string>
    <!-- String for filter that makes colors a bluish (filtershow_fx_0003_blue_crush) [CHAR LIMIT=10] -->
    <string name="ffx_blue_crush">Blue</string>
    <!-- String for filter that makes image black & white (filtershow_fx_0004_bw_contrast) [CHAR LIMIT=10] -->
    <string name="ffx_bw_contrast">B/W</string>
    <!-- String for filter that makes colors a yellowish (filtershow_fx_0005_punch) [CHAR LIMIT=10] -->
    <string name="ffx_punch">Punch</string>
    <!-- String for filter that mimics the cross-process technique in
         photography (makes colors bluish) (filtershow_fx_0006_x_process) [CHAR LIMIT=10] -->
    <string name="ffx_x_process">X Process</string>
    <!-- String for filter that makes image coffee-colored (filtershow_fx_0007_washout) [CHAR LIMIT=10] -->
    <string name="ffx_washout">Latte</string>
    <!-- String for filter that makes colors washed out and brownish
         (filtershow_fx_0008_washout_color) [CHAR LIMIT=10] -->
    <string name="ffx_washout_color">Litho</string>

    <!-- Toast message shown after we make some album(s) available offline [CHAR LIMIT=50] -->
    <plurals name="make_albums_available_offline">
        <item quantity="one">Making album available offline.</item>
        <item quantity="other">Making albums available offline.</item>
    </plurals>

    <!-- 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>

    <!-- A label shown on the action bar. It indicates that the user is
         viewing all available albums [CHAR LIMIT=20] -->
    <string name="set_label_all_albums">All albums</string>

    <!-- A label shown on the action bar. It indicates that the user is
         viewing albums stored locally on the device [CHAR LIMIT=20] -->
    <string name="set_label_local_albums">Local albums</string>

    <!-- A label shown on the action bar. It indicates that the user is
         viewing MTP devices connected (like other digital cameras).
         [CHAR LIMIT=20] -->
    <string name="set_label_mtp_devices">MTP devices</string>

    <!-- A label shown on the action bar. It indicates that the user is
         viewing Picasa albums [CHAR LIMIT=20] -->
    <string name="set_label_picasa_albums">Picasa albums</string>

    <!-- Label indicating the amount on free space on the device. The parameter
         is a string representation of the amount of free space, eg. "20MB".
         [CHAR LIMIT=20]
    -->
    <string name="free_space_format"><xliff:g id="bytes">%s</xliff:g> free</string>

    <!-- Label of a group of pictures. The size of each picture in this group is
         less than a certain amount. The parameter is a string representation
         of that amount, eg. "10MB".
         [CHAR LIMIT=20]
    -->
    <string name="size_below"><xliff:g id="size">%1$s</xliff:g> or below</string>

    <!-- Label of a group of pictures. The size of each picture in this group is
         more than a certain amount. The parameter is a string representation
         of that amount, eg. "10MB".
         [CHAR LIMIT=20]
    -->
    <string name="size_above"><xliff:g id="size">%1$s</xliff:g> or above</string>

    <!-- Label of a group of pictures. The size of each picture in this group is
         between two amounts. The parameters are string representations of the two
         amounts, eg. "10MB", "100MB".
         [CHAR LIMIT=20]
    -->
    <string name="size_between"><xliff:g id="min_size">%1$s</xliff:g> to <xliff:g id="max_size">%2$s</xliff:g></string>

    <!-- A label shown on the action bar. It indicates that the operation
         to import media item(s) [CHAR LIMIT=20] -->
    <string name="Import">Import</string>

    <!-- A label shown on the action bar. It indicates whether the import
         operation succeeds or fails. [CHAR LIMIT=20] -->
    <string name="import_complete">Import complete</string>
    <string name="import_fail">Import unsuccessful</string>

    <!-- A toast indicating a camera is connected to the device [CHAR LIMIT=30]-->
    <string name="camera_connected">Camera connected.</string>
    <!-- A toast indicating a camera is disconnected [CHAR LIMIT=30] -->
    <string name="camera_disconnected">Camera disconnected.</string>
    <!-- A label shown on MTP albums thumbnail to instruct users to import
        [CHAR LIMIT=40] -->
    <string name="click_import">Touch here to import</string>

    <!-- The label on the radio button for the widget type that shows the images randomly. [CHAR LIMIT=30]-->
    <string name="widget_type_album">Choose an album</string>
    <!-- The label on the radio button for the widget type that shows the images in an album. [CHAR LIMIT=30]-->
    <string name="widget_type_shuffle">Shuffle all images</string>
    <!-- The label on the radio button for the widget type that shows only one image. [CHAR LIMIT=30]-->
    <string name="widget_type_photo">Choose an image</string>

    <!-- The title of the dialog for choosing the type of widget. [CHAR LIMIT=20] -->
    <string name="widget_type">Choose images</string>

    <!-- Title of the Android Dreams slideshow screensaver. [CHAR LIMIT=20] -->
    <string name="slideshow_dream_name">Slideshow</string>

    <!-- Group by Albums tab on Action Bar. [CHAR LIMIT=12] -->
    <string name="albums">Albums</string>

    <!-- Group by Times tab on Action Bar. [CHAR LIMIT=12] -->
    <string name="times">Times</string>

    <!-- Group by Locations tab on Action Bar. [CHAR LIMIT=12] -->
    <string name="locations">Locations</string>

    <!-- Group by People tab on Action Bar. [CHAR LIMIT=12] -->
    <string name="people">People</string>

    <!-- Group by Tags tab on Action Bar. [CHAR LIMIT=12] -->
    <string name="tags">Tags</string>

    <!-- Group by menu item. [CHAR LIMIT=20] -->
    <string name="group_by">Group by</string>

    <!-- The title of the menu item which enable the settings [CHAR LIMIT=20] -->
    <string name="settings">Settings</string>

    <!-- The title of menu item where user can add a new account -->
    <string name="add_account">Add account</string>

    <!-- The label for the folder contains pictures taken by the camera. [CHAR LIMIT=20]-->
    <string name="folder_camera">Camera</string>

    <!-- The label for the folder contains downloaded pictures. [CHAR LIMIT=20]-->
    <string name="folder_download">Download</string>

    <!-- The label for the folder contains edited online pictures. [CHAR LIMIT=40]-->
    <string name="folder_edited_online_photos">Edited Online Photos</string>

    <!-- The label for the folder contains pictures that was imported from an
         external camera. [CHAR LIMIT=20]-->
    <string name="folder_imported">Imported</string>

    <!-- The label for the folder contains screenshot images. [CHAR LIMIT=20]-->
    <string name="folder_screenshot">Screenshot</string>

    <!-- The title of the menu item which display online help in browser. [CHAR LIMIT=20]-->
    <string name="help">Help</string>

    <!-- Web address for gallery help.  DO NOT TRANSLATE -->
    <string name="help_url_gallery_main" translatable="false"></string>

    <!-- The tilte of a dialog showing there is no external storage. [CHAR LIMIT=20] -->
    <string name="no_external_storage_title">No Storage</string>

    <!-- The message of a dialog showing there is no external storage. [CHAR LIMIT=none] -->
    <string name="no_external_storage">No external storage available</string>

    <!-- Label for album filmstrip button -->
    <string name="switch_photo_filmstrip">Filmstrip view</string>

    <!-- Label for album grid button -->
    <string name="switch_photo_grid">Grid view</string>

    <!-- Label for fullscreen button. [CHAR LIMIT=20] -->
    <string name="switch_photo_fullscreen">Fullscreen view</string>

    <!-- The tilte of a dialog showing trimming in progress. [CHAR LIMIT=20] -->
    <string name="trimming">Trimming</string>

    <!-- The tilte of a dialog showing muting in progress. [CHAR LIMIT=20] -->
    <string name="muting">Muting</string>

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

    <!-- Toast after the trimming / muting is done. [CHAR LIMIT=50] -->
    <string name="save_into">Saving video to <xliff:g id="album_name">%1$s</xliff:g> \u2026</string>

    <!-- Toast if the trimmed video is too short to trim. [CHAR LIMIT=80] -->
    <string name="trim_too_short">Can not trim : target video is too short</string>

    <!-- Text to show with progress bar while stitching in Gallery -->
    <string name="pano_progress_text">Rendering panorama</string>

    <!-- The label on the button that will save an edited image -->
    <string name="save" msgid="8140440041190264400">Save</string>

    <!--  Text of notification message which is shown when user attaches camera -->
    <string name="ingest_scanning" msgid="2048262851775139720">Scanning content...</string>

    <!-- String indicating how many media items from the camera have been scanned -->
    <plurals name="ingest_number_of_items_scanned">
        <item quantity="zero">%1$d items scanned</item>
        <item quantity="one">%1$d item scanned</item>
        <item quantity="other">%1$d items scanned</item>
    </plurals>

    <!--  Status message shown when content from the camera is being sorted -->
    <string name="ingest_sorting" msgid="624687230903648118">Sorting...</string>

    <!--  Status message shown when scanning the content from the camera has completed -->
    <string name="ingest_scanning_done">Scanning done</string>

    <!--  Status message shown when content from an external camera is being imported -->
    <string name="ingest_importing">Importing...</string>

    <!--  Status message shown when there is no content available to be imported -->
    <string name="ingest_empty_device">There is no content available for importing on this device.</string>

    <!--  Status message shown when there is no MTP device connected  -->
    <string name="ingest_no_device">There is no MTP device connected</string>

    <!-- Camera resources below -->

    <!-- 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>

    <!--  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>
    <!-- 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 13 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_13mp">13M pixels</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 4 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_4mp">4M 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 2 megapixels picture size [CHAR LIMIT=15] -->
    <string name="pref_camera_picturesize_entry_2mp_wide">2M pixels (16:9)</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>

    <!-- 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>

    <!-- 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>
        <!-- flash label [CHAR LIMIT=50] -->
    <string name="pref_camera_flashmode_label">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>

    <!-- 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 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>
    <!-- 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 (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>

    <!-- 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 labels [CHAR LIMIT=50] -->
    <string name="pref_camera_countdown_label">COUNTDOWN TIMER</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>

    <!-- 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>

    <!-- 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>
    <!-- The button to play the video. [CHAR LIMIT = NONE] -->
    <string name="accessibility_play_video">Play video</string>
    <!-- The button to pause the video. [CHAR LIMIT = NONE] -->
    <string name="accessibility_pause_video">Pause video</string>
    <!-- The button to reload the video. [CHAR LIMIT = NONE] -->
    <string name="accessibility_reload_video">Reload video</string>
    <!-- The time bar of the media player. [CHAR LIMIT = NONE] -->
    <string name="accessibility_time_bar">Video player time bar</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>

    <!-- Menu item to launch the camera app [CHAR LIMIT=25] -->
    <string name="menu_camera">Camera</string>
    <!-- Menu item to search for photos [CHAR LIMIT=25] -->
    <string name="menu_search">Search</string>
    <!-- Title for the all photos tab [CHAR LIMIT=25] -->
    <string name="tab_photos">Photos</string>
    <!-- Title for the albums tab [CHAR LIMIT=25] -->
    <string name="tab_albums">Albums</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>

    <!-- String indicating how many photos are in an album [CHAR LIMIT=15] -->
    <plurals name="number_of_photos">
        <item quantity="one">%1$d photo</item>
        <item quantity="other">%1$d photos</item>
    </plurals>
</resources>
