Subversion Repositories DevTools

########################################################################
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
#
# Module name   : ANDROID.PL
# Module type   : Makefile system
# Compiler(s)   : Perl
# Environment(s): jats
#
# Description:
#       This file provides Toolset initialisation and plugin functions
#       to makelib.pl2
#
# Contents:     Basic (very basic) Android support
#
#............................................................................#

use strict;
use warnings;

#
#   Globals
#
my $androidBuilder;
my $postProcessUnitTest = 0;

##############################################################################
#   ToolsetInit()
#       Runtime initialisation
#
##############################################################################

ToolsetInit();

sub ToolsetInit
{

#.. Toolset configuration
#
    $::ScmToolsetVersion = "1.0.0";                 # our version
    $::ScmToolsetGenerate = 0;                      # generate optional
    $::ScmToolsetProperties{'AutoUnitTests'} = 1;   # Supports AutoUnit Tests

#.. Standard.rul requirements
#
    $::s =   'java';          # Assembler source file
    $::o =   '';              # Object file
    $::a =   'class';         # Library file
    $::so =  'jar';           # Shared library
    $::exe = '.apk';          # Linked binary images

#.. Toolset specific definitions
#
    Init( "android_sdk" );
    ToolsetDefines( 'ANDROID.DEF' );
#
#.. Locate the AndroidBuilder.pl script
#   This will be delivered by a package
#
    my $program = 'AndroidBuilder.pl';
    Verbose("Locate extension Program: $program");
    $androidBuilder = ToolExtensionProgram( $program );
    Error( "Tool program(s) required by toolset not found:", $program)
        unless ($androidBuilder);

    ToolsetDefine ('#   Android Builder Support Tool');
    ToolsetDefine ('ANDROIDBUILDER=' . $androidBuilder);

}

########################################################################
#
#   Generate a project from the provided build.xml
#
#   Arguments   : $name             - Base name of the project
#                 $androidxml       - Path to the AndroidManifest.xml file
#                 $pArgs            - Project specific options
#                 $auto_test        - Unit Test Target (optional)
#                 $unit_test        - Unit Test Target (optional)
#                 $pGenerated       - Ref to an array of Generated Files (optional)
#
########################################################################

our $ToolsetPROJECT_type = 'android';
sub ToolsetPROJECT
{
    my( $name, $androidxml ,$pArgs, $auto_test, $unit_test, $pGenerated ) = @_;

    #
    #   Kludge Alert
    #       The AndroidStudioBuilder needs to target platform
    #       The AndroidBuilder cannot handle this argument
    #       Luckily the AndroidStudioBuilder builds under windows
    #       and the AndroidBuilder under unix 
    #
    if ($::GBE_HOSTMACH eq 'win32')
    {
        push @{$pArgs}, '-pf', $::ScmPlatform;
    }

    #
    #   Populate the project for the user
    #
    ToolsetPROJECTPreBuild (@_);

    #
    #   Generate the recipe to create the project
    #   Add names of co-generated targets.
    #
    my $me = MakeEntry::New (*MAKEFILE, 'Project_'.$name );
    $me->AddComment ("Build Android Project: $name" );
    $me->AddDependancy ( $androidxml );
    $me->AddDependancy ( '$(SCM_MAKEFILE)' );
    $me->AddDependancy ( @{$pGenerated} );
    $me->AddRecipe ( "\$(XX_PRE)\$(call ProjectDefine_$name,)"  );
    $me->Print();

    #
    #   Generate the recipe to clean the project
    #
    $me = MakeEntry::New (*MAKEFILE, 'ProjectClean_'.$name );
    $me->AddComment ("Clean Android Project: $name" );
    $me->AddRecipe ( "\$(XX_PRE)\$(call ProjectDefine_$name,-clean)"  );
    $me->Print();

    #
    #   Generate the recipe to run unit tests on the project
    #   This is optional
    #
    if ( $auto_test )
    {
        $me = MakeEntry::New (*MAKEFILE, 'ProjectATest_'.$name );
        $me->AddComment ("Auto Test project: $name" );
        $me->AddDependancy ( $androidxml );
        $me->AddRecipe ( "\$(XX_PRE)\$(call ProjectDefine_$name,'-autotest')"  );
        $me->Print();

        #   Flag that we need to post process the test results
        #   Under Java the UTF tests MUST be Post processed
        $postProcessUnitTest = 1;

    }

    if ( $unit_test )
    {
        $me = MakeEntry::New (*MAKEFILE, 'ProjectUTest_'.$name );
        $me->AddComment ("Unit Test project: $name" );
        $me->AddDependancy ( $androidxml );
        $me->AddRecipe ( "\$(XX_PRE)\$(call ProjectDefine_$name,$unit_test)"  );
        $me->Print();
    }

    #
    #   Generate macro to contain the project invocation
    #   The first argument will be a 'build target' argument
    #
    my @cmdargs;
    push @cmdargs, '$(GBE_PERL)','$(ANDROIDBUILDER)';
    push @cmdargs, '-f', $androidxml;
    push @cmdargs, '-i=$(PWD)/$(INTERFACEDIR)';
    push @cmdargs, '-t=$(GBE_TYPE)';
    push @cmdargs, '-pn=$(GBE_PBASE) -pv=$(BUILDVER)';
    push @cmdargs, '-hasTests' if ( $auto_test || $unit_test );
    push @cmdargs, @{$pArgs}, '$1';

    $me = MakeEntry::New (*MAKEFILE, 'ProjectDefine_'.$name, '--Define' );
    $me->AddComment ("Macro to invoke project: $name" );
    $me->AddRecipe ( join(' ', @cmdargs)  );
    $me->Print();
}

