<?xml version="1.0" encoding="utf-8"?>
<!--
/**
 * Copyright (C) 2014 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">
  <!-- TODO: Review all strings before launch -->

  <!-- General provisioning strings used for both device owner and work profile provisioning -->

  <!-- Name of the application [CHAR LIMIT=NONE] -->
  <string name="app_name">Device Provisioner</string>
  <!-- Title of the provisioning error dialog. [CHAR LIMIT=45] -->
  <string name="provisioning_error_title">Oops!</string>

  <!-- Work profile provisioning flow UI. -->

  <!-- User consent -->
  <!-- Title of all work profile setup screens. [CHAR LIMIT=NONE] -->
  <string name="setup_work_space">Set up your profile</string>
  <!-- The text that asks for user consent to create a work profile [CHAR LIMIT=NONE] -->
  <string name="company_controls_workspace">Your organization controls this profile and keeps it secure. You control everything else on your device.</string>
  <!-- String shown above the icon of the app that will control the work profile after it is set up. [CHAR LIMIT=NONE]-->
  <string name="the_following_is_your_mdm">The following app will need to access this profile:</string>
  <!-- String for positive button on user consent dialog for creating a profile [CHAR LIMIT=NONE] -->
  <string name="set_up">Set up</string>
  <!-- Progress text shown when setting up work profile [CHAR LIMIT=NONE] -->
  <string name="setting_up_workspace">Setting up your work profile...</string>
  <!-- Text in a pop-up that asks the user to confirm that they allow the mobile device management app to take control of the profile they are creating. [CHAR LIMIT=NONE]-->
  <string name="admin_has_ability_to_monitor_profile">Your administrator has the ability to monitor and manage settings, corporate access, apps and data associated with the profile, including network activity and your device\'s location information.</string>
  <!-- Text in a pop-up that asks the user to confirm that they allow the mobile device management app to take control of the device. [CHAR LIMIT=NONE]-->
  <string name="admin_has_ability_to_monitor_device">Your administrator has the ability to monitor and manage settings, corporate access, apps, and data associated with this device, including network activity and your device\'s location information.</string>
  <!-- Text in a pop-up that asks the user to confirm that they allow the mobile device management app to take control of the device, identical to "admin_has_ability_to_monitor_device" but with extra warning about theft protection being disabled. [CHAR LIMIT=NONE]-->
  <string name="admin_has_ability_to_monitor_device_with_frp_disabled">Your administrator has the ability to monitor and manage settings, corporate access, apps, permissions, and data associated with this device, including network activity and your device\'s location information. Device theft protection features will not be enabled if you continue. You can cancel now and set this up as a personal device to enable theft protection features.</string>
  <!-- String telling the user how to get more information about their work profile-->
  <string name="contact_your_admin_for_more_info">Contact your administrator for more information, including your organization\'s privacy policies.</string>
  <!-- Text on the link that will forward the user to a website with more information about work profiles [CHAR LIMIT=30]-->
  <string name="learn_more_link">Learn more </string>
  <!-- Text on negative button in a popup shown to the user to confirm that they want to start setting up a work profile [CHAR LIMIT=15]-->
  <string name="cancel_setup">Cancel</string>
  <!-- Text on positive button in a popup shown to the user to confirm that they want to start setting up a work profile [CHAR LIMIT=15]-->
  <string name="ok_setup">OK</string>

  <!-- Default profile name used for the creation of work profiles. [CHAR LIMIT=NONE] -->
  <string name="default_managed_profile_name">Work profile</string>

  <!-- String shown when there is already a work profile for this user. CHAR LIMIT=NONE] -->
  <string name="managed_profile_already_present">You already have a work profile on your device. Do you want to remove it?</string>
  <!-- String on the dialog that prompts the user to confirm that they really want to delete their existing work profile-->
  <string name="sure_you_want_to_delete_profile">Are you sure you want to remove this work profile? All of its data will be deleted.</string>
  <!-- String on the button that triggers the deletion of a work profile.-->
  <string name="delete_profile">Remove</string>
  <!-- String on the button that cancels out of the deletion of a work profile.-->
  <string name="cancel_delete_profile">Cancel</string>

  <!-- String shown on prompt for user to encrypt and reboot the device [CHAR LIMIT=NONE]-->
  <string name="encrypt_device_text">To continue setting up your work profile, you\'ll need to encrypt your device. This may take some time.</string>
  <!-- String shown on button for user to cancel setup when asked to encrypt device. [CHAR LIMIT=20]-->
  <string name="encrypt_device_cancel">Cancel</string>
  <!-- String shown on button for user to continue to settings to encrypt the device. [CHAR LIMIT=20]-->
  <string name="encrypt_device_launch_settings">Encrypt</string>

  <!-- Title for reminder notification to resume provisioning after encryption [CHAR LIMIT=30] -->
  <string name="continue_provisioning_notify_title">Encryption complete</string>
  <!-- Body for reminder notification to resume provisioning after encryption [CHAR LIMIT=NONE] -->
  <string name="continue_provisioning_notify_text">Touch to continue setting up your work profile</string>

  <!-- Explains the failure and what to do to next. [CHAR LIMIT=NONE] -->
  <string name="managed_provisioning_error_text">Couldn\'t set up your work profile. Contact your IT department or try again later.</string>
  <!-- Error string displayed if this device doesn't support work profiles. -->
  <string name="managed_provisioning_not_supported">Your device doesn\'t support work profiles</string>
  <!-- Error string displayed if the user that initiated the provisioning is not the user owner. -->
  <string name="user_is_not_owner">Work profiles need to be set up by the device owner</string>
  <!-- Error string displayed if the selected launcher doesn't support work profiles. -->
  <string name="managed_provisioning_not_supported_by_launcher">Your work profile isn\'t supported by this launcher app. You\'ll need to switch to a launcher that\'s compatible.</string>
  <!-- Button text for the button that cancels provisioning  -->
  <string name="cancel_provisioning">Cancel</string>
  <!-- Button text for the button that opens the launcher picker  -->
  <string name="pick_launcher">Ok</string>

  <!-- Device owner provisioning flow UI. -->

  <!-- Default username for the user of the owned device. [CHAR LIMIT=45] -->
  <string name="default_owned_device_username">User of work device</string>

  <!-- Title of the work device setup screen. [CHAR LIMIT=NONE] -->
  <string name="setup_device">Set up your device</string>
  <!-- Progress text indicating that the setup data is processed. [CHAR LIMIT=45] -->
  <string name="progress_data_process">Processing setup data...</string>
  <!-- Progress text indicating that wifi is set up. [CHAR LIMIT=45] -->
  <string name="progress_connect_to_wifi">Connecting to Wi-Fi...</string>
  <!-- Progress text indicating that the device admin package is being downloaded. [CHAR LIMIT=45] -->
  <string name="progress_download">Downloading the admin app...</string>
  <!-- Progress text indicating that the device admin package is being installed. [CHAR LIMIT=45] -->
  <string name="progress_install">Installing the admin app...</string>
  <!-- Progress text indicating that the device admin package is set as ownder. [CHAR LIMIT=45] -->
  <string name="progress_set_owner">Setting the device owner...</string>

  <!-- Title of the cancel provisioning dialog. [CHAR LIMIT=45] -->
  <string name="device_owner_cancel_title">Stop setting up?</string>
  <!-- Message of the cancel dialog. [CHAR LIMIT=NONE] -->
  <string name="device_owner_cancel_message">Are you sure you want to stop setting up and erase your device\'s data?</string>
  <!-- Cancel button text of the cancel dialog. [CHAR LIMIT=45] -->
  <string name="device_owner_cancel_cancel">Cancel</string>
  <!-- OK button text of the error dialog. [CHAR LIMIT=45] -->
  <string name="device_owner_error_ok">OK</string>
  <!-- Reset button text of the error dialog. [CHAR LIMIT=45] -->
  <string name="device_owner_error_reset">Reset</string>
  <!-- Message of the error dialog in case of an unspecified error. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_general">Couldn\'t set up your device. Contact your IT department. </string>
  <!-- Message of the error dialog when already provisioned. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_already_provisioned">This device is already set up</string>
  <!-- Message of the error dialog when setting up wifi failed. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_wifi">Couldn\'t connect to Wi-Fi</string>
  <!-- Message of the error dialog when data integrity check fails. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_hash_mismatch">Couldn\'t use the admin app due to a checksum error. Contact your IT department.</string>
  <!-- Message of the error dialog when device owner apk could not be downloaded. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_download_failed">Couldn\'t download the admin app</string>
  <!-- Message of the error dialog when package to install is invalid. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_package_invalid">Can\'t use the admin app. It\'s missing components or corrupted. Contact your IT department.</string>
  <!-- Message of the error dialog when package could not be installed. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_installation_failed">Couldn\'t install the admin app</string>
  <!-- Message of the error dialog when device admin package is not installed. [CHAR LIMIT=NONE] -->
  <string name="device_owner_error_package_not_installed">The admin app isn\'t installed on your device</string>
  <!-- Title of the cancel profile owner provisioning dialog. [CHAR LIMIT=45] -->
  <string name="profile_owner_cancel_title">Stop setting up?</string>
  <!-- Message of the cancel dialog. [CHAR LIMIT=NONE] -->
  <string name="profile_owner_cancel_message">Are you sure you want to stop setting up?</string>
  <!-- Cancel button text of the cancel dialog. [CHAR LIMIT=45] -->
  <string name="profile_owner_cancel_cancel">No</string>
  <!-- OK button text of the error dialog. [CHAR LIMIT=45] -->
  <string name="profile_owner_cancel_ok">Yes</string>
  <!-- Message of the cancel progress dialog. [CHAR LIMIT=45] -->
  <string name="profile_owner_cancelling">Cancelling...</string>
</resources>
