ACE/bin/PerlACE/TestTarget_Android.pm

   1 #!/usr/bin/env perl
   2 package PerlACE::TestTarget_Android;
   3
   4 # ******************************************************************
   5 # Description : Creates a PerlACE::Android
   6 # Author      : Marcel Smit
   7 # Create Date : 29/20/2008
   8 # ******************************************************************
   9
  10 # ******************************************************************
  11 # Pragma Section
  12 # ******************************************************************
  13
  14 use strict;
  15
  16 use PerlACE::TestTarget;
  17 use PerlACE::ProcessVX;
  18 use File::Copy;
  19 use File::Glob;
  20 use File::Spec;
  21 use File::Basename;
  22 use Cwd;
  23 use English;
  24
  25 use POSIX "sys_wait_h";
  26 require PerlACE::ProcessAndroid;
  27
  28 our @ISA = qw(PerlACE::TestTarget);
  29
  30 $PerlACE::TestTarget_Android::EMULATOR_RUNNING = 0;
  31 $PerlACE::TestTarget_Android::LIBS = ();
  32
  33 sub new
  34 {
  35     my $proto = shift;
  36     my $config_name = shift;
  37     my $component = shift;
  38
  39     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
  40         print STDERR "New Android target: $config_name : $component\n";
  41     }
  42
  43     my $class = ref ($proto) || $proto;
  44     my $self = {};
  45     bless ($self, $class);
  46
  47     $self->GetConfigSettings($config_name);
  48     $self->{FSROOT} = $ENV{'ANDROID_FS_ROOT'};
  49     $self->{PROCESS} = undef;
  50     $self->{RUNNING} = 0;
  51
  52     # Start the target.
  53     if ($PerlACE::TestTarget_Android::EMULATOR_RUNNING == 0) {
  54         $self->start_target ();
  55     }
  56
  57     return $self;
  58 }
  59
  60 sub DESTROY
  61 {
  62     my $self = shift;
  63     if ($self->{RUNNING} == 1) {
  64         # kill the emulator. No need to shutdown gracefully.
  65         if (defined $ENV{'ACE_TEST_VERBOSE'}) {
  66             print STDERR "Killing the Android emulator\n";
  67         }
  68         $self->KillAll ('emulator*');
  69         $self->KillAll ('adb');
  70         $PerlACE::TestTarget_Android::EMULATOR_RUNNING = 0;
  71         $PerlACE::TestTarget_Android::LIBS = ();
  72     }
  73 }
  74
  75 # ******************************************************************
  76 # Subroutine Section
  77 # ******************************************************************
  78
  79 sub LocalFile
  80 {
  81     my $self = shift;
  82     my $file = shift;
  83
  84     my $newfile = $self->{FSROOT} . "/" . $file;
  85     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
  86         print STDERR "Android LocalFile for $file is $newfile\n";
  87     }
  88     return $newfile;
  89 }
  90
  91 sub AddLibPath ($)
  92 {
  93     my $self = shift;
  94     my $dir = shift;
  95     my $noarch = shift;
  96
  97     # If we have -Config ARCH, use the -ExeSubDir setting as a sub-directory
  98     # of the lib path.  This is in addition to the regular LibPath.
  99     if (!$noarch && defined $self->{ARCH}) {
 100         $self->AddLibPath($dir, 1);
 101         $dir .= '/' . $self->{EXE_SUBDIR};
 102     }
 103
 104     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 105         print STDERR "Adding libpath $dir\n";
 106     }
 107     $self->{LIBPATH} = PerlACE::concat_path ($self->{LIBPATH}, $dir);
 108 }
 109
 110 sub CreateProcess
 111 {
 112     my $self = shift;
 113     my $process = new PerlACE::ProcessAndroid ($self, @_);
 114     return $process;
 115 }
 116
 117 sub NeedReboot ($)
 118 {
 119     my $self = shift;
 120     $self->{REBOOT_NEEDED} = 1;
 121 }
 122
 123 # Reboot target
 124 sub RebootNow ($)
 125 {
 126     my $self = shift;
 127     $self->{REBOOT_NEEDED} = undef;
 128     print STDERR "Attempting to reboot target...\n";
 129     $self->reboot ();
 130 }
 131
 132 sub start_target ()
 133 {
 134     # For now, we're assuming one target (avd) is running in the test environment.
 135     # Need to change this when more than one avd's need to start
 136     my $self = shift;
 137     my $silent;
 138
 139     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 140       $silent = "2> /dev/null"
 141     }
 142
 143     if (! defined ($ENV{'ANDROID_SDK_ROOT'})) {
 144         print STDERR "Error: Android SDK root not defined.\n";
 145         return 0;
 146     }
 147     if (! defined ($ENV{'ANDROID_AVD_NAME'})) {
 148         print STDERR "Error: Android AVD name not defined.\n";
 149         return 0;
 150     }
 151     my $avd_name = $ENV{'ANDROID_AVD_NAME'};
 152     my $android_process = $ENV{'ANDROID_SDK_ROOT'} . "/tools/android";
 153     my $avd_process = $ENV{'ANDROID_SDK_ROOT'} . "/tools/emulator";
 154     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 155     my $user_data_image = $ENV{'ANDROID_SDK_HOME'} . "/.android/avd/" . $avd_name . ".avd/userdata-qemu.img";
 156
 157     my $avd_options = "-noaudio -no-window -wipe-data";
 158
 159     if (defined ($ENV{'ANDROID_AVD_OPTIONS'})) {
 160         print STDERR "Resetting AVD options\n";
 161         $avd_options = $ENV{'ANDROID_AVD_OPTIONS'};
 162     }
 163
 164     $self->KillAll ("emulator*");
 165
 166     FORK: {
 167         if ($self->{PROCESS} = fork) {
 168             #parent here
 169             bless $self;
 170         }
 171         elsif (defined $self->{PROCESS}) {
 172            #child here
 173            my $user_image_cmd = "rm -f " . $user_data_image;
 174            if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 175                print STDERR "Removing user data image: $user_image_cmd\n";
 176            }
 177
 178            system ( $user_image_cmd );
 179            if ($? != 0) {
 180                print STDERR "failed to execute: $!\n";
 181            }
 182
 183            my $avd_cmd = "$avd_process" .' -avd ' .  "$avd_name $avd_options";
 184            if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 185                print STDERR "Starting emulator cmd: $avd_cmd\n";
 186            }
 187
 188            system ( $avd_cmd );
 189            if ($? != 0) {
 190                print STDERR "failed to execute: $!\n";
 191            }
 192            exit;
 193        }
 194        elsif ($! =~ /No more process/) {
 195             #EAGAIN, supposedly recoverable fork error
 196             sleep 5;
 197             redo FORK;
 198        }
 199        else {
 200            # weird fork error
 201            print STDERR "ERROR: Can't fork <" . $avd_process . ">: $!\n";
 202        }
 203     }
 204
 205     eval {
 206         my $timeout = $self->AdbWaitForDeviceTimeout ();
 207
 208         local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required
 209         alarm $timeout;
 210         # start the waiting...
 211         my $wait_cmd = $adb_process . ' wait-for-device';
 212         system ( $wait_cmd );
 213         # reset alarm
 214         alarm 0;
 215     };
 216
 217     if ($@) {
 218         # timed out
 219         exit unless $@ eq "alarm\n";   # propagate unexpected errors
 220     }
 221     else {
 222         if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 223             print STDERR "Emulator is running <$self->{PROCESS}> -> start the tests.\n";
 224         }
 225     }
 226
 227
 228     # AVD is up and running and ready to spawn executables.
 229     # First some preparation.
 230     my $cmd = $adb_process . ' shell "mkdir ' . $self->{FSROOT} . '/tmp "' . $silent;
 231     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 232         print STDERR "Start to execute : $cmd\n";
 233     }
 234     system ( $cmd );
 235
 236     $self->{RUNNING} = 1;
 237     $PerlACE::TestTarget_Android::EMULATOR_RUNNING = 1;
 238     return 0;
 239 }
 240
 241 sub WaitForFileTimed ($)
 242 {
 243     my $self = shift;
 244     my $file = shift;
 245     my $timeout = shift;
 246     my $silent;
 247
 248     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 249       $silent = ' > /dev/null 2>&1';
 250     }
 251
 252     if ($PerlACE::Process::WAIT_DELAY_FACTOR > 0) {
 253         $timeout *= $PerlACE::Process::WAIT_DELAY_FACTOR;
 254     }
 255
 256     my $newfile = $self->LocalFile ($file);
 257     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 258         print STDERR "Android waits $timeout seconds for $newfile\n";
 259     }
 260
 261     # Since the file is available on the target (which we cannot reach),
 262     # we will try to pull the file from the target to a local directory.
 263     # If succeed, the the file is there an we can continue.
 264     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 265     my $fsroot_target = $self->{FSROOT};
 266
 267     my $cmd_copy_ior = $adb_process . ' pull ' . $newfile . ' ' .
 268                           File::Spec->tmpdir() . '/' .
 269                           basename ($newfile) . $silent;
 270
 271     while ($timeout-- != 0) {
 272         # copy the ior back to the host sytem
 273         if (system ( $cmd_copy_ior ) == 0) {
 274             if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 275                 print STDERR "Pull $newfile succeeded\n";
 276             }
 277             return 0;
 278         }
 279         sleep (1);
 280     }
 281     return -1;
 282 }
 283
 284 sub DeleteFile ($)
 285 {
 286     my $self = shift;
 287     my $file = shift;
 288     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 289     my $silent;
 290
 291     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 292       $silent = ' > /dev/null 2>&1';
 293     }
 294
 295     my $targetfile = $self->LocalFile ($file);
 296     my $cmd = "$adb_process" . ' shell rm '. "$targetfile" . $silent;
 297
 298     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 299       print STDERR "DeleteFile cmd: $cmd\n";
 300     }
 301
 302     system ( $cmd );
 303     if ($? != 0) {
 304         return -1;
 305     }
 306     return 0;
 307 }
 308
 309 sub Kill ()
 310 {
 311     my $self = shift;
 312
 313     if ($self->{RUNNING} == 1) {
 314         if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 315             print STDERR "Killing emulator process <$self->{PROCESS}>\n";
 316         }
 317
 318         my $cnt = kill (1, $self->{PROCESS});
 319
 320         waitpid ($self->{PROCESS}, WNOHANG);
 321         if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 322             print STDERR "Killed $cnt process(es)\n";
 323         }
 324         # $self->check_return_value ($?);
 325     }
 326
 327     $self->{RUNNING} = 0;
 328 }
 329
 330 sub KillAll ($)
 331 {
 332     my $self = shift;
 333     my $procmask = shift;
 334     if ($OSNAME eq 'MSWin32') {
 335         if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 336             print STDERR "Killall not implemented for Windows\n";
 337             return;
 338         }
 339     }
 340     else {
 341         my $cmd_killall = "killall -q -r $procmask";
 342         system ( $cmd_killall );
 343     }
 344 }
 345
 346 sub PutFile ($)
 347 {
 348     my $self = shift;
 349     my $src = shift;
 350     my $silent;
 351
 352     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 353       $silent = "2> /dev/null"
 354     }
 355
 356     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 357
 358     my $targetfile = $self->LocalFile ($src);
 359     my $cmd = "$adb_process" . ' push '. "\"$src\" \"$targetfile\" $silent";
 360
 361     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 362       print STDERR "PutFile cmd: $cmd\n";
 363     }
 364
 365     system ( $cmd );
 366     if ($? != 0) {
 367         return -1;
 368     }
 369     return 0;
 370 }
 371
 372 sub GetFile ($)
 373 {
 374     my $self = shift;
 375     my $remote_file = shift;
 376     my $local_file = shift;
 377     my $silent;
 378
 379     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 380       $silent = "2> /dev/null"
 381     }
 382
 383     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 384
 385     if (!defined $local_file) {
 386         $local_file = $remote_file;
 387     }
 388     $remote_file = $self->LocalFile($remote_file);
 389     my $cmd = "$adb_process" . ' pull '. "$remote_file $local_file $silent";
 390
 391     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 392       print STDERR "GetFile cmd: $cmd\n";
 393     }
 394
 395     system ( $cmd );
 396     if ($? != 0) {
 397         return -1;
 398     }
 399     return 0;
 400 }
 401
 402 sub PutLib ($)
 403 {
 404     my $self = shift;
 405     my $newlib = shift;
 406     my $tgtlib = shift;
 407     my $silent;
 408
 409     if (!defined $ENV{'ACE_TEST_VERBOSE'}) {
 410       $silent = "2> /dev/null"
 411     }
 412
 413     foreach my $lib (@{$PerlACE::TestTarget_Android::LIBS}) {
 414         if ($lib eq $newlib) {
 415             if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 416                 print STDERR "Duplicate lib $newlib\n";
 417             }
 418             return 0;
 419         }
 420     }
 421
 422     my $adb_process = $ENV{'ANDROID_SDK_ROOT'} . "/platform-tools/adb";
 423
 424     my $cmd = "$adb_process" . ' push '. "\"$newlib\" \"$tgtlib\" $silent";
 425
 426     if (defined $ENV{'ACE_TEST_VERBOSE'}) {
 427       print STDERR "PutLib cmd: $cmd\n";
 428     }
 429
 430     system ( $cmd );
 431     if ($? != 0) {
 432         return -1;
 433     }
 434
 435     # keep tabs on copied libs
 436     push(@{$PerlACE::TestTarget_Android::LIBS}, $newlib);
 437
 438     return 0;
 439 }
 440
 441 1;
 442