| /* |
| * Copyright (C) 2011 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. |
| */ |
| package com.android.tools.lint.checks |
| |
| import com.android.SdkConstants.ANDROID_URI |
| import com.android.SdkConstants.ATTR_ALLOW_BACKUP |
| import com.android.SdkConstants.ATTR_FULL_BACKUP_CONTENT |
| import com.android.SdkConstants.ATTR_ICON |
| import com.android.SdkConstants.ATTR_MIN_SDK_VERSION |
| import com.android.SdkConstants.ATTR_NAME |
| import com.android.SdkConstants.ATTR_PACKAGE |
| import com.android.SdkConstants.ATTR_TARGET_SDK_VERSION |
| import com.android.SdkConstants.ATTR_VERSION_CODE |
| import com.android.SdkConstants.ATTR_VERSION_NAME |
| import com.android.SdkConstants.DRAWABLE_PREFIX |
| import com.android.SdkConstants.PREFIX_RESOURCE_REF |
| import com.android.SdkConstants.TAG_ACTIVITY |
| import com.android.SdkConstants.TAG_APPLICATION |
| import com.android.SdkConstants.TAG_CATEGORY |
| import com.android.SdkConstants.TAG_INTENT_FILTER |
| import com.android.SdkConstants.TAG_PERMISSION |
| import com.android.SdkConstants.TAG_PERMISSION_GROUP |
| import com.android.SdkConstants.TAG_PROVIDER |
| import com.android.SdkConstants.TAG_QUERIES |
| import com.android.SdkConstants.TAG_RECEIVER |
| import com.android.SdkConstants.TAG_SERVICE |
| import com.android.SdkConstants.TAG_USES_FEATURE |
| import com.android.SdkConstants.TAG_USES_LIBRARY |
| import com.android.SdkConstants.TAG_USES_PERMISSION |
| import com.android.SdkConstants.TAG_USES_SDK |
| import com.android.SdkConstants.TOOLS_URI |
| import com.android.SdkConstants.VALUE_FALSE |
| import com.android.ide.common.rendering.api.ResourceNamespace |
| import com.android.ide.common.repository.GradleCoordinate |
| import com.android.ide.common.repository.MavenRepositories |
| import com.android.ide.common.repository.SdkMavenRepository |
| import com.android.resources.ResourceUrl |
| import com.android.tools.lint.client.api.ResourceRepositoryScope |
| import com.android.tools.lint.detector.api.Category |
| import com.android.tools.lint.detector.api.Context |
| import com.android.tools.lint.detector.api.Detector |
| import com.android.tools.lint.detector.api.Implementation |
| import com.android.tools.lint.detector.api.Incident |
| import com.android.tools.lint.detector.api.Issue |
| import com.android.tools.lint.detector.api.LintFix |
| import com.android.tools.lint.detector.api.Location |
| import com.android.tools.lint.detector.api.LocationType |
| import com.android.tools.lint.detector.api.Project |
| import com.android.tools.lint.detector.api.Scope |
| import com.android.tools.lint.detector.api.Severity |
| import com.android.tools.lint.detector.api.XmlContext |
| import com.android.tools.lint.detector.api.XmlScanner |
| import com.android.tools.lint.detector.api.targetSdkAtLeast |
| import com.android.tools.lint.model.LintModelExternalLibrary |
| import com.android.tools.lint.model.LintModelVariant |
| import com.android.utils.XmlUtils |
| import com.android.utils.iterator |
| import com.android.utils.usLocaleCapitalize |
| import com.android.xml.AndroidManifest |
| import org.w3c.dom.Attr |
| import org.w3c.dom.Document |
| import org.w3c.dom.Element |
| import org.w3c.dom.Node |
| import java.io.File |
| |
| /** |
| * Checks for issues in AndroidManifest files such as declaring elements |
| * in the wrong order. |
| */ |
| class ManifestDetector : |
| Detector(), XmlScanner { |
| companion object { |
| private val IMPLEMENTATION = Implementation( |
| ManifestDetector::class.java, Scope.MANIFEST_SCOPE |
| ) |
| |
| /** Wrong order of elements in the manifest */ |
| @JvmField |
| val ORDER = Issue.create( |
| id = "ManifestOrder", |
| briefDescription = "Incorrect order of elements in manifest", |
| explanation = """ |
| The `<application>` tag should appear after the elements which declare which version you need, \ |
| which features you need, which libraries you need, and so on. In the past there have been subtle \ |
| bugs (such as themes not getting applied correctly) when the `<application>` tag appears before \ |
| some of these other elements, so it's best to order your manifest in the logical dependency \ |
| order. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Missing a `<uses-sdk>` element */ |
| @JvmField |
| val USES_SDK = Issue.create( |
| id = "UsesMinSdkAttributes", |
| briefDescription = "Minimum SDK and target SDK attributes not defined", |
| explanation = """ |
| The manifest should contain a `<uses-sdk>` element which defines the minimum API Level \ |
| required for the application to run, as well as the target version (the highest API level \ |
| you have tested the version for). |
| """, |
| category = Category.CORRECTNESS, |
| priority = 9, |
| severity = Severity.WARNING, |
| moreInfo = "https://developer.android.com/guide/topics/manifest/uses-sdk-element.html", |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Using a targetSdkVersion that isn't recent */ |
| @JvmField |
| val TARGET_NEWER = Issue.create( |
| id = "OldTargetApi", |
| briefDescription = "Target SDK attribute is not targeting latest version", |
| explanation = """ |
| When your application runs on a version of Android that is more recent than your \ |
| `targetSdkVersion` specifies that it has been tested with, various compatibility modes \ |
| kick in. This ensures that your application continues to work, but it may look out of \ |
| place. For example, if the `targetSdkVersion` is less than 14, your app may get an \ |
| option button in the UI. |
| |
| To fix this issue, set the `targetSdkVersion` to the highest available value. Then test \ |
| your app to make sure everything works correctly. You may want to consult the \ |
| compatibility notes to see what changes apply to each version you are adding support \ |
| for: https://developer.android.com/reference/android/os/Build.VERSION_CODES.html as well \ |
| as follow this guide: |
| https://developer.android.com/distribute/best-practices/develop/target-sdk.html |
| """, |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| .addMoreInfo("https://developer.android.com/distribute/best-practices/develop/target-sdk.html") |
| .addMoreInfo("https://developer.android.com/reference/android/os/Build.VERSION_CODES.html") |
| |
| /** Using multiple `<uses-sdk>` elements */ |
| @JvmField |
| val MULTIPLE_USES_SDK = Issue.create( |
| id = "MultipleUsesSdk", |
| briefDescription = "Multiple `<uses-sdk>` elements in the manifest", |
| explanation = """ |
| The `<uses-sdk>` element should appear just once; the tools will **not** merge the contents \ |
| of all the elements so if you split up the attributes across multiple elements, only one of \ |
| them will take effect. To fix this, just merge all the attributes from the various elements \ |
| into a single <uses-sdk> element. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.FATAL, |
| moreInfo = "https://developer.android.com/guide/topics/manifest/uses-sdk-element.html", |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Missing a `<uses-sdk>` element */ |
| @JvmField |
| val WRONG_PARENT = Issue.create( |
| id = "WrongManifestParent", |
| briefDescription = "Wrong manifest parent", |
| explanation = """ |
| The `<uses-library>` element should be defined as a direct child of the `<application>` \ |
| tag, not the `<manifest>` tag or an `<activity>` tag. Similarly, a `<uses-sdk>` tag must \ |
| be declared at the root level, and so on. This check looks for incorrect declaration \ |
| locations in the manifest, and complains if an element is found in the wrong place. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.FATAL, |
| moreInfo = "https://developer.android.com/guide/topics/manifest/manifest-intro.html", |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Missing a `<uses-sdk>` element */ |
| @JvmField |
| val DUPLICATE_ACTIVITY = Issue.create( |
| id = "DuplicateActivity", |
| briefDescription = "Activity registered more than once", |
| explanation = """ |
| An activity should only be registered once in the manifest. If it is accidentally \ |
| registered more than once, then subtle errors can occur, since attribute declarations \ |
| from the two elements are not merged, so you may accidentally remove previous \ |
| declarations. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.FATAL, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Documentation URL for app backup. */ |
| private const val BACKUP_DOCUMENTATION_URL = "https://developer.android.com/guide/topics/data/autobackup" |
| |
| /** Not explicitly defining allowBackup */ |
| @JvmField |
| val ALLOW_BACKUP = Issue.create( |
| "AllowBackup", |
| briefDescription = "AllowBackup/FullBackupContent Problems", |
| explanation = """ |
| The `allowBackup` attribute determines if an application's data can be backed up and restored. \ |
| It is documented at https://developer.android.com/reference/android/R.attr.html#allowBackup |
| |
| By default, this flag is set to `true` which means application data can be backed up and \ |
| restored by the OS. Setting `allowBackup="false"` opts the application out of being backed up \ |
| and so users can't restore data related to it when they go through the device setup wizard. |
| |
| Allowing backups may have security consequences for an application. Currently `adb backup` \ |
| allows users who have enabled USB debugging to copy application data off of the device. Once \ |
| backed up, all application data can be read by the user. `adb restore` allows creation of \ |
| application data from a source specified by the user. Following a restore, applications should \ |
| not assume that the data, file permissions, and directory permissions were created by the \ |
| application itself. |
| |
| To fix this warning, decide whether your application should support backup, and explicitly set \ |
| `android:allowBackup=(true|false)"`. |
| |
| If not set to false, and if targeting API 23 or later, lint will also warn that you should set \ |
| `android:fullBackupContent` or `android:fullBackupOnly` to configure auto backup. |
| """, |
| category = Category.SECURITY, |
| priority = 3, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| .addMoreInfo(BACKUP_DOCUMENTATION_URL) |
| .addMoreInfo("https://developer.android.com/reference/android/R.attr.html#allowBackup") |
| |
| /** Conflicting permission names */ |
| @JvmField |
| val UNIQUE_PERMISSION = Issue.create( |
| id = "UniquePermission", |
| briefDescription = "Permission names are not unique", |
| explanation = """ |
| The unqualified names or your permissions must be unique. The reason for this is that at \ |
| build time, the `aapt` tool will generate a class named `Manifest` which contains a field \ |
| for each of your permissions. These fields are named using your permission unqualified names \ |
| (i.e. the name portion after the last dot). |
| |
| If more than one permission maps to the same field name, that field will arbitrarily name \ |
| just one of them. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 6, |
| severity = Severity.FATAL, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Using a resource for attributes that do not allow it */ |
| @JvmField |
| val SET_VERSION = Issue.create( |
| id = "MissingVersion", |
| briefDescription = "Missing application name/version", |
| explanation = """ |
| You should define the version information for your application. |
| |
| `android:versionCode`: An integer value that represents the version of the application code, \ |
| relative to other versions. |
| |
| `android:versionName`: A string value that represents the release version of the application \ |
| code, as it should be shown to users. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 2, |
| severity = Severity.WARNING, |
| moreInfo = "https://developer.android.com/studio/publish/versioning#appversioning", |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Using a resource for attributes that do not allow it */ |
| @JvmField |
| val ILLEGAL_REFERENCE = Issue.create( |
| id = "IllegalResourceRef", |
| briefDescription = "Name and version must be integer or string, not resource", |
| explanation = """ |
| For the `versionCode` attribute, you have to specify an actual integer literal; you cannot \ |
| use an indirection with a `@dimen/name` resource. Similarly, the `versionName` attribute \ |
| should be an actual string, not a string resource url. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 8, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Declaring a uses-feature multiple time */ |
| @JvmField |
| val DUPLICATE_USES_FEATURE = Issue.create( |
| id = "DuplicateUsesFeature", |
| briefDescription = "Feature declared more than once", |
| explanation = "A given feature should only be declared once in the manifest.", |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Not explicitly defining application icon */ |
| @JvmField |
| val APPLICATION_ICON = Issue.create( |
| id = "MissingApplicationIcon", |
| briefDescription = "Missing application icon", |
| explanation = """ |
| You should set an icon for the application as whole because there is no default. This \ |
| attribute must be set as a reference to a drawable resource containing the image (for \ |
| example `@drawable/icon`). |
| """, |
| category = Category.ICONS, |
| priority = 5, |
| severity = Severity.WARNING, |
| moreInfo = "https://developer.android.com/studio/publish/preparing#publishing-configure", |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Malformed Device Admin */ |
| @JvmField |
| val DEVICE_ADMIN = Issue.create( |
| id = "DeviceAdmin", |
| briefDescription = "Malformed Device Admin", |
| explanation = """ |
| If you register a broadcast receiver which acts as a device admin, you must also register \ |
| an `<intent-filter>` for the action `android.app.action.DEVICE_ADMIN_ENABLED`, without any \ |
| `<data>`, such that the device admin can be activated/deactivated. |
| |
| To do this, add |
| ```xml |
| `<intent-filter>` |
| `<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />` |
| `</intent-filter>` |
| ``` |
| to your `<receiver>`. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 7, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** |
| * Using a mock location in a non-debug-specific manifest file |
| */ |
| @JvmField |
| val MOCK_LOCATION = Issue.create( |
| id = "MockLocation", |
| briefDescription = "Using mock location provider in production", |
| explanation = """ |
| Using a mock location provider (by requiring the permission `android.permission.ACCESS_MOCK_LOCATION`) should **only** be done in debug builds (or from tests). In Gradle projects, that means you should only request this permission in a test or debug source set specific manifest file. |
| |
| To fix this, create a new manifest file in the debug folder and move the `<uses-permission>` element there. A typical path to a debug manifest override file in a Gradle project is src/debug/AndroidManifest.xml. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 8, |
| severity = Severity.FATAL, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Defining a value that is overridden by Gradle */ |
| @JvmField |
| val GRADLE_OVERRIDES = Issue.create( |
| id = "GradleOverrides", |
| briefDescription = "Value overridden by Gradle build script", |
| explanation = """ |
| The value of (for example) `minSdkVersion` is only used if it is not specified in the \ |
| `build.gradle` build scripts. When specified in the Gradle build scripts, the manifest \ |
| value is ignored and can be misleading, so should be removed to avoid ambiguity. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 4, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Using drawable rather than mipmap launcher icons */ |
| @JvmField |
| val MIPMAP = Issue.create( |
| id = "MipmapIcons", |
| briefDescription = "Use Mipmap Launcher Icons", |
| explanation = """ |
| Launcher icons should be provided in the `mipmap` resource directory. This is the same as \ |
| the `drawable` resource directory, except resources in the `mipmap` directory will not get \ |
| stripped out when creating density-specific APKs. |
| |
| In certain cases, the Launcher app may use a higher resolution asset (than would normally \ |
| be computed for the device) to display large app shortcuts. If drawables for densities \ |
| other than the device's resolution have been stripped out, then the app shortcut could \ |
| appear blurry. |
| |
| To fix this, move your launcher icons from `drawable-`dpi to `mipmap-`dpi and change \ |
| references from @drawable/ and R.drawable to @mipmap/ and R.mipmap. |
| |
| In Android Studio this lint warning has a quickfix to perform this automatically. |
| """, |
| category = Category.ICONS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = IMPLEMENTATION |
| ) |
| |
| /** Uses Wear Bind Listener which is deprecated */ |
| @JvmField |
| val WEARABLE_BIND_LISTENER = Issue.create( |
| id = "WearableBindListener", |
| briefDescription = "Usage of Android Wear BIND_LISTENER is deprecated", |
| explanation = """ |
| BIND_LISTENER receives all Android Wear events whether the application needs them or not. \ |
| This can be inefficient and cause applications to wake up unnecessarily. With Google Play \ |
| Services 8.2.0 or later it is recommended to use a more efficient combination of manifest \ |
| listeners and api-based live listeners filtered by action, path and/or path prefix. |
| """, |
| category = Category.PERFORMANCE, |
| priority = 6, |
| severity = Severity.FATAL, |
| moreInfo = "https://android-developers.googleblog.com/2016/04/deprecation-of-bindlistener.html", |
| implementation = IMPLEMENTATION |
| ) |
| |
| @JvmField |
| val APP_INDEXING_SERVICE = Issue.create( |
| id = "AppIndexingService", |
| briefDescription = "App Indexing Background Services", |
| explanation = """ |
| Apps targeting Android 8.0 or higher can no longer rely on background services while \ |
| listening for updates to the on-device index. Use a `BroadcastReceiver` for the \ |
| `UPDATE_INDEX` intent to continue supporting indexing in your app. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 4, |
| severity = Severity.WARNING, |
| moreInfo = "https://firebase.google.com/docs/app-indexing/android/personal-content#add-a-broadcast-receiver-to-your-app", |
| implementation = IMPLEMENTATION |
| ) |
| |
| @JvmStatic |
| fun isLaunchableActivity(activity: Element): Boolean = findLaunchableCategoryNode(activity) != null |
| |
| @JvmStatic |
| fun findLaunchableCategoryNode(activity: Element): Attr? { |
| if (TAG_ACTIVITY != activity.tagName) { |
| return null |
| } |
| for (filter in activity) { |
| if (filter.tagName == TAG_INTENT_FILTER) { |
| for (category in filter) { |
| if (category.tagName == TAG_CATEGORY) { |
| val attribute = category.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (attribute != null && attribute.value == "android.intent.category.LAUNCHER") { |
| return attribute |
| } |
| } |
| } |
| } |
| } |
| |
| return null |
| } |
| |
| /** Permission name of mock location permission */ |
| const val MOCK_LOCATION_PERMISSION = "android.permission.ACCESS_MOCK_LOCATION" |
| |
| // Error message used by quick fix |
| const val MISSING_FULL_BACKUP_CONTENT_RESOURCE = "Missing `<full-backup-content>` resource" |
| |
| private val MIN_WEARABLE_GMS_VERSION = GradleCoordinate.parseVersionOnly("8.2.0") |
| private const val PLAY_SERVICES_WEARABLE = GradleDetector.GMS_GROUP_ID + ":play-services-wearable" |
| } |
| |
| private var seenApplication = false |
| |
| /** |
| * Number of times we've seen the <uses-sdk> element </uses-sdk> |
| */ |
| private var seenUsesSdk = 0 |
| |
| /** Activities we've encountered */ |
| private var activities: MutableSet<String>? = null |
| |
| /** Features we've encountered */ |
| private var usesFeatures: MutableSet<String>? = null |
| |
| override fun beforeCheckFile(context: Context) { |
| seenApplication = false |
| seenUsesSdk = 0 |
| activities = null |
| usesFeatures = null |
| } |
| |
| override fun afterCheckFile(context: Context) { |
| val xmlContext = context as XmlContext |
| val element = xmlContext.document.documentElement |
| element?.let { checkDocumentElement(xmlContext, it) } |
| if (seenUsesSdk == 0 && context.isEnabled(USES_SDK) && |
| // Not required in Gradle projects; typically defined in build.gradle instead |
| // and inserted at build time |
| !context.project.isGradleProject |
| ) { |
| xmlContext.report( |
| USES_SDK, |
| element, |
| Location.create(context.file), |
| "Manifest should specify a minimum API level with " + |
| "`<uses-sdk android:minSdkVersion=\"?\" />`; if it really supports " + |
| "all versions of Android set it to 1" |
| ) |
| } |
| } |
| |
| /** |
| * Should we look at `<application>` tags in the source file? If |
| * true, yes, analyze source elements, if false, look at the merged |
| * manifest instead. |
| */ |
| private fun onlyCheckSourceManifest(context: Context): Boolean { |
| // When analyzing a single file in the IDE, limit the search to |
| // the current manifest in the source editor. This is useful |
| // because in the IDE, the merged manifest sometimes lags behind |
| // the typing a bit (it's not updated immediately upon typing) |
| // so we're making sure that we're reflecting the current |
| // reality. For some merged manifest operations we really can't |
| // limit ourselves to the current manifest because it depends |
| // heavily on elements merged from other manifest files (such |
| // as permission declarations) but that's not a factor for this |
| // check. |
| return context.driver.isIsolated() |
| } |
| |
| private fun checkApplication(context: Context) { |
| if (onlyCheckSourceManifest(context)) { |
| // Single file analysis: Already done by XML visitor |
| return |
| } |
| val mainProject = context.mainProject |
| val mergedManifest = mainProject.mergedManifest ?: return |
| val root = mergedManifest.documentElement ?: return |
| val application = XmlUtils.getFirstSubTagByName(root, TAG_APPLICATION) |
| // Just an injected <application/> node from the manifest merger? |
| if (application == null || application.firstChild == null && application.attributes.length == 0) { |
| return |
| } |
| checkApplication(context, application) |
| } |
| |
| /** |
| * Checks that the main `<application>` tag specifies both an icon |
| * and allowBackup, possibly merged from some upstream dependency |
| */ |
| private fun checkApplication(context: Context, application: Element) { |
| if (context.project.isLibrary) { |
| return |
| } |
| if (context.isEnabled(ALLOW_BACKUP)) { |
| val allowBackup = application.getAttributeNS(ANDROID_URI, ATTR_ALLOW_BACKUP) |
| var fullBackupNode = |
| application.getAttributeNodeNS(ANDROID_URI, ATTR_FULL_BACKUP_CONTENT) |
| val client = context.client |
| if (fullBackupNode != null && |
| fullBackupNode.value.startsWith(PREFIX_RESOURCE_REF) |
| ) { |
| val full = context.isGlobalAnalysis() |
| val project = if (full) context.mainProject else context.project |
| val resources = client.getResources(project, ResourceRepositoryScope.LOCAL_DEPENDENCIES) |
| val url = ResourceUrl.parse(fullBackupNode.value) |
| if (url != null && !url.isFramework && |
| !resources.hasResources(ResourceNamespace.TODO(), url.type, url.name) |
| ) { |
| val sourceFullBackupNode = |
| application.getAttributeNodeNS(ANDROID_URI, ATTR_FULL_BACKUP_CONTENT) |
| if (sourceFullBackupNode != null) { |
| // defined in this file, not merged from other file. Prefer it, since |
| // we have better source offsets than from manifest merges. |
| fullBackupNode = sourceFullBackupNode |
| } |
| reportFromManifest( |
| context, |
| ALLOW_BACKUP, |
| fullBackupNode, |
| MISSING_FULL_BACKUP_CONTENT_RESOURCE, |
| LocationType.VALUE |
| ) |
| } |
| } else if (fullBackupNode == null && VALUE_FALSE != allowBackup && |
| !application.hasAttributeNS(ANDROID_URI, "fullBackupOnly") && |
| context.mainProject.targetSdk >= 23 |
| ) { |
| var scope: Node? = |
| application.getAttributeNodeNS(ANDROID_URI, ATTR_ALLOW_BACKUP) |
| if (scope == null) { |
| scope = application |
| } |
| if (hasGcmReceiver(application)) { |
| reportFromManifest( |
| context, |
| ALLOW_BACKUP, |
| scope, |
| "" + |
| "On SDK version 23 and up, your app data will be automatically " + |
| "backed up, and restored on app install. Your GCM regid will not " + |
| "work across restores, so you must ensure that it is excluded " + |
| "from the back-up set. Use the attribute " + |
| "`android:fullBackupContent` to specify an `@xml` resource which " + |
| "configures which files to backup. More info: " + |
| BACKUP_DOCUMENTATION_URL, |
| LocationType.NAME |
| ) |
| } else { |
| reportFromManifest( |
| context, |
| ALLOW_BACKUP, |
| scope, |
| "" + |
| "On SDK version 23 and up, your app data will be automatically " + |
| "backed up and restored on app install. Consider adding the " + |
| "attribute `android:fullBackupContent` to specify an `@xml` " + |
| "resource which configures which files to backup, or just " + |
| "set `android:fullBackupOnly=true`. More info: " + |
| BACKUP_DOCUMENTATION_URL, |
| LocationType.NAME |
| ) |
| } |
| } |
| if (allowBackup == null || allowBackup.isEmpty()) { |
| reportFromManifest( |
| context, |
| ALLOW_BACKUP, |
| application, |
| "Should explicitly set `android:allowBackup` to `true` or " + |
| "`false` (it's `true` by default, and that can have some security " + |
| "implications for the application's data)", |
| LocationType.NAME |
| ) |
| } |
| } |
| if (!application.hasAttributeNS(ANDROID_URI, ATTR_ICON) && |
| context.isEnabled(APPLICATION_ICON) |
| ) { |
| val fix = fix().set(ANDROID_URI, ATTR_ICON, "@mipmap/").caretEnd().build() |
| reportFromManifest( |
| context, |
| APPLICATION_ICON, |
| application, |
| "Should explicitly set `android:icon`, there is no default", |
| LocationType.NAME, |
| fix |
| ) |
| } |
| } |
| |
| private fun checkDocumentElement(context: XmlContext, element: Element) { |
| val codeNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_VERSION_CODE) |
| if (codeNode != null && codeNode.value.startsWith(PREFIX_RESOURCE_REF) && |
| context.isEnabled(ILLEGAL_REFERENCE) |
| ) { |
| context.report( |
| ILLEGAL_REFERENCE, |
| element, |
| context.getLocation(codeNode), |
| "The `android:versionCode` cannot be a resource url, it must be " + |
| "a literal integer" |
| ) |
| } else if (codeNode == null && context.isEnabled(SET_VERSION) && |
| !context.project.isLibrary && // Not required in Gradle projects; typically defined in build.gradle instead |
| // and inserted at build time |
| !context.project.isGradleProject |
| ) { |
| val fix = fix().set().todo(ANDROID_URI, ATTR_VERSION_CODE).build() |
| context.report( |
| SET_VERSION, |
| element, |
| context.getNameLocation(element), |
| "Should set `android:versionCode` to specify the application version", |
| fix |
| ) |
| } |
| val nameNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_VERSION_NAME) |
| if (nameNode == null && context.isEnabled(SET_VERSION) && |
| !context.project.isLibrary && // Not required in Gradle projects; typically defined in build.gradle instead |
| // and inserted at build time |
| !context.project.isGradleProject |
| ) { |
| val fix = fix().set().todo(ANDROID_URI, ATTR_VERSION_NAME).build() |
| context.report( |
| SET_VERSION, |
| element, |
| context.getNameLocation(element), |
| "Should set `android:versionName` to specify the application version", |
| fix |
| ) |
| } |
| val pkgNode = element.getAttributeNode(ATTR_PACKAGE) |
| if (pkgNode != null) { |
| val pkg = pkgNode.value |
| if (pkg.contains("\${") && context.project.isGradleProject) { |
| context.report( |
| GRADLE_OVERRIDES, |
| pkgNode, |
| context.getLocation(pkgNode), |
| "Cannot use placeholder for the package in the manifest; " + |
| "set `applicationId` in `build.gradle` instead" |
| ) |
| } |
| } |
| } |
| |
| private fun reportFromManifest( |
| context: Context, |
| issue: Issue, |
| node: Node?, |
| message: String, |
| type: LocationType, |
| fix: LintFix? = null |
| ) { |
| val location = context.getLocation(node, type) |
| if (location.start == null) { |
| // Couldn't find a specific location in the merged manifest. That means |
| // that none of the manifests contained this tag -- which means |
| // we're reporting an issue on <application> in an Android project |
| // with no <application>; we don't want that. |
| return |
| } |
| val incident = Incident(issue, message, location, fix) |
| context.report(incident) |
| } |
| |
| private fun checkOverride(context: XmlContext, element: Element, attributeName: String) { |
| val project = context.project |
| val attribute = element.getAttributeNodeNS(ANDROID_URI, attributeName) |
| if (attribute != null && context.isEnabled(GRADLE_OVERRIDES)) { |
| val variant = project.buildVariant |
| if (variant != null) { |
| val gradleValue = when { |
| ATTR_MIN_SDK_VERSION == attributeName -> { |
| if (element.hasAttributeNS(TOOLS_URI, "overrideLibrary")) { |
| // The manifest may be setting a minSdkVersion here to deliberately |
| // let the manifest merger know that a library dependency's manifest |
| // with a higher value is okay: this value wins. The manifest merger |
| // should really be taking the Gradle file into account instead, |
| // but for now we filter these out; http://b.android.com/186762 |
| return |
| } |
| val minSdkVersion = variant.minSdkVersion |
| minSdkVersion?.apiString |
| } |
| ATTR_TARGET_SDK_VERSION == attributeName -> { |
| val targetSdkVersion = variant.targetSdkVersion |
| targetSdkVersion?.apiString |
| } |
| else -> { |
| assert(false) { attributeName } |
| return |
| } |
| } |
| if (gradleValue != null) { |
| val manifestValue = attribute.value |
| val message = |
| "This `$attributeName` value (`$manifestValue`) is not used; it is " + |
| "always overridden by the value specified in the Gradle build " + |
| "script (`$gradleValue`)" |
| context.report( |
| GRADLE_OVERRIDES, attribute, context.getLocation(attribute), message |
| ) |
| } |
| } |
| } |
| } |
| |
| // ---- Implements XmlScanner ---- |
| |
| override fun getApplicableElements(): Collection<String> { |
| return listOf( |
| TAG_APPLICATION, |
| TAG_USES_PERMISSION, |
| TAG_PERMISSION, |
| "permission-tree", |
| "permission-group", |
| TAG_USES_SDK, |
| "uses-configuration", |
| TAG_USES_FEATURE, |
| "supports-screens", |
| "compatible-screens", |
| "supports-gl-texture", |
| TAG_USES_LIBRARY, |
| TAG_ACTIVITY, |
| TAG_SERVICE, |
| TAG_PROVIDER, |
| TAG_RECEIVER |
| ) |
| } |
| |
| override fun visitElement(context: XmlContext, element: Element) { |
| val tag = element.tagName |
| val parentNode = element.parentNode |
| val isReceiver = tag == TAG_RECEIVER |
| if (isReceiver) { |
| checkDeviceAdmin(context, element) |
| } |
| if (tag == TAG_USES_LIBRARY || tag == TAG_ACTIVITY || tag == TAG_SERVICE || isReceiver) { |
| if (TAG_APPLICATION != parentNode.nodeName && context.isEnabled(WRONG_PARENT)) { |
| context.report( |
| WRONG_PARENT, |
| element, |
| context.getNameLocation(element), |
| "The `<$tag>` element must be a direct child of the <application> element" |
| ) |
| } |
| if (tag == TAG_ACTIVITY) { |
| val nameNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (nameNode != null) { |
| var name = nameNode.value |
| if (name.isNotEmpty()) { |
| val pkg = context.project.getPackage() |
| if (name[0] == '.') { |
| name = pkg + name |
| } else if (name.indexOf('.') == -1) { |
| name = "$pkg.$name" |
| } |
| val activities = this.activities ?: mutableSetOf<String>().also { this.activities = it } |
| if (!activities.add(name)) { |
| val message = "Duplicate registration for activity `$name`" |
| context.report(DUPLICATE_ACTIVITY, element, context.getLocation(nameNode), message) |
| } |
| } |
| } |
| checkMipmapIcon(context, element) |
| } else if (tag == TAG_SERVICE && context.project.isGradleProject) { |
| if (context.project.targetSdk >= 26) { |
| for (child in XmlUtils.getSubTagsByName(element, TAG_INTENT_FILTER)) { |
| for (innerChild in XmlUtils.getSubTagsByName(child, AndroidManifest.NODE_ACTION)) { |
| val attr = innerChild.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (attr != null && "com.google.firebase.appindexing.UPDATE_INDEX" == attr.value) { |
| val message = "`UPDATE_INDEX` is configured as a service in your app, " + |
| "which is no longer supported for the API level you're targeting. " + |
| "Use a `BroadcastReceiver` instead." |
| val incident = Incident(APP_INDEXING_SERVICE, attr, context.getLocation(attr), message) |
| context.report(incident, targetSdkAtLeast(26)) |
| break |
| } |
| } |
| } |
| } |
| var bindListenerAttr: Attr? = null |
| for (child in XmlUtils.getSubTagsByName(element, TAG_INTENT_FILTER)) { |
| for (innerChild in XmlUtils.getSubTagsByName(child, AndroidManifest.NODE_ACTION)) { |
| val attr = innerChild.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (attr != null && "com.google.android.gms.wearable.BIND_LISTENER" == attr.value) { |
| bindListenerAttr = attr |
| break |
| } |
| } |
| } |
| if (bindListenerAttr == null) { |
| return |
| } |
| // Ensure that the play-services-wearable version dependency is >= 8.2.0 |
| val variant = context.project.buildVariant |
| if (variant != null && hasWearableGmsDependency(variant)) { |
| context.report( |
| WEARABLE_BIND_LISTENER, |
| bindListenerAttr, |
| context.getLocation(bindListenerAttr), |
| "The `com.google.android.gms.wearable.BIND_LISTENER`" + |
| " action is deprecated" |
| ) |
| return |
| } |
| |
| // It's possible they are using an older version of play services so |
| // check the build version and report an error if compileSdkVersion >= 24 |
| val sdkHome = context.client.getSdkHome() |
| if (context.project.buildSdk >= 24 && sdkHome != null) { |
| val repository = SdkMavenRepository.GOOGLE.getRepositoryLocation(sdkHome.toPath(), true) |
| var message = "The `com.google.android.gms.wearable.BIND_LISTENER`" + |
| " action is deprecated. Please upgrade to the latest version" + |
| " of play-services-wearable 8.2.0 or later" |
| if (repository != null) { |
| val max = MavenRepositories.getHighestInstalledVersion( |
| GradleDetector.GMS_GROUP_ID, |
| "play-services-wearable", |
| repository, |
| null, |
| false |
| ) |
| if (max != null && GradleCoordinate.COMPARE_PLUS_HIGHER.compare(max, MIN_WEARABLE_GMS_VERSION) > 0) { |
| message = "The `com.google.android.gms.wearable.BIND_LISTENER` " + |
| "action is deprecated. Please upgrade to the latest available" + |
| " version of play-services-wearable: `${max.revision}`" |
| } |
| } |
| val location = context.getLocation(bindListenerAttr) |
| context.report(WEARABLE_BIND_LISTENER, bindListenerAttr, location, message) |
| } |
| } |
| return |
| } |
| if (tag == TAG_PROVIDER) { |
| if (TAG_APPLICATION != parentNode.nodeName && |
| TAG_QUERIES != parentNode.nodeName && |
| context.isEnabled(WRONG_PARENT) |
| ) { |
| context.report( |
| WRONG_PARENT, |
| element, |
| context.getNameLocation(element), |
| "The `<$tag>` element must be a direct child of the `<application>` element or the `<queries>` element" |
| ) |
| } |
| return |
| } |
| if (parentNode !== element.ownerDocument.documentElement && |
| tag.indexOf(':') == -1 && |
| context.isEnabled(WRONG_PARENT) |
| ) { |
| context.report( |
| WRONG_PARENT, |
| element, |
| context.getNameLocation(element), |
| "The `<$tag>` element must be a direct child of the `<manifest>` root element" |
| ) |
| } |
| if (tag == TAG_USES_SDK) { |
| seenUsesSdk++ |
| if (seenUsesSdk == 2) { // Only warn when we encounter the first one |
| val location = context.getNameLocation(element) |
| |
| // Link up *all* encountered locations in the document |
| val elements = element.ownerDocument.getElementsByTagName(TAG_USES_SDK) |
| var secondary: Location? = null |
| for (i in elements.length - 1 downTo 0) { |
| val e = elements.item(i) as Element |
| if (e !== element) { |
| val l = context.getNameLocation(e) |
| l.secondary = secondary |
| l.message = "Also appears here" |
| secondary = l |
| } |
| } |
| location.secondary = secondary |
| if (context.isEnabled(MULTIPLE_USES_SDK)) { |
| context.report( |
| MULTIPLE_USES_SDK, |
| element, |
| location, |
| "There should only be a single `<uses-sdk>` element in the manifest:" + |
| " merge these together" |
| ) |
| } |
| return |
| } |
| if (!element.hasAttributeNS(ANDROID_URI, ATTR_MIN_SDK_VERSION)) { |
| if (context.isEnabled(USES_SDK) && !context.project.isGradleProject) { |
| context.report( |
| USES_SDK, |
| element, |
| context.getNameLocation(element), |
| "`<uses-sdk>` tag should specify a minimum API level with " + |
| "`android:minSdkVersion=\"?\"`" |
| ) |
| } |
| } else { |
| val codeNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_MIN_SDK_VERSION) |
| if (codeNode != null && codeNode.value.startsWith(PREFIX_RESOURCE_REF) && |
| context.isEnabled(ILLEGAL_REFERENCE) |
| ) { |
| context.report( |
| ILLEGAL_REFERENCE, |
| element, |
| context.getLocation(codeNode), |
| "The `android:minSdkVersion` cannot be a resource url, it must be " + |
| "a literal integer (or string if a preview codename)" |
| ) |
| } |
| checkOverride(context, element, ATTR_MIN_SDK_VERSION) |
| } |
| if (!element.hasAttributeNS(ANDROID_URI, ATTR_TARGET_SDK_VERSION)) { |
| // Warn if not setting target SDK -- but only if the min SDK is somewhat |
| // old so there's some compatibility stuff kicking in (such as the menu |
| // button etc) |
| if (context.isEnabled(USES_SDK) && !context.project.isGradleProject) { |
| context.report( |
| USES_SDK, |
| element, |
| context.getNameLocation(element), |
| "`<uses-sdk>` tag should specify a target API level (the " + |
| "highest verified version; when running on later versions, " + |
| "compatibility behaviors may be enabled) with " + |
| "`android:targetSdkVersion=\"?\"`" |
| ) |
| } |
| } else { |
| checkOverride(context, element, ATTR_TARGET_SDK_VERSION) |
| if (context.isEnabled(TARGET_NEWER)) { |
| val targetSdkVersionNode = |
| element.getAttributeNodeNS(ANDROID_URI, ATTR_TARGET_SDK_VERSION) |
| if (targetSdkVersionNode != null) { |
| val target = targetSdkVersionNode.value |
| try { |
| val api = target.toInt() |
| val highest = context.client.highestKnownApiLevel |
| if (api < highest) { |
| val fix = fix().name("Update targetSdkVersion to $highest") |
| .replace() |
| .pattern("targetSdkVersion\\s*=\\s*[\"'](.*)[\"']") |
| .with(highest.toString()) |
| .build() |
| val location = context.getLocation(targetSdkVersionNode) |
| context.report( |
| TARGET_NEWER, |
| element, |
| location, |
| "Not targeting the latest versions of Android; compatibility " + |
| "modes apply. Consider testing and updating this version. " + |
| "Consult the `android.os.Build.VERSION_CODES` javadoc for details.", |
| fix |
| ) |
| } |
| } catch (ignore: NumberFormatException) { |
| // Ignore: AAPT will enforce this. |
| } |
| } |
| } |
| } |
| val nameNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_TARGET_SDK_VERSION) |
| if (nameNode != null && nameNode.value.startsWith(PREFIX_RESOURCE_REF) && |
| context.isEnabled(ILLEGAL_REFERENCE) |
| ) { |
| context.report( |
| ILLEGAL_REFERENCE, |
| element, |
| context.getLocation(nameNode), |
| "The `android:targetSdkVersion` cannot be a resource url, it must be " + |
| "a literal integer (or string if a preview codename)" |
| ) |
| } |
| } |
| if (tag == TAG_PERMISSION || tag == TAG_PERMISSION_GROUP) { |
| // Outside of the IDE we'll do this in processMergedProject instead at reporting time |
| if (context.isGlobalAnalysis()) { |
| ensureUniquePermission(context) |
| } |
| } |
| if (tag == TAG_USES_PERMISSION) { |
| val name = element.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (name != null && name.value == MOCK_LOCATION_PERMISSION && context.project.buildModule != null && |
| !isDebugOrTestManifest(context, context.file) && context.isEnabled(MOCK_LOCATION) |
| ) { |
| val message = ( |
| "Mock locations should only be requested in a test or " + |
| "debug-specific manifest file (typically `src/debug/AndroidManifest.xml`)" |
| ) |
| val location = context.getLocation(name) |
| context.report(MOCK_LOCATION, element, location, message) |
| } |
| } |
| if (tag == TAG_APPLICATION) { |
| seenApplication = true |
| if (element.hasAttributeNS(ANDROID_URI, ATTR_ICON)) { |
| checkMipmapIcon(context, element) |
| } |
| if (onlyCheckSourceManifest(context)) { |
| checkApplication(context, element) |
| } |
| } else if (seenApplication) { |
| if (context.isEnabled(ORDER)) { |
| context.report( |
| ORDER, |
| element, |
| context.getNameLocation(element), |
| "`<$tag>` tag appears after `<application>` tag" |
| ) |
| } |
| |
| // Don't complain for *every* element following the <application> tag |
| seenApplication = false |
| } |
| if (tag == TAG_USES_FEATURE) { |
| val nameNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (nameNode != null) { |
| val name = nameNode.value |
| if (name.isNotEmpty()) { |
| val usesFeatures = this.usesFeatures ?: mutableSetOf<String>().also { this.usesFeatures = it } |
| if (!usesFeatures.add(name)) { |
| val message = "Duplicate declaration of uses-feature `$name`" |
| context.report( |
| DUPLICATE_USES_FEATURE, |
| element, |
| context.getLocation(nameNode), |
| message |
| ) |
| } |
| } |
| } |
| } |
| } |
| |
| private var checkedUniquePermissions = false |
| |
| private fun ensureUniquePermission(context: Context) { |
| // Only check this for the first encountered manifest permission tag; it will consult |
| // the merged manifest to perform a global check and report errors it finds, so we don't |
| // need to repeat that for each sibling permission element |
| if (checkedUniquePermissions) { |
| return |
| } |
| checkedUniquePermissions = true |
| val mainProject = context.mainProject |
| val mergedManifest = mainProject.mergedManifest // This only happens when there is a parse error, for example if user |
| // is editing the manifest in the IDE and it's currently invalid |
| ?: return |
| lookForNonUniqueNames(context, mainProject, mergedManifest, "permission", TAG_PERMISSION) |
| lookForNonUniqueNames( |
| context, mainProject, mergedManifest, "permission group", TAG_PERMISSION_GROUP |
| ) |
| } |
| |
| override fun checkMergedProject(context: Context) { |
| ensureUniquePermission(context) |
| checkApplication(context) |
| } |
| |
| private fun lookForNonUniqueNames( |
| context: Context, |
| mainProject: Project, |
| mergedManifest: Document, |
| humanReadableName: String, |
| tagName: String |
| ) { |
| var nameToFull: MutableMap<String, String>? = null |
| val root = mergedManifest.documentElement ?: return |
| for (element in root) { |
| if (element.tagName != tagName || manifestMergerSkips(element)) { |
| continue |
| } |
| val nameNode = element.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) ?: continue |
| var name = nameNode.value |
| val base = name.substring(name.lastIndexOf('.') + 1) |
| val pkg = mainProject.getPackage() |
| |
| if (!mainProject.isLibrary && pkg != null && name.contains("\${applicationId}")) { |
| name = name.replace("\${applicationId}", pkg) |
| } |
| if (name.contains("\${")) { |
| // Unknown manifest placeholder: don't try to enforce uniqueness; we don't |
| // know whether the values turn out to be identical |
| continue |
| } |
| |
| val map: MutableMap<String, String> = if (nameToFull != null) { |
| if (nameToFull.containsKey(base) && name != nameToFull[base]) { |
| val prevName = nameToFull[base] |
| val location = context.getLocation(nameNode, LocationType.ALL) |
| val siblings = element.parentNode.childNodes |
| var i = 0 |
| val n = siblings.length |
| while (i < n) { |
| val node = siblings.item(i) |
| if (node === element) { |
| break |
| } else if (node.nodeType == Node.ELEMENT_NODE) { |
| val sibling = node as Element |
| if (sibling.tagName == tagName) { |
| if (prevName == sibling.getAttributeNS( |
| ANDROID_URI, |
| ATTR_NAME |
| ) |
| ) { |
| val no = |
| sibling.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| val prevLocation = context.getLocation(no, LocationType.VALUE) |
| prevLocation.message = "Previous $humanReadableName here" |
| location.secondary = prevLocation |
| break |
| } |
| } |
| } |
| i++ |
| } |
| val message = |
| "${humanReadableName.usLocaleCapitalize()} name `$base` is not unique (appears in both `$prevName` and `$name`)" |
| val incident = Incident(UNIQUE_PERMISSION, element, location, message) |
| context.report(incident) |
| } |
| nameToFull |
| } else { |
| mutableMapOf<String, String>().also { nameToFull = it } |
| } |
| map[base] = name |
| } |
| } |
| |
| /** |
| * Returns true if the manifest merger will skip this element due to |
| * a tools:node action attribute |
| */ |
| private fun manifestMergerSkips(element: Element): Boolean { |
| val operation = element.getAttributeNodeNS(TOOLS_URI, "node") |
| if (operation != null) { |
| val action = operation.value |
| if (action.startsWith("remove") || action == "replace") { |
| return true |
| } |
| } |
| return false |
| } |
| |
| // Method to check if the app has a gms wearable dependency that |
| // matches the specific criteria i.e >= MIN_WEARABLE_GMS_VERSION |
| private fun hasWearableGmsDependency(variant: LintModelVariant): Boolean { |
| val library = |
| variant.mainArtifact.findCompileDependency(PLAY_SERVICES_WEARABLE) as? LintModelExternalLibrary |
| ?: return false |
| val mc = library.resolvedCoordinates |
| val gc = GradleCoordinate.parseVersionOnly(mc.version) |
| return GradleCoordinate.COMPARE_PLUS_HIGHER.compare(gc, MIN_WEARABLE_GMS_VERSION) >= 0 |
| } |
| |
| /** |
| * Returns true if the given application element has a receiver with |
| * an intent filter action for GCM receive |
| */ |
| private fun hasGcmReceiver(application: Element): Boolean { |
| val applicationChildren = application.childNodes |
| var i1 = 0 |
| val n1 = applicationChildren.length |
| while (i1 < n1) { |
| val applicationChild = applicationChildren.item(i1) |
| if (applicationChild.nodeType == Node.ELEMENT_NODE && |
| TAG_RECEIVER == applicationChild.nodeName |
| ) { |
| val receiverChildren = applicationChild.childNodes |
| var i2 = 0 |
| val n2 = receiverChildren.length |
| while (i2 < n2) { |
| val receiverChild = receiverChildren.item(i2) |
| if (receiverChild.nodeType == Node.ELEMENT_NODE && |
| TAG_INTENT_FILTER == receiverChild.nodeName |
| ) { |
| val filterChildren = receiverChild.childNodes |
| var i3 = 0 |
| val n3 = filterChildren.length |
| while (i3 < n3) { |
| val filterChild = filterChildren.item(i3) |
| if (filterChild.nodeType == Node.ELEMENT_NODE && |
| AndroidManifest.NODE_ACTION == filterChild.nodeName |
| ) { |
| val action = filterChild as Element |
| val name = action.getAttributeNS(ANDROID_URI, ATTR_NAME) |
| if ("com.google.android.c2dm.intent.RECEIVE" == name) { |
| return true |
| } |
| } |
| i3++ |
| } |
| } |
| i2++ |
| } |
| } |
| i1++ |
| } |
| return false |
| } |
| |
| private fun checkMipmapIcon(context: XmlContext, element: Element) { |
| val attribute = element.getAttributeNodeNS(ANDROID_URI, ATTR_ICON) |
| ?: return |
| val icon = attribute.value |
| if (icon.startsWith(DRAWABLE_PREFIX)) { |
| if (TAG_ACTIVITY == element.tagName && !isLaunchableActivity(element)) { |
| return |
| } |
| if (context.isEnabled(MIPMAP) && // Only complain if this app is skipping some densities |
| context.project.applicableDensities != null |
| ) { |
| context.report( |
| MIPMAP, |
| element, |
| context.getLocation(attribute), |
| "Should use `@mipmap` instead of `@drawable` for launcher icons" |
| ) |
| } |
| } |
| } |
| |
| /** |
| * Returns true iff the given manifest file is in a debug-specific |
| * source set, or a test source set |
| */ |
| private fun isDebugOrTestManifest( |
| context: XmlContext, |
| manifestFile: File |
| ): Boolean { |
| val variant = context.project.buildVariant |
| if (variant != null) { |
| for (provider in variant.sourceProviders) { |
| if (provider.isDebugOnly() || provider.isTest()) { |
| //noinspection FileComparisons |
| if (manifestFile == provider.manifestFile) { |
| return true |
| } |
| } |
| } |
| } |
| return false |
| } |
| |
| private fun checkDeviceAdmin(context: XmlContext, element: Element) { |
| var requiredIntentFilterFound = false |
| var deviceAdmin = false |
| var locationNode: Attr? = null |
| for (child in XmlUtils.getSubTags(element)) { |
| val tagName = child.tagName |
| if (tagName == TAG_INTENT_FILTER && !requiredIntentFilterFound) { |
| var dataFound = false |
| var actionFound = false |
| for (filterChild in XmlUtils.getSubTags(child)) { |
| val filterTag = filterChild.tagName |
| if (filterTag == AndroidManifest.NODE_ACTION) { |
| val name = filterChild.getAttributeNS(ANDROID_URI, ATTR_NAME) |
| if ("android.app.action.DEVICE_ADMIN_ENABLED" == name) { |
| actionFound = true |
| } |
| } else if (filterTag == AndroidManifest.NODE_DATA) { |
| dataFound = true |
| } |
| } |
| if (actionFound && !dataFound) { |
| requiredIntentFilterFound = true |
| } |
| } else if (tagName == AndroidManifest.NODE_METADATA) { |
| val valueNode = child.getAttributeNodeNS(ANDROID_URI, ATTR_NAME) |
| if (valueNode != null) { |
| val name = valueNode.value |
| if ("android.app.device_admin" == name) { |
| deviceAdmin = true |
| locationNode = valueNode |
| } |
| } |
| } |
| } |
| if (deviceAdmin && !requiredIntentFilterFound && context.isEnabled(DEVICE_ADMIN)) { |
| context.report( |
| DEVICE_ADMIN, |
| locationNode, |
| context.getLocation(locationNode), |
| "You must have an intent filter for action " + |
| "`android.app.action.DEVICE_ADMIN_ENABLED`" |
| ) |
| } |
| } |
| } |
