Android Use

#!/bin/bash
# Check if an Android device is connected via ADB
# Usage: check-device.sh [-s <serial>]
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: check-device.sh [-s <serial>]"; exit 1 ;;
    esac
done

# Check if adb is available
if ! command -v adb &> /dev/null; then
    echo "Error: adb is not installed or not in PATH"
    exit 1
fi

# Get list of connected devices
devices=$(adb devices | grep -v "List of devices" | grep -v "^$" | grep -v "offline")

if [ -z "$devices" ]; then
    echo "Error: No Android device connected"
    echo ""
    echo "Troubleshooting:"
    echo "1. Connect your device via USB"
    echo "2. Enable USB debugging in Developer Options"
    echo "3. Accept the 'Allow USB debugging?' prompt on device"
    echo "4. Run 'adb devices' to verify"
    exit 1
fi

# Count connected devices
device_count=$(echo "$devices" | wc -l | tr -d ' ')

if [ "$device_count" -gt 1 ]; then
    echo "Multiple devices connected ($device_count):"
    echo ""

    # List all devices with details
    while IFS= read -r line; do
        dev_serial=$(echo "$line" | awk '{print $1}')
        dev_state=$(echo "$line" | awk '{print $2}')

        if [ "$dev_state" = "device" ]; then
            dev_model=$(adb -s "$dev_serial" shell getprop ro.product.model 2>/dev/null | tr -d '\r')
            dev_type=$(adb -s "$dev_serial" shell getprop ro.build.characteristics 2>/dev/null | tr -d '\r')

            # Determine if emulator or physical device
            if [[ "$dev_serial" == emulator-* ]] || [[ "$dev_type" == *"emulator"* ]]; then
                dev_label="[EMULATOR]"
            else
                dev_label="[PHYSICAL]"
            fi

            echo "  $dev_label $dev_serial - $dev_model"
        else
            echo "  [OFFLINE]  $dev_serial - state: $dev_state"
        fi
    done <<< "$devices"

    echo ""

    if [ -z "$SERIAL" ]; then
        echo "Use -s <serial> to specify which device to use."
        echo "Example: check-device.sh -s $(echo "$devices" | head -1 | awk '{print $1}')"
        exit 1
    fi
fi

# If serial specified, verify it exists
if [ -n "$SERIAL" ]; then
    if ! echo "$devices" | grep -q "^$SERIAL"; then
        echo "Error: Device '$SERIAL' not found"
        echo ""
        echo "Available devices:"
        echo "$devices" | awk '{print "  " $1}'
        exit 1
    fi
    device_serial="$SERIAL"
else
    # Use first device
    device_serial=$(echo "$devices" | head -1 | awk '{print $1}')
fi

device_state=$(echo "$devices" | grep "^$device_serial" | awk '{print $2}')

if [ "$device_state" != "device" ]; then
    echo "Error: Device '$device_serial' is in state '$device_state' (expected 'device')"
    exit 1
fi

# Get device model and info
device_model=$(adb -s "$device_serial" shell getprop ro.product.model 2>/dev/null | tr -d '\r')
android_version=$(adb -s "$device_serial" shell getprop ro.build.version.release 2>/dev/null | tr -d '\r')
dev_type=$(adb -s "$device_serial" shell getprop ro.build.characteristics 2>/dev/null | tr -d '\r')

# Determine device type
if [[ "$device_serial" == emulator-* ]] || [[ "$dev_type" == *"emulator"* ]]; then
    device_type="Emulator"
else
    device_type="Physical"
fi

echo "Device connected: $device_model"
echo "Serial: $device_serial"
echo "Type: $device_type"
echo "Android: $android_version"
echo "Status: Ready"

#!/bin/bash
# Dump the current UI hierarchy (accessibility tree) from the Android device
# Usage: get-screen.sh [-s <serial>]
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: get-screen.sh [-s <serial>]"; exit 1 ;;
    esac
done

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

# Paths
DEVICE_PATH="/sdcard/window_dump.xml"
LOCAL_PATH="/tmp/android_ui_dump.xml"

