Subversion Repositories DevTools

########################################################################

# Copyright (c) VIX TECHNOLOGY (AUST) LTD

#

# Module name   : androidBuilder.pl

# Module type   : Makefile system

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   : This program is invoked by the JATS Makefile System

#                 to 'build' an Android project from an AndroidStudio based

#                 Android project. It does this by:

#                   Creating a build.xml file from the Eclispe files

#                   Injecting properties into the build

#                       Create gradle.properties (Must not be version controlled)

#                       Create local.properties (Must not be version controlled)

#                   Insert external dependencies

#                       Jar files

#                       Aar files

#                       JNI Libraries

#                   Invoking 'gradle' to perform the build 

#

#                 This process requires external tool - delivered in packages

#                 These are:

#                   gradle      - Provides the core of gradle

#                   androidSdk  - From package rather than installed

#                                 This provides flexability when a new Sdk

#                                 is required

#

# Usage:        The utility is invoked in a controlled manner from a Jats

#               makefile. The call is generated by the Android Toolset

#               Arguments:

#                -verbose                   - Increase debugging

#                -verbose=n                 - Increase debugging

#                -f=manifestFile.xml        - project Manifest file

#                -i=path                    - Path to the interface directory

#                -t=[P|D]"                  - Build Type. Production or Debug

#                -pn=PackageName            - Package Name

#                -pv=PackageVersion         - Package Version

#                -clean                     - Will clean the build

#                -populate                  - Test Env and Populate 'libs'

#                -autotest                  - Run Unit Tests

#                -hasTests                  - Build unit tests too    

#               Aguments that can be provided by the user

#                -Jar=name                  - Name of a Jar to include

#                -Aar=name                  - Name of an Aar to include

#                -lname                     - Name of a Jats library to include

#                -Lname                     - Name of a 3rd party library to include

#

# Note: This function may be provided by several packages, 

#       thus the interface must not change - this include the name of 

#       this file. See the AndroidBuilder package too.

#

#

#......................................................................#

require 5.008_002;

use strict;

use warnings;

use Getopt::Long qw(:config pass_through);

use File::Path;

use JatsError;

use JatsSystem;

use JatsEnv;

use FileUtils;

use JatsProperties;

use JatsVersionUtils;

use ReadBuildConfig;

use JatsCopy;

use ArrayHashUtils;

#

#   Globals

#   Command line arguments

#

my $opt_verbose = $ENV{GBE_VERBOSE};

my $opt_buildFile;

my $opt_interface;

my $opt_gbetype = 'P';

my @opt_gbetypes;

my $opt_clean;

my $opt_pkgname;

my $opt_pkgversion;

my $opt_platform;

my $opt_populate;

my $opt_populateDebug;

my $opt_populateProd;

my $opt_autotest;

my $opt_hastests;

my @opt_jlibs;                  # List of Jats Libraries

my @opt_elibs;                  # List of 3rd party libraries

my @opt_jars;                   # List of JARs

my @opt_aars;                   # List of AARs

#

#   Configuration

#   Map JATS platforms to Shared library targets

#

my %SharedLibMap = (

    'ANDROIDARM'    => 'armeabi, armeabi-v7a',

    'ANDROIDMIPS'   => 'mips',

    'ANDROIDX86'    => 'x86',

    'ANDROIDARM64'  => 'arm64-v8a',

    'ANDROIDMIPS64' => 'mips64',

    'ANDROIDX86_64' => 'x86_64',

    );

our $GBE_HOSTMACH;              # Sanity Test of machine type

our $GBE_MAKE_TARGET;           # Current build target

my $androidJars;                # Root of injected JARs and AARs

my $androidJniBase;             # Root of injected JNI files

my $androidJniProd;             # Root of injected JNI files - Prod

my $androidJniDebug;            # Root of injected JNI files - Debug

my $androidBuildSuffix = '';    # Prefix build commands

#-------------------------------------------------------------------------------

# Function        : Main Entry Point 

#

# Description     : Main entry to this program

#

# Inputs          : @ARGV           - Array of command line arguments

#                                     See file header

#

# Returns         : 0               - No Error

#                   1               - Error encountered    

#

InitFileUtils();

