LintCliFlags (Android Lint Tool)

java.lang.Object
- com.android.tools.lint.LintCliFlags

```
@Beta
public class LintCliFlags
extends java.lang.Object
```
Flags used by the LintCliClient
NOTE: This is not a public or final API; if you rely on this be prepared to adjust your code for the next tools release.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ERRNO_APPLIED_SUGGESTIONS`
`static int`	`ERRNO_CREATED_BASELINE`
`static int`	`ERRNO_ERRORS`
`static int`	`ERRNO_EXISTS`
`static int`	`ERRNO_HELP`
`static int`	`ERRNO_INVALID_ARGS`
`static int`	`ERRNO_SUCCESS`
`static int`	`ERRNO_USAGE`

Constructor Summary

Constructors
Constructor and Description

LintCliFlags()

Constructors
Constructor and Description
`LintCliFlags()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDisabledCategory(com.android.tools.lint.detector.api.Category category)` Adds a category to disable
`void`	`addEnabledCategory(com.android.tools.lint.detector.api.Category category)` Adds a category to enable
`void`	`addExactCategory(com.android.tools.lint.detector.api.Category category)` Adds a category to check exactly
`void`	`addExactId(java.lang.String id)` Adds an id to check (will disable everything else)
`java.io.File`	`getBaselineFile()` Returns the baseline file to use, if any.
`java.util.List<java.io.File>`	`getClassesOverride()` Gets the optional manual override of the class file directories.
`java.lang.String`	`getCompileSdkVersionOverride()` Gets the optional compileSdkVersion override.
`java.io.File`	`getDefaultConfiguration()` Returns the default configuration file to use as a fallback
`java.util.Set<com.android.tools.lint.detector.api.Category>`	`getDisabledCategories()` Returns the set of categories to disable, if any.
`java.util.Set<com.android.tools.lint.detector.api.Category>`	`getEnabledCategories()` Returns the set of categories to enable, if any.
`java.util.Set<java.lang.String>`	`getEnabledIds()` Returns the set of issue id's to enable.
`java.util.Set<com.android.tools.lint.detector.api.Category>`	`getExactCategories()` Returns the set of exact categories to check, if any.
`java.util.Set<java.lang.String>`	`getExactCheckedIds()` Returns the exact set of issues to check, or null to run the issues that are enabled by default plus any issues enabled via `getEnabledIds()` and without issues disabled via `getSuppressedIds()`.
`java.util.List<java.io.File>`	`getLibrariesOverride()` Gets the optional manual override of the library directories.
`java.io.File`	`getProjectDescriptorOverride()` Gets the optional manual override of the project hierarchy.
`java.util.List<Reporter>`	`getReporters()` Returns the list of error reports to generate.
`java.util.List<java.io.File>`	`getResourcesOverride()` Gets the optional manual override of the resources directories.
`java.util.Map<java.lang.String,com.android.tools.lint.detector.api.Severity>`	`getSeverityOverrides()` Returns a map of manually configured severities to use
`java.util.List<java.io.File>`	`getSourcesOverride()` Gets the optional manual override of the source directories.
`java.util.Set<java.lang.String>`	`getSuppressedIds()` Returns the set of issue id's to suppress.
`boolean`	`isAutoFix()` Whether to apply safe suggestions
`boolean`	`isCheckAllWarnings()` Returns whether lint should check all warnings, including those off by default
`boolean`	`isCheckDependencies()` Returns whether lint should check all dependencies too as part of its analysis.
`boolean`	`isCheckGeneratedSources()` Returns whether lint should run checks on generated sources.
`boolean`	`isCheckTestSources()` Returns whether lint should run all checks on test sources, instead of just the lint checks that have been specifically written to include tests (e.g.
`boolean`	`isExplainIssues()` Whether text reports should include full explanation texts.
`boolean`	`isFatalOnly()` Returns true if we should only check fatal issues
`boolean`	`isFullPath()` Whether lint should display full paths in the error output.
`boolean`	`isIgnoreTestSources()` Like `isCheckTestSources()`, but always skips analyzing tests -- meaning that it also ignores checks that have explicitly asked to look at test sources, such as the unused resource check.
`boolean`	`isIgnoreWarnings()` Returns whether lint will only check for errors (ignoring warnings)
`boolean`	`isQuiet()` Returns whether lint should be quiet (for example, not show progress dots for each analyzed file)
`boolean`	`isRemoveFixedBaselineIssues()` Whether lint will update the baseline file to remove any issues that are no longer present in the codebase.
`boolean`	`isSetExitCode()` Whether lint should set the exit code of the process if errors are found
`boolean`	`isShowEverything()` Returns whether lint should include all output (e.g.
`boolean`	`isShowSourceLines()` Whether lint should include the source lines in the output where errors occurred (true by default)
`boolean`	`isWarningsAsErrors()` Returns whether lint should treat all warnings as errors
`boolean`	`isWriteBaselineIfMissing()` If true, write the baseline file if missing.
`void`	`setAutoFix(boolean autoFix)` Sets whether to apply safe suggestions
`void`	`setBaselineFile(java.io.File baselineFile)` Sets the baseline file, if any.
`void`	`setCheckAllWarnings(boolean warnAll)` Sets whether lint should check all warnings, including those off by default
`void`	`setCheckDependencies(boolean checkDependencies)` Sets whether lint should check dependencies too
`void`	`setCheckGeneratedSources(boolean checkGenerated)` Sets whether lint should check generated sources
`void`	`setCheckTestSources(boolean checkTests)` Sets whether lint should run all the normal checks on test sources
`void`	`setClassesOverride(java.util.List<java.io.File> classes)` Sets the optional manual override of the class file directories.
`void`	`setCompileSdkVersionOverride(java.lang.String compileSdkVersion)` Sets the optional compileSdkVersion override.
`void`	`setDefaultConfiguration(java.io.File defaultConfiguration)` Sets the default config file to use as a fallback.
`void`	`setExactCheckedIds(java.util.Set<java.lang.String> check)` Sets the exact set of issues to check.
`void`	`setExplainIssues(boolean explainText)` Sets whether text reports should include full explanation texts.
`void`	`setFatalOnly(boolean fatalOnly)` Sets whether we should only check fatal issues
`void`	`setFullPath(boolean fullPath)` Sets whether lint should display full paths in the error output.
`void`	`setIgnoreTestSources(boolean ignoreTests)` Sets whether we should completely skip test sources.
`void`	`setIgnoreWarnings(boolean noWarnings)` Sets whether lint will only check for errors (ignoring warnings)
`void`	`setLibrariesOverride(java.util.List<java.io.File> libraries)` Sets the optional manual override of the library directories.
`void`	`setProjectDescriptorOverride(java.io.File projectDescriptor)` Sets the optional manual override of the project hierarchy.
`void`	`setQuiet(boolean quiet)` Sets whether lint should be quiet (for example, not show progress dots for each analyzed file)
`void`	`setRemovedFixedBaselineIssues(boolean removeFixed)` Sets whether lint should remove fixed baseline issues.
`void`	`setResourcesOverride(java.util.List<java.io.File> resources)` Gets the optional manual override of the resource directories.
`void`	`setSetExitCode(boolean setExitCode)` Sets whether lint should set the exit code of the process if errors are found
`void`	`setSeverityOverrides(java.util.Map<java.lang.String,com.android.tools.lint.detector.api.Severity> severities)` Sets a map of severities to use
`void`	`setShowEverything(boolean showAll)` Sets whether lint should include all output (e.g.
`void`	`setShowSourceLines(boolean showLines)` Sets whether lint should include the source lines in the output where errors occurred (true by default)
`void`	`setSourcesOverride(java.util.List<java.io.File> sources)` Sets the optional manual override of the source directories.
`void`	`setWarningsAsErrors(boolean allErrors)` Sets whether lint should treat all warnings as errors
`void`	`setWriteBaselineIfMissing(boolean writeBaselineIfMissing)` If true, write the baseline file if missing.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ERRNO_SUCCESS
```
public static final int ERRNO_SUCCESS
```
    See Also:
    
    Constant Field Values
  - ERRNO_ERRORS
```
public static final int ERRNO_ERRORS
```
    See Also:
    
    Constant Field Values
  - ERRNO_USAGE
```
public static final int ERRNO_USAGE
```
    See Also:
    
    Constant Field Values
  - ERRNO_EXISTS
```
public static final int ERRNO_EXISTS
```
    See Also:
    
    Constant Field Values
  - ERRNO_HELP
```
public static final int ERRNO_HELP
```
    See Also:
    
    Constant Field Values
  - ERRNO_INVALID_ARGS
```
public static final int ERRNO_INVALID_ARGS
```
    See Also:
    
    Constant Field Values
  - ERRNO_CREATED_BASELINE
```
public static final int ERRNO_CREATED_BASELINE
```
    See Also:
    
    Constant Field Values
  - ERRNO_APPLIED_SUGGESTIONS
```
public static final int ERRNO_APPLIED_SUGGESTIONS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - LintCliFlags
```
public LintCliFlags()
```
- Method Detail
  - getSuppressedIds
