Android-Build
view release on metacpan or search on metacpan
lib/Android/Build.pm view on Meta::CPAN
sub getLintFile # Name of the file to be linted
{my ($a) = @_;
my $f = $a->lintFileX;
$f or confess <<END;
"lintFile" parameter required to lint a file
END
-e $f or confess <<END;
File to be linted does not exist:
$f
END
$f
}
sub getActivity # Activity for app
{my ($a) = @_;
$a->activity // 'Activity';
}
sub getAppName # Single word name of app used to construct file names
{my ($a) = @_;
my $d = $a->getPackage;
(split /\./, $d)[-1];
}
sub getTitle # Title of app
{my ($a) = @_;
$a->title // $a->getAppName;
}
sub apkFileName # Apk name - shorn of path
{my ($a) = @_;
$a->getAppName.'.apk';
}
sub apk # Apk name - with full path
{my ($a) = @_;
$a->getBinFolder.$a->apkFileName;
}
sub getVersion # Version of the app or default to today's date
{my ($a) = @_;
$a->version // $version;
}
sub buildArea($) # Build folder name
{my ($a) = @_;
$a->buildFolder // '/tmp/app/' # Either the user supplied build folder name or the default
}
sub getAssFolder($) {my ($a) = @_; $a->buildArea.'assets/'} # Assets folder name
sub getBinFolder($) {my ($a) = @_; $a->buildArea.'bin/'} # Bin folder name
sub getGenFolder($) {my ($a) = @_; $a->buildArea.'gen/'} # Gen folder name
sub getResFolder($) {my ($a) = @_; $a->buildArea.'res/'} # Res folder name
sub getManifestFile($) {my ($a) = @_; $a->buildArea.'AndroidManifest.xml'} # Name of manifest file
sub logMessage($@) # Log a message
{my ($android, @message) = @_;
my $s = join '', grep {$_} @message;
chomp($s) if $s =~ /\n\Z/;
push @{$android->log}, $s;
say STDERR $s if -t STDERR;
}
#-------------------------------------------------------------------------------
# Create icons for app
#-------------------------------------------------------------------------------
sub pushIcon # Create and transfer each icon using Imagemagick
{my ($android, $icon, $size, $dir) = @_;
my $res = $android->getResFolder;
my $man = $android->getManifestFile;
for my $i(qw(ic_launcher))
{for my $d(qw(drawable))
{my $s = $size;
my $T = $res.$d.'-'.$dir.'dpi/'.$i.'.png';
makePath($T);
unlink $T;
my $c = "convert -strip \"$icon\" -resize ${s}x${s}! \"$T\""; # Convert icon to required size and make it square
my $r = zzz($c);
# say STDERR dump([$c, $icon, $T, -e $T, fileSize($T), $r ]);
confess "Unable to create icon:\n$T\n$r\n" # Check icon was created
if $r or !-e $T or fileSize($T) < 10;
}
}
}
sub pushIcons # Create icons possibly in parallel
{my ($android) = @_;
my $icon = $android->iconX;
-e $icon or confess "Cannot find icon file:\n$icon\n";
my @pid;
my @i = ([48, "m"], [72, "h"], [96, "xh"], [144, "xxh"]); # Icon specifications
if ($android->fastIcons) # Speed up - but it does produce a lot of error messages
{for(@i)
{if (my $pid = fork())
{push @pid, $pid
}
else
{eval {$android->pushIcon($icon, @$_)};
exit;
}
}
waitpid($_, 0) for @pid;
}
else
{$android->pushIcon($icon, @$_) for @i;
}
}
#-------------------------------------------------------------------------------
# Create manifest for app
#-------------------------------------------------------------------------------
sub addPermissions # Create permissions
{my ($android) = @_;
my $P = "android.permission";
my %p = (map {$_=>1} @{$android->permissions});
my $p = "\n";
for(sort keys %p)
{$p .= " <uses-permission android:name=\"$P.$_\"/>\n";
}
$p
}
sub manifest
{my ($android) = @_;
my $permissions = $android->addPermissions;
my ($minSdk, $targetSdk) = $android->getSDKLevels;
my $package = $android->getPackage;
my $version = $android->getVersion;
my $man = $android->getManifestFile;
my $activity = $android->activityX;
my $manifest = << "END";
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="$package"
lib/Android/Build.pm view on Meta::CPAN
if ($assetsFiles or -d $assetsFolder) # Create asset files if necessary
{writeFiles($assetsFiles, $assetsFolder) if $assetsFiles; # Write assets file system hash if supplied
zzz(qq(cd $assetsFolder && cd .. && zip -rv $apj assets)); # Add assets to apk
}
$android->signApkFile($apj); # Sign the apk file
zzz("$zipAlign -f 4 $apj $apk"); # Zip align
unlink $_ for $api, $apj; # Remove intermediate apks
}
sub cloneApk2($$) # Clone an apk file: copy the apk, replace the L<assets|assets/>, re-sign, zipalign, return the name of the newly created apk file.
{my ($android, $oldApk) = @_; # Android, file name of apk to be cloned
$android->confirmRequiredUtilitiesAreInPosition;
confess "Old apk file name not supplied\n" unless $oldApk;
confess "Old apk does not exist:\n$oldApk\n" unless -e $oldApk;
my $buildTools = $android->getBuildTools;
my $zipAlign = filePath($buildTools, qw(zipalign));
my $tempFolder = temporaryFolder; # Temporary folder to unzip into
zzz(<<"END", 0, 0, "Unable to unzip"); # Unzip old apk
unzip -o $oldApk -d $tempFolder -x "assets/*" "META-INF/*"
END
if (my $assetsFiles = $android->assets) # Create asset files if necessary
{my $assetsFolder = fpd($tempFolder, q(assets));
writeFiles($assetsFiles, $assetsFolder);
}
my $tmpApk = fpe(temporaryFile, q(apk)); # Temporary Apk
zzz(qq(cd $tempFolder && zip -rv $tmpApk *), 0, 0, "Unable to rezip"); # Recreate apk
$android->signApkFile($tmpApk); # Sign
my $newApk = fpe(temporaryFile, q(apk)); # New apk
zzz("$zipAlign -f 4 $tmpApk $newApk", 0, 0, "Unable to zipalign"); # Zip align
unlink $tmpApk; # Clean up
clearFolder($tempFolder, 100);
return $newApk;
}
sub compile2($) #P Compile the app
{my ($android) = @_; # Android build
$android->create;
$android->make; # Compile the app
}
sub install2($) #P Install an already L<compiled|/compile> app on the selected L<device|/device>:
{my ($android) = @_; # Android build
my $apk = $android->apk;
my $device = $android->getDevice;
my $package = $android->getPackage;
my $activity = $android->activityX;
my $adb = $android->getAdb." $device ";
# say STDERR "Install app";
zzz("$adb install -r $apk");
# say STDERR "Start app";
zzz("$adb shell am start $package/.Activity");
# say STDERR "App installed and started";
}
sub lint2($) #P Lint all the source code java files for the app
{my ($android) = @_; # Android build
my $src = $android->getLintFile;
my $androidJar = $android->getAndroidJar;
my $area = $android->classes // 'Classes';
makePath($area);
zzz("javac *.java -d $area -cp $androidJar:$area"); # Android, plus locally created classes
}
#1 Methods and attributes
sub new() #S Create a new build.
{bless{action =>qq(run),
activity =>qw(Activity),
device =>qq(emulator-5554),
home =>$home,
icon =>'icon.png',
log =>[],
parameters =>'',
permissions=>$permissions,
version =>$version};
}
if (1) { # Parameters that can be set by the caller - see the pod at the end of this file for a complete description of what each parameter does
genLValueScalarMethods(qw(activity)); # Activity name: default is B<Activity>. The name of the activity to start on your android device: L<device|/device> is L<package|/package>/L<Activity|/Activity>
genLValueScalarMethods(qw(assets)); # A hash containing your assets folder (if any). Each key is the file name in the assets folder, each corresponding value is the data for that file. The keys of this has...
genLValueScalarMethods(qw(buildTools)); # Name of the folder containing the build tools to be used to build the app, see L<prerequisites|/prerequisites>
genLValueScalarMethods(qw(buildFolder)); # Name of a folder in which to build the app, The default is B</tmp/app/>. If you wish to include assets with your app, specify a named build folder and load it with the ...
genLValueScalarMethods(qw(classes)); # A folder containing precompiled java classes and jar files that you wish to L<lint|/lint> against.
genLValueScalarMethods(qw(debug)); # The app will be debuggable if this option is true.
genLValueScalarMethods(qw(device)); # Device to run on, default is the only emulator or specify '-d', '-e', or '-s SERIAL' per L<adb|http://developer.android.com/guide/developing/tools/adb.html>
genLValueScalarMethods(qw(fastIcons)); # Create icons in parallel if true - the default is to create them serially which takes more elapsed time.
genLValueScalarMethods(qw(icon)); # Jpg file containing a picture that will be converted and scaled by L<ImageMagick|http://imagemagick.org/script/index.php> to make an icon for the app, default is B<icon...
genLValueScalarMethods(qw(keyAlias)); # Alias of the key in your key store file which will be used to sign this app. See L<Signing key|/Signing key> for how to generate a key.
genLValueScalarMethods(qw(keyStoreFile)); # Name of your key store file. See L<Signing key|/Signing key> for how to generate a key.
genLValueScalarMethods(qw(keyStorePwd)); # Password of your key store file. See L<Signing key|/Signing key> for how to generate a key.
genLValueArrayMethods (qw(libs)); # A reference to an array of jar files to be copied into the app build to be used as libraries.
genLValueScalarMethods(qw(lintFile)); # A file to be linted with the L<lint|/lint> action using the android L<platform|/platform> and the L<classes|/classes> specified.
genLValueArrayMethods (qw(log)); # Output: a reference to an array of messages showing all the non fatal errors produced by this running this build. To catch fatal error enclose L<build|/build> with L<ev...
genLValueScalarMethods(qw(package)); # The package name used in the manifest file to identify the app. The java file containing the L<activity|/activity> for this app should use this package name on its B<pa...
genLValueScalarMethods(qw(parameters)); # Optional parameter string to be placed in folder: B<res> as a string accessible via: B<R.string.parameters> from within the app. Alternatively, if this is a reference t...
genLValueArrayMethods (qw(permissions)); # A reference to an array of permissions, a standard useful set is applied by default if none are specified.
genLValueScalarMethods(qw(platform)); # Folder containing B<android.jar>. For example B<~/Android/sdk/platforms/25.0.2>
genLValueScalarMethods(qw(platformTools)); # Folder containing L<adb|https://developer.android.com/studio/command-line/adb.html>
genLValueArrayMethods (qw(sdkLevels)); # [minSdkVersion, targetSdkVersion], default is [15, 25]
genLValueArrayMethods (qw(src)); # A reference to an array of java source files to be compiled to create this app.
genLValueScalarMethods(qw(title)); # Title of app, the default is the L<package|/package> name of the app.
genLValueScalarMethods(qw(titles)); # A hash of translated titles: {ISO::639 2 digit language code=>title in that language}* for this app.
genLValueScalarMethods(qw(verifyApk)); # Verify the signed apk if this is true.
genLValueScalarMethods(qw(version)); # The version number of the app. Default is today's date, formatted as B<YYYYMMDD>
}
sub compile($) # Compile the app.
{my ($android) = @_; # Android build
eval {&compile2(@_)};
if ($@)
{$android->logMessage($@);
return $@;
( run in 0.313 second using v1.01-cache-2.11-cpan-483215c6ad5 )