ErrorConfig( 'name'    => 'ANDROIDBUILDER',

             'verbose' => $opt_verbose);

$opt_verbose = $::ScmVerbose;               # Get the calculated verbosity level

#

#   Install local signal handlers to process GetOptions messages

#

local $SIG{__WARN__} = sub { ReportError('AndroidBuilder.' . "@_"); };

local $SIG{__DIE__} = sub { ReportError('AndroidBuilder.' . "@_"); };

my $result = GetOptions (

                "verbose:+"     => \$opt_verbose,       # flag

                "f=s"           => \$opt_buildFile,     # string

                "i=s"           => \$opt_interface,     # Interface directory

                "t=s"           => \@opt_gbetypes,      # string

                "pn=s"          => \$opt_pkgname,       # string

                "pv=s"          => \$opt_pkgversion,    # string

                "pf=s"          => \$opt_platform,      # string

                "clean"         => \$opt_clean,         # flag

                "populate"      => \$opt_populate,      # flag

                "autotest"      => \$opt_autotest,      # flag

                "hastests"      => \$opt_hastests,      # flag

                "Jar=s"         => \@opt_jars,

                "Aar=s"         => \@opt_aars,

                );

#

#   Restore signal handlers and report parse errors

#

$SIG{__WARN__} = 'DEFAULT';

$SIG{__DIE__} = 'DEFAULT';

Error('AndroidBuilder. Invalid call options detected') if (!$result);

#

#   Process remaining arguments

#   Only --Lname and --lname are valid

#

foreach my $arg (@ARGV) {

    if ($arg =~ m~^[-]{1,2}l(.*)~) {

        push @opt_jlibs, $1;

    } elsif ($arg =~ m~^[-]{1,2}L(.*)~) {

        push @opt_elibs, $1;

    } else {

        ReportError("Invalid option: $arg");

    }

}

ErrorDoExit();

#

#   Sanity Test

#

ReportError ("Gradle build file not specified") unless ( defined $opt_buildFile); 

ReportError ("Gradle build file not found: $opt_buildFile") unless ( -f $opt_buildFile);

ReportError ("Interface directory not specified") unless ( defined $opt_interface);

ReportError ("Interface directory not found: $opt_interface") unless ( -d $opt_interface);

ReportError ("Package Name not specified") unless ( defined $opt_pkgname); 

ReportError ("Package Version not specified") unless ( defined $opt_pkgversion); 

EnvImport('GBE_HOSTMACH');

ReportError ("AndroidStudioBuilder is only supported under win32","This machine is: ".$::GBE_HOSTMACH ) unless ( $::GBE_HOSTMACH eq 'win32' );

ReportError ("Platform not found") unless ( defined $opt_platform );

ErrorDoExit();

#

#   Basic setup

#

#   Handle multiple opt_gbetypes for populate mode

#   If we are ony building for Prod, then only populate production artifacts 

#   If we are ony building for Debug, then only populate debug artifacts 

foreach ( @opt_gbetypes) {

    $opt_gbetype = $_;

    $opt_populateProd = 1 if ($opt_gbetype eq 'P');

    $opt_populateDebug = 1 if ($opt_gbetype eq 'D');

}

$androidBuildSuffix = ($opt_gbetype eq 'P') ? 'Release' : 'Debug';

#

#   The user provides the root build.gradle file

#   There MUST be a settings.gradle in the same directory

#       This is a JATS assumption - subject to change

#   There will be some other files there too

#   Calculate the root of the project

#

$opt_buildFile = RelPath(AbsPath($opt_buildFile));

my $project_root = StripFileExt($opt_buildFile);

   $project_root = '.' unless $project_root;

my $project_settingsFile = catfile($project_root, 'settings.gradle');

Message ("Project Base:" . Getcwd());

Message ("Project Root:" . $project_root);

Verbose ("Project Settings file:" . $project_settingsFile);

#

#   Directories to store Jar's, Aar's and JNI shared libarares

#   are created in the interface directory

#

$androidJars      = catdir($opt_interface, 'jatsLibs');

$androidJniBase   = catdir($opt_interface, 'jatsJni');

$androidJniProd   = catdir($androidJniBase, 'Release');

