//
// This Gradle build file illustrates how to process a program
// library, such that it remains usable as a library.
// Usage:
//     gradle -b library.gradle proguard
//

// Tell Gradle where to find the ProGuard task.

buildscript {
    repositories {
        flatDir dirs: '../../lib'
    }
    dependencies {
        classpath ':proguard'
    }
}

// Define a ProGuard task.

task proguard(type: proguard.gradle.ProGuardTask) {

    // You should probably import a more compact ProGuard-style configuration
    // file for all static settings, but we're specifying them all here, for
    // the sake of the example.
    //configuration 'configuration.pro'

    // Specify the input jars, output jars, and library jars.
    // In this case, the input jar is the program library that we want to process.

    injars  'in.jar'
    outjars 'out.jar'

    libraryjars  "${System.getProperty('java.home')}/lib/rt.jar"

    // Save the obfuscation mapping to a file, so we can de-obfuscate any stack
    // traces later on. Keep a fixed source file attribute and all line number
    // tables to get line numbers in the stack traces.
    // You can comment this out if you're not interested in stack traces.

    printmapping 'out.map'
    keepparameternames
    renamesourcefileattribute 'SourceFile'
    keepattributes 'Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,EnclosingMethod'

    // Preserve all annotations.

    keepattributes '*Annotation*'

    // Preserve all public classes, and their public and protected fields and
    // methods.

    keep 'public class * { \
        public protected *; \
    }'

    // Preserve all .class method names.

    keepclassmembernames 'class * { \
        java.lang.Class class$(java.lang.String); \
        java.lang.Class class$(java.lang.String, boolean); \
    }'

    // Preserve all native method names and the names of their classes.

    keepclasseswithmembernames includedescriptorclasses:true, 'class * { \
        native <methods>; \
    }'

    // Preserve the special static methods that are required in all enumeration
    // classes.

    keepclassmembers allowshrinking:true, 'enum * { \
        public static **[] values(); \
        public static ** valueOf(java.lang.String); \
    }'

    // Explicitly preserve all serialization members. The Serializable interface
    // is only a marker interface, so it wouldn't save them.
    // You can comment this out if your library doesn't use serialization.
    // If your code contains serializable classes that have to be backward
    // compatible, please refer to the manual.

    keepclassmembers 'class * implements java.io.Serializable { \
        static final long serialVersionUID; \
        static final java.io.ObjectStreamField[] serialPersistentFields; \
        private void writeObject(java.io.ObjectOutputStream); \
        private void readObject(java.io.ObjectInputStream); \
        java.lang.Object writeReplace(); \
        java.lang.Object readResolve(); \
    }'

    // Your library may contain more items that need to be preserved; 
    // typically classes that are dynamically created using Class.forName:

    // keep 'public class mypackage.MyClass'
    // keep 'public interface mypackage.MyInterface'
    // keep 'public class * implements mypackage.MyInterface'
}