#-------------------------------------------------------------------------------
# Function        : ToolsetPROJECTPreBuild 
#
# Description     : This ANDROID Specific operation is used to perform some of the 
#                   build opertaions at 'build' time. These include:
#                       - Verify that required packages are available
#                       - Populate the targets 'libs' directory so that the user can
#                         develop with the external dependencies in place 
#
# Inputs          : $name             - Base name of the project
#                   $androidxml       - Path to the AndroidManifest.xml file
#                   $pArgs            - Project specific options
#                   $auto_test        - Unit Test Target (optional)
#                   $unit_test        - Unit Test Target (optional)
#                   $pGenerated       - Ref to an array of Generated Files (optional)
#
# Returns         : Nothing
#
sub ToolsetPROJECTPreBuild
{
    my( $name, $androidxml ,$pArgs, $auto_test, $unit_test, $pGenerated, $project ) = @_;

    #
    #   Determine the populate mode
    #   Used to limit the shared libraries that are included
    #   In populate mode may have both -tD and -tP
    #       Need -tD last for backward compatability
    #
    my @tArgs;
    if (exists $project->{Prod} && $project->{Prod}) {
        push @tArgs, '-t=P';
    } elsif (exists $project->{Debug} && $project->{Debug}) {
        push @tArgs, '-t=D';
    } else {
        push @tArgs, '-t=P', '-t=D';
    }

    #
    #   Invoke the androidBuilder in a mode so that it will populate the Eclipse project
    #   in a suitable manner.
    #
    EnvImport( "GBE_PERL" );
    System ( '--NoShell', '--Exit', $::GBE_PERL, $androidBuilder, 
             '-f', $androidxml,
             '-i', catdir( $::ScmRoot, $::ScmInterface),
             @tArgs,
             '-pn', $::Pbase,
             '-pv', $::ScmBuildVersionFull,
             '-populate',
             @{$pArgs}
           );
}

#-------------------------------------------------------------------------------
# Function        : ToolsetPostprocess 
#
# Description     : Last chance by the toolset to perform processing
#                   All Directives have been processed
#
#                   If the Project has indicated that it has an automated unit test
#                   then we need to post process the results
#
# Inputs          : None
#
# Returns         : 
#

sub ToolsetPostprocess
{
    if ($postProcessUnitTest)
    {
        MakeHeader ("Automated tests Post Processing");

        #   Extend the list of Post Unit Tests recipes that are run
        my $recipeName = 'post_utf_processing';
        ToolsetAddUnitTestPostProcess($recipeName);

        #
        #   Create the Post Unit Test Recipe
        #
        my $me = MakeEntry::New (*MAKEFILE, $recipeName, '--Phony' );

        #   Insert test EnvVars
        #       In the Java toolset these are not as useful in a Jats RunTest
        $me->AddDefn('export GBE_UTFNAME', 'AndroidStudioTest');
        $me->AddDefn('export GBE_UTFUID', '$(MAKEFILEUID)' . '_' . '1');
        $me->AddDefn('export GBE_UTFFILE','$(UTFDIR_PKG)/$(GBE_PLATFORM)-$(GBE_TYPE)-$(GBE_UTFUID)' . '.xml');
        $me->AddDefn('export GBE_UTFTEST','TEST-$(GBE_UTFNAME)-$(GBE_TYPE)-$(GBE_UTFUID)' );

        $me->SectionIfDef ('UTF_POSTPROCESS');
        $me->AddRecipe  ( [
                           '$(GBE_PERL) -Mjats_runutf -e processUtf -- ',
                           '$(VERBOSE_OPT)',
                           '-filter=androidStudio',
                           '-root=$(GBE_ROOT_ABS)',
                           '-target=$(GBE_PLATFORM)', 
                           '-pkgdir=$(PKGDIR)',
                           '-local=$(LOCALDIR)',
                           '-interface=$(INTERFACEDIR)' 
                          ]);
        $me->Print();

        #   Clean up files that look like Junit output files
        ToolsetGenerate( 'TEST-*.xml' );
    }
}


1;