```
@NonNull
public java.util.Set<java.lang.String> getSuppressedIds()
```
    Returns the set of issue id's to suppress. Callers are allowed to modify this collection. To suppress a given issue, add the Issue.getId() to the returned set.
  - getEnabledIds
```
@NonNull
public java.util.Set<java.lang.String> getEnabledIds()
```
    Returns the set of issue id's to enable. Callers are allowed to modify this collection. To enable a given issue, add the Issue.getId() to the returned set.
  - getEnabledCategories
```
@Nullable
public java.util.Set<com.android.tools.lint.detector.api.Category> getEnabledCategories()
```
    Returns the set of categories to enable, if any.
  - getDisabledCategories
```
@Nullable
public java.util.Set<com.android.tools.lint.detector.api.Category> getDisabledCategories()
```
    Returns the set of categories to disable, if any.
  - getExactCategories
```
@Nullable
public java.util.Set<com.android.tools.lint.detector.api.Category> getExactCategories()
```
    Returns the set of exact categories to check, if any.
  - getSeverityOverrides
```
@NonNull
public java.util.Map<java.lang.String,com.android.tools.lint.detector.api.Severity> getSeverityOverrides()
```
    Returns a map of manually configured severities to use
    
    Returns:
    
    the severity to use for a given issue id
  - getExactCheckedIds
