#!/usr/bin/env bash

# Function to extract APK from AAB using bundletool

# Usage: aabtoapk <input_aab_name> <output_name>

# Example: aabtoapk app-release lms-prod-2025-06-20

function aabtoapk() {

# Check if correct number of arguments provided

if [ $# -ne 2 ]; then

echo "Usage: aabtoapk <input_aab_name> <output_name>"

echo "Example: aabtoapk app-release output"

return 1

fi

local input_name="$1"

local output_name="$2"

local input_aab="${input_name}.aab"

local output_apks="${output_name}.apks"

local bundletool_path="~/app/bundletool.jar"

# Check if input AAB file exists

if [ ! -f "$input_aab" ]; then

echo "Error: Input file '$input_aab' not found!"

return 1

fi

# Check if bundletool exists

if [ ! -f ~/app/bundletool.jar ]; then

echo "Error: bundletool.jar not found at ~/app/bundletool.jar"

echo "Please download it first using:"

echo "wget https://github.com/google/bundletool/releases/download/1.15.6/bundletool-all-1.15.6.jar -O ~/app/bundletool.jar"

return 1

fi

echo "Converting $input_aab to APK..."

# Build APKs from AAB

echo "Step 1: Building APKs from AAB..."

java -jar ~/app/bundletool.jar build-apks \

--bundle="$input_aab" \

--output="$output_apks" \

--ks=keystoreMoodle.jks \

--ks-key-alias=keystoreMoodle \

--ks-pass=pass:123456 \

--key-pass=pass:123456 \

--mode=universal

if [ $? -ne 0 ]; then

echo "Error: Failed to build APKs from AAB"

return 1

fi

# Extract APKs and clean up

echo "Step 2: Extracting APKs..."

unzip "$output_apks" -d "$output_name"

rm "$output_apks" "$output_name/toc.pb"

if [ $? -ne 0 ]; then

echo "Error: Failed to extract APKs"

return 1

fi

# Rename universal.apk to match output name

if [ -f "${output_name}/universal.apk" ]; then

mv "${output_name}/universal.apk" "${output_name}/${output_name}.apk"

echo "Success! APK created at: ${output_name}/${output_name}.apk"

echo ""

echo "To install on device (with USB debugging enabled):"

echo "adb install ${output_name}/${output_name}.apk"

else

echo "Warning: universal.apk not found in extracted files"

echo "Available files in ${output_name}/${output_name}:"

ls -la "$output_name"

fi

# auto install the apk to attached device

if [ $? -eq 0 ]; then

echo ""

read -p "Do you want to install the APK on connected device? (y/n): " -n 1 -r

echo

if [[ $REPLY =~ ^[Yy]$ ]]; then

echo "Installing APK on device..."

adb install "${output_name}/${output_name}.apk"

if [ $? -eq 0 ]; then

echo "APK installed successfully!"

else

echo "Failed to install APK. Make sure USB debugging is enabled and device is connected."

fi

fi

fi

}

# Create a source.http from swagger.json file to use with rest.nvim

function swaggertohttp() {

local input_file="${1:-swagger.json}"

local output_file="${2:-source.http}"

if [[ ! -f "$input_file" ]]; then

echo "Error: Input file '$input_file' not found."

return 1

fi

# Initialize the output file with standard metadata

echo "@api = " >"$output_file"

echo "@token = " >>"$output_file"

# Extract all unique parameters from paths

unique_params=$(cat "$input_file" | jq -r '.paths | to_entries[] | .key | select(contains("{")) | capture("\\{(?<param>[^}]+)\\}") | .param' | sort -u)

# Add each unique parameter as a variable at the top

for param in $unique_params; do

echo "@$param = " >>"$output_file"

done

# Add a blank line after the variables

echo "" >>"$output_file"

# Create the endpoints in a temporary file

cat "$input_file" | jq -r '

.paths | to_entries[] | .key as $path | .value | to_entries[] |

($path

| sub("^/api/v1"; "{api}")

| sub("^/api"; "{api}")) as $normalized_path |

"###\n\(.key | ascii_upcase) \($normalized_path)\nAuthorization: Bearer {token}\n"

' >"$output_file.tmp"

# Transform parameters and append to the output file

sed -E 's/\{([^}]+)\}/\{\{\1\}\}/g' "$output_file.tmp" >>"$output_file"

rm "$output_file.tmp"

echo "Successfully converted $input_file to $output_file with $(grep -c '###' "$output_file") endpoints."

}

# Create a new tmux session with 4 default windows: vim, term(inal), git, apis

# at current working directory, the second parameter is the name of the session

function pj() {

tmux new-session -d -s "$1" -n vim \; \

new-window -n term 'bash' \; \

new-window -n git 'bash' \; \

new-window -n apis -c ~/project/apis-testing/ 'bash' \; \

select-window -t 2 \; \

attach

}

# Create a new directory and enter it

function mcd() {

mkdir -p "$@" && cd "$_"

}

# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression

function targz() {

local tmpFile="${@%/}.tar"

tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1

size=$(

stat -f"%z" "${tmpFile}" 2>/dev/null # macOS `stat`

stat -c"%s" "${tmpFile}" 2>/dev/null # GNU `stat`

)

local cmd=""

if ((size < 52428800)) && hash zopfli 2>/dev/null; then

# the .tar file is smaller than 50 MB and Zopfli is available; use it

cmd="zopfli"

else

if hash pigz 2>/dev/null; then

cmd="pigz"

else

cmd="gzip"

fi

fi

echo "Compressing .tar ($((size / 1000)) kB) using \`${cmd}\`…"

"${cmd}" -v "${tmpFile}" || return 1

[ -f "${tmpFile}" ] && rm "${tmpFile}"

zippedSize=$(

stat -f"%z" "${tmpFile}.gz" 2>/dev/null # macOS `stat`

stat -c"%s" "${tmpFile}.gz" 2>/dev/null # GNU `stat`

)

echo "${tmpFile}.gz ($((zippedSize / 1000)) kB) created successfully."

}

# Determine size of a file or total size of a directory

function fs() {

if du -b /dev/null >/dev/null 2>&1; then

local arg=-sbh

else

local arg=-sh

fi

if [[ -n "$@" ]]; then

du $arg -- "$@"

else

du $arg .[^.]* ./*

fi

}

# Use Git’s colored diff when available

hash git &>/dev/null

if [ $? -eq 0 ]; then

function diff() {

git diff --no-index --color-words "$@"

}

fi

# Create a data URL from a file

function dataurl() {

local mimeType=$(file -b --mime-type "$1")

if [[ $mimeType == text/* ]]; then

mimeType="${mimeType};charset=utf-8"

fi

echo "data:${mimeType};base64,$(openssl base64 -in "$1" | tr -d '\n')"

}

# Start an HTTP server from a directory, optionally specifying the port

function server() {

local port="${1:-8000}"

sleep 1 && xdg-open "http://localhost:${port}/" &

# Set the default Content-Type to `text/plain` instead of `application/octet-stream`

# And serve everything as UTF-8 (although not technically correct, this doesn’t break anything for binary files)

python3 -c $'import http.server;\nmap = http.server.SimpleHTTPRequestHandler.extensions_map;\nmap[""] = "text/plain";\nfor key, value in map.items():\n\tmap[key] = value + ";charset=UTF-8";\nhttp.server.test(HandlerClass=http.server.SimpleHTTPRequestHandler, port=int("'$port'"))'

}

# Start a PHP server from a directory, optionally specifying the port

# (Requires PHP 5.4.0+.)

function phpserver() {

local port="${1:-4000}"

local ip=$(ipconfig getifaddr en1)

sleep 1 && open "http://${ip}:${port}/" &

php -S "${ip}:${port}"

}

# Compare original and gzipped file size

function gz() {

local origsize=$(wc -c <"$1")

local gzipsize=$(gzip -c "$1" | wc -c)

local ratio=$(echo "$gzipsize * 100 / $origsize" | bc -l)

printf "orig: %d bytes\n" "$origsize"

printf "gzip: %d bytes (%2.2f%%)\n" "$gzipsize" "$ratio"

}

# Run `dig` and display the most useful info

function digga() {

dig +nocmd "$1" any +multiline +noall +answer

}

# Show all the names (CNs and SANs) listed in the SSL certificate

# for a given domain

function getcertnames() {

if [ -z "${1}" ]; then

echo "ERROR: No domain specified."

return 1

fi

local domain="${1}"

echo "Testing ${domain}…"

echo "" # newline

local tmp=$(echo -e "GET / HTTP/1.0\nEOT" |

openssl s_client -connect "${domain}:443" -servername "${domain}" 2>&1)

if [[ "${tmp}" = *"-----BEGIN CERTIFICATE-----"* ]]; then

local certText=$(echo "${tmp}" |

openssl x509 -text -certopt "no_aux, no_header, no_issuer, no_pubkey, \

no_serial, no_sigdump, no_signame, no_validity, no_version")

echo "Common Name:"

echo "" # newline

echo "${certText}" | grep "Subject:" | sed -e "s/^.*CN=//" | sed -e "s/\/emailAddress=.*//"

echo "" # newline

echo "Subject Alternative Name(s):"

echo "" # newline

echo "${certText}" | grep -A 1 "Subject Alternative Name:" |

sed -e "2s/DNS://g" -e "s/ //g" | tr "," "\n" | tail -n +2

return 0

else

echo "ERROR: Certificate not found."

return 1

fi

}

# Normalize `open` across Linux, macOS, and Windows.

# This is needed to make the `o` function (see below) cross-platform.

if [ ! $(uname -s) = 'Darwin' ]; then

if grep -q Microsoft /proc/version; then

# Ubuntu on Windows using the Linux subsystem

alias open='explorer.exe'

else

alias open='xdg-open'

fi

fi

# `o` with no arguments opens the current directory, otherwise opens the given

# location

function o() {

if [ $# -eq 0 ]; then

open .

else

open "$@"

fi

}

# `tre` is a shorthand for `tree` with hidden files and color enabled, ignoring

# the `.git` directory, listing directories first. The output gets piped into

# `less` with options to preserve color and line numbers, unless the output is

# small enough for one screen.

function tre() {

tree -aC -I '.git|node_modules|bower_components' --dirsfirst "$@" | less -FRNX

}