# Dump UI hierarchy on device
$ADB_CMD shell uiautomator dump "$DEVICE_PATH" > /dev/null 2>&1

# Pull the file
$ADB_CMD pull "$DEVICE_PATH" "$LOCAL_PATH" > /dev/null 2>&1

# Clean up device file
$ADB_CMD shell rm -f "$DEVICE_PATH" > /dev/null 2>&1

# Output the XML content
cat "$LOCAL_PATH"

#!/bin/bash
# Install an APK file to the Android device
# Usage: install-apk.sh [-s <serial>] <path_to_apk>
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: install-apk.sh [-s <serial>] <path_to_apk>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -ne 1 ]; then
    echo "Usage: install-apk.sh [-s <serial>] <path_to_apk>"
    echo "Example: install-apk.sh /path/to/app.apk"
    echo "Example: install-apk.sh -s emulator-5554 /path/to/app.apk"
    exit 1
fi

apk_path="$1"

# Check if file exists
if [ ! -f "$apk_path" ]; then
    echo "Error: APK file not found: $apk_path"
    exit 1
fi

# Check if it's an APK file
if [[ ! "$apk_path" == *.apk ]]; then
    echo "Warning: File does not have .apk extension"
fi

# Get file size
file_size=$(ls -lh "$apk_path" | awk '{print $5}')
echo "Installing APK: $apk_path"
echo "Size: $file_size"
echo ""

# Install the APK
# -r: replace existing application
# -t: allow test packages
# -d: allow version code downgrade
result=$($ADB_CMD install -r "$apk_path" 2>&1)

if echo "$result" | grep -q "Success"; then
    echo "Installation successful!"

    # Try to get the package name from the APK
    if command -v aapt &> /dev/null; then
        package=$(aapt dump badging "$apk_path" 2>/dev/null | grep "package:" | sed "s/.*name='//" | sed "s/'.*//")
        if [ -n "$package" ]; then
            echo "Package: $package"
        fi
    fi
else
    echo "Installation failed!"
    echo "$result"
    exit 1
fi

#!/bin/bash
# Press a key on the Android device
# Usage: key.sh [-s <serial>] <keyname>
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: key.sh [-s <serial>] <keyname>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -ne 1 ]; then
    echo "Usage: key.sh [-s <serial>] <keyname>"
    echo "Keys: home, back, enter, recent, menu, search, power, volume_up, volume_down, tab, delete"
    echo "Example: key.sh home"
    echo "Example: key.sh -s 1A051FDF6007PA back"
    exit 1
fi

keyname="$1"

# Map key names to Android keycodes
case "$keyname" in
    home)
        keycode=3
        ;;
    back)
        keycode=4
        ;;
    enter|return)
        keycode=66
        ;;
    recent|recents|overview)
        keycode=187
        ;;
    menu)
        keycode=82
        ;;
    search)
        keycode=84
        ;;
    power)
        keycode=26
        ;;
    volume_up|vol_up)
        keycode=24
        ;;
    volume_down|vol_down)
        keycode=25
        ;;
    tab)
        keycode=61
        ;;
    delete|del|backspace)
        keycode=67
        ;;
    space)
        keycode=62
        ;;
    escape|esc)
        keycode=111
        ;;
    dpad_up)
        keycode=19
        ;;
    dpad_down)
        keycode=20
        ;;
    dpad_left)
        keycode=21
        ;;
    dpad_right)
        keycode=22
        ;;
    dpad_center)
        keycode=23
        ;;
    *)
        # Check if it's a numeric keycode
        if [[ "$keyname" =~ ^[0-9]+$ ]]; then
            keycode=$keyname
        else
            echo "Error: Unknown key '$keyname'"
            echo "Available keys: home, back, enter, recent, menu, search, power, volume_up, volume_down, tab, delete, space, escape"
            echo "Or use numeric keycode directly"
            exit 1
        fi
        ;;
esac

$ADB_CMD shell input keyevent "$keycode"