```
@Nullable
public java.util.Set<java.lang.String> getExactCheckedIds()
```
    Returns the exact set of issues to check, or null to run the issues that are enabled by default plus any issues enabled via getEnabledIds() and without issues disabled via getSuppressedIds(). If non-null, callers are allowed to modify this collection.
  - setExactCheckedIds
```
public void setExactCheckedIds(@Nullable
                               java.util.Set<java.lang.String> check)
```
    Sets the exact set of issues to check.
    
    Parameters:
    
    check - the set of issue id's to check
  - addExactId
```
public void addExactId(@NonNull
                       java.lang.String id)
```
    Adds an id to check (will disable everything else)
  - addEnabledCategory
```
public void addEnabledCategory(@NonNull
                               com.android.tools.lint.detector.api.Category category)
```
    Adds a category to enable
  - addDisabledCategory
```
public void addDisabledCategory(@NonNull
                                com.android.tools.lint.detector.api.Category category)
```
    Adds a category to disable
  - addExactCategory
```
public void addExactCategory(@NonNull
                             com.android.tools.lint.detector.api.Category category)
```
    Adds a category to check exactly
  - isSetExitCode
```
public boolean isSetExitCode()
```
    Whether lint should set the exit code of the process if errors are found
  - setSetExitCode
```
public void setSetExitCode(boolean setExitCode)
```
    Sets whether lint should set the exit code of the process if errors are found
  - isFullPath
```
public boolean isFullPath()
```
    Whether lint should display full paths in the error output. By default the paths are relative to the path lint was invoked from.
  - setFullPath