$androidJniDebug  = catdir($androidJniBase, 'Debug');

Verbose ("Interface:" . $opt_interface);

Verbose ("Android Jars: $androidJars");

Verbose ("Android JNI : $androidJniBase");

Error ("Gradle settings file not found: $project_settingsFile") unless ( -f $project_settingsFile);

#

#   Essential tool

#       gradle     - setup 

#                    GRADLE_USER_HOME

#                    JAVA_HOME

#                    

ReadBuildConfig( $opt_interface, $opt_platform, '--NoTest' );

my $gradleTool = getToolInfo('gradle', 'JAVA_VERSION', 'GRADLE_BIN');

my $gradleBinDir = catdir($gradleTool->{PKGBASE}, $gradleTool->{TOOLROOT}, $gradleTool->{GRADLE_BIN});

#

#   Setup a gradle home

#   Its used to cache stuff - create it within the interface directory

#

my $gradleHomeTarget = CleanPath(FullPath(catdir($opt_interface, 'gradleUserHome')));

mkpath($gradleHomeTarget, 0, 0775) 

    unless ( -d $gradleHomeTarget);

$ENV{GRADLE_USER_HOME} = $gradleHomeTarget;

Verbose("GRADLE_USER_HOME:", $ENV{GRADLE_USER_HOME});

#

#   Setup the required version of Java for the tool

#   Force JAVA_OPTS to set Min/Max Heap

#       Use JAVA_OPTS because

#           _JAVA_OPTIONS causes ssytem to emit a lot of warnings that _JAVA_OPTIONS is being used

#           Use of org.gradle.jvmargs in gradle.properties causes warnins about forking speed

#           Fixing the max size will provide consistent builds

#           Perhaps one day it will be configured 

#

my $javaVersion = $gradleTool->{JAVA_VERSION};

ReportError ("$javaVersion not defined.", "Building ANDROID requires $javaVersion be installed and correctly configured.") 

    unless $ENV{$javaVersion};

$ENV{JAVA_HOME}=$ENV{$javaVersion};

$ENV{JAVA_OPTS} = '-Xms256m -Xmx1024m';

#

#   Essential tool

#       androidSdk  - setup path to the android executable

#

my $androidSdkTool = getToolInfo('androidSdk');

my $androidSdk = catdir($androidSdkTool->{PKGBASE}, $androidSdkTool->{TOOLROOT} );

Verbose ("Android SDK : $androidSdk");

ReportError("Tool Package 'androidSdk' - Invalid SDK Basedir", "Sdk Base: $androidSdk" )

    unless -d ($androidSdk);

#   Essential tool

#       androidGradleRepo   - A repo of gradle plugings for android

#

my $androidGradleRepo = getToolInfo('androidGradleRepo');

my $gradleMavenRepo = catdir($androidGradleRepo->{PKGBASE}, $androidGradleRepo->{TOOLROOT});

Verbose ("Maven Repo. Gradle support for android : $gradleMavenRepo");

ErrorDoExit();

#

#   Create a gradle file with JATS provided version information

#   and paths for use within the gradle build.

#

#   Always do this as the 'clean' will need them

#

createGradleFiles($opt_clean);

#

#   Clean out any build artifacts

#

if ($opt_clean)

{

    #

    #   Invoke GRADLE on the build script - if present

    #

    Message ("Clean the existing build");

    runGradle ('clean');

    deleteGeneratedFiles();

    exit 0;

}

#

#   If we are only populating the build then we 

#   need to inject dependencies.

#

if ($opt_populate)

{

    deleteInjectedFiles();

    injectDependencies();

    Verbose ("Populate complete");

    exit 0;

}

#

#   Build the Android project through gradle

#

my $rv = 0;

if ( ! $opt_autotest )

{

    #

    #   Build the project - does not run unit tests

    #       assemble all the code

    #       assemble code for unit tests -  does not run unit tests 

    #

    Message ("Build the android project: $androidBuildSuffix");

    my @tasks;

    push (@tasks, 'assemble'. $androidBuildSuffix); 

    push (@tasks, 'assemble' . $androidBuildSuffix . 'UnitTest') if $opt_hastests;

    $rv = runGradle('assemble'. $androidBuildSuffix , 'assemble' . $androidBuildSuffix . 'UnitTest');

    Error("Cannot build AndroidStudio project") if $rv;

}

