#!/bin/perl
use strict;use warnings;
my @DELETE_LIST = ( qr/app:layout_behavior="[^"^`]*"/);
my $ANDROID_VERSION;my $LIB_RES_DIR;my $LIB_CLASS_DIR;my $CMD_DELETE;my $CMD_COPY;my $CMD_7Z;
# get variables from includes.sh{ open(my $FILE, '<', "includes.sh");
foreach my $line (<$FILE>) { if (length($line) < 2 or substr($line, 0, 1) eq '#') { next; } my $decl = substr($line, 0, -1); $decl =~ s/="/ = "/; $decl =~ s/='/ = '/; $decl = "\$" . $decl . ";\n"; eval($decl); }
close($FILE);}
# I make the assumption that all tags that don't directly belong to the <resources> tag can be ignored when looking for merge conflicts.# This is a helper function that keeps track of how many tag levels deep the interpreter is.sub level_delta { my @chars = split('', shift);
my $delta = 0; my $quotes = 0; my $tag = 0; my $prev = '';
foreach (@chars) { if ($_ eq '"') { $quotes ^= 1; } if (!$quotes) { if ($_ eq '<') { $tag = 1; $delta += 1; } elsif ($_ eq '/' and $prev eq '<') { $delta -= 2; } elsif ($_ eq '>' and $prev eq '/') { $delta -= 1; } } $prev = $_; }
return $delta;}
# The purpose of this function is self-explanatory, but I'm not sure if this is a particularly good way of going about it.# The reason I converted this into a hash tree instead of a single hash was to potentially reduce lookup times,# but it seems to only be about 15% faster...sub value_exists { my $root = shift; my $dir = shift; my $type = shift; my $name = shift;
if (exists($root->{$dir})) { my $dir_hash = $root->{$dir}; if (exists($dir_hash->{$type})) { my $type_hash = $dir_hash->{$type}; if (exists($type_hash->{$name})) { return 1; } else { $type_hash->{$name} = 1; # $values_hash{$name} = "$pkg_name:$line_no$value"; } } else { $dir_hash->{$type} = {}; } } else { $root->{$dir} = {}; }
return 0;}
if (!-d "lib") { print( "lib/ folder has not been created.\n", "Try running get-packages.sh to retrieve some library packages.\n" ); exit;}
if (-d "$LIB_RES_DIR") { print("Clearing old library resources...\n"); exit if (system("$CMD_DELETE $LIB_RES_DIR") != 0); mkdir("$LIB_RES_DIR");}
if (-d "$LIB_CLASS_DIR") { print("Clearing old library classes...\n"); exit if (system("$CMD_DELETE $LIB_CLASS_DIR") != 0); mkdir("$LIB_CLASS_DIR");}
print("Extracting library resources and classes...\n");
# A JAR is basically just a ZIP file packed with classes in a certain folder structure, so we just extract everything.foreach (<lib/*.jar>) { system("$CMD_7Z x -y '$_' -o$LIB_CLASS_DIR > /dev/null");}
# AAR is the Android library format. It's essentially a ZIP containing a JAR and some resources.foreach (<lib/*.aar>) { system("$CMD_7Z x -y '$_' -o$LIB_RES_DIR res classes.jar R.txt AndroidManifest.xml > /dev/null");
system("$CMD_7Z x -y '$LIB_RES_DIR/classes.jar' -o$LIB_CLASS_DIR > /dev/null"); unlink("$LIB_RES_DIR/classes.jar");
my $name = substr($_, 4, -4);
rename("$LIB_RES_DIR/R.txt", "$LIB_RES_DIR/${name}_R.txt") if (-f "$LIB_RES_DIR/R.txt"); rename("$LIB_RES_DIR/AndroidManifest.xml", "$LIB_RES_DIR/${name}_mf.xml") if (-f "$LIB_RES_DIR/AndroidManifest.xml"); rename("$LIB_RES_DIR/res", "$LIB_RES_DIR/res_$name") if (-d "$LIB_RES_DIR/res");}
print("Merging library resources...\n");
# This is the interesting part.# In order for the libraries to be loaded and work during run-time, all resources have to co-exist in the same space.# AAPT2 handles ID allocation to consistently map a single number to a single resource each, but in order for it to work,# there must not be any resources across all packages/libraries (including your project) that share the same name.# The purpose of this part of the script is to remove resources with conflicting names, for better or worse.
mkdir("$LIB_RES_DIR/res");
my %xml_hash;my %values_hash;
my $n_delete_items = scalar @DELETE_LIST;
# For each package (=library)foreach my $pkg (<$LIB_RES_DIR/res_*>) { # 12 == length of "$LIB_RES_DIR/res_" my $pkg_name = substr($pkg, 12);
# The resources' sub-folders represent resource "types". The ones we'll focus on here are the "values*" types. foreach my $type_dir (<$pkg/*>) { # Get the name of the current folder my $dir = substr($type_dir, length($pkg) + 1); # Mirror this folder name in the output my $out_dir = "$LIB_RES_DIR/res/$dir";
# Non-"values" directories if ($type_dir !~ /\/values/) { if ($n_delete_items > 0) { mkdir $out_dir if (!-d $out_dir);
foreach my $fname (<$type_dir/*>) { open(my $fh, '<', $fname); read($fh, my $content, -s $fh); close($fh);
foreach my $r (@DELETE_LIST) { $content =~ s/$r//g; }
my $xml_name = substr($fname, length($type_dir) + 1); my $out_xml = "$out_dir/$xml_name";
open($fh, '>', $out_xml); print $fh $content; close($fh); } } else { system("$CMD_COPY -r '$type_dir' $LIB_RES_DIR/res"); } next; }
mkdir $out_dir if (!-d $out_dir);
# For each xml foreach my $v_xml (<$type_dir/*>) { open(my $fh, '<', $v_xml); chomp(my @xml = <$fh>); close($fh);
my $xml_name = substr($v_xml, length($type_dir) + 1); my $out_xml = "$out_dir/$xml_name";
# Treat the name of this file has being a key in a hash. # When the same file is encountered in a different library package, # it will be checked for any duplicates before being appended to the existing text for that file.
if (!exists($xml_hash{$out_xml})) { $xml_hash{$out_xml} = []; }
my $line_no = 0; my $level = 0;
# For each line in the new XML foreach (@xml) { $line_no += 1;
my $line = $_; $line =~ s/^\s+|\s+$//g;
# Skip this line if it's a comment my $pref = substr($line, 0, 2); next if ($pref eq "<!");
# Delete all meta-tags and the resource tags, so that multiple XMLs can be stitched together and still be parsed all the way through # Note that we delete the contents of the line rather than the line itself, since we're iterating forwards over the same array if ($pref eq "<?" or $line eq "</resources>") { $xml[$line_no - 1] = ""; next; } if (substr($line, 0, 10) eq "<resources") { $xml[$line_no - 1] = ""; $level++; # prime hackery daiquiri next; }
my $new = 0; my $name = "";
# If this tag has a 'name' attribute and we're only one level down from the root if ($level == 1 and $line =~ /<(\w+) .*name="([^"]+)/) { # Check this name for this resource type under this type sub-folder if (value_exists(\%values_hash, $dir, $1, $2)) { print("Eliminating re-def in $pkg_name at line $line_no for $dir/$1/$2\n"); $xml[$line_no - 1] = ""; } }
$level += level_delta($line); }
# Now that the headers and conflicting lines have been deleted, we append all the lines left to its kind of XML push(@{$xml_hash{$out_xml}}, @xml); } }}
print("Writing values XMLs...\n");
foreach (keys %xml_hash) { # We make sure to add a single set of headers/footer at the end. # Note that unshift() makes the new element come first on the list. unshift(@{$xml_hash{$_}}, '<resources xmlns:ns1="urn:oasis:names:tc:xliff:document:1.2" xmlns:ns2="http://schemas.android.com/tools">'); unshift(@{$xml_hash{$_}}, '<?xml version="1.0" encoding="utf-8"?>'); push(@{$xml_hash{$_}}, '</resources>');
my $content = join("\n", @{$xml_hash{$_}}); foreach my $r (@DELETE_LIST) { $content =~ s/$r//g; }
open(my $fh, '>', $_); print $fh $content; close($fh);}