```
public void setFullPath(boolean fullPath)
```
    Sets whether lint should display full paths in the error output. By default the paths are relative to the path lint was invoked from.
  - isShowSourceLines
```
public boolean isShowSourceLines()
```
    Whether lint should include the source lines in the output where errors occurred (true by default)
  - setShowSourceLines
```
public void setShowSourceLines(boolean showLines)
```
    Sets whether lint should include the source lines in the output where errors occurred (true by default)
  - getReporters
```
@NonNull
public java.util.List<Reporter> getReporters()
```
    Returns the list of error reports to generate. Clients can modify the returned list and add additional reporters such as XmlReporter and HtmlReporter.
  - isQuiet
```
public boolean isQuiet()
```
    Returns whether lint should be quiet (for example, not show progress dots for each analyzed file)
  - setQuiet
```
public void setQuiet(boolean quiet)
```
    Sets whether lint should be quiet (for example, not show progress dots for each analyzed file)
  - isCheckAllWarnings
```
public boolean isCheckAllWarnings()
```
    Returns whether lint should check all warnings, including those off by default
  - setCheckAllWarnings
```
public void setCheckAllWarnings(boolean warnAll)
```
    Sets whether lint should check all warnings, including those off by default
  - isIgnoreWarnings
```
public boolean isIgnoreWarnings()
```
    Returns whether lint will only check for errors (ignoring warnings)
  - setIgnoreWarnings
```
public void setIgnoreWarnings(boolean noWarnings)
```
    Sets whether lint will only check for errors (ignoring warnings)
  - isWarningsAsErrors
```
public boolean isWarningsAsErrors()
```
    Returns whether lint should treat all warnings as errors
  - setWarningsAsErrors
```
public void setWarningsAsErrors(boolean allErrors)
```
    Sets whether lint should treat all warnings as errors
  - isCheckTestSources
```
public boolean isCheckTestSources()
```
    Returns whether lint should run all checks on test sources, instead of just the lint checks that have been specifically written to include tests (e.g. checks looking for specific test errors, or checks that need to consider testing code such as the unused resource detector)
    
    Returns:
    
    true to check tests, defaults to false
  - setCheckTestSources
```
public void setCheckTestSources(boolean checkTests)
```
    Sets whether lint should run all the normal checks on test sources
  - isIgnoreTestSources
```
public boolean isIgnoreTestSources()
```
    Like isCheckTestSources(), but always skips analyzing tests -- meaning that it also ignores checks that have explicitly asked to look at test sources, such as the unused resource check.
  - setIgnoreTestSources
```
public void setIgnoreTestSources(boolean ignoreTests)
```
    Sets whether we should completely skip test sources.
    
    Parameters:
    
    ignoreTests - if true, ignore tests completely
  - isCheckGeneratedSources
```
public boolean isCheckGeneratedSources()
```
    Returns whether lint should run checks on generated sources.
  - setCheckGeneratedSources
```
public void setCheckGeneratedSources(boolean checkGenerated)
```
    Sets whether lint should check generated sources
  - isCheckDependencies
```
public boolean isCheckDependencies()
```
    Returns whether lint should check all dependencies too as part of its analysis. Default is true.
  - setCheckDependencies
```
public void setCheckDependencies(boolean checkDependencies)
```
    Sets whether lint should check dependencies too
  - isShowEverything
```
public boolean isShowEverything()
```
    Returns whether lint should include all output (e.g. include all alternate locations, not truncating long messages, etc.)
  - setShowEverything
```
public void setShowEverything(boolean showAll)
```
    Sets whether lint should include all output (e.g. include all alternate locations, not truncating long messages, etc.)
  - getDefaultConfiguration
```
@Nullable
public java.io.File getDefaultConfiguration()
```
    Returns the default configuration file to use as a fallback
  - setDefaultConfiguration
```
public void setDefaultConfiguration(@Nullable
                                    java.io.File defaultConfiguration)
```
    Sets the default config file to use as a fallback. This corresponds to a lint.xml file with severities etc to use when a project does not have more specific information. To construct a configuration from a File, use LintCliClient.createConfigurationFromFile(java.io.File).
  - getSourcesOverride
