Android-Build
view release on metacpan or search on metacpan
lib/Android/Build.pm view on Meta::CPAN
if (1) # Create apk and sign
{zzz("mv $api $apj"); # Create apk
zzz("cd $bin && zip -qv $apj classes.dex"); # Add dexed classes
}
my $assetsFolder = $android->getAssFolder;
my $assetsFiles = $android->assets; # Create asset files if necessary
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 $@;
}
undef # No errors encountered
}
sub cloneApk($$) # Clone an apk file: copy the existing apk, replace the L<assets|/assets>, re-sign, zipalign, return the name of the newly created apk file.
{my ($android, $oldApk) = @_; # Android build, the file name of the apk to be cloned
&cloneApk2(@_);
}
sub lint($) # Lint all the Java source code files for the app.
{my ($android) = @_; # Android build
eval {&lint2(@_)};
if ($@)
{$android->logMessage($@);
return $@;
}
undef # No errors encountered
}
sub install($) # Install an already L<compiled|/compile> app on to the selected L<device|/device>
{my ($android) = @_; # Android build
eval {&install2(@_)};
if ($@)
{$android->logMessage($@);
return $@;
}
undef # No errors encountered
}
sub run($) # L<Compile|/compile> the app, L<install|/install> and then run it on the selected L<device|/device>
{my ($android) = @_; # Android build
for(qw(compile install)) # Compile, install and run
{my $r = $android->$_;
return $r if $r;
}
undef # No errors encountered
}
# podDocumentation
=encoding utf-8
=head1 Name
Android::Build - Lint, compile, install, run an Android app using the command line tools minus Ant and Gradle thus freeing development effort from the strictures imposed by Android Studio.
=head1 Synopsis
You can see Android::Build in action in GitHub Actions at the end of:
L<https://github.com/philiprbrenan/AppaAppsGitHubPhotoApp/blob/main/genApp.pm>
=head2 Prerequisites
sudo apt-get install imagemagick zip openjdk-8-jdk openjdk-8-jre
sudo cpan install Data::Table::Text Data::Dump Carp POSIX File::Copy;
You will need a version of the
L<Android Build Tools|https://developer.android.com/studio/index.html>
as specified right at the end of the page below all the inappropriate
advertising for Android Studio.
Download:
wget https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip
and unzip to get a copy of B<sdkmanager> which can be used to get the version of
the SDK that you want to use, for example:
sdkmanager --list --verbose
Download the SDK components to be used:
(cd android/sdk/; tools/bin/sdkmanager \
echo 'y' | android/sdk/tools/bin/sdkmanager \
'build-tools;25.0.3' emulator 'platform-tools' \
'platforms;android-25' 'system-images;android-25;google_apis;x86_64')
Add to these components to the B<$PATH> variable for easy command line use:
export PATH=$PATH:~/android/sdk/tools/:~/android/sdk/tools/bin:\
~/android/sdk/platform-tools/:~/android/sdk/build-tools/25.0.3
Create an AVD:
avdmanager create avd --name aaa \
-k 'system-images;android-25;google_apis;x86_64' -g google_apis
Start the B<AVD> with a specified screen size (you might need to go into the
B<android/sdk/tools> folder):
( run in 1.779 second using v1.01-cache-2.11-cpan-df04353d9ac )