Manage Inputs

To protect your application, PreEmptive Protection™ DashO™ must first analyze its bytecode and resources. This article explains how to configure your project's inputs, supporting classpath, non-class files, and input options. DashO handles inputs differently in Standard Mode and Android Mode:

Prerequisites

• A DashO project in Standard Mode or Android Mode.
• For Android Mode: A build of the current configuration that has run on the current machine.

Configure Inputs in Standard Mode

In Standard Mode, you manually manage the files DashO processes.

Jars and Classes

1. Navigate to the Input page.
   
2. Add inputs in one of these ways:
   1. Click Add, then select JAR, WAR, or ZIP files, single APK files, or directories of classes from your file system.
   2. Click New, then type the path. Use this option when the path contains property references.
3. If you typed a path, refresh the class tree. 
4. Save your project. 

Note: Adding and removing entries automatically refreshes the class tree, unless you manually enter the name. Use the refresh option after editing the name.

For more information, see <inputpath> Element.

Supporting Classpath

DashO requires access to the Java or Android runtime and any third-party libraries your application uses. DashO needs the classes you reference here for analysis, but does not process them. 

1. Navigate to Input > Support.
   
2. Add supports in one of these ways:
   1. Click Add, then select the entries.
   2. Click New, then type the entry.
3. Configure the JDK settings. For more information, see Settings.
4. Save your project.

Note: By default, the build fails with an error when DashO can't find a configured support entry. To get a warning instead, add a User Property named WARN_ON_MISSING_SUPPORT_ENTRY and set it to true.

Settings

Warning: Don't include the JDK in projects that use the Android API or J2ME. Add the runtime JAR for the applicable environment instead, such as Android.jar or midpapi10.jar. 

Note: DashO also uses the included JDK when locating and running other programs such as jarsigner.

For more information, see <classpath> Element.

Included Non-Class Files

Use the Included Non-Class Files page to specify resources like images, property files, or XML configurations that should be part of the final package.

1. Navigate to Input > Non-Class Files.
   
2. Add entries in one of these ways:
   1. Click Add, then select directories, individual files, or JAR files.
   2. Click New, then type the entry. In directory entries, use the * wildcard to select specific file types.
3. Save your project.

DashO copies non-class files from directory, ZIP, JAR, and WAR sources to the output and keeps their relative internal directories. For directories and JAR files, it copies all non-class files.

How DashO handles non-class files from your inputs depends on whether you merge inputs:

Note: DashO may update XML configuration files it finds while processing non-class files, so they reflect changed class and method names.

For more information, see <includenonclassfiles> element and Auto Copy. 

Input Options

The Input > Options page controls basic options DashO uses while analyzing input classes. 

1. In the navigation tree, select Input > Options.

2. Select the options you need.

   Option	Description
   Ignore Missing Classes	Instructs DashO to proceed with analysis even if a called class is missing.  Note: DashO cannot ignore missing classes and interfaces that your application extends or implements.
   Ignore Missing Members	Instructs DashO to proceed with the build even if a referenced method or field cannot be located. Warning: Use this option with caution.
   Ignore Missing Entry Points	Generates warnings for entry points that DashO cannot locate, rather than stopping the build with errors. By default, the build stops with an error if any configured Java project entry point is missing.  On large projects with multiple missing entry points, this option prevents the build from halting repeatedly after you resolve or remove a single entry point.
   Exclude classes having a method larger than 64K	Automatically excludes classes containing methods that exceed 65,535 bytes of code after obfuscation to prevent build failures. When you enable this option, DashO adds these classes to the Global Processing Exclusions list. This excludes all methods within those classes from obfuscation, even the smaller methods.
   Bypass DashO Processing	Configures DashO to perform no processing and simply copy the inputs directly to your output destination. This option is supported when you output to an unmerged directory or an APK.
   Reflection Halts Build	Halts the build when DashO encounters reflection, making it easier to note reflection usage and identify targets.  Note: Disable Checks when enabling this option because some injected check code uses reflection.
   Determine Reflected Classes	Automatically detects reflection targets and ensures they appear in the final output.  Note: Enabling this option can increase build times.
   Rename Reflected Classes	Allows classes accessed via reflection to be renamed. By default, targets of reflection retain their original names.

3. Save your project and build it to apply the changes. 

Configure Inputs in Android Mode

In Android Mode, DashO uses Automatic Input Management (AIM) to identify your application's components based on the Path Map generated during your Gradle build.

The Input page in Android Mode is populated only when:

• A build has run on the current machine using the current DashO configuration.
• The related files remain on disk.

If DashO cannot locate the inputs for a saved Android Mode configuration, it displays the following message:

Your inputs could not be located. Please run a build and refresh the path map.

Limitations and Troubleshooting

Resolve the Superclass Class Not Found Error

Maven and Spring Boot applications often depend on external JAR files. If one of your classes extends a class from an external JAR that DashO can't find, the build fails with a Superclass Class Not Found error. Ignore Missing Classes doesn't help, because DashO can't ignore missing classes your application extends or implements. Add the JAR file as a support instead:

1. Build your Maven or Spring Boot application.
2. Find the required external JAR file in your local .m2 repository.
3. Add the JAR file on the Input > Support page. For more information, see Supporting Classpath.
4. Click Build. 
5. Validate the protected application:
   java -jar <obfuscated-application>.war

The build completes without a Superclass Class Not Found error, and the protected application runs.

Display a Different Build Variant

1. Clean and build only the variant you want to display. 
   gradlew clean assembleSomeFlavorRelease
2. Refresh the Path Map. 

Related Articles

• Use the DashO GUI
• Graphical Rules Editor
• Entry Points