```
@Nullable
public java.util.List<java.io.File> getSourcesOverride()
```
    Gets the optional manual override of the source directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - setSourcesOverride
```
public void setSourcesOverride(@Nullable
                               java.util.List<java.io.File> sources)
```
    Sets the optional manual override of the source directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - getClassesOverride
```
@Nullable
public java.util.List<java.io.File> getClassesOverride()
```
    Gets the optional manual override of the class file directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - setClassesOverride
```
public void setClassesOverride(@Nullable
                               java.util.List<java.io.File> classes)
```
    Sets the optional manual override of the class file directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - getLibrariesOverride
```
@Nullable
public java.util.List<java.io.File> getLibrariesOverride()
```
    Gets the optional manual override of the library directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - setLibrariesOverride
```
public void setLibrariesOverride(@Nullable
                                 java.util.List<java.io.File> libraries)
```
    Sets the optional manual override of the library directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - getResourcesOverride
```
@Nullable
public java.util.List<java.io.File> getResourcesOverride()
```
    Gets the optional manual override of the resources directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - setResourcesOverride
```
public void setResourcesOverride(@Nullable
                                 java.util.List<java.io.File> resources)
```
    Gets the optional manual override of the resource directories. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can set the source paths explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make.
  - getProjectDescriptorOverride
```
@Nullable
public java.io.File getProjectDescriptorOverride()
```
    Gets the optional manual override of the project hierarchy. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can specify the project hierarchy explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make).
  - setProjectDescriptorOverride
```
public void setProjectDescriptorOverride(@Nullable
                                         java.io.File projectDescriptor)
```
    Sets the optional manual override of the project hierarchy. Normally null.
    Normally, the source, library and resource paths for a project should be computed by the LintClient itself, using available project metadata. However, the user can specify the project hierarchy explicitly. This is normally done when running lint on raw source code without proper metadata (or when using a build system unknown to lint, such as say make).
  - getCompileSdkVersionOverride
