<?xml version="1.0" encoding="UTF-8"?>
<!--
 Copyright 2013 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.
-->

<sample>
    <name>WearAccessibilityApp</name>
    <group>Wearable</group>
    <package>com.example.android.wearable.wear.wearaccessibilityapp</package>

    <minSdkVersionWear>24</minSdkVersionWear>
    <compileSdkVersionWear>26</compileSdkVersionWear>
    <targetSdkVersionWear>26</targetSdkVersionWear>

    <multiDexEnabled>true</multiDexEnabled>

    <dependency_wearable>com.android.support:wear:27.1.1</dependency_wearable>
    <dependency_wearable>com.android.support.constraint:constraint-layout:1.0.2</dependency_wearable>
    <dependency_wearable>com.android.support:appcompat-v7:27.1.1</dependency_wearable>


    <strings>
        <intro>
            <![CDATA[
            Sample demostrates best practices for accessibility (a11y support).
            ]]>
        </intro>
    </strings>

    <template src="base-build" />
    <template src="Wear" />

    <metadata>
        <!-- Values: {DRAFT | PUBLISHED | INTERNAL | DEPRECATED | SUPERCEDED} -->
        <status>PUBLISHED</status>
        <!-- See http://go/sample-categories for details on the next 4 fields. -->
        <!-- Most samples just need to udpate the Categories field. This is a comma-
             seperated list of topic tags. Unlike the old category system, samples
             may have multiple categories, so feel free to add extras. Try to avoid
             simply tagging everything with "UI". :)-->
        <categories>Wearable</categories>
        <technologies>Android</technologies>
        <languages>Java</languages>
        <solutions>Mobile</solutions>
        <!-- Values: {BEGINNER | INTERMEDIATE | ADVANCED | EXPERT} -->
        <!-- Beginner is for "getting started" type content, or essential content.
             (e.g. "Hello World", activities, intents)

             Intermediate is for content that covers material a beginner doesn't need
             to know, but that a skilled developer is expected to know.
             (e.g. services, basic styles and theming, sync adapters)

             Advanced is for highly technical content geared towards experienced developers.
             (e.g. performance optimizations, custom views, bluetooth)

             Expert is reserved for highly technical or specialized content, and should
             be used sparingly. (e.g. VPN clients, SELinux, custom instrumentation runners) -->
        <level>INTERMEDIATE</level>
        <!-- Dimensions: 512x512, PNG fomrat -->
        <icon>screenshots/icon-web.png</icon>
        <!-- Path to screenshots. Use <img> tags for each. -->
        <screenshots>
            <img>screenshots/main_screen.png</img>
            <img>screenshots/progress_screen.png</img>
            <img>screenshots/controls_screen.png</img>
        </screenshots>
        <!-- List of APIs that this sample should be cross-referenced under. Use <android>
        for fully-qualified Framework class names ("android:" namespace).

        Use <ext> for custom namespaces, if needed. See "Samples Index API" documentation
        for more details. -->
        <api_refs>
            <android>android.support.wear.widget.WearableRecyclerView</android>
            <android>android.preference.Preference</android>
            <android>android.support.v4.app.NotificationCompat</android>
        </api_refs>

        <!-- 1-3 line description of the sample here.

            Avoid simply rearranging the sample's title. What does this sample actually
            accomplish, and how does it do it? -->
        <description>
            Sample demonstrates how to include accessibility support for your wearable app.
        </description>

        <!-- Multi-paragraph introduction to sample, from an educational point-of-view.
        Makrdown formatting allowed. This will be used to generate a mini-article for the
        sample on DAC. -->
        <intro>
            Accessibility is an important part of any app (especially wearable apps). By
            integrating accessible components and services, you can improve your app's usability,
            particularly for users with disabilities.

            This sample demonstrates common UX patterns in wearable apps along with accessibility
            support of those patterns. Be sure to review the [Accessibility Developer Checklist][1]
            for your own app. For additional information please see our
            [Best Practices for User Interface][2] page.

            [1]: https://developer.android.com/guide/topics/ui/accessibility/checklist.html
            [2]: https://developer.android.com/training/accessibility/index.html
        </intro>
    </metadata>
</sample>
