<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/**
 * Copyright (c) 2009, 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:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="dock_alignment_slow_charging" product="default" msgid="6997633396534416792">"Räta upp telefonen för att ladda snabbare"</string>
    <string name="dock_alignment_not_charging" product="default" msgid="3980752926226749808">"Räta upp telefonen för att ladda trådlöst"</string>
    <string name="inattentive_sleep_warning_message" product="tv" msgid="6844464574089665063">"Android TV-enheten stängs snart av. Tryck på en knapp för att behålla den på."</string>
    <string name="inattentive_sleep_warning_message" product="default" msgid="5693904520452332224">"Enheten stängs snart av. Tryck för att behålla den på."</string>
    <string name="keyguard_missing_sim_message" product="tablet" msgid="5018086454277963787">"Inget SIM-kort i surfplattan."</string>
    <string name="keyguard_missing_sim_message" product="default" msgid="7053347843877341391">"Inget SIM-kort i telefonen."</string>
    <string name="kg_invalid_confirm_pin_hint" product="default" msgid="6278551068943958651">"Pinkoderna stämmer inte överens"</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet" msgid="302165994845009232">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök återställs surfplattan och all data raderas."</string>
    <string name="kg_failed_attempts_almost_at_wipe" product="default" msgid="2594813176164266847">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök återställs telefonen och all data raderas."</string>
    <string name="kg_failed_attempts_now_wiping" product="tablet" msgid="8710104080409538587">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Surfplattan återställs och all data raderas."</string>
    <string name="kg_failed_attempts_now_wiping" product="default" msgid="6381835450014881813">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Telefonen återställs och all data raderas."</string>
    <string name="kg_failed_attempts_almost_at_erase_user" product="tablet" msgid="7325071812832605911">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök tas användaren bort och all användardata raderas."</string>
    <string name="kg_failed_attempts_almost_at_erase_user" product="default" msgid="8110939900089863103">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök tas användaren bort och all användardata raderas."</string>
    <string name="kg_failed_attempts_now_erasing_user" product="tablet" msgid="8509811676952707883">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Användaren tas bort och all användardata raderas."</string>
    <string name="kg_failed_attempts_now_erasing_user" product="default" msgid="3051962486994265014">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Användaren tas bort och all användardata raderas."</string>
    <string name="kg_failed_attempts_almost_at_erase_profile" product="tablet" msgid="1049523640263353830">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök tas jobbprofilen bort och all profildata raderas."</string>
    <string name="kg_failed_attempts_almost_at_erase_profile" product="default" msgid="3280816298678433681">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök tas jobbprofilen bort och all profildata raderas."</string>
    <string name="kg_failed_attempts_now_erasing_profile" product="tablet" msgid="4417100487251371559">"Du har försökt låsa upp surfplattan på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Jobbprofilen tas bort och all profildata raderas."</string>
    <string name="kg_failed_attempts_now_erasing_profile" product="default" msgid="4682221342671290678">"Du har försökt låsa upp telefonen på ett felaktigt sätt <xliff:g id="NUMBER">%d</xliff:g> gånger. Jobbprofilen tas bort och all profildata raderas."</string>
    <string name="kg_failed_attempts_almost_at_login" product="tablet" msgid="1860049973474855672">"Du har ritat ditt grafiska lösenord fel <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök måste du låsa upp surfplattan med hjälp av ett e-postkonto.\n\n Försök igen om <xliff:g id="NUMBER_2">%3$d</xliff:g> sekunder."</string>
    <string name="kg_failed_attempts_almost_at_login" product="default" msgid="44112553371516141">"Du har ritat ditt grafiska lösenord fel <xliff:g id="NUMBER_0">%1$d</xliff:g> gånger. Efter ytterligare <xliff:g id="NUMBER_1">%2$d</xliff:g> försök måste du låsa upp telefonen med hjälp av ett e-postkonto.\n\n Försök igen om <xliff:g id="NUMBER_2">%3$d</xliff:g> sekunder."</string>
    <!-- no translation found for global_action_lock_message (7092460751050168771) -->
    <skip />
    <!-- no translation found for global_action_lock_message (1024230056230539493) -->
    <skip />
    <!-- no translation found for global_action_lock_message (3165224897120346096) -->
    <skip />
</resources>
