functestlib: move Bluetooth-specific logic to lib_bluetooth

Drop duplicated BT helpers in favour of lib_bluetooth.sh implementations.
Retain only generic logging, dependency, and common infra helpers here.
Update callers to source lib_bluetooth.sh for adapter/scan operations.
No change to existing test result (.res) handling semantics.

Signed-off-by: Srikanth Muppandam <[email protected]>

Author: smuppand

Runner/utils/functestlib.sh

@@ -1615,377 +1615,6 @@ EOF
     return 0
 }
 
-# Remove paired BT device by MAC
-bt_cleanup_paired_device() {
-    mac="$1"
-    log_info "Removing paired device: $mac"
- 
-    # Non-interactive remove to avoid “AlreadyExists”
-    bluetoothctl remove "$mac" >/dev/null 2>&1 || true
- 
-    # Full Expect cleanup (captures transcript in a logfile)
-    cleanup_log="bt_cleanup_${mac}_$(date +%Y%m%d_%H%M%S).log"
-    if expect <<EOF >"$cleanup_log" 2>&1
-log_user 1
-spawn bluetoothctl
-set timeout 10
- 
-# Match the prompt once, then send all commands in sequence
-expect -re "#|\\[.*\\]#" {
-    send "power on\r"
-    send "agent off\r"
-    send "agent NoInputNoOutput\r"
-    send "default-agent\r"
-    send "remove $mac\r"
-    send "quit\r"
-}
- 
-expect eof
-EOF
-    then
-        log_info "Device $mac removed successfully (see $cleanup_log)"
-    else
-        log_warn "Failed to remove device $mac (see $cleanup_log)"
-    fi
-}
-
-# Retry a shell command N times with sleep
-retry_command_bt() {
-    cmd="$1"
-    msg="$2"
-    max="${3:-3}"
-    count=1
-    while [ "$count" -le "$max" ]; do
-        if eval "$cmd"; then
-            return 0
-        fi
-        log_warn "Retry $count/$max failed: $msg"
-        count=$((count + 1))
-        sleep 2
-    done
-    return 1
-}
-
-# Check if a device (MAC or Name) is in the whitelist
-bt_in_whitelist() {
-    device_name="$1"
-    device_mac="$2"
-
-    whitelist_value="${WHITELIST:-}"
-    log_info "Checking if MAC='$device_mac' or NAME='$device_name' is in whitelist: '$whitelist_value'"
-
-    echo "$whitelist_value" | tr -s ' ' '\n' | while IFS= read -r allowed; do
-        if [ "$allowed" = "$device_mac" ] || [ "$allowed" = "$device_name" ]; then
-            log_info "MAC or NAME matched and allowed: $allowed"
-            return 0
-        fi
-    done
-
-    log_info "MAC matched but neither MAC nor NAME in whitelist"
-    return 1
-}
-# bt_parse_whitelist <whitelist_file>
-# Reads a whitelist file where each line has:
-bt_parse_whitelist() {
-    WHITELIST_ENTRIES=""
-    if [ -n "$1" ] && [ -f "$1" ]; then
-        while IFS= read -r line || [ -n "$line" ]; do
-            case "$line" in
-                ""|\#*) continue ;;  # Skip blank lines and comments
-                *) WHITELIST_ENTRIES="${WHITELIST_ENTRIES}${line}
-" ;;
-            esac
-        done < "$1"
-    fi
-}
-
-# bt_in_whitelist <mac> <name>
-# Checks if a given device (MAC and optional name) exists
-# Returns:
-#     0 (success) if found
-#     1 (failure) if not found
-bt_in_whitelist() {
-    mac="$1"
-    name="$2"
-
-    echo "$WHITELIST_ENTRIES" | while IFS= read -r entry || [ -n "$entry" ]; do
-        entry_mac=$(echo "$entry" | awk '{print $1}')
-        entry_name=$(echo "$entry" | cut -d' ' -f2-)
-        if [ "$mac" = "$entry_mac" ] && { [ -z "$entry_name" ] || [ "$name" = "$entry_name" ]; }; then
-            exit 0
-        fi
-    done
-
-    return 1
-}
-
-# bt_scan_devices
-# Attempts to detect nearby Bluetooth devices using:
-#   1. hcitool scan
-#   2. fallback: bluetoothctl scan (via expect)
-# Returns:
-#   0 - if devices found
-#   1 - if no devices found or error
-bt_scan_devices() {
-    timestamp=$(date '+%Y%m%d_%H%M%S')
-    scan_log="scan_${timestamp}.log"
-    found_log="found_devices_${timestamp}.log"
- 
-    : > "$scan_log"
-    : > "$found_log"
- 
-    log_info "Detecting Bluetooth adapter..."
-    hcidev=$(hciconfig | awk '/^hci/ { print $1 }' | head -n1)
-    if [ -z "$hcidev" ]; then
-        log_error "No Bluetooth adapter found"
-        return 1
-    fi
- 
-    log_info "Using Bluetooth adapter: $hcidev"
-    hciconfig "$hcidev" up
-    sleep 1
- 
-    log_info "Running Bluetooth scan via hcitool (synchronous)..."
-    script -q -c "hcitool -i $hcidev scan" "$scan_log"
-    grep -E '^(\s)*([0-9A-F]{2}:){5}[0-9A-F]{2}' "$scan_log" | awk '{print $1, $2}' > "$found_log"
- 
-    if [ -s "$found_log" ]; then
-        log_info "hcitool scan found devices, skipping bluetoothctl fallback."
-        return 0
-    fi
- 
-    log_warn "hcitool scan returned nothing. Falling back to bluetoothctl scan..."
- 
-    expect <<EOF >> "$scan_log"
-log_user 0
-spawn bluetoothctl
-expect -re "#|\\\[.*\\\]#" { send "power on\r" }
-expect -re "#|\\\[.*\\\]#" { send "agent NoInputNoOutput\r" }
-expect -re "#|\\\[.*\\\]#" { send "default-agent\r" }
-expect -re "#|\\\[.*\\\]#" { send "scan on\r" }
-sleep 10
-send "scan off\r"
-expect -re "#|\\\[.*\\\]#" { send "quit\r" }
-EOF
- 
-    grep -E "^\s*\[NEW\] Device" "$scan_log" | awk '{print $4, substr($0, index($0, $5))}' > "$found_log"
- 
-    if [ ! -s "$found_log" ]; then
-        log_warn "Scan log is empty. Possible issue with bluetoothctl or adapter."
-        return 1
-    fi
- 
-    return 0
-}
-
-# Pair with Bluetooth device using MAC (with retries and timestamped logs)
-bt_pair_with_mac() {
-    bt_mac="$1"
-    # Replace colons, strip any whitespace so no trailing spaces in filenames
-    safe_mac=$(echo "$bt_mac" | tr ':' '_' | tr -d '[:space:]')
-    max_retries=3
-    retry=1
- 
-    while [ "$retry" -le "$max_retries" ]; do
-        log_info "Interactive pairing attempt $retry for $bt_mac"
-        log_file="$PWD/bt_headless_pair_${safe_mac}_$(date +%s).log"
- 
-        expect -c "
-log_user 1
-set timeout 30
-set bt_mac \"$bt_mac\"
- 
-spawn bluetoothctl
- 
-expect -re {#|\\\[.*\\\]#} { send \"power on\r\" }
-expect -re {#|\\\[.*\\\]#} { send \"agent NoInputNoOutput\r\" }
-expect -re {#|\\\[.*\\\]#} { send \"default-agent\r\" }
-expect -re {#|\\\[.*\\\]#} { send \"scan on\r\" }
-sleep 10
-send \"scan off\r\"
-sleep 1
-send \"pair \$bt_mac\r\"
- 
-expect {
-    -re {Confirm passkey.*yes/no} {
-        send \"yes\r\"
-        exp_continue
-    }
-    -re {Authorize service.*yes/no} {
-        send \"yes\r\"
-        exp_continue
-    }
-    timeout {
-        send \"quit\r\"
-        exit 0
-    }
-    eof {
-        exit 0
-    }
-}
-" > "$log_file" 2>&1
- 
-        # Now analyze the log
-        if grep -q "Pairing successful" "$log_file"; then
-            log_pass "Pairing successful with $bt_mac"
-            return 0
-        elif grep -q "Failed to pair: org.bluez.Error" "$log_file"; then
-            log_warn "Pairing failed with $bt_mac (BlueZ error)"
-        elif grep -q "AuthenticationCanceled" "$log_file"; then
-            log_warn "Pairing canceled with $bt_mac"
-        else
-            log_warn "Pairing failed with unknown reason (check $log_file)"
-        fi
- 
-        bt_cleanup_paired_device "$bt_mac"
-        retry=$((retry + 1))
-        sleep 2
-    done
- 
-    log_fail "Pairing failed after $max_retries attempts for $bt_mac"
-    return 1
-}
-
-# Utility to reliably scan and pair Bluetooth devices through a unified workflow of repeated attempts.
-retry_scan_and_pair() {
-    retry=1
-    max_retries=2
- 
-    while [ "$retry" -le "$max_retries" ]; do
-        log_info "Bluetooth scan attempt $retry..."
-        bt_scan_devices
- 
-        if [ -n "$BT_MAC" ]; then
-            log_info "Matching against: BT_NAME='$BT_NAME', BT_MAC='$BT_MAC', WHITELIST='$WHITELIST'"
-            if ! bt_in_whitelist "$BT_MAC" "$BT_NAME"; then
-                log_warn "Expected device not found or not in whitelist"
-                retry=$((retry + 1))
-                continue
-            fi
-            bt_cleanup_paired_device "$BT_MAC"
-            if bt_pair_with_mac "$BT_MAC"; then
-                return 0
-            fi
- 
-        elif [ -n "$BT_NAME" ]; then
-            matched_mac=$(awk -v name="$BT_NAME" 'tolower($0) ~ tolower(name) { print $1; exit }' "$SCAN_RESULT")
-            if [ -n "$matched_mac" ]; then
-                log_info "Found matching device by name ($BT_NAME): $matched_mac"
-                bt_cleanup_paired_device "$matched_mac"
-                if bt_pair_with_mac "$matched_mac"; then
-                    BT_MAC="$matched_mac"
-                    return 0
-                fi
-            else
-                log_warn "Device with name $BT_NAME not found in scan results"
-            fi
- 
-        else
-            log_warn "No MAC or device name provided, and whitelist is empty"
-        fi
- 
-        retry=$((retry + 1))
-    done
- 
-    log_fail "Retry scan and pair failed after $max_retries attempts"
-    return 1
-}
-
-# Post-pairing connection test with bluetoothctl and l2ping fallback
-bt_post_pair_connect() {
-    target_mac="$1"
-    sanitized_mac=$(echo "$target_mac" | tr ':' '_')
-    timestamp=$(date '+%Y%m%d_%H%M%S')
-    base_logfile="bt_connect_${sanitized_mac}_${timestamp}"
-    max_attempts=3
-    attempt=1
- 
-    if bluetoothctl info "$target_mac" | grep -q "Connected: yes"; then
-        log_info "Device $target_mac is already connected, skipping explicit connect"
-        log_pass "Post-pair connection successful"
-        return 0
-    fi
- 
-    while [ "$attempt" -le "$max_attempts" ]; do
-        log_info "Attempting to connect post-pair (try $attempt): $target_mac"
-        logfile="${base_logfile}_attempt${attempt}.log"
- 
-        expect <<EOF >"$logfile" 2>&1
-log_user 1
-set timeout 10
-spawn bluetoothctl
-expect -re "#|\\[.*\\]#" { send "trust $target_mac\r" }
-expect -re "#|\\[.*\\]#" { send "connect $target_mac\r" }
- 
-expect {
-    -re "Connection successful" { exit 0 }
-    -re "Failed to connect|Device not available" { exit 1 }
-    timeout { exit 1 }
-}
-EOF
-        result=$?
-        if [ "$result" -eq 0 ]; then
-            log_pass "Post-pair connection successful"
-            return 0
-        fi
-        log_warn "Connect attempt $attempt failed (check $logfile)"
-        attempt=$((attempt + 1))
-        sleep 2
-    done
- 
-    # Fallback to l2ping
-    log_info "Falling back to l2ping for $target_mac"
-    l2ping_log="${base_logfile}_l2ping_${timestamp}.log"
-    if command -v l2ping >/dev/null 2>&1; then
-        # Capture all output—even if ping succeeds, we log it
-        if l2ping -c 3 -t 5 "$target_mac" 2>&1 | tee "$l2ping_log" | grep -q "bytes from"; then
-            log_pass "Fallback l2ping succeeded for $target_mac (see $l2ping_log)"
-            return 0
-        else
-            log_warn "l2ping failed or no response for $target_mac (see $l2ping_log)"
-        fi
-    else
-        log_warn "l2ping not available, skipping fallback"
-    fi 
-    log_fail "Post-pair connection failed for $target_mac"
-    return 1
-}
-
-# Find MAC address from device name in scan log
-bt_find_mac_by_name() {
-    target="$1"
-    log="$2"
-    grep -i "$target" "$log" | awk '{print $3}' | head -n1
-}
-
-bt_remove_all_paired_devices() {
-    log_info "Removing all previously paired Bluetooth devices..."
-    bluetoothctl paired-devices | awk '/Device/ {print $2}' | while read -r dev; do
-        log_info "Removing paired device $dev"
-        bluetoothctl remove "$dev" >/dev/null
-    done
-}
-
-# Validate connectivity using l2ping
-bt_l2ping_check() {
-    target_mac="$1"
-    logfile="$2"
-
-    if ! command -v l2ping >/dev/null 2>&1; then
-        log_warn "l2ping command not available - skipping"
-        return 1
-    fi
-
-    log_info "Running l2ping test for $target_mac"
-    if l2ping -c 3 -t 5 "$target_mac" >>"$logfile" 2>&1; then
-        log_pass "l2ping to $target_mac succeeded"
-        return 0
-    else
-        log_warn "l2ping to $target_mac failed"
-        return 1
-    fi
-}
-
 ###############################################################################
 # get_remoteproc_by_firmware <short-fw-name> [outfile] [all]
 # - If outfile is given: append *all* matches as "<path>|<state>|<firmware>|<name>"