else

{

    #

    #   Run unit tests - does not build the project, although it 

    #   will build the unit tests, but these have been buitl before

    #   

    #   If the gradle run fails, then its because one or more of the unit tests failed

    #   This is not a build failure as we want to process the test results and feed

    #   them up the chain

    #   

    #   Post processing MUST detect and report errors

    #

    Message ("Run Unit Tests within the android project: $androidBuildSuffix");

    $rv = runGradle('test'. $androidBuildSuffix);

    Message ("Unit Test reports: $rv");

}

exit(0);

#-------------------------------------------------------------------------------

# Function        : runGradle 

#

# Description     : Run gradle to build the project

#                   Generate a command like:

#                   PathToGradle/gradle --offline -I SomePath/init.gradle <task> 

#

#                   Use an init-script to inject a sanity test into the build

#                   Ensure that the user is using our version numbers.

#

# Inputs          : task        - Task to run

#

# Returns         : Returns the error code of the build

#

sub runGradle

{

    my (@tasks) = @_;

    Verbose ("runGradle: @tasks");

    #   The Windows batch file can run in debug mode

    #   Make sure that it doesn't by default

    $ENV{DEBUG} = "" unless $opt_verbose;

    my $gradleProg = catdir($gradleBinDir, 'gradle');

    Verbose ("GradleProg: $gradleProg");

    #

    #   Locate the 'init.gradle' script

    #   Its co-located with this script

    #

    my $initScript = catdir(StripFileExt(__FILE__), 'init.gradle');

    Verbose ("Gradle Init Script: $initScript");

    #

    #   Build up the arg list

    #

    my @gradleArgs;

    push (@gradleArgs, '--offline');

#    push (@gradleArgs, '--info');

#    push (@gradleArgs, '--debug');

#    push (@gradleArgs, '--stacktrace');

    push (@gradleArgs, '--info') if $opt_verbose;

    push (@gradleArgs, '--debug') if ($opt_verbose > 2);

    push (@gradleArgs, '--stacktrace') if ($opt_verbose > 3);

    push (@gradleArgs, '-I', $initScript) unless ($tasks[0] =~ m/clean/); 

    push (@gradleArgs, '-p', $project_root);

    my $rv = System('--NoShell', '--NoExit', $gradleProg, @gradleArgs, @tasks);

    return $rv;

}

#-------------------------------------------------------------------------------

# Function        : createGradleFiles 

#

# Description     : Calculate Version information

#                       gradle.properies

#                       local.properties

#

# Inputs          : quiet           - No output 

#

# Returns         : Nothing

#

sub createGradleFiles

{

    my ($quiet) = @_;

    #

    #   Generate Package Versioning information   

    #       Need a text string and a number

    #       Generate the 'number' from the version number

    #

    my $version_text;

    my $version_num;

    $version_text = $opt_pkgversion;

    my ($major, $minor, $patch, $build )= SplitVersion($opt_pkgversion);

    foreach my $item ($major, $minor, $patch, $build)

    {

        Error("Package version has invalid form. It contains non-numeric parts", $item)

            unless ( $item =~ m~^\d+$~);

    }

    $version_num = ($major << 24) + ($minor << 16) + ($patch << 8) + $build;

    Message ("Project Version Txt:" . $version_text) unless $quiet;

    Message ("Project Version Num:" . $version_num) unless $quiet;

    #

    #   Create the gradle.properties file

    #       It needs to be in the projects root directory

    #

    my $gradleProperies = catfile($project_root,'gradle.properties');

    Message ("Create gradle.properties file: " . $gradleProperies) unless $quiet;

    my $data = JatsProperties::New();

    $data->setProperty('GBE_VERSION_NAME' , $version_text);

    $data->setProperty('GBE_VERSION_CODE' , $version_num);

    $data->setProperty('GBE_JARLIBS'        , NicePath($androidJars));

    $data->setProperty('GBE_JNI_RELEASE'    , NicePath($androidJniProd));

    $data->setProperty('GBE_JNI_DEBUG'      , NicePath($androidJniDebug));

    $data->setProperty('GBE_GRADLE_REPO'    , NicePath($gradleMavenRepo));

    #

    #   Create properties for JAVA Stores

    #   Name of variable is based on the package name and prject suffix

    #       Forced to uppercase

    #       '-' replaced with '_'

    #

    foreach my $pkg (getPackageList())

    {

        my $base = $pkg->getBase(3);

        if ($base)

        {

            my $jarDir = catdir($base, 'jar');

            if (-d $jarDir )

            {

                $data->setProperty( $pkg->getUnifiedName('GBE_REPO_') , NicePath($jarDir));

            }

        }

    }

    $data->store( $gradleProperies );

    #

    #   Create the local.properties file

    #       It needs to be in the projects root directory

    #

    #   May be able to do without this file - iff we set ANDROID_HOME

    #

    my $localProperies = catfile($project_root,'local.properties');

    Message ("Create local.properties file: " . $localProperies) unless $quiet;

    $data = JatsProperties::New();

    $data->setProperty('sdk.dir' , NicePath($androidSdk));

    $data->store( $localProperies );

}