echo "Pressed $keyname (keycode $keycode)"

#!/bin/bash
# Launch an app on the Android device by package name or app name
# Usage: launch-app.sh [-s <serial>] <package_name_or_app_name>
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: launch-app.sh [-s <serial>] <package_name_or_app_name>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -lt 1 ]; then
    echo "Usage: launch-app.sh [-s <serial>] <package_name_or_app_name>"
    echo "Examples:"
    echo "  launch-app.sh com.android.chrome"
    echo "  launch-app.sh Chrome"
    echo "  launch-app.sh -s emulator-5554 settings"
    exit 1
fi

app="$1"

# Convert to lowercase for matching
app_lower=$(echo "$app" | tr '[:upper:]' '[:lower:]')

# Map common app names to package names
get_package() {
    case "$1" in
        chrome) echo "com.android.chrome" ;;
        settings) echo "com.android.settings" ;;
        phone|dialer) echo "com.android.dialer" ;;
        messages|sms) echo "com.google.android.apps.messaging" ;;
        camera) echo "com.android.camera" ;;
        photos) echo "com.google.android.apps.photos" ;;
        gmail) echo "com.google.android.gm" ;;
        maps) echo "com.google.android.apps.maps" ;;
        youtube) echo "com.google.android.youtube" ;;
        playstore|play_store) echo "com.android.vending" ;;
        calendar) echo "com.google.android.calendar" ;;
        clock) echo "com.google.android.deskclock" ;;
        calculator) echo "com.google.android.calculator" ;;
        contacts) echo "com.android.contacts" ;;
        files) echo "com.google.android.documentsui" ;;
        whatsapp) echo "com.whatsapp" ;;
        instagram) echo "com.instagram.android" ;;
        facebook) echo "com.facebook.katana" ;;
        twitter|x) echo "com.twitter.android" ;;
        spotify) echo "com.spotify.music" ;;
        netflix) echo "com.netflix.mediaclient" ;;
        telegram) echo "org.telegram.messenger" ;;
        discord) echo "com.discord" ;;
        slack) echo "com.Slack" ;;
        zoom) echo "us.zoom.videomeetings" ;;
        teams) echo "com.microsoft.teams" ;;
        outlook) echo "com.microsoft.office.outlook" ;;
        drive) echo "com.google.android.apps.docs" ;;
        keep|notes) echo "com.google.android.keep" ;;
        *) echo "" ;;
    esac
}

# Check if it's a known app name
package=$(get_package "$app_lower")

if [ -n "$package" ]; then
    echo "Resolved '$app' to package: $package"
elif [[ "$app" == *"."* ]]; then
    # Looks like a package name (contains dots)
    package="$app"
else
    # Try to find the package by searching installed apps
    echo "Searching for app: $app"

    # Get list of installed packages and their labels
    matches=$($ADB_CMD shell pm list packages 2>/dev/null | grep -i "$app" | head -5)

    if [ -z "$matches" ]; then
        echo "Error: Could not find app '$app'"
        echo ""
        echo "Try using the full package name, e.g.:"
        echo "  com.example.myapp"
        echo ""
        echo "Or use one of these common app names:"
        echo "  chrome, settings, messages, camera, photos, gmail, maps, youtube"
        echo "  instagram, whatsapp, facebook, twitter, spotify, telegram, discord"
        exit 1
    fi

    # Extract first matching package
    package=$(echo "$matches" | head -1 | sed 's/package://')

    if [ -z "$package" ]; then
        echo "Error: Could not parse package from matches"
        echo "Matches found:"
        echo "$matches"
        exit 1
    fi

    echo "Found package: $package"
fi

# Launch the app
echo "Launching $package..."

# Method 1: Use monkey to launch (most reliable)
result=$($ADB_CMD shell monkey -p "$package" -c android.intent.category.LAUNCHER 1 2>&1)

