Introduction

Creating a custom APK installer for Android apps on Linux can be a convenient way to deploy applications without relying on the Google Play Store. This process involves several steps, including setting up the necessary development environment, compiling the APK, and configuring the installation package.

Prerequisites

Before starting, ensure you have the following:

  • A Linux system (Ubuntu or similar)
  • Android SDK tools installed (android, adb)
  • Java Development Kit (JDK) 8 or higher
  • Apache Ant or Gradle for building APKs

Setting up the Development Environment

Installing Required Packages

First, update your package list and install the necessary packages:

sudo apt-get update
sudo apt-get install android-sdk-platform-tools-common openjdk-8-jdk ant

Next, download and extract the Android SDK tools from the official website.

Configuring the Android SDK Tools

Create a new directory for the Android SDK tools and navigate to it in your terminal:

mkdir ~/android_sdk
cd ~/android_sdk

Extract the downloaded Android SDK tools archive into this directory. Then, configure the ~/.bashrc file by adding the following lines:

export ANDROID_HOME=~/android_sdk
export PATH=$PATH:$ANDROID_HOME/platform-tools:$ANDROID_HOME/tools

Re-source your shell configuration to apply these changes:

source ~/.bashrc

Compiling an APK

To compile an APK, you’ll need a Java project structure. Create a new directory for your project and navigate to it in the terminal:

mkdir my_app
cd my_app

Create a build.gradle file with the following contents:

apply plugin: 'com.android.application'

android {
    compileSdkVersion 29
    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"
    }
}

dependencies {
    implementation 'com.google.code.gson:gson:2.8.6'
}

Create a src/main/java/com/example/MyApp.java file with the following contents:

package com.example;

import android.app.Activity;
import android.os.Bundle;

public class MyApp extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Create a src/main/res/layout/activity_main.xml file with the following contents:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello, World!" />

</LinearLayout>

Finally, compile the APK using Gradle:

./gradlew assembleRelease

This will create a my_app-release.apk file in the build/outputs/apks/release/ directory.

Creating a Custom Installer

To create a custom installer, you’ll need to package the APK and any additional files into an executable package. Create a new directory for your installer project and navigate to it in the terminal:

mkdir my_installer
cd my_installer

Create a build.xml file with the following contents:

<?xml version="1.0" encoding="UTF-8"?>
<project name="my-installer" default="dist" basedir=".">
    <property name="src.dir" value="${basedir}/src"/>
    <property name="build.dir" value="${basedir}/build"/>
    <property name="dist.dir" value="${basedir}/dist"/>

    <target name="clean">
        <delete dir="${build.dir}"/>
        <delete dir="${dist.dir}"/>
    </target>

    <target name="compile" depends="clean">
        <mkdir dir="${build.dir}"/>
        <javac srcdir="${src.dir}" destdir="${build.dir}"/>
    </target>

    <target name="build" depends="compile">
        <zip zipfile="${dist.dir}/my-installer.zip">
            <fileset dir="${build.dir}">
                <include name="**/*.class"/>
            </fileset>
            <fileset dir="${basedir}">
                <include name="my_app-release.apk"/>
            </fileset>
        </zip>
    </target>

    <target name="dist" depends="build">
        <zip zipfile="${dist.dir}/my-installer.zip">
            <fileset dir="${dist.dir}">
                <include name="**/*.zip"/>
            </fileset>
        </zip>
    </target>
</project>

Create a src/main/java/com/example/MyInstaller.java file with the following contents:

package com.example;

import java.io.File;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class MyInstaller {
    public static void main(String[] args) throws IOException {
        // Create a new ZipOutputStream instance
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream("my-installer.jar"));

        // Add the APK file to the ZIP archive
        File apkFile = new File("my_app-release.apk");
        if (apkFile.exists()) {
            FileInputStream in = new FileInputStream(apkFile);
            zipOut.putNextEntry(new ZipEntry("my_app-release.apk"));
            byte[] buffer = new byte[1024];
            int len;
            while ((len = in.read(buffer)) > 0) {
                zipOut.write(buffer, 0, len);
            }
            in.close();
        }

        // Add any additional files to the ZIP archive
        File dir = new File("src/main/res/");
        if (dir.exists()) {
            File[] files = dir.listFiles();
            for (File file : files) {
                zipOut.putNextEntry(new ZipEntry(file.getName()));
                FileInputStream in = new FileInputStream(file);
                byte[] buffer = new byte[1024];
                int len;
                while ((len = in.read(buffer)) > 0) {
                    zipOut.write(buffer, 0, len);
                }
                in.close();
            }
        }

        // Close the ZipOutputStream instance
        zipOut.close();
    }
}

Finally, compile and package the installer using Ant:

ant dist

This will create a my-installer.jar file in the dist/ directory.

Conclusion

Creating a custom APK installer for Android apps on Linux requires setting up the necessary development environment, compiling the APK, and configuring the installation package. By following this guide, you should now have a basic understanding of how to create a custom APK installer using Ant or Gradle.

Note that this is just one possible approach to creating a custom APK installer, and there are many other ways to accomplish this task. Additionally, be sure to test your installer thoroughly before deploying it in production environments.