<?xml version="1.0" encoding="utf-8"?>
<!--
/**
 * Copyright (C) 2017 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>
    <!-- A list of apps to be retained on the managed user.
            Takes precedence over the disallowed apps lists. -->
    <string-array translatable="false" name="required_apps_managed_user">
        <item>com.android.settings</item>
        <item>com.android.contacts</item>
        <item>com.android.dialer</item>
        <item>com.android.stk</item>  <!-- Required by com.android.phone by certain carriers -->
        <item>com.android.providers.downloads</item>
        <item>com.android.providers.downloads.ui</item>
        <item>com.android.documentsui</item>
    </string-array>
</resources>