if echo "$result" | grep -q "No activities found"; then
    # Method 2: Try am start with action MAIN
    echo "Trying alternative launch method..."
    $ADB_CMD shell am start -a android.intent.action.MAIN -c android.intent.category.LAUNCHER "$package" 2>/dev/null || {
        echo "Error: Failed to launch $package"
        echo "The app may not be installed or may not have a launcher activity."
        exit 1
    }
fi

echo "Launched: $package"

#!/bin/bash
# Take a screenshot of the Android device
# Usage: screenshot.sh [-s <serial>]
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: screenshot.sh [-s <serial>]"; exit 1 ;;
    esac
done

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

# Paths
DEVICE_PATH="/sdcard/screen.png"
LOCAL_DIR="/tmp"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LOCAL_PATH="$LOCAL_DIR/android_screenshot_$TIMESTAMP.png"

# Take screenshot on device
$ADB_CMD shell screencap -p "$DEVICE_PATH"

# Pull to local
$ADB_CMD pull "$DEVICE_PATH" "$LOCAL_PATH" > /dev/null 2>&1

# Clean up device file
$ADB_CMD shell rm -f "$DEVICE_PATH" > /dev/null 2>&1

echo "Screenshot saved: $LOCAL_PATH"
echo ""
echo "Use the Read tool to view this image."

#!/bin/bash
# Swipe in a direction on the Android device
# Usage: swipe.sh [-s <serial>] <direction>
#   -s <serial>  Target specific device by serial number
#   direction: up, down, left, right

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: swipe.sh [-s <serial>] <direction>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -ne 1 ]; then
    echo "Usage: swipe.sh [-s <serial>] <direction>"
    echo "Directions: up, down, left, right"
    echo "Example: swipe.sh up"
    echo "Example: swipe.sh -s emulator-5554 down"
    exit 1
fi

direction="$1"

# Get screen dimensions
screen_size=$($ADB_CMD shell wm size | grep -oE '[0-9]+x[0-9]+' | head -1)
width=$(echo "$screen_size" | cut -d'x' -f1)
height=$(echo "$screen_size" | cut -d'x' -f2)

# Calculate center and edges
center_x=$((width / 2))
center_y=$((height / 2))

# Swipe margins (20% from edges)
margin_x=$((width / 5))
margin_y=$((height / 5))

# Swipe duration in milliseconds
duration=300

case "$direction" in
    up)
        # Swipe up (scrolls content down)
        x1=$center_x
        y1=$((height - margin_y))
        x2=$center_x
        y2=$margin_y
        ;;
    down)
        # Swipe down (scrolls content up)
        x1=$center_x
        y1=$margin_y
        x2=$center_x
        y2=$((height - margin_y))
        ;;
    left)
        # Swipe left
        x1=$((width - margin_x))
        y1=$center_y
        x2=$margin_x
        y2=$center_y
        ;;
    right)
        # Swipe right
        x1=$margin_x
        y1=$center_y
        x2=$((width - margin_x))
        y2=$center_y
        ;;
    *)
        echo "Error: Unknown direction '$direction'"
        echo "Use: up, down, left, right"
        exit 1
        ;;
esac

$ADB_CMD shell input swipe "$x1" "$y1" "$x2" "$y2" "$duration"

echo "Swiped $direction (from $x1,$y1 to $x2,$y2)"

#!/bin/bash
# Tap at the specified x,y coordinates on the Android device
# Usage: tap.sh [-s <serial>] <x> <y>
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: tap.sh [-s <serial>] <x> <y>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -ne 2 ]; then
    echo "Usage: tap.sh [-s <serial>] <x> <y>"
    echo "Example: tap.sh 540 960"
    echo "Example: tap.sh -s emulator-5554 540 960"
    exit 1
fi

x="$1"
y="$2"

# Validate coordinates are numbers
if ! [[ "$x" =~ ^[0-9]+$ ]] || ! [[ "$y" =~ ^[0-9]+$ ]]; then
    echo "Error: Coordinates must be positive integers"
    exit 1
fi

$ADB_CMD shell input tap "$x" "$y"

echo "Tapped at ($x, $y)"

