Home » Android » android – Removing unused strings during ProGuard optimisation

android – Removing unused strings during ProGuard optimisation

Posted by: admin April 23, 2020 Leave a comment

Questions:

I include this ProGuard configuration to strip out debug log statements when I release an Android application:

-assumenosideeffects class android.util.Log {
    public static *** d(...);
    public static *** v(...);
}

This works as expected — I can see from the ProGuard logs and Android log output that calls such as Log.d("This is a debug statement"); are removed.

However, if I decompile the app at this stage, I can still see all the String literals that were used — i.e. This is a debug statement in this example.

Is there a way to also remove each String that’s no longer needed from the bytecode?

How to&Answers:

ProGuard can remove simple constant arguments (Strings, integers, etc). So in this case, the code and the string constant should disappear completely:

Log.d("This is a debug statement");

However, you may have observed the issue with some code like this:

Log.d("The answer is "+answer);

After compilation, this actually corresponds to:

Log.d(new StringBuilder().append("The answer is ").append(answer).toString());

ProGuard version 4.6 can simplify this to something like:

new StringBuilder().append("The answer is ").append(answer).toString();

So the logging is gone, but the optimization step still leaves some fluff behind. It’s surprisingly tricky to simplify this without some deeper knowledge about the StringBuilder class. As far as ProGuard is concerned, it could say:

new DatabaseBuilder().setup("MyDatabase").initialize(table).close();

For a human, the StringBuilder code can obviously be removed, but the DatabaseBuilder code probably can’t. ProGuard requires escape analysis and a few other techniques, which aren’t in this version yet.

As for a solution: you can create additional debug methods that take simple arguments, and let ProGuard remove those:

MyLog.d("The answer is ", answer);

Alternatively, you can try prefixing every debug statement with a condition that ProGuard can later evaluate as false. This option may be a bit more convoluted, requiring some additional -assumenosideeffects option on an initialization method for the debug flag.

Answer:

here is how we do it – using ant task

<target name="base.removelogs">
    <replaceregexp byline="true">
        <regexp pattern="Log.d\s*\(\s*\)\s*;"/>
        <substitution expression="{};"/>
        <fileset dir="src/"><include name="**/*.java"/></fileset>
    </replaceregexp>
</target>

Answer:

As I don’t have enough rep to comment the ant task answer directly, here some corrections for it as it proves to be very helpful in combination with a CI-Server like Jenkins who can execute it for a release build:

<target name="removelogs">
    <replaceregexp byline="true">
        <regexp pattern="\s*Log\.d\s*\(.*\)\s*;"/>
        <substitution expression="{};"/>
        <fileset dir="src">
            <include name="**/*.java"/>
        </fileset>
    </replaceregexp>
</target>

The ‘.’ after Log must be escaped and a ‘.’ inside of the brackets targets any logging statement, not just whitespaces as ‘\s*’ does.

As I don’t have much experience with RegEx I hope this will help some people in the same situation to get this ant task working (e.g. on Jenkins).

Answer:

If you want to support multiline log calls, you can use this regexp instead:

(android\.util\.)*Log\[email protected]([ewidv]|wtf)\s*\([\S\s]*?\)\s*;

You should be able to use this within an ant replaceregexp task like so:

<replaceregexp>
    <regexp pattern="((android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;)"/>
    <substitution expression="if(false){}"/>
    <fileset dir="src/">
        <include name="**/*.java"/>
    </fileset>
</replaceregexp>

Note: this surrounds the Log calls with if(false){ and } so the original call is preserved, both for reference and to preserve line numbers when inspecting the intermediate build files, letting the java compiler strip the calls during compilation.

If you prefer to remove the log calls completely, you could do so like this:

<replaceregexp>
    <regexp pattern="(android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;"/>
    <substitution expression=""/>
    <fileset dir="src/">
        <include name="**/*.java"/>
    </fileset>
</replaceregexp>

You could also apply the regular expression as a filter within a <copy> task like so:

<copy ...>
    <fileset ... />
    <filterchain>
        <tokenfilter if:true="${strip.log.calls}">
            <stringtokenizer delims=";" includeDelims="true"/>
            <replaceregex pattern="((android\.util\.)*Log\.([ewidv]|wtf)\s*\([\S\s]*?\)\s*;)" replace="if(false){}"/>
        </tokenfilter>
    </filterchain>
    <!-- other-filters-etc -->
</copy>