<!--
  ~ Copyright (C) 2023 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.
  -->
<idea-plugin>
  <extensions defaultExtensionNs="com.android.tools.idea.uibuilder.editor.multirepresentation.sourcecode">
    <sourceCodePreviewRepresentationProvider implementation="com.android.tools.idea.wear.preview.WearTilePreviewRepresentationProvider"/>
  </extensions>

  <extensions defaultExtensionNs="com.intellij">
    <notificationGroup id="Wear Tile Preview Notification" displayType="NONE"/>

    <deadCode implementation="com.android.tools.idea.wear.preview.WearTilePreviewEntryPoint"/>

    <languageInjectionContributor language="kotlin"
                                  implementationClass="com.android.tools.idea.wear.preview.util.device.WearTileDeviceSpecInjectionContributor"/>
    <languageInjectionContributor language="JAVA"
                                  implementationClass="com.android.tools.idea.wear.preview.util.device.WearTileDeviceSpecInjectionContributor"/>
    <deadCode implementation="com.android.tools.idea.wear.preview.WearTilePreviewEntryPoint" />

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewNotSupportedInUnitTestFiles"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.unit.test.files"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewMethodIsAnnotatedWithTilePreviewAnnotation"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.preview.annotation.not.from.tile.package"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewComposableAnnotationIsNotSupported"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.preview.annotation.composable.not.supported"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewContextComesFromParameter"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.context.comes.from.parameter"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewHasValidMethodSignature"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.invalid.signature"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewShouldBeTopLevelFunction"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.top.level.function"
                     level="ERROR"/>

    <localInspection implementationClass="com.android.tools.idea.wear.preview.lint.WearTilePreviewDeviceSpecInspection"
                     language="UAST"
                     enabledByDefault="true"
                     bundle="bundle.wear.WearBundle"
                     groupKey="inspection.group.name"
                     key="inspection.device.spec"
                     level="ERROR"/>

  </extensions>
</idea-plugin>