#!/bin/bash
# Type text on the Android device
# Handles special characters by escaping them properly
# Usage: type-text.sh [-s <serial>] <text>
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: type-text.sh [-s <serial>] <text>"; exit 1 ;;
    esac
done
shift $((OPTIND - 1))

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

if [ $# -lt 1 ]; then
    echo "Usage: type-text.sh [-s <serial>] <text>"
    echo "Example: type-text.sh \"Hello World\""
    echo "Example: type-text.sh -s 1A051FDF6007PA \"Hello World\""
    exit 1
fi

text="$*"

# For simple alphanumeric text, use input text directly
# For complex text with special chars, escape them

# Check if text contains only simple characters
if [[ "$text" =~ ^[a-zA-Z0-9]+$ ]]; then
    # Simple text - use input text
    $ADB_CMD shell input text "$text"
else
    # Complex text - escape special characters for shell
    # Replace spaces with %s (ADB convention)
    escaped="${text// /%s}"

    # Escape shell special characters
    escaped="${escaped//\'/\\\'}"
    escaped="${escaped//\"/\\\"}"
    escaped="${escaped//\\/\\\\}"
    escaped="${escaped//\(/\\\(}"
    escaped="${escaped//\)/\\\)}"
    escaped="${escaped//\&/\\\&}"
    escaped="${escaped//\|/\\\|}"
    escaped="${escaped//\;/\\\;}"
    escaped="${escaped//\</\\\<}"
    escaped="${escaped//\>/\\\>}"
    escaped="${escaped//\$/\\\$}"
    escaped="${escaped//\`/\\\`}"

    $ADB_CMD shell input text "$escaped"
fi

echo "Typed: $text"

#!/bin/bash
# Wake up the Android device and dismiss lock screen
# Usage: wake.sh [-s <serial>]
#   -s <serial>  Target specific device by serial number

set -e

# Parse arguments
SERIAL=""
ADB_CMD="adb"

while getopts "s:" opt; do
    case $opt in
        s) SERIAL="$OPTARG" ;;
        *) echo "Usage: wake.sh [-s <serial>]"; exit 1 ;;
    esac
done

# Build ADB command with optional serial
if [ -n "$SERIAL" ]; then
    ADB_CMD="adb -s $SERIAL"
fi

# Check if screen is on or off
# mScreenState=ON or mScreenState=OFF (varies by Android version)
screen_state=$($ADB_CMD shell "dumpsys display | grep -E 'mScreenState|Display Power: state'" 2>/dev/null | head -1)

is_screen_on() {
    if echo "$screen_state" | grep -qiE "ON|BRIGHT"; then
        return 0
    else
        return 1
    fi
}

if is_screen_on; then
    echo "Screen already on"
else
    echo "Screen is off, waking device..."

    # Send WAKEUP keyevent (224)
    $ADB_CMD shell input keyevent 224

    # Brief wait for screen to turn on
    sleep 0.5

    # Get screen dimensions for swipe
    size=$($ADB_CMD shell wm size | grep -oE '[0-9]+x[0-9]+' | tail -1)
    width=$(echo "$size" | cut -d'x' -f1)
    height=$(echo "$size" | cut -d'x' -f2)

    # Calculate swipe coordinates (bottom center to middle)
    center_x=$((width / 2))
    start_y=$((height * 4 / 5))
    end_y=$((height / 3))

    # Swipe up to dismiss lock screen (works for swipe-to-unlock)
    # Won't bypass PIN/pattern/password - user must handle that
    $ADB_CMD shell input swipe $center_x $start_y $center_x $end_y 300

    sleep 0.3

    echo "Woke device and dismissed lock screen"
fi

# Verify final state
final_state=$($ADB_CMD shell "dumpsys display | grep -E 'mScreenState|Display Power: state'" 2>/dev/null | head -1)
if echo "$final_state" | grep -qiE "ON|BRIGHT"; then
    echo "Status: Screen is now on"
else
    echo "Status: Screen may still be off (check for PIN/pattern lock)"
fi