#-------------------------------------------------------------------------------

# Function        : injectDependencies 

#

# Description     : Inject dependencies

#

#                   The android build can make use of files in a specific directory

#                   Place Jar and Aar files in a specific directory under the root of the project

#                   Use a directory called jatsLibs

#                   There are two types of files that can be placed in that directory

#                   These appear to be:

#                       1) .jar files

#                       2) .aar files

#

#                   NDK files will be process automatically by the builder, once the build is made

#                   aware of the location. We are not using the AndroidStudio default location

#                   Place them into jatsJni within the project root

#                       1) Shared libraries provided by NDK components

#

#                   Need to keep the production and debug JNI files seperate

#

#                   The gradle dependency processing needs both production and

#                   debug dependencies to be present at all times

#                   

#                   Create three areas:

#                       jatsLibs        - Prod and Debug Jars and Ars

#                       jatsJniDebug    - Debug JNI files

#                       jatsJniProd     - Production JNI files

#

# Inputs          : 

#

# Returns         : 

#

sub injectDependencies

{

    my @jlist;                  # List of JARs from default directories

    my @jpathlist;              # List of JARs from named directories

    my @alist;                  # List of AARs from default directories

    my @apathlist;              # List of AARs from named directories

    my @libListProd;            # List of production libraries

    my @libListDebug;           # List of debug libraries

    my @platformParts;          # Platforms Parts

    my @jarSearch;              # Search paths - diagnostic display

    my @aarSearch;

    my @libSearch;

    #

    #   Only if we need to do something

    #

    return unless (@opt_jars || @opt_aars || @opt_elibs || @opt_jlibs);

    #

    #   Determine the list of platformm parts

    #   This is where 'lib' files will be found

    #

    @platformParts = getPlatformParts();

    Verbose("Platform Parts", @platformParts);

    #

    #   Create search entries suitable for the CopyDir

    #   We will delete entries as the files are copied

    #   Allow for:

    #       jar/aar files to have a .jar /.aar suffix (optional)

    #       jar/aar files to have path specified with a package

    #

    #   Split into two lists ( per type ): 

    #       Those with a path and those without

    #

    foreach my $item ( @opt_jars) {

        $item =~ s~\.jar~~i;

        if ($item =~ m~/~) {

            UniquePush \@jpathlist, $item;

        } else {

            UniquePush \@jlist, $item;

        }

    }

    foreach my $item ( @opt_aars) {

        $item =~ s~\.aar~~i;

        if ($item =~ m~/~) {

            UniquePush \@apathlist, $item;

        } else {

            UniquePush \@alist, $item;

        }

    }

    #   Shared libraries

    #   Create full names

    foreach my $item ( @opt_elibs) {

        UniquePush (\@libListDebug, 'lib' . $item . '.so');

        UniquePush (\@libListProd,  'lib' . $item . '.so');

    }

    foreach my $item ( @opt_jlibs) {

        UniquePush (\@libListDebug, 'lib' . $item . 'D.so') if $opt_populateDebug;

        UniquePush (\@libListProd , 'lib' . $item . 'P.so') if $opt_populateProd;

    }

    #

    #   Where does it go

    #       JARs/AARs - ROOT/jatsLibs

    #       LIBS      - ROOT/jatsJni

    #

    #   Scan all external packages, and the interface directory

    #       Transfer in the required file types

    #

    my @pkg_paths = getPackagePaths("--Interface=$opt_interface");

    foreach my $pkg ( @pkg_paths)

    {

        #

        #   Copy in all JAR files found in dependent packages

        #   Need to allow for Jars that have a P/D suffix as well as those that don't

        #

        my $jarDir = catdir($pkg,'jar');

        push @jarSearch, $jarDir;

        if (-d $jarDir && @jlist)

        {

            Verbose("Jar Dir Found found", $jarDir);

            Message ("Copy in: $jarDir");

            #

            #   Create a matchlist from the JAR list

            #   Create a regular expresssion to find a suitable file

            #

            my @mlist;

            foreach  ( @jlist) {

                push @mlist, $_ . '.jar|' . $_ . 'P.jar|'. $_ . 'D.jar';

            }

            CopyDir ( $jarDir, $androidJars,

                        'MatchRE' => \@mlist,

                        'Log' => $opt_verbose + 1,

                        'SymlinkFiles' => 1,

                        'Examine' => sub 

                            {

                                my ($opt) = @_;

                                my $baseName = $opt->{file};

                                $baseName =~ s~\.jar~~;

                                $baseName =~ s~[PD]$~~;

                                ArrayDelete \@jlist, $baseName;

                                return 1;

                            },

                    );

        }

        #

        #   Copy in JARs specified by a full pathname

        #   Need to allow for Jars that have a P/D suffix as well as those that don't

        #

        my @jpathlistBase = @jpathlist;

        foreach my $file (@jpathlistBase) 

        {

            foreach my $suffix ( '', 'P' ,'D')

            {

                my $jarFile = catdir($pkg, $file . $suffix . '.jar');

                push @jarSearch, $jarFile;

                if (-f $jarFile)

                {

                    Verbose("Jar File Found found", $jarDir);

                    Message ("Copy in: $jarFile");

                    CopyFile ( $jarFile, $androidJars,

                                'Log' => $opt_verbose + 1,

                                'SymlinkFiles' => 1,

                             );

                    ArrayDelete \@jpathlist, $file;

                }

            }

        }

        #

        #   Copy in AAR files found in dependent packages

        #   Need to allow for both AAR files with a -debug/-release suffix 

        #   as well as those without

        #

        foreach my $part (@platformParts)

        {

            my $aarDir = catdir($pkg,'lib/' . $part);

            push @aarSearch, $aarDir;

            if (-d $aarDir && @alist)

            {

                Verbose("Library Dir Found found", $aarDir);

                Message ("Copy in: $aarDir");

                #

                #   Create a matchlist from the AAR list

                #   Create a regular expresssion to find a suitable file

                #

                my @mlist;

                foreach  ( @alist) {

                    push @mlist, $_ . '.aar|' . $_ . '-debug.aar|' . $_ . '-release.aar';

                }

                CopyDir ( $aarDir, $androidJars,

                            'MatchRE' => \@mlist,

                            'Log' => $opt_verbose + 1,

                            'SymlinkFiles' => 1,

                            'Examine' => sub 

                                {

                                    my ($opt) = @_;

                                    my $baseName = $opt->{file};

                                    $baseName =~ s~\.aar$~~;

                                    $baseName =~ s~-release$~~;

                                    $baseName =~ s~-debug$~~;

                                    ArrayDelete \@alist, $baseName;

                                    return 1;

                                },

                            );

            }

        }

        #

        #   Copy in AAR files specified by a full pathname

        #   Need to allow for both AAR files with a -debug/-release suffix 

        #   as well as those without

        #

        my @apathlistBase = @apathlist;

        foreach my $file (@apathlistBase) 

        {

            foreach my $suffix ( '', '-release', '-debug')

            {

                my $aarFile = catdir($pkg, $file . $suffix . '.aar');

                push @aarSearch, $aarFile;

                if (-f $aarFile)

                {

                    Verbose("Aar File Found found", $aarFile);

                    Message ("Copy in: $aarFile");

                    CopyFile ( $aarFile, $androidJars,

                                'Log' => $opt_verbose + 1,

                                'SymlinkFiles' => 1,

                             );

                    ArrayDelete \@apathlist, $file;

                }

            }

        }

        #

        #   Build up the Shared Library structure as used by JNI

        #   Note: Only support current JATS format

        #   Copy in .so files and in to process massage the pathname so that

        #   it confirms to that expected by the Android Project

        #

        my $libDir = catdir($pkg, 'lib');

        push @libSearch, $libDir;

        if (-d $libDir && @libListProd)

        {

            Verbose("Lib Dir Found found", $libDir);

            Message ("Copy in: $libDir");

            CopyDir ( $libDir, $androidJniProd,

                        'Match' => \@libListProd,

                        'Log' => $opt_verbose + 1,

                        'SymlinkFiles' => 1,

                        'Examine' => sub 

                            { 

                                my ($opt) = @_;

                                foreach my $platform ( keys %SharedLibMap ) {

                                    my $replace = $SharedLibMap{$platform};

                                    if ($opt->{'target'} =~ s~/$platform/~/$replace/~)

                                    {

                                        ArrayDelete \@libListProd, $opt->{file};

                                        return 1;

                                    }

                                }

                                return 0;

                            },

                    );

        }

        if (-d $libDir && @libListDebug)

        {

            Verbose("Lib Dir Found found", $libDir);

            Message ("Copy in: $libDir");

            CopyDir ( $libDir, $androidJniDebug,

                        'Match' => \@libListDebug,

                        'Log' => $opt_verbose + 1,

                        'SymlinkFiles' => 1,

                        'Examine' => sub 

                            { 

                                my ($opt) = @_;

                                foreach my $platform ( keys %SharedLibMap ) {

                                    my $replace = $SharedLibMap{$platform};

                                    if ($opt->{'target'} =~ s~/$platform/~/$replace/~)

                                    {

                                        ArrayDelete \@libListDebug, $opt->{file};

                                        return 1;

                                    }

                                }

                                return 0;

                            },

                    );

        }

    }

    #

    #   Report files that could not be located. They were deleted from the lists

    #   as they were processed

    #

    if (@jlist || @jpathlist || @alist || @apathlist ||  @libListProd || @libListDebug )

    {

        ReportError("External dependencies not found:", @jlist , @jpathlist , @alist , @apathlist ,  @libListProd , @libListDebug);

        if (@jlist || @jpathlist)

        {

            ReportError("Jar Search Path", @jarSearch);

        }

        if (@alist || @apathlist)

        {

            ReportError("Aar Search Path", @aarSearch);

        }

        if ( @libListProd || @libListDebug)

        {

            ReportError("Lib Search Path", @libSearch);

        }

    ErrorDoExit();

    }

}