```
@Nullable
public java.lang.String getCompileSdkVersionOverride()
```
    Gets the optional compileSdkVersion override. Normally null.
    Normally, the compileSdkVersion (e.g. the build target version) is known by lint from the build system (it's specified explicitly in build.gradle, and in older Eclipse-based projects, in the project.properties file). However, when using third party / unsupported build systems, there's a fallback mechanism you can use specifying the set of manifests, resources and sources via dedicated flags. In those cases the compileSdkVersion is unknown. This flag lets you provide a specific dedicated version to use.
  - setCompileSdkVersionOverride
```
public void setCompileSdkVersionOverride(@Nullable
                                         java.lang.String compileSdkVersion)
```
    Sets the optional compileSdkVersion override. Normally null.
    Normally, the compileSdkVersion (e.g. the build target version) is known by lint from the build system (it's specified explicitly in build.gradle, and in older Eclipse-based projects, in the project.properties file). However, when using third party / unsupported build systems, there's a fallback mechanism you can use specifying the set of manifests, resources and sources via dedicated flags. In those cases the compileSdkVersion is unknown. This flag lets you provide a specific dedicated version to use.
  - isFatalOnly
```
public boolean isFatalOnly()
```
    Returns true if we should only check fatal issues
    
    Returns:
    
    true if we should only check fatal issues
  - setFatalOnly
```
public void setFatalOnly(boolean fatalOnly)
```
    Sets whether we should only check fatal issues
    
    Parameters:
    
    fatalOnly - if true, only check fatal issues
  - setSeverityOverrides
```
public void setSeverityOverrides(@NonNull
                                 java.util.Map<java.lang.String,com.android.tools.lint.detector.api.Severity> severities)
```
    Sets a map of severities to use
    
    Parameters:
    
    severities - map from issue id to severity
  - isExplainIssues
```
public boolean isExplainIssues()
```
    Whether text reports should include full explanation texts. (HTML and XML reports always do, unconditionally.)
    
    Returns:
    
    true if text reports should include explanation text
  - setExplainIssues
```
public void setExplainIssues(boolean explainText)
```
    Sets whether text reports should include full explanation texts. (HTML and XML reports always do, unconditionally.)
    
    Parameters:
    
    explainText - true if text reports should include explanation text
  - getBaselineFile
```
@Nullable
public java.io.File getBaselineFile()
```
    Returns the baseline file to use, if any. The baseline file is an XML report previously created by lint, and any warnings and errors listed in that report will be ignored from analysis.
    If you have a project with a large number of existing warnings, this lets you set a baseline and only see newly introduced warnings until you get a chance to go back and address the "technical debt" of the earlier warnings.
    
    Returns:
    
    the baseline file, if any
  - setBaselineFile
```
public void setBaselineFile(@Nullable
                            java.io.File baselineFile)
```
    Sets the baseline file, if any.
    
    See Also:
    
    getBaselineFile()
  - isRemoveFixedBaselineIssues
```
public boolean isRemoveFixedBaselineIssues()
```
    Whether lint will update the baseline file to remove any issues that are no longer present in the codebase. This will only remove fixed issues, it will not insert any newly found issues.
    Only applies when a baseline file has been configured.
    
    Returns:
    
    whether to update the baseline file.
  - setRemovedFixedBaselineIssues
```
public void setRemovedFixedBaselineIssues(boolean removeFixed)
```
    Sets whether lint should remove fixed baseline issues.
    
    See Also:
    
    isRemoveFixedBaselineIssues()
  - isWriteBaselineIfMissing
```
public boolean isWriteBaselineIfMissing()
```
    If true, write the baseline file if missing. (This is the default.)
  - setWriteBaselineIfMissing
```
public void setWriteBaselineIfMissing(boolean writeBaselineIfMissing)
```
    If true, write the baseline file if missing. (This is the default.)
  - isAutoFix
```
public boolean isAutoFix()
```
    Whether to apply safe suggestions
  - setAutoFix
```
public void setAutoFix(boolean autoFix)
```
    Sets whether to apply safe suggestions

Class LintCliFlags

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ERRNO_SUCCESS

ERRNO_ERRORS

ERRNO_USAGE

ERRNO_EXISTS

ERRNO_HELP

ERRNO_INVALID_ARGS

ERRNO_CREATED_BASELINE

ERRNO_APPLIED_SUGGESTIONS

Constructor Detail

LintCliFlags

Method Detail

getSuppressedIds

getEnabledIds

getEnabledCategories

getDisabledCategories

getExactCategories

getSeverityOverrides

getExactCheckedIds

setExactCheckedIds

addExactId

addEnabledCategory

addDisabledCategory

addExactCategory

isSetExitCode

setSetExitCode

isFullPath

setFullPath

isShowSourceLines

setShowSourceLines

getReporters

isQuiet

setQuiet

isCheckAllWarnings

setCheckAllWarnings

isIgnoreWarnings

setIgnoreWarnings

isWarningsAsErrors

setWarningsAsErrors

isCheckTestSources

setCheckTestSources

isIgnoreTestSources

setIgnoreTestSources

isCheckGeneratedSources

setCheckGeneratedSources

isCheckDependencies

setCheckDependencies

isShowEverything

setShowEverything

getDefaultConfiguration

setDefaultConfiguration

getSourcesOverride

setSourcesOverride

getClassesOverride

setClassesOverride

getLibrariesOverride

setLibrariesOverride

getResourcesOverride

setResourcesOverride

getProjectDescriptorOverride

setProjectDescriptorOverride

getCompileSdkVersionOverride

setCompileSdkVersionOverride

isFatalOnly

setFatalOnly

setSeverityOverrides

isExplainIssues

setExplainIssues

getBaselineFile

setBaselineFile

isRemoveFixedBaselineIssues

setRemovedFixedBaselineIssues

isWriteBaselineIfMissing

setWriteBaselineIfMissing

isAutoFix