#-------------------------------------------------------------------------------

# Function        : deleteGeneratedFiles 

#

# Description     : Delete files that we generate

#

# Inputs          : 

#

# Returns         : 

#

sub deleteGeneratedFiles

{

    #

    #   Delete files that we will create

    #

    my @deleteList = qw(local.properties gradle.properties);

    foreach my $file (@deleteList)

    {

        Verbose ("Deleting $project_root/$file");

        unlink catfile($project_root, $file);

    }

}

#-------------------------------------------------------------------------------

# Function        : deleteInjectedFiles 

#

# Description     : Delete files that we inject

#

# Inputs          : 

#

# Returns         : 

#

sub deleteInjectedFiles

{

    #

    #   Remove the jatsJars and JatsJni directories

    #   These are created by this tool

    #

    Verbose("RmDirTree($androidJars)");

    RmDirTree($androidJars);

    Verbose("RmDirTree($androidJniBase)");

    RmDirTree($androidJniBase);

}

#-------------------------------------------------------------------------------

# Function        : NicePath 

#

# Description     : Process a path and return one that is

#                       An absolute Path

#                       Uses '/'

#

# Inputs          : path            - Path to process

#

# Returns         : A Nice version of path

#

sub NicePath

{

    my ($path) = @_;

    $path = FullPath($path);

    $path =~ s~\\~/~g;

    $path = CleanPath($path);

    return $path;

}