Initial v1.1.8 Commits
This commit is contained in:
amurcanov
@@ -0,0 +1,143 @@
|
||||
import java.util.Properties
|
||||
|
||||
plugins {
|
||||
id("com.android.application")
|
||||
id("org.jetbrains.kotlin.plugin.compose")
|
||||
}
|
||||
|
||||
android {
|
||||
namespace = "com.wdtt.client"
|
||||
compileSdk = 35
|
||||
|
||||
defaultConfig {
|
||||
applicationId = "com.wdtt.client"
|
||||
minSdk = 29
|
||||
targetSdk = 35
|
||||
versionCode = 118
|
||||
versionName = "1.1.8"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
vectorDrawables {
|
||||
useSupportLibrary = true
|
||||
}
|
||||
|
||||
ndk {
|
||||
abiFilters.addAll(listOf("arm64-v8a", "armeabi-v7a", "x86_64"))
|
||||
}
|
||||
}
|
||||
|
||||
splits {
|
||||
abi {
|
||||
isEnable = true
|
||||
reset()
|
||||
include("arm64-v8a", "armeabi-v7a", "x86_64")
|
||||
isUniversalApk = true
|
||||
}
|
||||
}
|
||||
|
||||
val localProperties = Properties()
|
||||
val localPropertiesFile = rootProject.file("local.properties")
|
||||
if (localPropertiesFile.exists()) {
|
||||
localProperties.load(localPropertiesFile.inputStream())
|
||||
}
|
||||
|
||||
signingConfigs {
|
||||
create("release") {
|
||||
val keyFile = localProperties.getProperty("KEYSTORE_FILE")
|
||||
if (keyFile != null) {
|
||||
// Резолвим путь: если начинается с "..", берём от корня проекта
|
||||
val resolvedFile = if (keyFile.startsWith("..")) {
|
||||
// ../release.keystore -> корень проекта / release.keystore
|
||||
file(rootDir.resolve(keyFile.substring(3)))
|
||||
} else {
|
||||
file(keyFile)
|
||||
}
|
||||
if (resolvedFile.exists()) {
|
||||
storeFile = resolvedFile
|
||||
storePassword = localProperties.getProperty("KEYSTORE_PASSWORD")
|
||||
keyAlias = localProperties.getProperty("KEY_ALIAS")
|
||||
keyPassword = localProperties.getProperty("KEY_PASSWORD")
|
||||
} else {
|
||||
println("WARNING: Keystore file not found: $keyFile (resolved: ${resolvedFile.absolutePath})")
|
||||
}
|
||||
}
|
||||
enableV1Signing = true
|
||||
enableV2Signing = true
|
||||
enableV3Signing = true
|
||||
}
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
getByName("release") {
|
||||
isMinifyEnabled = true
|
||||
isShrinkResources = true
|
||||
proguardFiles(
|
||||
getDefaultProguardFile("proguard-android-optimize.txt"),
|
||||
"proguard-rules.pro"
|
||||
)
|
||||
val keyFile = localProperties.getProperty("KEYSTORE_FILE")
|
||||
val resolvedFile = if (keyFile != null && keyFile.startsWith("..")) {
|
||||
file(rootDir.resolve(keyFile.substring(3)))
|
||||
} else if (keyFile != null) {
|
||||
file(keyFile)
|
||||
} else null
|
||||
|
||||
if (resolvedFile != null && resolvedFile.exists()) {
|
||||
signingConfig = signingConfigs.getByName("release")
|
||||
println("✅ Signing config applied: ${resolvedFile.absolutePath}")
|
||||
} else {
|
||||
println("⚠️ WARNING: Keystore not found, using debug signing")
|
||||
println(" Looked for: ${resolvedFile?.absolutePath ?: keyFile}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
packaging {
|
||||
jniLibs {
|
||||
useLegacyPackaging = true
|
||||
}
|
||||
resources {
|
||||
excludes += "/META-INF/{AL2.0,LGPL2.1}"
|
||||
excludes += "/META-INF/INDEX.LIST"
|
||||
excludes += "/META-INF/DEPENDENCIES"
|
||||
}
|
||||
}
|
||||
|
||||
buildFeatures {
|
||||
compose = true
|
||||
buildConfig = true
|
||||
}
|
||||
|
||||
lint {
|
||||
checkReleaseBuilds = false
|
||||
abortOnError = false
|
||||
}
|
||||
|
||||
compileOptions {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
sourceSets {
|
||||
getByName("main") {
|
||||
jniLibs.setSrcDirs(listOf("src/main/jniLibs"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation("androidx.core:core-ktx:1.15.0")
|
||||
implementation(platform("androidx.compose:compose-bom:2024.12.01"))
|
||||
implementation("androidx.compose.ui:ui")
|
||||
implementation("androidx.compose.ui:ui-graphics")
|
||||
implementation("androidx.compose.ui:ui-tooling-preview")
|
||||
implementation("androidx.compose.foundation:foundation")
|
||||
implementation("androidx.compose.material3:material3")
|
||||
implementation("androidx.compose.material:material-icons-extended")
|
||||
implementation("androidx.activity:activity-compose:1.9.3")
|
||||
implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
|
||||
implementation("androidx.lifecycle:lifecycle-runtime-compose:2.8.7")
|
||||
implementation("androidx.datastore:datastore-preferences:1.1.1")
|
||||
implementation("com.wireguard.android:tunnel:1.0.20230706")
|
||||
implementation("com.github.mwiede:jsch:0.2.16")
|
||||
}
|
||||
Vendored
+4
@@ -0,0 +1,4 @@
|
||||
-keep class com.jcraft.jsch.** { *; }
|
||||
-keep class com.mwiede.jsch.** { *; }
|
||||
-dontwarn com.jcraft.jsch.**
|
||||
-dontwarn com.mwiede.jsch.**
|
||||
@@ -0,0 +1,57 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:tools="http://schemas.android.com/tools">
|
||||
|
||||
<uses-permission android:name="android.permission.INTERNET" />
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
|
||||
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
|
||||
<uses-permission android:name="android.permission.WAKE_LOCK" />
|
||||
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
|
||||
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
|
||||
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
|
||||
<uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" tools:ignore="QueryAllPackagesPermission" />
|
||||
<uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
|
||||
|
||||
<application
|
||||
android:name=".WdttApplication"
|
||||
android:allowBackup="false"
|
||||
android:icon="@mipmap/ic_launcher"
|
||||
android:label="WDTT"
|
||||
android:roundIcon="@mipmap/ic_launcher_round"
|
||||
android:supportsRtl="true"
|
||||
android:theme="@style/Theme.WDTTClient">
|
||||
|
||||
<activity
|
||||
android:name=".MainActivity"
|
||||
android:configChanges="orientation|screenSize"
|
||||
android:exported="true">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
</activity>
|
||||
|
||||
<service
|
||||
android:name=".TunnelService"
|
||||
android:exported="false"
|
||||
android:foregroundServiceType="specialUse"
|
||||
android:stopWithTask="false">
|
||||
<property
|
||||
android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
|
||||
android:value="persistent_vpn_tunnel_transport" />
|
||||
</service>
|
||||
|
||||
<activity
|
||||
android:name=".ManlCaptchaActivity"
|
||||
android:theme="@android:style/Theme.Translucent.NoTitleBar"
|
||||
android:launchMode="singleTask"
|
||||
android:windowSoftInputMode="adjustResize"
|
||||
android:exported="false" />
|
||||
|
||||
<receiver
|
||||
android:name=".CaptchaCancelReceiver"
|
||||
android:exported="false" />
|
||||
|
||||
</application>
|
||||
|
||||
</manifest>
|
||||
@@ -0,0 +1,585 @@
|
||||
#!/bin/bash
|
||||
# ==============================================================================
|
||||
# WDTT VPN Server — Универсальный установщик для VPS
|
||||
# Поддержка: Debian 11+, Ubuntu 20.04+, CentOS/RHEL/Fedora/AlmaLinux/Rocky
|
||||
# Версия: 3.2 | Дата: 2026-05-13
|
||||
# NAT: MASQUERADE через iptables
|
||||
# WG: порт 56001 (не конфликтует с существующим WG на 51820)
|
||||
# DTLS: порт 56000
|
||||
# ==============================================================================
|
||||
set -uo pipefail
|
||||
|
||||
readonly SCRIPT_VERSION="3.2"
|
||||
readonly LOG_FILE="/var/log/wdtt-install.log"
|
||||
readonly WG_PORT="${WDTT_WG_PORT:-56001}"
|
||||
readonly DTLS_PORT="${WDTT_DTLS_PORT:-56000}"
|
||||
readonly SSH_PORT="${WDTT_SSH_PORT:-22}"
|
||||
readonly WDTT_ARGS="${WDTT_ARGS:-}"
|
||||
readonly WDTT_IFACE="wdtt0"
|
||||
readonly WDTT_CONFIG_DIR="/etc/wdtt"
|
||||
readonly WDTT_ACCESS_DB="passwords.json"
|
||||
readonly IPT_COMMENT="WDTT_MANAGED"
|
||||
readonly IPT_MIRROR_COMMENT="WDTT_MIRRORED"
|
||||
|
||||
validate_port() {
|
||||
local name="$1" value="$2"
|
||||
case "$value" in
|
||||
''|*[!0-9]*) die "$name должен быть числом от 1 до 65535, получено: $value" ;;
|
||||
esac
|
||||
if [ "$value" -lt 1 ] || [ "$value" -gt 65535 ]; then
|
||||
die "$name должен быть в диапазоне 1..65535, получено: $value"
|
||||
fi
|
||||
}
|
||||
|
||||
# ─── Цвета ───────────────────────────────────────────────────────────────────
|
||||
C_GREEN=''; C_YELLOW=''; C_RED=''
|
||||
C_CYAN=''; C_BOLD=''; C_NC=''
|
||||
|
||||
log_info() { echo -e "${C_GREEN}[✓]${C_NC} $*" | tee -a "$LOG_FILE"; }
|
||||
log_warn() { echo -e "${C_YELLOW}[!]${C_NC} $*" | tee -a "$LOG_FILE"; }
|
||||
log_error() { echo -e "${C_RED}[✗]${C_NC} $*" | tee -a "$LOG_FILE"; }
|
||||
log_step() { echo -e "${C_CYAN}[►]${C_NC} ${C_BOLD}$*${C_NC}" | tee -a "$LOG_FILE"; }
|
||||
|
||||
die() { log_error "$*"; exit 1; }
|
||||
|
||||
prog() { echo "WDTT_PROGRESS|$1|$2"; }
|
||||
|
||||
# ─── Проверка root ────────────────────────────────────────────────────────────
|
||||
check_root() {
|
||||
if [ "$(id -u)" -ne 0 ]; then
|
||||
die "Скрипт должен быть запущен от root. Если sudo отсутствует, зайдите под root и запустите: bash $0 $*"
|
||||
fi
|
||||
}
|
||||
|
||||
# ─── Определение ОС ──────────────────────────────────────────────────────────
|
||||
OS_ID="" ; PKG_MGR=""
|
||||
|
||||
detect_os() {
|
||||
log_step "Определение операционной системы..."
|
||||
if [ ! -f /etc/os-release ]; then
|
||||
die "Файл /etc/os-release не найден."
|
||||
fi
|
||||
. /etc/os-release
|
||||
OS_ID="${ID:-unknown}"
|
||||
case "$OS_ID" in
|
||||
ubuntu|debian|linuxmint|pop) PKG_MGR="apt" ;;
|
||||
centos|rhel|rocky|almalinux|oracle) PKG_MGR="yum"
|
||||
command -v dnf &>/dev/null && PKG_MGR="dnf" ;;
|
||||
fedora) PKG_MGR="dnf" ;;
|
||||
arch|manjaro|endeavouros) PKG_MGR="pacman" ;;
|
||||
*) die "Неподдерживаемый дистрибутив: $OS_ID" ;;
|
||||
esac
|
||||
log_info "ОС: ${PRETTY_NAME:-$OS_ID} | PM: $PKG_MGR"
|
||||
}
|
||||
|
||||
# ─── Пакеты ──────────────────────────────────────────────────────────────────
|
||||
pkg_update_done=0
|
||||
|
||||
pkg_update() {
|
||||
[ "$pkg_update_done" = "1" ] && return 0
|
||||
log_step "Обновление индексов пакетов..."
|
||||
case "$PKG_MGR" in
|
||||
apt)
|
||||
export DEBIAN_FRONTEND=noninteractive
|
||||
apt-get update -y >>"$LOG_FILE" 2>&1 || log_warn "apt update завершился с ошибкой, пробую продолжить"
|
||||
;;
|
||||
dnf) dnf makecache -y >>"$LOG_FILE" 2>&1 || true ;;
|
||||
yum) yum makecache -y >>"$LOG_FILE" 2>&1 || true ;;
|
||||
pacman) pacman -Sy --noconfirm >>"$LOG_FILE" 2>&1 || true ;;
|
||||
esac
|
||||
pkg_update_done=1
|
||||
}
|
||||
|
||||
pkg_install() {
|
||||
[ "$#" -eq 0 ] && return 0
|
||||
case "$PKG_MGR" in
|
||||
apt)
|
||||
export DEBIAN_FRONTEND=noninteractive
|
||||
apt-get install -y -qq "$@" >>"$LOG_FILE" 2>&1
|
||||
;;
|
||||
dnf) dnf install -y "$@" >>"$LOG_FILE" 2>&1 ;;
|
||||
yum) yum install -y "$@" >>"$LOG_FILE" 2>&1 ;;
|
||||
pacman) pacman -S --noconfirm --needed "$@" >>"$LOG_FILE" 2>&1 ;;
|
||||
esac
|
||||
}
|
||||
|
||||
install_prerequisites() {
|
||||
prog 0.08 "Пакеты..."
|
||||
pkg_update
|
||||
log_step "Установка базовых зависимостей..."
|
||||
|
||||
case "$PKG_MGR" in
|
||||
apt)
|
||||
pkg_install ca-certificates iproute2 iptables nftables procps psmisc || \
|
||||
log_warn "Часть apt-пакетов не установилась, продолжаю с доступными утилитами"
|
||||
;;
|
||||
dnf|yum)
|
||||
pkg_install ca-certificates iproute iptables nftables procps-ng psmisc || \
|
||||
log_warn "Часть rpm-пакетов не установилась, продолжаю с доступными утилитами"
|
||||
;;
|
||||
pacman)
|
||||
pkg_install ca-certificates iproute2 iptables nftables procps-ng psmisc || \
|
||||
log_warn "Часть pacman-пакетов не установилась, продолжаю с доступными утилитами"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
require_runtime_tools() {
|
||||
command -v ip >/dev/null 2>&1 || die "Команда ip не найдена. Установите iproute2/iproute."
|
||||
command -v systemctl >/dev/null 2>&1 || die "systemctl не найден. Нужен VPS с systemd."
|
||||
}
|
||||
|
||||
# ─── Автоопределение WAN-интерфейса ──────────────────────────────────────────
|
||||
detect_wan_interface() {
|
||||
local iface=""
|
||||
iface=$(ip route show default 2>/dev/null | head -1 | awk '{for(i=1;i<=NF;i++) if($i=="dev") print $(i+1)}')
|
||||
[ -z "$iface" ] && iface=$(ip -4 addr show scope global 2>/dev/null | grep -oP '(?<=dev )\S+' | head -1)
|
||||
[ -z "$iface" ] && iface=$(ls /sys/class/net/ | grep -v lo | head -1)
|
||||
echo "$iface"
|
||||
}
|
||||
|
||||
# ─── Firewall helpers ────────────────────────────────────────────────────────
|
||||
FW_BACKEND=""
|
||||
|
||||
iptables_add_input() {
|
||||
local proto="$1" port="$2" comment="$3"
|
||||
[ "$FW_BACKEND" = "iptables" ] || return 0
|
||||
case "$proto:$port" in
|
||||
tcp:[0-9]*|udp:[0-9]*) ;;
|
||||
*) return 0 ;;
|
||||
esac
|
||||
[ "$port" -ge 1 ] 2>/dev/null && [ "$port" -le 65535 ] 2>/dev/null || return 0
|
||||
iptables -C INPUT -p "$proto" --dport "$port" -m comment --comment "$comment" -j ACCEPT 2>/dev/null || \
|
||||
iptables -I INPUT -p "$proto" --dport "$port" -m comment --comment "$comment" -j ACCEPT 2>/dev/null || true
|
||||
}
|
||||
|
||||
mirror_port_to_iptables() {
|
||||
local proto="$1" port="$2" source="$3"
|
||||
iptables_add_input "$proto" "$port" "$IPT_MIRROR_COMMENT"
|
||||
log_info "iptables: сохранён доступ $port/$proto из $source"
|
||||
}
|
||||
|
||||
mirror_existing_firewall_ports_to_iptables() {
|
||||
[ "$FW_BACKEND" = "iptables" ] || return 0
|
||||
local tmp
|
||||
tmp="$(mktemp)"
|
||||
|
||||
if command -v ufw >/dev/null 2>&1 && ufw status 2>/dev/null | grep -qi "Status: active"; then
|
||||
log_info "UFW активен: переношу разрешённые tcp/udp порты в iptables"
|
||||
ufw status 2>/dev/null | sed -nE 's#^([0-9]{1,5})/(tcp|udp)[[:space:]].*ALLOW IN.*#\2 \1 ufw#p' >> "$tmp" || true
|
||||
fi
|
||||
|
||||
if command -v nft >/dev/null 2>&1; then
|
||||
local nft_ports
|
||||
nft_ports="$(nft -a list ruleset 2>/dev/null | sed -nE 's/.*(tcp|udp) dport ([0-9]{1,5}).*accept.*/\1 \2 nft/p' | sort -u || true)"
|
||||
if [ -n "$nft_ports" ]; then
|
||||
log_info "nftables найден: переношу простые accept dport правила в iptables"
|
||||
printf '%s\n' "$nft_ports" >> "$tmp"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -s "$tmp" ]; then
|
||||
sort -u "$tmp" | while read -r proto port source; do
|
||||
mirror_port_to_iptables "$proto" "$port" "$source"
|
||||
done
|
||||
else
|
||||
log_info "UFW/nftables разрешённых tcp/udp портов для переноса не найдено"
|
||||
fi
|
||||
rm -f "$tmp"
|
||||
}
|
||||
|
||||
detect_firewall() {
|
||||
if ! command -v iptables &>/dev/null; then
|
||||
log_warn "iptables не найден. Пытаюсь установить firewall-пакеты..."
|
||||
pkg_update
|
||||
pkg_install iptables nftables || true
|
||||
fi
|
||||
if command -v iptables &>/dev/null; then
|
||||
FW_BACKEND="iptables"
|
||||
log_info "Firewall backend: iptables (принудительно)"
|
||||
mirror_existing_firewall_ports_to_iptables
|
||||
else
|
||||
FW_BACKEND="none"
|
||||
log_warn "iptables не найден. Установка продолжится, но NAT/firewall нужно настроить вручную."
|
||||
fi
|
||||
}
|
||||
|
||||
# ─── Firewall-абстракция ─────────────────────────────────────────────────────
|
||||
fw_add_input_udp() {
|
||||
local port="$1"
|
||||
case "$FW_BACKEND" in
|
||||
iptables)
|
||||
iptables -C INPUT -p udp --dport "$port" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || \
|
||||
iptables -I INPUT -p udp --dport "$port" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
;;
|
||||
nft)
|
||||
ensure_nft_wdtt
|
||||
nft add rule inet wdtt input udp dport "$port" accept 2>/dev/null || true
|
||||
;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_input_tcp() {
|
||||
local port="$1"
|
||||
case "$FW_BACKEND" in
|
||||
iptables)
|
||||
iptables -C INPUT -p tcp --dport "$port" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || \
|
||||
iptables -I INPUT -p tcp --dport "$port" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
;;
|
||||
nft)
|
||||
ensure_nft_wdtt
|
||||
nft add rule inet wdtt input tcp dport "$port" accept 2>/dev/null || true
|
||||
;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_input_udp_range() {
|
||||
local from="$1" to="$2"
|
||||
case "$FW_BACKEND" in
|
||||
iptables|nft) log_warn "Пропускаю широкий UDP range $from-$to: это не изолировано и может влиять на чужие сервисы." ;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_forward() {
|
||||
case "$FW_BACKEND" in
|
||||
iptables)
|
||||
iptables -C FORWARD -i "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || \
|
||||
iptables -I FORWARD -i "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -C FORWARD -o "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || \
|
||||
iptables -I FORWARD -o "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
;;
|
||||
nft)
|
||||
ensure_nft_wdtt
|
||||
nft add rule inet wdtt forward iifname "$WDTT_IFACE" accept 2>/dev/null || true
|
||||
nft add rule inet wdtt forward oifname "$WDTT_IFACE" accept 2>/dev/null || true
|
||||
;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_masquerade() {
|
||||
local iface="$1" subnet="$2"
|
||||
case "$FW_BACKEND" in
|
||||
iptables)
|
||||
iptables -t nat -C POSTROUTING -s "$subnet" -o "$iface" -m comment --comment "$IPT_COMMENT" -j MASQUERADE 2>/dev/null || \
|
||||
iptables -t nat -A POSTROUTING -s "$subnet" -o "$iface" -m comment --comment "$IPT_COMMENT" -j MASQUERADE 2>/dev/null || true
|
||||
;;
|
||||
nft)
|
||||
nft add table ip wdtt 2>/dev/null || true
|
||||
nft add chain ip wdtt postrouting '{ type nat hook postrouting priority 100; }' 2>/dev/null || true
|
||||
nft add rule ip wdtt postrouting ip saddr "$subnet" oifname "$iface" masquerade 2>/dev/null || true
|
||||
;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_mss_clamping() {
|
||||
local subnet="$1"
|
||||
case "$FW_BACKEND" in
|
||||
iptables)
|
||||
# Применяем правило ТОЛЬКО к нашей подсети WDTT
|
||||
iptables -t mangle -C FORWARD -s "$subnet" -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || \
|
||||
iptables -t mangle -I FORWARD -s "$subnet" -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || true
|
||||
iptables -t mangle -C FORWARD -d "$subnet" -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || \
|
||||
iptables -t mangle -I FORWARD -d "$subnet" -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || true
|
||||
;;
|
||||
nft)
|
||||
nft add table inet wdtt_mangle 2>/dev/null || true
|
||||
nft add chain inet wdtt_mangle forward '{ type filter hook forward priority -150; policy accept; }' 2>/dev/null || true
|
||||
nft add rule inet wdtt_mangle forward ip saddr "$subnet" tcp flags syn tcp option maxseg size set rt mtu 2>/dev/null || true
|
||||
nft add rule inet wdtt_mangle forward ip daddr "$subnet" tcp flags syn tcp option maxseg size set rt mtu 2>/dev/null || true
|
||||
;;
|
||||
none) ;;
|
||||
esac
|
||||
}
|
||||
|
||||
fw_add_established() {
|
||||
return 0
|
||||
}
|
||||
|
||||
fw_cleanup_wdtt_rules() {
|
||||
local iface="$1"
|
||||
if command -v iptables >/dev/null 2>&1; then
|
||||
for i in {1..5}; do
|
||||
local nat_iface
|
||||
for nat_iface in "$iface" $(ls /sys/class/net 2>/dev/null || true); do
|
||||
[ -n "$nat_iface" ] && iptables -t nat -D POSTROUTING -s 10.66.66.0/24 -o "$nat_iface" -m comment --comment "$IPT_COMMENT" -j MASQUERADE 2>/dev/null || true
|
||||
done
|
||||
iptables -t mangle -D FORWARD -s 10.66.66.0/24 -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || true
|
||||
iptables -t mangle -D FORWARD -d 10.66.66.0/24 -p tcp -m tcp --tcp-flags SYN,RST SYN -m comment --comment "$IPT_COMMENT" -j TCPMSS --clamp-mss-to-pmtu 2>/dev/null || true
|
||||
iptables -D INPUT -p udp --dport ${DTLS_PORT} -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -D INPUT -p udp --dport ${WG_PORT} -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -D INPUT -p tcp --dport ${SSH_PORT} -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -D INPUT -p tcp --dport 22 -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -D FORWARD -i "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
iptables -D FORWARD -o "$WDTT_IFACE" -m comment --comment "$IPT_COMMENT" -j ACCEPT 2>/dev/null || true
|
||||
done
|
||||
fi
|
||||
if command -v nft >/dev/null 2>&1; then
|
||||
nft delete table ip wdtt 2>/dev/null || true
|
||||
nft delete table inet wdtt 2>/dev/null || true
|
||||
nft delete table inet wdtt_mangle 2>/dev/null || true
|
||||
fi
|
||||
}
|
||||
|
||||
cleanup_config_dir_keep_access_db() {
|
||||
[ -d "$WDTT_CONFIG_DIR" ] || return 0
|
||||
find "$WDTT_CONFIG_DIR" -mindepth 1 -maxdepth 1 ! -name "$WDTT_ACCESS_DB" -exec rm -rf {} + 2>/dev/null || true
|
||||
[ -f "$WDTT_CONFIG_DIR/$WDTT_ACCESS_DB" ] && chmod 600 "$WDTT_CONFIG_DIR/$WDTT_ACCESS_DB" 2>/dev/null || true
|
||||
}
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# WDTT VPN SERVER DEPLOYMENT
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
# ─── Очистка старого WDTT ─────────────────────────────────────────────────────
|
||||
wdtt_cleanup() {
|
||||
prog 0.05 "Очистка..."
|
||||
echo "🧹 Очистка старой установки WDTT..."
|
||||
|
||||
systemctl unmask wdtt 2>/dev/null || true
|
||||
systemctl stop wdtt 2>/dev/null || true
|
||||
systemctl disable wdtt 2>/dev/null || true
|
||||
rm -f /etc/systemd/system/wdtt.service 2>/dev/null || true
|
||||
systemctl daemon-reload 2>/dev/null || true
|
||||
pkill -x wdtt-server 2>/dev/null || killall wdtt-server 2>/dev/null || true
|
||||
|
||||
# Удаляем только собственный интерфейс WDTT.
|
||||
ip link show "$WDTT_IFACE" >/dev/null 2>&1 && ip link del "$WDTT_IFACE" 2>/dev/null || true
|
||||
|
||||
# Удаляем старые правила NAT для WDTT подсети
|
||||
fw_cleanup_wdtt_rules "$(detect_wan_interface)"
|
||||
|
||||
rm -f /usr/local/bin/wdtt-server 2>/dev/null || true
|
||||
cleanup_config_dir_keep_access_db
|
||||
|
||||
echo "✓ Очистка завершена (база доступа сохранена)"
|
||||
}
|
||||
|
||||
# ─── Sysctl тюнинг ───────────────────────────────────────────────────────────
|
||||
setup_sysctl() {
|
||||
prog 0.20 "Sysctl..."
|
||||
echo "⚙️ Настройка сетевых параметров..."
|
||||
|
||||
echo 1 > /proc/sys/net/ipv4/ip_forward 2>/dev/null || true
|
||||
mkdir -p /etc/sysctl.d
|
||||
cat > /etc/sysctl.d/99-wdtt.conf << 'SYSEOF'
|
||||
net.ipv4.ip_forward = 1
|
||||
SYSEOF
|
||||
|
||||
sysctl -p /etc/sysctl.d/99-wdtt.conf >/dev/null 2>&1 || true
|
||||
|
||||
echo "✓ Sysctl настроен"
|
||||
}
|
||||
|
||||
# ─── Настройка NAT + Firewall ─────────────────────────────────────────────────
|
||||
setup_nat_and_firewall() {
|
||||
prog 0.40 "NAT + Firewall..."
|
||||
echo "🛡 Настройка NAT и фаервола..."
|
||||
|
||||
local iface
|
||||
iface=$(detect_wan_interface)
|
||||
|
||||
if [ -z "$iface" ]; then
|
||||
log_warn "Не удалось определить WAN-интерфейс!"
|
||||
log_warn "Настройте NAT вручную для подсети 10.66.66.0/24."
|
||||
return 0
|
||||
fi
|
||||
|
||||
log_info "WAN-интерфейс: $iface"
|
||||
|
||||
# === WDTT порты ===
|
||||
fw_add_input_udp "$DTLS_PORT" # 56000 — DTLS сервер
|
||||
fw_add_input_udp "$WG_PORT" # 56001 — WireGuard
|
||||
fw_add_input_tcp "$SSH_PORT" # SSH порт, указанный пользователем в приложении
|
||||
|
||||
# === Forward ===
|
||||
fw_add_forward
|
||||
|
||||
# === NAT: MASQUERADE для подсети WireGuard ===
|
||||
fw_add_masquerade "$iface" "10.66.66.0/24"
|
||||
|
||||
# === MSS Clamping для исправления MTU (DonationAlerts / Cloudflare) ===
|
||||
fw_add_mss_clamping "10.66.66.0/24"
|
||||
|
||||
if [ "$FW_BACKEND" = "none" ]; then
|
||||
echo "⚠ NAT не настроен автоматически: firewall-бэкенд отсутствует"
|
||||
else
|
||||
echo "✓ NAT: MASQUERADE на $iface для 10.66.66.0/24"
|
||||
fi
|
||||
echo "✓ Порты: ${DTLS_PORT}/udp(DTLS), ${WG_PORT}/udp(WG), ${SSH_PORT}/tcp(SSH)"
|
||||
echo "✓ TCP MSS Clamping включен"
|
||||
}
|
||||
|
||||
# ─── Установка бинарника wdtt-server ──────────────────────────────────────────
|
||||
setup_wdtt_binary() {
|
||||
prog 0.60 "Бинарник..."
|
||||
echo "📦 Установка wdtt-server..."
|
||||
|
||||
if [ -f /tmp/wdtt-server ]; then
|
||||
chmod +x /tmp/wdtt-server
|
||||
install -m 0755 /tmp/wdtt-server /usr/local/bin/wdtt-server 2>/dev/null || mv /tmp/wdtt-server /usr/local/bin/wdtt-server
|
||||
echo "✓ wdtt-server установлен"
|
||||
elif [ -f /usr/local/bin/wdtt-server ]; then
|
||||
echo "✓ wdtt-server уже установлен"
|
||||
else
|
||||
echo "⚠ wdtt-server не найден в /tmp/ — пропускаем"
|
||||
echo " Загрузите бинарник вручную в /usr/local/bin/wdtt-server"
|
||||
fi
|
||||
|
||||
mkdir -p "$WDTT_CONFIG_DIR"
|
||||
}
|
||||
|
||||
# ─── Systemd-сервис WDTT ─────────────────────────────────────────────────────
|
||||
setup_wdtt_service() {
|
||||
prog 0.75 "Сервис..."
|
||||
echo "🔧 Создание systemd-сервиса WDTT..."
|
||||
|
||||
cat > /etc/systemd/system/wdtt.service << WDTTSVC
|
||||
[Unit]
|
||||
Description=WDTT VPN Server
|
||||
After=network.target network-online.target
|
||||
Wants=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
ExecStartPre=-/usr/bin/env bash -c "ip link show ${WDTT_IFACE} >/dev/null 2>&1 && ip link del ${WDTT_IFACE} 2>/dev/null || true"
|
||||
ExecStartPre=-/usr/bin/env bash -c "if command -v iptables >/dev/null 2>&1; then iptables -C INPUT -p udp --dport ${DTLS_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT 2>/dev/null || iptables -I INPUT -p udp --dport ${DTLS_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT; iptables -C INPUT -p udp --dport ${WG_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT 2>/dev/null || iptables -I INPUT -p udp --dport ${WG_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT; iptables -C INPUT -p tcp --dport ${SSH_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT 2>/dev/null || iptables -I INPUT -p tcp --dport ${SSH_PORT} -m comment --comment ${IPT_COMMENT} -j ACCEPT; fi"
|
||||
ExecStart=/usr/local/bin/wdtt-server -listen 0.0.0.0:${DTLS_PORT} -wg-port ${WG_PORT} -config-dir ${WDTT_CONFIG_DIR} ${WDTT_ARGS}
|
||||
Restart=always
|
||||
RestartSec=5
|
||||
LimitNOFILE=65535
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
WDTTSVC
|
||||
|
||||
systemctl daemon-reload
|
||||
systemctl unmask wdtt >/dev/null 2>&1 || true
|
||||
systemctl enable wdtt >/dev/null 2>&1 || true
|
||||
echo "✓ Сервис wdtt.service создан и включён"
|
||||
}
|
||||
|
||||
# ─── Запуск WDTT ─────────────────────────────────────────────────────────────
|
||||
start_wdtt() {
|
||||
prog 0.90 "Запуск..."
|
||||
echo "🚀 Запуск WDTT VPN Server..."
|
||||
|
||||
if [ ! -f /usr/local/bin/wdtt-server ]; then
|
||||
echo "⚠ wdtt-server не установлен — запуск пропущен"
|
||||
return 0
|
||||
fi
|
||||
|
||||
systemctl restart wdtt
|
||||
|
||||
sleep 2
|
||||
local status
|
||||
status=$(systemctl is-active wdtt 2>/dev/null || echo "unknown")
|
||||
|
||||
prog 1.0 "Готово!"
|
||||
|
||||
echo ""
|
||||
echo "══════════════════════════════════════════════════════════════"
|
||||
|
||||
if [ "$status" = "active" ]; then
|
||||
echo "✅ Деплой успешно завершён!"
|
||||
echo " NAT: MASQUERADE (стандартный)"
|
||||
echo " DTLS: порт ${DTLS_PORT}"
|
||||
echo " WG: порт ${WG_PORT}"
|
||||
echo " SSH: порт ${SSH_PORT}"
|
||||
else
|
||||
echo "⚠️ Сервис wdtt не запустился. Статус: $status"
|
||||
echo " Последние логи:"
|
||||
journalctl -u wdtt -n 7 --no-pager 2>/dev/null | sed 's/^/ >> /'
|
||||
fi
|
||||
|
||||
echo " Логи: journalctl -u wdtt -f"
|
||||
echo " Статус: systemctl status wdtt"
|
||||
echo "══════════════════════════════════════════════════════════════"
|
||||
echo ""
|
||||
}
|
||||
|
||||
# ─── Команда: uninstall ──────────────────────────────────────────────────────
|
||||
do_uninstall() {
|
||||
log_step "Удаление WDTT..."
|
||||
|
||||
systemctl stop wdtt 2>/dev/null || true
|
||||
systemctl disable wdtt 2>/dev/null || true
|
||||
rm -f /etc/systemd/system/wdtt.service
|
||||
systemctl daemon-reload
|
||||
|
||||
ip link show "$WDTT_IFACE" >/dev/null 2>&1 && ip link del "$WDTT_IFACE" 2>/dev/null || true
|
||||
pkill -x wdtt-server 2>/dev/null || true
|
||||
|
||||
fw_cleanup_wdtt_rules "$(detect_wan_interface)"
|
||||
|
||||
rm -f /usr/local/bin/wdtt-server
|
||||
cleanup_config_dir_keep_access_db
|
||||
rm -f /etc/sysctl.d/99-wdtt.conf
|
||||
sysctl --system >/dev/null 2>&1 || true
|
||||
|
||||
log_info "WDTT удалён. База доступа сохранена: ${WDTT_CONFIG_DIR}/${WDTT_ACCESS_DB}"
|
||||
}
|
||||
|
||||
# ─── Команда: status ─────────────────────────────────────────────────────────
|
||||
do_status() {
|
||||
echo "Статус WDTT:"
|
||||
echo ""
|
||||
if systemctl is-active wdtt &>/dev/null; then
|
||||
log_info "Сервис: АКТИВЕН"
|
||||
else
|
||||
log_warn "Сервис: НЕ АКТИВЕН"
|
||||
fi
|
||||
if [ -f /usr/local/bin/wdtt-server ]; then
|
||||
log_info "Бинарник: установлен"
|
||||
else
|
||||
log_warn "Бинарник: НЕ найден"
|
||||
fi
|
||||
if ip link show "$WDTT_IFACE" &>/dev/null; then
|
||||
log_info "WDTT интерфейс ($WDTT_IFACE): активен"
|
||||
else
|
||||
log_warn "WDTT интерфейс ($WDTT_IFACE): не активен"
|
||||
fi
|
||||
}
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# MAIN
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
main() {
|
||||
echo "╔══════════════════════════════════════════════════════════════╗"
|
||||
echo "║ WDTT VPN Server — Installer v${SCRIPT_VERSION} ║"
|
||||
echo "║ DTLS: ${DTLS_PORT} | WG: ${WG_PORT} | SSH: ${SSH_PORT} ║"
|
||||
echo "╚══════════════════════════════════════════════════════════════╝"
|
||||
|
||||
local action="${1:-install}"
|
||||
check_root
|
||||
validate_port "WDTT_DTLS_PORT" "$DTLS_PORT"
|
||||
validate_port "WDTT_WG_PORT" "$WG_PORT"
|
||||
validate_port "WDTT_SSH_PORT" "$SSH_PORT"
|
||||
|
||||
mkdir -p "$(dirname "$LOG_FILE")"
|
||||
echo "=== WDTT Installer v${SCRIPT_VERSION} — $(date) ===" >> "$LOG_FILE"
|
||||
|
||||
detect_os
|
||||
install_prerequisites
|
||||
require_runtime_tools
|
||||
detect_firewall
|
||||
|
||||
case "$action" in
|
||||
status|--status|-s) do_status ;;
|
||||
uninstall|--uninstall|-u) do_uninstall ;;
|
||||
install|--install|-i|*)
|
||||
wdtt_cleanup
|
||||
setup_sysctl
|
||||
setup_nat_and_firewall
|
||||
setup_wdtt_binary
|
||||
setup_wdtt_service
|
||||
start_wdtt
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
main "$@"
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
@@ -0,0 +1,276 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
|
||||
const val UPDATE_CHECK_NEVER = -1
|
||||
const val DEFAULT_UPDATE_CHECK_INTERVAL_HOURS = 12
|
||||
const val UPDATE_DIALOG_ACTION_POSTPONED = "postponed"
|
||||
const val UPDATE_DIALOG_ACTION_UPDATE = "update"
|
||||
|
||||
private const val UPDATE_LOG_TAG = "WDTT"
|
||||
private const val GITHUB_RELEASES_URL = "https://api.github.com/repos/amurcanov/proxy-turn-vk-android/releases?per_page=30"
|
||||
private const val GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/amurcanov/proxy-turn-vk-android/releases/latest"
|
||||
private const val GITHUB_LATEST_RELEASE_WEB_URL = "https://github.com/amurcanov/proxy-turn-vk-android/releases/latest"
|
||||
private const val GITHUB_RELEASE_TAG_URL_PREFIX = "https://github.com/amurcanov/proxy-turn-vk-android/releases/tag/"
|
||||
private const val GITHUB_TAGS_URL = "https://api.github.com/repos/amurcanov/proxy-turn-vk-android/tags?per_page=100"
|
||||
private const val GITHUB_TAG_TREE_URL_PREFIX = "https://github.com/amurcanov/proxy-turn-vk-android/tree/"
|
||||
private const val GITHUB_API_RATE_LIMIT_FALLBACK_MS = 30L * 60L * 1000L
|
||||
private val VERSION_NUMBER_REGEX = Regex("\\d+(?:\\.\\d+)*")
|
||||
|
||||
@Volatile
|
||||
private var githubApiCooldownUntilMs = 0L
|
||||
|
||||
fun updateIntervalHoursToMillis(hours: Int): Long? = when {
|
||||
hours <= 0 -> null
|
||||
else -> hours * 60L * 60L * 1000L
|
||||
}
|
||||
|
||||
data class AppReleaseInfo(
|
||||
val versionTag: String,
|
||||
val releaseUrl: String,
|
||||
val source: RemoteVersionSource
|
||||
)
|
||||
|
||||
enum class RemoteVersionSource {
|
||||
Release,
|
||||
Tag
|
||||
}
|
||||
|
||||
suspend fun fetchLatestReleaseInfo(localVersion: String? = null): AppReleaseInfo? = withContext(Dispatchers.IO) {
|
||||
val latestRelease = fetchReleaseFromLatestWebRedirect()
|
||||
?: fetchReleaseFromLatestEndpoint()
|
||||
?: fetchLatestStableReleaseFromList()
|
||||
val latestTag = fetchLatestTagFromList()
|
||||
|
||||
when {
|
||||
latestRelease == null -> latestTag
|
||||
latestTag == null -> latestRelease
|
||||
isNewerVersion(latestRelease.versionTag, latestTag.versionTag) -> latestTag
|
||||
else -> latestRelease
|
||||
}
|
||||
}
|
||||
|
||||
fun isNewerVersion(local: String, remote: String): Boolean {
|
||||
val localParts = versionParts(local)
|
||||
val remoteParts = versionParts(remote)
|
||||
if (remoteParts.isEmpty()) return false
|
||||
|
||||
val maxLen = maxOf(localParts.size, remoteParts.size)
|
||||
for (i in 0 until maxLen) {
|
||||
val localPart = localParts.getOrElse(i) { 0 }
|
||||
val remotePart = remoteParts.getOrElse(i) { 0 }
|
||||
if (remotePart > localPart) return true
|
||||
if (remotePart < localPart) return false
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
private fun fetchLatestStableReleaseFromList(): AppReleaseInfo? {
|
||||
val response = fetchGitHubApi(GITHUB_RELEASES_URL) ?: return null
|
||||
val releases = try {
|
||||
JSONArray(response)
|
||||
} catch (e: Exception) {
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: failed to parse releases list", e)
|
||||
return null
|
||||
}
|
||||
|
||||
var bestRelease: AppReleaseInfo? = null
|
||||
for (i in 0 until releases.length()) {
|
||||
val json = releases.optJSONObject(i) ?: continue
|
||||
if (json.optBoolean("draft") || json.optBoolean("prerelease")) continue
|
||||
val release = json.toAppReleaseInfo() ?: continue
|
||||
if (bestRelease == null || isNewerVersion(bestRelease.versionTag, release.versionTag)) {
|
||||
bestRelease = release
|
||||
}
|
||||
}
|
||||
return bestRelease
|
||||
}
|
||||
|
||||
private fun fetchLatestTagFromList(): AppReleaseInfo? {
|
||||
val response = fetchGitHubApi(GITHUB_TAGS_URL) ?: return null
|
||||
val tags = try {
|
||||
JSONArray(response)
|
||||
} catch (e: Exception) {
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: failed to parse tags list", e)
|
||||
return null
|
||||
}
|
||||
|
||||
var bestTag: AppReleaseInfo? = null
|
||||
for (i in 0 until tags.length()) {
|
||||
val json = tags.optJSONObject(i) ?: continue
|
||||
val tagName = normalizeVersionTag(json.optString("name"))
|
||||
if (tagName.isBlank()) continue
|
||||
val tag = AppReleaseInfo(
|
||||
versionTag = tagName,
|
||||
releaseUrl = "$GITHUB_TAG_TREE_URL_PREFIX$tagName",
|
||||
source = RemoteVersionSource.Tag
|
||||
)
|
||||
if (bestTag == null || isNewerVersion(bestTag.versionTag, tag.versionTag)) {
|
||||
bestTag = tag
|
||||
}
|
||||
}
|
||||
return bestTag
|
||||
}
|
||||
|
||||
private fun fetchReleaseFromLatestEndpoint(): AppReleaseInfo? {
|
||||
val response = fetchGitHubApi(GITHUB_LATEST_RELEASE_URL) ?: return null
|
||||
val json = try {
|
||||
JSONObject(response)
|
||||
} catch (e: Exception) {
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: failed to parse latest release", e)
|
||||
return null
|
||||
}
|
||||
return json.toAppReleaseInfo()
|
||||
}
|
||||
|
||||
private fun fetchReleaseFromLatestWebRedirect(): AppReleaseInfo? {
|
||||
var conn: HttpURLConnection? = null
|
||||
return try {
|
||||
conn = URL(GITHUB_LATEST_RELEASE_WEB_URL).openConnection() as HttpURLConnection
|
||||
applyNoCacheHeaders(conn)
|
||||
conn.instanceFollowRedirects = false
|
||||
conn.requestMethod = "GET"
|
||||
conn.setRequestProperty("Accept", "text/html,*/*")
|
||||
conn.setRequestProperty("User-Agent", "WDTTAndroid/${BuildConfig.VERSION_NAME}")
|
||||
conn.connectTimeout = 8_000
|
||||
conn.readTimeout = 8_000
|
||||
|
||||
val responseCode = conn.responseCode
|
||||
val location = conn.getHeaderField("Location")
|
||||
if (!location.isNullOrBlank()) {
|
||||
val releaseUrl = URL(URL(GITHUB_LATEST_RELEASE_WEB_URL), location).toString()
|
||||
val versionTag = extractTagFromReleaseUrl(releaseUrl)
|
||||
if (!versionTag.isNullOrBlank()) {
|
||||
return AppReleaseInfo(versionTag, releaseUrl, RemoteVersionSource.Release)
|
||||
}
|
||||
}
|
||||
|
||||
if (responseCode in 200..299) {
|
||||
val response = conn.inputStream.bufferedReader().use { it.readText() }
|
||||
val versionTag = Regex("/releases/tag/([^\"?#<]+)").find(response)?.groupValues?.getOrNull(1)
|
||||
if (!versionTag.isNullOrBlank()) {
|
||||
return AppReleaseInfo(versionTag, "$GITHUB_RELEASE_TAG_URL_PREFIX$versionTag", RemoteVersionSource.Release)
|
||||
}
|
||||
}
|
||||
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: GitHub web fallback returned $responseCode")
|
||||
null
|
||||
} catch (e: Exception) {
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: GitHub web fallback failed", e)
|
||||
null
|
||||
} finally {
|
||||
conn?.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun fetchGitHubApi(url: String): String? {
|
||||
val now = System.currentTimeMillis()
|
||||
if (now < githubApiCooldownUntilMs) return null
|
||||
return fetchHttpText(
|
||||
url = url,
|
||||
sourceLabel = "GitHub API",
|
||||
accept = "application/vnd.github+json",
|
||||
isGitHubApi = true
|
||||
)
|
||||
}
|
||||
|
||||
private fun fetchHttpText(
|
||||
url: String,
|
||||
sourceLabel: String,
|
||||
accept: String,
|
||||
isGitHubApi: Boolean = false
|
||||
): String? {
|
||||
var conn: HttpURLConnection? = null
|
||||
return try {
|
||||
conn = URL(url).openConnection() as HttpURLConnection
|
||||
applyNoCacheHeaders(conn)
|
||||
conn.requestMethod = "GET"
|
||||
conn.setRequestProperty("Accept", accept)
|
||||
if (isGitHubApi) {
|
||||
conn.setRequestProperty("X-GitHub-Api-Version", "2022-11-28")
|
||||
}
|
||||
conn.setRequestProperty("User-Agent", "WDTTAndroid/${BuildConfig.VERSION_NAME}")
|
||||
conn.connectTimeout = 8_000
|
||||
conn.readTimeout = 8_000
|
||||
|
||||
val responseCode = conn.responseCode
|
||||
val stream = if (responseCode in 200..299) conn.inputStream else conn.errorStream
|
||||
val response = stream?.bufferedReader()?.use { it.readText() }.orEmpty()
|
||||
|
||||
if (responseCode in 200..299) {
|
||||
if (isGitHubApi) githubApiCooldownUntilMs = 0L
|
||||
response
|
||||
} else {
|
||||
if (isGitHubApi) noteGitHubApiCooldown(conn, responseCode, response)
|
||||
Log.w(
|
||||
UPDATE_LOG_TAG,
|
||||
"[WARN] Update check: $sourceLabel returned $responseCode ${response.take(300)}"
|
||||
)
|
||||
null
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
Log.w(UPDATE_LOG_TAG, "[WARN] Update check: $sourceLabel request failed", e)
|
||||
null
|
||||
} finally {
|
||||
conn?.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun applyNoCacheHeaders(conn: HttpURLConnection) {
|
||||
conn.useCaches = false
|
||||
conn.setRequestProperty("Cache-Control", "no-cache, no-store, max-age=0")
|
||||
conn.setRequestProperty("Pragma", "no-cache")
|
||||
conn.setRequestProperty("Expires", "0")
|
||||
}
|
||||
|
||||
private fun noteGitHubApiCooldown(conn: HttpURLConnection, responseCode: Int, response: String) {
|
||||
if (responseCode != HttpURLConnection.HTTP_FORBIDDEN && responseCode != 429) return
|
||||
val now = System.currentTimeMillis()
|
||||
val retryAfterUntil = conn.getHeaderField("Retry-After")?.trim()?.toLongOrNull()?.takeIf { it > 0L }?.let { now + it * 1000L }
|
||||
val rateLimitResetUntil = conn.getHeaderField("X-RateLimit-Reset")?.trim()?.toLongOrNull()?.takeIf { it > 0L }?.let { it * 1000L }
|
||||
val fallbackUntil = now + if (response.contains("rate limit", ignoreCase = true)) GITHUB_API_RATE_LIMIT_FALLBACK_MS else 5L * 60L * 1000L
|
||||
val cooldownUntil = listOfNotNull(retryAfterUntil, rateLimitResetUntil).filter { it > now }.minOrNull() ?: fallbackUntil
|
||||
if (cooldownUntil > githubApiCooldownUntilMs) {
|
||||
githubApiCooldownUntilMs = cooldownUntil
|
||||
Log.w(
|
||||
UPDATE_LOG_TAG,
|
||||
"[WARN] Update check: GitHub API cooldown ${(cooldownUntil - now) / 1000}s after HTTP $responseCode"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private fun JSONObject.toAppReleaseInfo(): AppReleaseInfo? {
|
||||
val versionTag = normalizeVersionTag(optString("tag_name"))
|
||||
val releaseUrl = optString("html_url").trim()
|
||||
if (versionTag.isBlank() || releaseUrl.isBlank()) return null
|
||||
return AppReleaseInfo(versionTag, releaseUrl, RemoteVersionSource.Release)
|
||||
}
|
||||
|
||||
private fun versionParts(version: String): List<Int> {
|
||||
val normalized = VERSION_NUMBER_REGEX.find(version.trim())?.value ?: return emptyList()
|
||||
return normalized.split(".").mapNotNull { it.toIntOrNull() }
|
||||
}
|
||||
|
||||
private fun normalizeVersionTag(version: String): String {
|
||||
val trimmed = version.trim()
|
||||
if (trimmed.isBlank()) return ""
|
||||
return if (trimmed.startsWith("v", ignoreCase = true)) trimmed else "v$trimmed"
|
||||
}
|
||||
|
||||
private fun extractTagFromReleaseUrl(releaseUrl: String): String? {
|
||||
val marker = "/releases/tag/"
|
||||
val index = releaseUrl.indexOf(marker)
|
||||
if (index < 0) return null
|
||||
return releaseUrl.substring(index + marker.length)
|
||||
.substringBefore("?")
|
||||
.substringBefore("#")
|
||||
.substringBefore("/")
|
||||
.takeIf { it.isNotBlank() }
|
||||
?.let(::normalizeVersionTag)
|
||||
}
|
||||
@@ -0,0 +1,599 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import android.util.Log
|
||||
import android.view.MotionEvent
|
||||
import android.view.View
|
||||
import android.webkit.JavascriptInterface
|
||||
import android.webkit.WebResourceRequest
|
||||
import android.webkit.WebResourceResponse
|
||||
import android.webkit.WebChromeClient
|
||||
import android.webkit.WebView
|
||||
import android.webkit.WebViewClient
|
||||
import kotlinx.coroutines.CompletableDeferred
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import java.util.concurrent.CountDownLatch
|
||||
import java.util.concurrent.TimeUnit
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import java.util.concurrent.atomic.AtomicReference
|
||||
import kotlin.coroutines.cancellation.CancellationException
|
||||
import kotlin.random.Random
|
||||
|
||||
/**
|
||||
* Управляет «невидимым» WebView для автоматического прохождения VK Smart Captcha.
|
||||
*
|
||||
* Один запрос = один свежий WebView:
|
||||
* 1. Создаёт WebView с рандомизированным fingerprint (UA, viewport)
|
||||
* 2. Загружает redirect_uri, ждёт короткую паузу загрузки
|
||||
* 3. Находит чекбокс "Я не робот" (label.vkc__Checkbox-module__Checkbox)
|
||||
* 4. Кликает в рандомную точку внутри label с коротким human-like таймингом
|
||||
* 5. JS-interceptor перехватывает captchaNotRobot.check → success_token
|
||||
* 6. Уничтожает WebView
|
||||
*/
|
||||
object CaptchaWebViewManager {
|
||||
|
||||
private const val TAG = "CaptchaWV"
|
||||
private const val CAPTCHA_TIMEOUT_MS = 10_000L
|
||||
private const val WV_CREATE_TIMEOUT_MS = 3000L
|
||||
const val ERROR_SLIDER_DETECTED = "slider_detected"
|
||||
|
||||
// Рандомизируемые параметры viewport (чтобы VK не видел одинаковый size)
|
||||
private val VIEWPORT_WIDTHS = intArrayOf(356, 358, 360, 362, 364, 366, 368)
|
||||
private val VIEWPORT_HEIGHTS = intArrayOf(376, 378, 380, 382, 384, 386, 388)
|
||||
|
||||
// Пул Chrome-версий (minor builds) для варьирования
|
||||
private val CHROME_BUILDS = arrayOf(
|
||||
"146.0.0.0", "145.0.6422.60", "145.0.6422.53",
|
||||
"144.0.6367.78", "144.0.6367.61", "143.0.6312.99"
|
||||
)
|
||||
|
||||
private val mainHandler = Handler(Looper.getMainLooper())
|
||||
private val captchaMutex = Mutex()
|
||||
|
||||
@Volatile
|
||||
private var isTunnelActive = false
|
||||
|
||||
@Volatile
|
||||
private var appContext: Context? = null
|
||||
|
||||
private val pendingResult = AtomicReference<CompletableDeferred<Result<String>>?>(null)
|
||||
private val postClickSliderWatcher = AtomicReference<Runnable?>(null)
|
||||
|
||||
@Volatile
|
||||
private var currentWebView: WebView? = null
|
||||
|
||||
// Interceptor: перехватывает ответ captchaNotRobot.check → достаёт success_token
|
||||
private val interceptorJSCode = """
|
||||
(function() {
|
||||
if (window.__wdtt_interceptor_installed) return;
|
||||
window.__wdtt_interceptor_installed = true;
|
||||
|
||||
const origFetch = window.fetch;
|
||||
window.fetch = async function() {
|
||||
const args = arguments;
|
||||
const url = args[0] || '';
|
||||
if (typeof url === 'string' && url.includes('captchaNotRobot.check')) {
|
||||
const response = await origFetch.apply(this, args);
|
||||
const clone = response.clone();
|
||||
try {
|
||||
const data = await clone.json();
|
||||
if (data.response && data.response.success_token) {
|
||||
window.WdttCaptcha.onSuccess(data.response.success_token);
|
||||
} else if (
|
||||
data.response &&
|
||||
data.response.show_captcha_type === 'slider'
|
||||
) {
|
||||
window.WdttCaptcha.onSliderDetected('check_response');
|
||||
} else if (data.error) {
|
||||
window.WdttCaptcha.onError(JSON.stringify(data.error));
|
||||
}
|
||||
} catch(e) {}
|
||||
return response;
|
||||
}
|
||||
return origFetch.apply(this, args);
|
||||
};
|
||||
|
||||
const origXHROpen = XMLHttpRequest.prototype.open;
|
||||
const origXHRSend = XMLHttpRequest.prototype.send;
|
||||
XMLHttpRequest.prototype.open = function(method, url) {
|
||||
this._wdtt_url = url;
|
||||
return origXHROpen.apply(this, arguments);
|
||||
};
|
||||
XMLHttpRequest.prototype.send = function() {
|
||||
const xhr = this;
|
||||
if (xhr._wdtt_url && xhr._wdtt_url.includes('captchaNotRobot.check')) {
|
||||
xhr.addEventListener('load', function() {
|
||||
try {
|
||||
const data = JSON.parse(xhr.responseText);
|
||||
if (data.response && data.response.success_token) {
|
||||
window.WdttCaptcha.onSuccess(data.response.success_token);
|
||||
} else if (
|
||||
data.response &&
|
||||
data.response.show_captcha_type === 'slider'
|
||||
) {
|
||||
window.WdttCaptcha.onSliderDetected('check_response');
|
||||
} else if (data.error) {
|
||||
window.WdttCaptcha.onError(JSON.stringify(data.error));
|
||||
}
|
||||
} catch(e) {}
|
||||
});
|
||||
}
|
||||
return origXHRSend.apply(this, arguments);
|
||||
};
|
||||
})();
|
||||
""".trimIndent()
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// Lifecycle
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
fun onTunnelStart(context: Context) {
|
||||
appContext = context.applicationContext
|
||||
isTunnelActive = true
|
||||
Log.d(TAG, "Туннель активен")
|
||||
}
|
||||
|
||||
fun onTunnelStop() {
|
||||
isTunnelActive = false
|
||||
cancelPendingResult("tunnel stopped")
|
||||
destroyCurrentWebView()
|
||||
appContext = null
|
||||
Log.d(TAG, "Туннель остановлен")
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// Публичный API
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
suspend fun solveCaptchaAsync(redirectUri: String, sessionToken: String, onStep: (String) -> Unit = {}): String {
|
||||
if (!isTunnelActive) throw IllegalStateException("WV не готов — туннель не активен")
|
||||
val ctx = appContext ?: throw IllegalStateException("WV не готов — контекст null")
|
||||
|
||||
// Используем Mutex вместо AtomicBoolean: если запрашивается вторая капча до закрытия первой,
|
||||
// она просто подождет в очереди (несколько секунд), вместо того чтобы вылетать с ошибкой.
|
||||
return captchaMutex.withLock {
|
||||
try {
|
||||
withTimeout(CAPTCHA_TIMEOUT_MS) {
|
||||
doSolveCaptcha(ctx, redirectUri, onStep)
|
||||
}
|
||||
} finally {
|
||||
pendingResult.set(null)
|
||||
destroyCurrentWebView()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// Внутренняя логика
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
private suspend fun doSolveCaptcha(context: Context, redirectUri: String, onStep: (String) -> Unit): String {
|
||||
val deferred = CompletableDeferred<Result<String>>()
|
||||
pendingResult.set(deferred)
|
||||
|
||||
val webView = createWebViewSync(context, onStep)
|
||||
?: throw IllegalStateException("Не удалось создать WebView")
|
||||
|
||||
Log.d(TAG, "WebView создан ✓")
|
||||
|
||||
// Загружаем страницу капчи
|
||||
withContext(Dispatchers.Main) {
|
||||
webView.evaluateJavascript(interceptorJSCode, null)
|
||||
kotlinx.coroutines.delay(80)
|
||||
webView.loadUrl(redirectUri)
|
||||
}
|
||||
|
||||
// Ждём success_token от JS-bridge
|
||||
try {
|
||||
val token = deferred.await().getOrThrow()
|
||||
Log.d(TAG, "Капча решена ✓")
|
||||
return token
|
||||
} catch (e: CancellationException) {
|
||||
throw e
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "Ошибка: ${e::class.simpleName} — ${e.message}")
|
||||
throw e
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// Создание WebView с рандомизированным fingerprint
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
@SuppressLint("SetJavaScriptEnabled")
|
||||
private fun createWebViewSync(context: Context, onStep: (String) -> Unit): WebView? {
|
||||
// Рандомизируем параметры для КАЖДОГО запроса
|
||||
val vw = VIEWPORT_WIDTHS[Random.Default.nextInt(VIEWPORT_WIDTHS.size)]
|
||||
val vh = VIEWPORT_HEIGHTS[Random.Default.nextInt(VIEWPORT_HEIGHTS.size)]
|
||||
val chromeBuild = CHROME_BUILDS[Random.Default.nextInt(CHROME_BUILDS.size)]
|
||||
val ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$chromeBuild Safari/537.36"
|
||||
|
||||
Log.d(TAG, "Fingerprint: ${vw}x${vh}, Chrome/$chromeBuild")
|
||||
|
||||
val latch = CountDownLatch(1)
|
||||
var webView: WebView? = null
|
||||
|
||||
val createAction = Runnable {
|
||||
try {
|
||||
val wv = WebView(context.applicationContext)
|
||||
wv.apply {
|
||||
settings.apply {
|
||||
javaScriptEnabled = true
|
||||
domStorageEnabled = true
|
||||
databaseEnabled = true
|
||||
mediaPlaybackRequiresUserGesture = false
|
||||
loadWithOverviewMode = true
|
||||
useWideViewPort = true
|
||||
blockNetworkLoads = false
|
||||
cacheMode = android.webkit.WebSettings.LOAD_NO_CACHE
|
||||
userAgentString = ua
|
||||
}
|
||||
|
||||
addJavascriptInterface(CaptchaJSBridge(), "WdttCaptcha")
|
||||
|
||||
webViewClient = object : WebViewClient() {
|
||||
override fun onPageStarted(
|
||||
view: WebView, url: String?, favicon: android.graphics.Bitmap?
|
||||
) {
|
||||
super.onPageStarted(view, url, favicon)
|
||||
view.evaluateJavascript(interceptorJSCode, null)
|
||||
}
|
||||
|
||||
override fun onPageFinished(view: WebView, url: String?) {
|
||||
super.onPageFinished(view, url)
|
||||
|
||||
val isCaptchaPage = url?.let {
|
||||
it.contains("not_robot_captcha") ||
|
||||
it.contains("id.vk.ru/captcha") ||
|
||||
it.contains("not_robot")
|
||||
} ?: false
|
||||
|
||||
if (isCaptchaPage) {
|
||||
Log.d(TAG, "Страница капчи загружена")
|
||||
view.evaluateJavascript(interceptorJSCode, null)
|
||||
|
||||
if (currentWebView === view && isTunnelActive) {
|
||||
// Быстрый auto-pass: WebView получает такой же короткий темп, как Go v2.
|
||||
val pageLoadDelay = 650L + Random.Default.nextLong(0, 550)
|
||||
mainHandler.postDelayed({
|
||||
if (currentWebView === view && isTunnelActive) {
|
||||
solveCaptchaAutomatedSync(view)
|
||||
}
|
||||
}, pageLoadDelay)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun shouldInterceptRequest(
|
||||
view: WebView, request: WebResourceRequest
|
||||
): WebResourceResponse? {
|
||||
return super.shouldInterceptRequest(view, request)
|
||||
}
|
||||
|
||||
override fun onReceivedSslError(
|
||||
view: WebView,
|
||||
handler: android.webkit.SslErrorHandler,
|
||||
error: android.net.http.SslError
|
||||
) {
|
||||
// Разрешаем только для доверенных доменов VK/OK
|
||||
val url = error.url ?: ""
|
||||
if (url.contains("vk.ru") || url.contains("vk.com") || url.contains("okcdn.ru")) {
|
||||
handler.proceed()
|
||||
} else {
|
||||
handler.cancel()
|
||||
Log.w(TAG, "SSL error rejected for: $url")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
webChromeClient = WebChromeClient()
|
||||
|
||||
measure(
|
||||
View.MeasureSpec.makeMeasureSpec(vw, View.MeasureSpec.EXACTLY),
|
||||
View.MeasureSpec.makeMeasureSpec(vh, View.MeasureSpec.EXACTLY)
|
||||
)
|
||||
layout(0, 0, vw, vh)
|
||||
onResume()
|
||||
}
|
||||
webView = wv
|
||||
currentWebView = wv
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "Ошибка создания WebView: ${e.message}")
|
||||
webView = null
|
||||
} finally {
|
||||
latch.countDown()
|
||||
}
|
||||
}
|
||||
|
||||
if (Looper.myLooper() == Looper.getMainLooper()) {
|
||||
createAction.run()
|
||||
} else {
|
||||
mainHandler.post(createAction)
|
||||
}
|
||||
|
||||
val ok = latch.await(WV_CREATE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
|
||||
if (!ok) {
|
||||
Log.e(TAG, "Таймаут создания WebView")
|
||||
return null
|
||||
}
|
||||
return webView
|
||||
}
|
||||
|
||||
private fun destroyCurrentWebView() {
|
||||
val wv = currentWebView ?: return
|
||||
currentWebView = null
|
||||
postClickSliderWatcher.getAndSet(null)?.let { mainHandler.removeCallbacks(it) }
|
||||
|
||||
val destroyAction = Runnable {
|
||||
try {
|
||||
wv.stopLoading()
|
||||
wv.loadUrl("about:blank")
|
||||
try { wv.removeJavascriptInterface("WdttCaptcha") } catch (_: Exception) {}
|
||||
wv.webViewClient = WebViewClient()
|
||||
wv.webChromeClient = null
|
||||
wv.onPause()
|
||||
wv.removeAllViews()
|
||||
wv.destroy()
|
||||
Log.d(TAG, "WebView уничтожен ✓")
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "Ошибка уничтожения: ${e.message}")
|
||||
}
|
||||
}
|
||||
|
||||
if (Looper.myLooper() == Looper.getMainLooper()) {
|
||||
destroyAction.run()
|
||||
} else {
|
||||
val latch = CountDownLatch(1)
|
||||
mainHandler.post {
|
||||
try { destroyAction.run() } finally { latch.countDown() }
|
||||
}
|
||||
latch.await(2000, TimeUnit.MILLISECONDS)
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// Авто-решение: клик по чекбоксу «Я не робот»
|
||||
//
|
||||
// Структура VK капчи (из HTML):
|
||||
// label.vkc__Checkbox-module__Checkbox ← КЛИКАБЕЛЬНЫЙ label (~200x32px)
|
||||
// input#not-robot-captcha-checkbox ← скрытый checkbox
|
||||
// div.vkc__Checkbox-module__Checkbox__iconBlock ← иконка чекбокса
|
||||
// div.vkc__Checkbox-module__Checkbox__title ← текст "Я не робот"
|
||||
//
|
||||
// Стратегия: находим ВЕСЬ label, получаем его размеры,
|
||||
// кликаем в РАНДОМНУЮ точку внутри него (не в центр).
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
private fun solveCaptchaAutomatedSync(webView: WebView) {
|
||||
if (currentWebView !== webView || !isTunnelActive) return
|
||||
|
||||
// Ищем LABEL целиком (он большой, ~200x32px — как человек кликает).
|
||||
// Если вместо checkbox открыт slider/kaleidoscope, скрытый WebView сразу отдаёт fallback ручному WV.
|
||||
val findLabelJS = """
|
||||
(function() {
|
||||
var slider = document.querySelector(
|
||||
'[class*="SliderCaptcha"], [class*="Kaleidoscope"], ' +
|
||||
'.vkc__SliderCaptcha-module__description, ' +
|
||||
'.vkc__KaleidoscopeScreen-module__captchaId'
|
||||
);
|
||||
if (slider) return '${ERROR_SLIDER_DETECTED}';
|
||||
|
||||
// Приоритет: label обёртка (самый большой кликабельный элемент)
|
||||
var el = document.querySelector('label.vkc__Checkbox-module__Checkbox');
|
||||
// Fallback: прямой поиск по ID
|
||||
if (!el) el = document.querySelector('label[for="not-robot-captcha-checkbox"]');
|
||||
// Fallback: сам чекбокс
|
||||
if (!el) el = document.getElementById('not-robot-captcha-checkbox');
|
||||
if (!el) return 'not_found';
|
||||
|
||||
var rect = el.getBoundingClientRect();
|
||||
var style = window.getComputedStyle(el);
|
||||
if (rect.width < 5 || rect.height < 5 ||
|
||||
style.display === 'none' || style.visibility === 'hidden') {
|
||||
return 'not_found';
|
||||
}
|
||||
// Возвращаем left,top,width,height — чтобы кликнуть в РАНДОМНУЮ точку
|
||||
return rect.left + ',' + rect.top + ',' + rect.width + ',' + rect.height;
|
||||
})();
|
||||
""".trimIndent()
|
||||
|
||||
webView.evaluateJavascript(findLabelJS) { rawValue ->
|
||||
val result = rawValue?.replace("\"", "") ?: ""
|
||||
Log.d(TAG, "Label чекбокса: $result")
|
||||
|
||||
if (currentWebView !== webView || !isTunnelActive) return@evaluateJavascript
|
||||
|
||||
if (result == ERROR_SLIDER_DETECTED) {
|
||||
Log.i(TAG, "Обнаружен слайдер — fallback на ручной WebView")
|
||||
notifyResult(Result.failure(IllegalStateException(ERROR_SLIDER_DETECTED)))
|
||||
return@evaluateJavascript
|
||||
}
|
||||
|
||||
if (result == "not_found" || result.split(",").size < 4) {
|
||||
// Fallback: JS .click() — не идеально, но лучше чем ничего
|
||||
Log.w(TAG, "Label не найден — JS-клик (fallback)")
|
||||
val jsClick = """
|
||||
(function() {
|
||||
var el = document.querySelector('label.vkc__Checkbox-module__Checkbox');
|
||||
if (!el) el = document.getElementById('not-robot-captcha-checkbox');
|
||||
if (el) { el.click(); return 'clicked'; }
|
||||
return 'nothing';
|
||||
})();
|
||||
""".trimIndent()
|
||||
webView.evaluateJavascript(jsClick) { clickResult ->
|
||||
if ((clickResult ?: "").replace("\"", "") == "clicked") {
|
||||
startPostClickSliderWatcher(webView)
|
||||
}
|
||||
}
|
||||
return@evaluateJavascript
|
||||
}
|
||||
|
||||
val parts = result.split(",")
|
||||
val left = parts[0].toFloatOrNull() ?: return@evaluateJavascript
|
||||
val top = parts[1].toFloatOrNull() ?: return@evaluateJavascript
|
||||
val width = parts[2].toFloatOrNull() ?: return@evaluateJavascript
|
||||
val height = parts[3].toFloatOrNull() ?: return@evaluateJavascript
|
||||
|
||||
// Рандомная точка внутри label (60-90% ширины, 25-75% высоты)
|
||||
// Человек кликает не ровно в центр, а примерно туда
|
||||
val randX = left + width * (0.15f + Random.Default.nextFloat() * 0.7f)
|
||||
val randY = top + height * (0.25f + Random.Default.nextFloat() * 0.5f)
|
||||
|
||||
Log.d(TAG, "Клик: (${randX.toInt()}, ${randY.toInt()}) в зоне ${width.toInt()}x${height.toInt()}")
|
||||
|
||||
val thinkDelay = 420L + Random.Default.nextLong(0, 260)
|
||||
|
||||
mainHandler.postDelayed({
|
||||
if (currentWebView === webView && isTunnelActive) {
|
||||
simulateHumanTouch(webView, randX, randY)
|
||||
startPostClickSliderWatcher(webView)
|
||||
}
|
||||
}, thinkDelay)
|
||||
}
|
||||
}
|
||||
|
||||
private fun startPostClickSliderWatcher(webView: WebView) {
|
||||
postClickSliderWatcher.getAndSet(null)?.let { mainHandler.removeCallbacks(it) }
|
||||
|
||||
var attemptsLeft = 14
|
||||
val watcher = object : Runnable {
|
||||
override fun run() {
|
||||
if (currentWebView !== webView || !isTunnelActive) return
|
||||
|
||||
val detectSliderJS = """
|
||||
(function() {
|
||||
var slider = document.querySelector(
|
||||
'[class*="SliderCaptcha"], [class*="Kaleidoscope"], ' +
|
||||
'.vkc__SliderCaptcha-module__description, ' +
|
||||
'.vkc__KaleidoscopeScreen-module__captchaId, ' +
|
||||
'.vkc__SwipeButton-module__track'
|
||||
);
|
||||
if (slider) return 'slider';
|
||||
|
||||
var success = document.querySelector(
|
||||
'[class*="success"], [class*="Success"], [class*="passed"], [class*="Passed"]'
|
||||
);
|
||||
if (success) return 'success_ui';
|
||||
|
||||
return 'none';
|
||||
})();
|
||||
""".trimIndent()
|
||||
|
||||
webView.evaluateJavascript(detectSliderJS) { rawValue ->
|
||||
if (currentWebView !== webView || !isTunnelActive) return@evaluateJavascript
|
||||
|
||||
val result = rawValue?.replace("\"", "") ?: "none"
|
||||
when (result) {
|
||||
"slider" -> {
|
||||
Log.i(TAG, "После checkbox появился слайдер — fallback на ручной WebView")
|
||||
notifyResult(Result.failure(IllegalStateException(ERROR_SLIDER_DETECTED)))
|
||||
}
|
||||
"success_ui" -> {
|
||||
postClickSliderWatcher.set(null)
|
||||
}
|
||||
else -> {
|
||||
attemptsLeft--
|
||||
if (attemptsLeft > 0) {
|
||||
mainHandler.postDelayed(this, 350L)
|
||||
} else {
|
||||
postClickSliderWatcher.set(null)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
postClickSliderWatcher.set(watcher)
|
||||
mainHandler.postDelayed(watcher, 450L)
|
||||
}
|
||||
|
||||
/**
|
||||
* Имитирует нативный тач как от пальца:
|
||||
* - ACTION_DOWN с рандомным pressure (0.5-0.9)
|
||||
* - Удержание 80-180мс (как палец на экране)
|
||||
* - ACTION_UP с лёгким смещением (палец дрожит)
|
||||
*/
|
||||
private fun simulateHumanTouch(webView: WebView, cssX: Float, cssY: Float) {
|
||||
if (currentWebView !== webView) return
|
||||
|
||||
val density = webView.resources.displayMetrics.density
|
||||
val physX = cssX * density
|
||||
val physY = cssY * density
|
||||
val downTime = SystemClock.uptimeMillis()
|
||||
|
||||
// Рандомный pressure — палец нажимает с разной силой
|
||||
val pressure = 0.5f + Random.Default.nextFloat() * 0.4f
|
||||
|
||||
val downEvent = MotionEvent.obtain(
|
||||
downTime, downTime, MotionEvent.ACTION_DOWN, physX, physY, pressure, 1f, 0, 1f, 1f, 0, 0
|
||||
)
|
||||
downEvent.source = android.view.InputDevice.SOURCE_TOUCHSCREEN
|
||||
webView.dispatchTouchEvent(downEvent)
|
||||
downEvent.recycle()
|
||||
|
||||
// Удержание пальца: 80-180мс
|
||||
val holdTime = 80L + Random.Default.nextLong(0, 100)
|
||||
|
||||
mainHandler.postDelayed({
|
||||
if (currentWebView === webView) {
|
||||
// Лёгкое смещение при отпускании (палец не стоит идеально на месте)
|
||||
val jitterX = physX + (-1f + Random.Default.nextFloat() * 2f) * density
|
||||
val jitterY = physY + (-0.5f + Random.Default.nextFloat() * 1f) * density
|
||||
|
||||
val upEvent = MotionEvent.obtain(
|
||||
downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_UP,
|
||||
jitterX, jitterY, 0f, 1f, 0, 1f, 1f, 0, 0
|
||||
)
|
||||
upEvent.source = android.view.InputDevice.SOURCE_TOUCHSCREEN
|
||||
webView.dispatchTouchEvent(upEvent)
|
||||
upEvent.recycle()
|
||||
}
|
||||
}, holdTime)
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// JS Bridge — вызывается из JavaScript background thread
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
||||
private class CaptchaJSBridge {
|
||||
@JavascriptInterface
|
||||
fun onSuccess(token: String) {
|
||||
Log.d(TAG, "JS: success_token получен (${token.length} символов)")
|
||||
notifyResult(Result.success(token))
|
||||
}
|
||||
|
||||
@JavascriptInterface
|
||||
fun onSliderDetected(source: String) {
|
||||
Log.i(TAG, "JS: обнаружен slider после auto-step ($source)")
|
||||
notifyResult(Result.failure(IllegalStateException(ERROR_SLIDER_DETECTED)))
|
||||
}
|
||||
|
||||
@JavascriptInterface
|
||||
fun onError(error: String) {
|
||||
Log.e(TAG, "JS: ошибка — $error")
|
||||
notifyResult(Result.failure(Exception("VK: $error")))
|
||||
}
|
||||
}
|
||||
|
||||
private fun notifyResult(result: Result<String>) {
|
||||
val deferred = pendingResult.getAndSet(null) ?: return
|
||||
if (!deferred.isCompleted) {
|
||||
deferred.complete(result)
|
||||
}
|
||||
}
|
||||
|
||||
private fun cancelPendingResult(reason: String) {
|
||||
val deferred = pendingResult.getAndSet(null) ?: return
|
||||
if (!deferred.isCompleted) {
|
||||
deferred.complete(Result.failure(CancellationException(reason)))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.content.Context
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import java.io.File
|
||||
import java.text.SimpleDateFormat
|
||||
import java.util.Date
|
||||
import java.util.Locale
|
||||
|
||||
object DeployManager {
|
||||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
|
||||
|
||||
val isDeploying = MutableStateFlow(false)
|
||||
val deployProgress = MutableStateFlow(0f)
|
||||
val currentStep = MutableStateFlow("")
|
||||
val lastResult = MutableStateFlow("") // "success", "error: ...", ""
|
||||
|
||||
@Volatile
|
||||
var activeSession: com.jcraft.jsch.Session? = null
|
||||
private var deployStartTime = 0L
|
||||
private var errorsFile: File? = null
|
||||
private val dateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
|
||||
|
||||
/** Вызвать один раз при старте приложения */
|
||||
fun init(context: Context) {
|
||||
val dir = context.getExternalFilesDir(null) ?: context.filesDir
|
||||
errorsFile = File(dir, "errors.log")
|
||||
}
|
||||
|
||||
fun getErrorsFile(): File? = errorsFile
|
||||
|
||||
/** Записать ошибку в файл (потокобезопасно) */
|
||||
@Synchronized
|
||||
fun writeError(msg: String) {
|
||||
val file = errorsFile ?: return
|
||||
try {
|
||||
val timestamp = dateFormat.format(Date())
|
||||
file.appendText("[$timestamp] $msg\n")
|
||||
// Ротация: если файл > 500 КБ, обрезаем до последних 200 КБ
|
||||
if (file.length() > 500_000) {
|
||||
val text = file.readText()
|
||||
file.writeText(text.takeLast(200_000))
|
||||
}
|
||||
} catch (_: Exception) { }
|
||||
}
|
||||
|
||||
fun startDeploy() {
|
||||
// Автосброс зависшего деплоя > 30 минут
|
||||
if (isDeploying.value && deployStartTime > 0 &&
|
||||
System.currentTimeMillis() - deployStartTime > 30 * 60 * 1000) {
|
||||
writeError("Автосброс: предыдущий деплой завис >30 мин")
|
||||
forceReset()
|
||||
}
|
||||
isDeploying.value = true
|
||||
deployStartTime = System.currentTimeMillis()
|
||||
deployProgress.value = 0f
|
||||
currentStep.value = "Инициализация..."
|
||||
lastResult.value = ""
|
||||
}
|
||||
|
||||
fun stopDeploy(result: String = "") {
|
||||
isDeploying.value = false
|
||||
deployStartTime = 0L
|
||||
if (result.isNotBlank()) lastResult.value = result
|
||||
val session = activeSession
|
||||
activeSession = null
|
||||
try { session?.disconnect() } catch (_: Exception) {}
|
||||
}
|
||||
|
||||
/** Принудительный сброс — для восстановления из любого состояния */
|
||||
fun forceReset() {
|
||||
val session = activeSession
|
||||
activeSession = null
|
||||
try { session?.disconnect() } catch (_: Exception) {}
|
||||
isDeploying.value = false
|
||||
deployStartTime = 0L
|
||||
deployProgress.value = 0f
|
||||
currentStep.value = ""
|
||||
}
|
||||
|
||||
fun updateProgress(progress: Float, step: String) {
|
||||
deployProgress.value = progress
|
||||
currentStep.value = step
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,671 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.Manifest
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.net.Uri
|
||||
import android.net.VpnService
|
||||
import android.os.Build
|
||||
import android.os.Bundle
|
||||
import android.os.PowerManager
|
||||
import android.provider.Settings
|
||||
import android.util.Log
|
||||
import android.view.HapticFeedbackConstants
|
||||
import android.widget.Toast
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.activity.enableEdgeToEdge
|
||||
import androidx.activity.result.contract.ActivityResultContracts
|
||||
import androidx.compose.animation.AnimatedContent
|
||||
import androidx.compose.animation.core.Animatable
|
||||
import androidx.compose.animation.core.CubicBezierEasing
|
||||
import androidx.compose.animation.core.tween
|
||||
import androidx.compose.animation.fadeIn
|
||||
import androidx.compose.animation.fadeOut
|
||||
import androidx.compose.animation.togetherWith
|
||||
import androidx.compose.foundation.BorderStroke
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.border
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.gestures.detectHorizontalDragGestures
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.shape.GenericShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import kotlinx.coroutines.launch
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Cloud
|
||||
import androidx.compose.material.icons.filled.FilterList
|
||||
import androidx.compose.material.icons.filled.Info
|
||||
import androidx.compose.material.icons.filled.Terminal
|
||||
import androidx.compose.material.icons.filled.VpnKey
|
||||
import androidx.compose.material.icons.outlined.Cloud
|
||||
import androidx.compose.material.icons.outlined.FilterList
|
||||
import androidx.compose.material.icons.outlined.Info
|
||||
import androidx.compose.material.icons.outlined.Terminal
|
||||
import androidx.compose.material.icons.outlined.VpnKey
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.graphics.Brush
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.Shape
|
||||
import androidx.compose.ui.graphics.lerp
|
||||
import androidx.compose.ui.graphics.luminance
|
||||
import androidx.compose.ui.graphics.vector.ImageVector
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.ui.platform.LocalView
|
||||
import androidx.compose.ui.platform.LocalDensity
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.core.content.ContextCompat
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import com.wdtt.client.ui.AppUpdateDialog
|
||||
import com.wdtt.client.ui.FloatingToolbar
|
||||
import com.wdtt.client.ui.LogsTab
|
||||
import com.wdtt.client.ui.SettingsTab
|
||||
import com.wdtt.client.ui.DeployTab
|
||||
import com.wdtt.client.ui.ExceptionsTab
|
||||
import com.wdtt.client.ui.InfoTab
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlin.math.PI
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.min
|
||||
import kotlin.math.sin
|
||||
|
||||
class MainActivity : ComponentActivity() {
|
||||
|
||||
private val vpnLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
|
||||
// VPN permission dialog finished
|
||||
}
|
||||
|
||||
private val batteryLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
|
||||
checkAndRequestVpn()
|
||||
}
|
||||
|
||||
private val notificationLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) {
|
||||
checkAndRequestBattery()
|
||||
}
|
||||
|
||||
companion object {
|
||||
var activeActivities = 0
|
||||
var isForeground: Boolean
|
||||
get() = activeActivities > 0
|
||||
set(value) {}
|
||||
}
|
||||
|
||||
override fun onStart() {
|
||||
super.onStart()
|
||||
activeActivities++
|
||||
ManlCaptchaWebViewManager.checkAndShowPendingCaptcha(this)
|
||||
}
|
||||
|
||||
override fun onStop() {
|
||||
super.onStop()
|
||||
activeActivities--
|
||||
}
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
enableEdgeToEdge()
|
||||
|
||||
checkAndRequestNotifications()
|
||||
|
||||
setContent {
|
||||
val settingsStore = remember { SettingsStore(this) }
|
||||
val themeMode by settingsStore.themeMode.collectAsStateWithLifecycle(initialValue = "system")
|
||||
val isDynamicColor by settingsStore.isDynamicColor.collectAsStateWithLifecycle(initialValue = false)
|
||||
val themePalette by settingsStore.themePalette.collectAsStateWithLifecycle(initialValue = "indigo")
|
||||
val scope = rememberCoroutineScope()
|
||||
|
||||
WDTTTheme(themeMode = themeMode, dynamicColor = isDynamicColor, themePalette = themePalette) {
|
||||
MainScreen(
|
||||
settingsStore = settingsStore,
|
||||
themeMode = themeMode,
|
||||
onThemeChange = { mode ->
|
||||
scope.launch {
|
||||
settingsStore.saveThemeMode(mode)
|
||||
}
|
||||
},
|
||||
isDynamicColor = isDynamicColor,
|
||||
onDynamicColorChange = { enabled ->
|
||||
scope.launch { settingsStore.saveDynamicColor(enabled) }
|
||||
},
|
||||
currentPalette = themePalette,
|
||||
onPaletteChange = { palette ->
|
||||
scope.launch { settingsStore.saveThemePalette(palette) }
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun checkAndRequestNotifications() {
|
||||
if (Build.VERSION.SDK_INT >= 33) {
|
||||
if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
|
||||
notificationLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
|
||||
} else {
|
||||
checkAndRequestBattery()
|
||||
}
|
||||
} else {
|
||||
checkAndRequestBattery()
|
||||
}
|
||||
}
|
||||
|
||||
private fun checkAndRequestBattery() {
|
||||
val pm = getSystemService(Context.POWER_SERVICE) as PowerManager
|
||||
if (!pm.isIgnoringBatteryOptimizations(packageName)) {
|
||||
try {
|
||||
val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
|
||||
data = Uri.parse("package:$packageName")
|
||||
}
|
||||
batteryLauncher.launch(intent)
|
||||
} catch (e: Exception) {
|
||||
checkAndRequestVpn()
|
||||
}
|
||||
} else {
|
||||
checkAndRequestVpn()
|
||||
}
|
||||
}
|
||||
|
||||
private fun checkAndRequestVpn() {
|
||||
try {
|
||||
val vpnIntent = VpnService.prepare(this)
|
||||
if (vpnIntent != null) {
|
||||
vpnLauncher.launch(vpnIntent)
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
e.printStackTrace()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Навигация ═══
|
||||
|
||||
private data class NavItem(
|
||||
val label: String,
|
||||
val selectedIcon: ImageVector,
|
||||
val unselectedIcon: ImageVector,
|
||||
)
|
||||
|
||||
private val navItems = listOf(
|
||||
NavItem("Туннель", Icons.Filled.VpnKey, Icons.Outlined.VpnKey),
|
||||
NavItem("Деплой", Icons.Filled.Cloud, Icons.Outlined.Cloud),
|
||||
NavItem("Исключ.", Icons.Filled.FilterList, Icons.Outlined.FilterList),
|
||||
NavItem("Логи", Icons.Filled.Terminal, Icons.Outlined.Terminal),
|
||||
NavItem("Инфо", Icons.Filled.Info, Icons.Outlined.Info),
|
||||
)
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun MainScreen(
|
||||
settingsStore: SettingsStore,
|
||||
themeMode: String = "system",
|
||||
onThemeChange: (String) -> Unit = {},
|
||||
isDynamicColor: Boolean = false,
|
||||
onDynamicColorChange: (Boolean) -> Unit = {},
|
||||
currentPalette: String = "indigo",
|
||||
onPaletteChange: (String) -> Unit = {}
|
||||
) {
|
||||
val unreadErrors by TunnelManager.unreadErrorCount.collectAsStateWithLifecycle()
|
||||
val tunnelRunning by TunnelManager.running.collectAsStateWithLifecycle()
|
||||
val view = LocalView.current
|
||||
val context = LocalContext.current
|
||||
val density = LocalDensity.current
|
||||
val scope = rememberCoroutineScope()
|
||||
var selectedTab by rememberSaveable { mutableIntStateOf(0) }
|
||||
var dragTargetIndex by remember { mutableIntStateOf(-1) }
|
||||
var dragProgress by remember { mutableFloatStateOf(0f) }
|
||||
val updateCheckIntervalHours by settingsStore.updateCheckIntervalHours.collectAsStateWithLifecycle(
|
||||
initialValue = DEFAULT_UPDATE_CHECK_INTERVAL_HOURS
|
||||
)
|
||||
var pendingRelease by remember { mutableStateOf<AppReleaseInfo?>(null) }
|
||||
val currentVersion = remember { "v${BuildConfig.VERSION_NAME.removePrefix("v")}" }
|
||||
val safeBottomInset = with(density) { WindowInsets.safeDrawing.getBottom(density).toDp() }
|
||||
val navOverlayReserve = safeBottomInset + 96.dp
|
||||
|
||||
LaunchedEffect(selectedTab) {
|
||||
if (selectedTab == 3) TunnelManager.clearUnreadErrors()
|
||||
}
|
||||
|
||||
LaunchedEffect(updateCheckIntervalHours) {
|
||||
if (updateCheckIntervalHours == UPDATE_CHECK_NEVER) return@LaunchedEffect
|
||||
|
||||
val intervalMillis = updateIntervalHoursToMillis(updateCheckIntervalHours)
|
||||
?: updateIntervalHoursToMillis(DEFAULT_UPDATE_CHECK_INTERVAL_HOURS)
|
||||
?: 12L * 60L * 60L * 1000L
|
||||
|
||||
suspend fun runUpdateCheck(reason: String) {
|
||||
val checkedAt = System.currentTimeMillis()
|
||||
val release = fetchLatestReleaseInfo(currentVersion)
|
||||
settingsStore.saveUpdateState(
|
||||
lastCheckAt = checkedAt,
|
||||
latestVersion = release?.versionTag ?: "",
|
||||
error = if (release == null) "Не удалось проверить" else ""
|
||||
)
|
||||
|
||||
if (release == null) {
|
||||
Log.w("WDTT", "[WARN] Update check: no release info, local=$currentVersion reason=$reason")
|
||||
return
|
||||
}
|
||||
|
||||
val hasUpdate = isNewerVersion(currentVersion, release.versionTag)
|
||||
val postponeVer = settingsStore.updatePostponeVersion.first()
|
||||
val postponeUntil = settingsStore.updatePostponeUntil.first()
|
||||
val isPostponed = postponeVer == release.versionTag && checkedAt < postponeUntil
|
||||
Log.i(
|
||||
"WDTT",
|
||||
"Update check: local=$currentVersion remote=${release.versionTag} newer=$hasUpdate postponed=$isPostponed reason=$reason"
|
||||
)
|
||||
|
||||
if (hasUpdate && !isPostponed) {
|
||||
settingsStore.saveUpdateDialogShown(release.versionTag, checkedAt)
|
||||
pendingRelease = release
|
||||
}
|
||||
}
|
||||
|
||||
runUpdateCheck("startup")
|
||||
|
||||
while (isActive) {
|
||||
val now = System.currentTimeMillis()
|
||||
val lastCheck = settingsStore.updateLastCheckAt.first()
|
||||
val nextCheckAt = lastCheck + intervalMillis
|
||||
val waitMs = (nextCheckAt - now).coerceAtLeast(intervalMillis)
|
||||
delay(waitMs)
|
||||
if (isActive) {
|
||||
runUpdateCheck("periodic")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Box(modifier = Modifier.fillMaxSize()) {
|
||||
AppBackdrop(modifier = Modifier.matchParentSize())
|
||||
|
||||
Scaffold(
|
||||
contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Horizontal + WindowInsetsSides.Top),
|
||||
containerColor = Color.Transparent,
|
||||
) { padding ->
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.padding(padding)
|
||||
.consumeWindowInsets(padding)
|
||||
.pointerInput(selectedTab) {
|
||||
var totalDrag = 0f
|
||||
detectHorizontalDragGestures(
|
||||
onDragStart = {
|
||||
totalDrag = 0f
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
},
|
||||
onDragCancel = {
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
},
|
||||
onDragEnd = {
|
||||
if (dragTargetIndex in navItems.indices && dragProgress >= 0.5f) {
|
||||
selectedTab = dragTargetIndex
|
||||
if (selectedTab == 3) TunnelManager.clearUnreadErrors()
|
||||
}
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
}
|
||||
) { change, dragAmount ->
|
||||
change.consume()
|
||||
totalDrag += dragAmount
|
||||
if (abs(totalDrag) < 12f) {
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
return@detectHorizontalDragGestures
|
||||
}
|
||||
|
||||
val candidate = if (totalDrag < 0f) selectedTab + 1 else selectedTab - 1
|
||||
if (candidate !in navItems.indices) {
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
return@detectHorizontalDragGestures
|
||||
}
|
||||
|
||||
dragTargetIndex = candidate
|
||||
dragProgress = (abs(totalDrag) / 180f).coerceIn(0f, 1f)
|
||||
}
|
||||
}
|
||||
) {
|
||||
AnimatedContent(
|
||||
targetState = selectedTab,
|
||||
transitionSpec = {
|
||||
fadeIn(tween(300)) togetherWith fadeOut(tween(225))
|
||||
},
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.padding(bottom = navOverlayReserve),
|
||||
label = "tab_content"
|
||||
) { tab ->
|
||||
when (tab) {
|
||||
0 -> SettingsTab()
|
||||
1 -> DeployTab()
|
||||
2 -> ExceptionsTab()
|
||||
3 -> LogsTab()
|
||||
4 -> InfoTab()
|
||||
}
|
||||
}
|
||||
|
||||
ProxyNavigationBar(
|
||||
navItems = navItems,
|
||||
selectedTab = selectedTab,
|
||||
dragTargetIndex = dragTargetIndex,
|
||||
dragProgress = dragProgress,
|
||||
unreadErrors = unreadErrors,
|
||||
tunnelRunning = tunnelRunning,
|
||||
onTabSelected = { index ->
|
||||
if (selectedTab != index) {
|
||||
view.performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK)
|
||||
selectedTab = index
|
||||
if (index == 3) TunnelManager.clearUnreadErrors()
|
||||
}
|
||||
dragTargetIndex = -1
|
||||
dragProgress = 0f
|
||||
},
|
||||
modifier = Modifier.align(Alignment.BottomCenter)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// Floating theme toolbar overlay
|
||||
FloatingToolbar(
|
||||
currentTheme = themeMode,
|
||||
onThemeChange = onThemeChange,
|
||||
isDynamicColor = isDynamicColor,
|
||||
onDynamicColorChange = onDynamicColorChange,
|
||||
currentPalette = currentPalette,
|
||||
onPaletteChange = onPaletteChange
|
||||
)
|
||||
}
|
||||
|
||||
pendingRelease?.let { release ->
|
||||
AppUpdateDialog(
|
||||
release = release,
|
||||
onPostpone = {
|
||||
pendingRelease = null
|
||||
Toast.makeText(context, "Обновление отложено на 24 часа.", Toast.LENGTH_SHORT).show()
|
||||
scope.launch {
|
||||
val now = System.currentTimeMillis()
|
||||
settingsStore.saveUpdatePostpone(
|
||||
version = release.versionTag,
|
||||
until = now + 24L * 60L * 60L * 1000L
|
||||
)
|
||||
settingsStore.saveUpdateDialogAction(
|
||||
version = release.versionTag,
|
||||
action = UPDATE_DIALOG_ACTION_POSTPONED,
|
||||
actedAt = now
|
||||
)
|
||||
}
|
||||
},
|
||||
onUpdate = {
|
||||
pendingRelease = null
|
||||
scope.launch {
|
||||
settingsStore.saveUpdateDialogAction(
|
||||
version = release.versionTag,
|
||||
action = UPDATE_DIALOG_ACTION_UPDATE,
|
||||
actedAt = System.currentTimeMillis()
|
||||
)
|
||||
openReleaseUrl(context, release.releaseUrl)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ProxyNavigationBar(
|
||||
navItems: List<NavItem>,
|
||||
selectedTab: Int,
|
||||
dragTargetIndex: Int,
|
||||
dragProgress: Float,
|
||||
unreadErrors: Int,
|
||||
tunnelRunning: Boolean,
|
||||
onTabSelected: (Int) -> Unit,
|
||||
modifier: Modifier = Modifier
|
||||
) {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val isDark = colors.background.luminance() < 0.22f
|
||||
val selectedColor = colors.primary
|
||||
val unselectedColor = colors.onSurfaceVariant.copy(alpha = 0.55f)
|
||||
val shellColor = if (isDark) {
|
||||
colors.surface.copy(alpha = 0.78f)
|
||||
} else {
|
||||
lerp(colors.surface, colors.surfaceVariant, 0.48f).copy(alpha = 0.95f)
|
||||
}
|
||||
val shellBorder = if (isDark) {
|
||||
colors.outlineVariant.copy(alpha = 0.42f)
|
||||
} else {
|
||||
colors.outline.copy(alpha = 0.16f)
|
||||
}
|
||||
val indicatorColor = if (isDark) {
|
||||
colors.primaryContainer.copy(alpha = 0.84f)
|
||||
} else {
|
||||
lerp(colors.primaryContainer, colors.surface, 0.18f).copy(alpha = 0.97f)
|
||||
}
|
||||
val indicatorIndex = remember { Animatable(selectedTab.toFloat()) }
|
||||
val dragVisualIndex = indicatorIndex.value
|
||||
|
||||
LaunchedEffect(selectedTab) {
|
||||
if (dragTargetIndex !in navItems.indices) {
|
||||
indicatorIndex.animateTo(
|
||||
targetValue = selectedTab.toFloat(),
|
||||
animationSpec = tween(
|
||||
durationMillis = 720,
|
||||
easing = CubicBezierEasing(0.2f, 0.9f, 0.24f, 1f)
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
LaunchedEffect(selectedTab, dragTargetIndex, dragProgress) {
|
||||
if (dragTargetIndex in navItems.indices) {
|
||||
val target = selectedTab.toFloat() + (dragTargetIndex - selectedTab) * dragProgress
|
||||
indicatorIndex.snapTo(target)
|
||||
}
|
||||
}
|
||||
|
||||
BoxWithConstraints(
|
||||
modifier = modifier
|
||||
.fillMaxWidth()
|
||||
.windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Horizontal + WindowInsetsSides.Bottom))
|
||||
.padding(horizontal = 22.dp, vertical = 12.dp)
|
||||
) {
|
||||
val trackPadding = 8.dp
|
||||
val itemWidth = (maxWidth - trackPadding * 2) / navItems.size
|
||||
val indicatorOffset = trackPadding + itemWidth * dragVisualIndex
|
||||
|
||||
Surface(
|
||||
shape = RoundedCornerShape(28.dp),
|
||||
color = shellColor,
|
||||
border = BorderStroke(1.dp, shellBorder),
|
||||
tonalElevation = 0.dp,
|
||||
shadowElevation = if (isDark) 10.dp else 8.dp,
|
||||
modifier = Modifier.fillMaxWidth()
|
||||
) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.height(72.dp)
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(22.dp),
|
||||
color = indicatorColor,
|
||||
modifier = Modifier
|
||||
.offset(x = indicatorOffset)
|
||||
.padding(vertical = 6.dp)
|
||||
.width(itemWidth)
|
||||
.fillMaxHeight()
|
||||
) {}
|
||||
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.padding(horizontal = trackPadding, vertical = 6.dp)
|
||||
) {
|
||||
navItems.forEachIndexed { index, item ->
|
||||
val emphasis = (1f - abs(index - dragVisualIndex)).coerceIn(0f, 1f)
|
||||
val iconColor = lerp(unselectedColor, selectedColor, emphasis)
|
||||
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.weight(1f)
|
||||
.fillMaxHeight()
|
||||
.clip(RoundedCornerShape(22.dp))
|
||||
.clickable { onTabSelected(index) },
|
||||
verticalArrangement = Arrangement.Center,
|
||||
horizontalAlignment = Alignment.CenterHorizontally
|
||||
) {
|
||||
Box(contentAlignment = Alignment.TopEnd) {
|
||||
Icon(
|
||||
imageVector = if (emphasis > 0.55f) item.selectedIcon else item.unselectedIcon,
|
||||
contentDescription = item.label,
|
||||
modifier = Modifier.size(22.dp),
|
||||
tint = iconColor
|
||||
)
|
||||
if (index == 3 && unreadErrors > 0) {
|
||||
Badge(
|
||||
containerColor = if (tunnelRunning) colors.primary else WDTTColors.warning,
|
||||
contentColor = colors.onPrimary,
|
||||
modifier = Modifier.offset(x = 12.dp, y = (-8).dp)
|
||||
) {
|
||||
Text("$unreadErrors")
|
||||
}
|
||||
}
|
||||
}
|
||||
Spacer(Modifier.height(4.dp))
|
||||
Text(
|
||||
text = item.label,
|
||||
style = MaterialTheme.typography.labelSmall,
|
||||
fontWeight = if (emphasis > 0.55f) FontWeight.SemiBold else FontWeight.Medium,
|
||||
color = iconColor,
|
||||
maxLines = 1
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun openReleaseUrl(context: Context, url: String) {
|
||||
try {
|
||||
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url)).apply {
|
||||
addCategory(Intent.CATEGORY_BROWSABLE)
|
||||
}
|
||||
context.startActivity(intent)
|
||||
} catch (_: Exception) {
|
||||
Toast.makeText(context, "Не удалось открыть ссылку", Toast.LENGTH_SHORT).show()
|
||||
}
|
||||
}
|
||||
|
||||
private fun android16OrbShape(points: Int, innerRatio: Float): Shape = GenericShape { size, _ ->
|
||||
val centerX = size.width / 2f
|
||||
val centerY = size.height / 2f
|
||||
val outerRadius = min(size.width, size.height) / 2f
|
||||
val innerRadius = outerRadius * innerRatio
|
||||
|
||||
for (i in 0 until points * 2) {
|
||||
val angle = (-PI / 2.0) + (i * PI / points)
|
||||
val radius = if (i % 2 == 0) outerRadius else innerRadius
|
||||
val x = centerX + (radius * cos(angle)).toFloat()
|
||||
val y = centerY + (radius * sin(angle)).toFloat()
|
||||
if (i == 0) moveTo(x, y) else lineTo(x, y)
|
||||
}
|
||||
close()
|
||||
}
|
||||
|
||||
private val Android16OrbLarge: Shape = android16OrbShape(points = 18, innerRatio = 0.90f)
|
||||
private val Android16OrbMedium: Shape = android16OrbShape(points = 20, innerRatio = 0.92f)
|
||||
private val Android16OrbSmall: Shape = android16OrbShape(points = 16, innerRatio = 0.88f)
|
||||
|
||||
@Composable
|
||||
private fun AppBackdrop(modifier: Modifier = Modifier) {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val isDark = colors.background.luminance() < 0.22f
|
||||
val baseBrush = remember(colors.background, colors.surface, colors.surfaceVariant) {
|
||||
Brush.verticalGradient(
|
||||
colors = if (isDark) {
|
||||
listOf(
|
||||
lerp(colors.background, colors.surface, 0.18f),
|
||||
colors.background,
|
||||
lerp(colors.surfaceVariant, colors.background, 0.72f)
|
||||
)
|
||||
} else {
|
||||
listOf(
|
||||
lerp(colors.background, colors.surface, 0.78f),
|
||||
colors.background,
|
||||
lerp(colors.surfaceVariant, colors.background, 0.30f)
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
val topGlow = colors.primary.copy(alpha = if (isDark) 0.055f else 0.09f)
|
||||
val leftGlow = if (isDark) {
|
||||
colors.tertiary.copy(alpha = 0.045f)
|
||||
} else {
|
||||
lerp(colors.tertiary, colors.secondaryContainer, 0.74f).copy(alpha = 0.24f)
|
||||
}
|
||||
val bottomGlow = if (isDark) {
|
||||
colors.primary.copy(alpha = 0.04f)
|
||||
} else {
|
||||
lerp(colors.secondary, colors.primaryContainer, 0.70f).copy(alpha = 0.22f)
|
||||
}
|
||||
val lightOrbOutline = colors.outlineVariant.copy(alpha = 0.26f)
|
||||
val topOrbGlow = if (isDark) {
|
||||
topGlow
|
||||
} else {
|
||||
lerp(colors.primary, colors.primaryContainer, 0.72f).copy(alpha = 0.32f)
|
||||
}
|
||||
|
||||
Box(
|
||||
modifier = modifier
|
||||
.fillMaxSize()
|
||||
.background(baseBrush)
|
||||
) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.align(Alignment.TopStart)
|
||||
.offset(x = (-86).dp, y = (-126).dp)
|
||||
.size(258.dp)
|
||||
.clip(Android16OrbLarge)
|
||||
.background(topOrbGlow)
|
||||
.then(
|
||||
if (isDark) Modifier else Modifier.border(1.dp, lightOrbOutline, Android16OrbLarge)
|
||||
)
|
||||
)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.align(Alignment.CenterStart)
|
||||
.offset(x = (-44).dp, y = 28.dp)
|
||||
.size(146.dp)
|
||||
.clip(Android16OrbSmall)
|
||||
.background(leftGlow)
|
||||
.then(
|
||||
if (isDark) Modifier else Modifier.border(1.dp, lightOrbOutline.copy(alpha = 0.22f), Android16OrbSmall)
|
||||
)
|
||||
)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.align(Alignment.BottomEnd)
|
||||
.offset(x = 62.dp, y = (-208).dp)
|
||||
.size(198.dp)
|
||||
.clip(Android16OrbMedium)
|
||||
.background(bottomGlow)
|
||||
.then(
|
||||
if (isDark) Modifier else Modifier.border(1.dp, lightOrbOutline.copy(alpha = 0.20f), Android16OrbMedium)
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,388 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.os.Bundle
|
||||
import android.util.Log
|
||||
import android.view.ViewGroup
|
||||
import android.webkit.*
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.core.app.NotificationCompat
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Close
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.foundation.isSystemInDarkTheme
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.viewinterop.AndroidView
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.CompletableDeferred
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.coroutines.withTimeout
|
||||
import java.util.concurrent.atomic.AtomicReference
|
||||
import kotlin.random.Random
|
||||
|
||||
object ManlCaptchaWebViewManager {
|
||||
private const val TAG = "ManlCaptchaWV"
|
||||
private const val CAPTCHA_TIMEOUT_MS = 60_000L
|
||||
|
||||
val captchaMutex = Mutex()
|
||||
val pendingResult = AtomicReference<CompletableDeferred<Result<String>>?>(null)
|
||||
var activeActivity: ManlCaptchaActivity? = null
|
||||
var pendingIntentToStart: Intent? = null
|
||||
var isCaptchaPending = false
|
||||
|
||||
fun checkAndShowPendingCaptcha(context: Context) {
|
||||
val intent = pendingIntentToStart
|
||||
if (intent != null && activeActivity == null) {
|
||||
context.startActivity(intent)
|
||||
}
|
||||
}
|
||||
|
||||
fun cancelCaptcha() {
|
||||
pendingResult.get()?.completeExceptionally(kotlin.coroutines.cancellation.CancellationException("Cancelled by system"))
|
||||
}
|
||||
|
||||
private const val NOTIFICATION_ID = 9001
|
||||
private const val CHANNEL_ID = "captcha_channel"
|
||||
|
||||
private fun showCaptchaNotification(context: Context, redirectUri: String) {
|
||||
if (MainActivity.isForeground) return // Если юзер уже в приложении — не спамим пушом
|
||||
|
||||
val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
|
||||
|
||||
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
|
||||
val channel = NotificationChannel(
|
||||
CHANNEL_ID,
|
||||
"Уведомления защиты (Капча)",
|
||||
NotificationManager.IMPORTANCE_HIGH
|
||||
)
|
||||
notificationManager.createNotificationChannel(channel)
|
||||
}
|
||||
|
||||
val openIntent = Intent(context, ManlCaptchaActivity::class.java).apply {
|
||||
putExtra("redirectUri", redirectUri)
|
||||
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
|
||||
}
|
||||
|
||||
val openPendingIntent = PendingIntent.getActivity(
|
||||
context, 0, openIntent, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
|
||||
)
|
||||
|
||||
val cancelIntent = Intent(context, CaptchaCancelReceiver::class.java)
|
||||
val cancelPendingIntent = PendingIntent.getBroadcast(
|
||||
context, 1, cancelIntent, PendingIntent.FLAG_IMMUTABLE
|
||||
)
|
||||
|
||||
val notification = NotificationCompat.Builder(context, CHANNEL_ID)
|
||||
.setSmallIcon(android.R.drawable.ic_dialog_alert)
|
||||
.setContentTitle("Требуется подтверждение капчи")
|
||||
.setContentText("ВК запросил проверку безопасности. Нажмите для решения.")
|
||||
.setPriority(NotificationCompat.PRIORITY_HIGH)
|
||||
.setContentIntent(openPendingIntent)
|
||||
.setAutoCancel(true)
|
||||
.addAction(0, "Отменить и выключить", cancelPendingIntent)
|
||||
.build()
|
||||
|
||||
notificationManager.notify(NOTIFICATION_ID, notification)
|
||||
}
|
||||
|
||||
private fun clearCaptchaNotification(context: Context) {
|
||||
val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
|
||||
notificationManager.cancel(NOTIFICATION_ID)
|
||||
}
|
||||
|
||||
suspend fun solveCaptchaAsync(context: Context, redirectUri: String, sessionToken: String): String {
|
||||
return captchaMutex.withLock {
|
||||
isCaptchaPending = true
|
||||
val deferred = CompletableDeferred<Result<String>>()
|
||||
// Если предыдущий вызов завис, отменяем его
|
||||
pendingResult.getAndSet(deferred)?.cancel()
|
||||
|
||||
showCaptchaNotification(context, redirectUri)
|
||||
|
||||
val intent = Intent(context, ManlCaptchaActivity::class.java).apply {
|
||||
putExtra("redirectUri", redirectUri)
|
||||
addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
|
||||
}
|
||||
pendingIntentToStart = intent
|
||||
|
||||
if (MainActivity.isForeground) {
|
||||
// Запускаем окно только если интерфейс приложения активен (иначе Android блокирует старт)
|
||||
context.startActivity(intent)
|
||||
}
|
||||
|
||||
try {
|
||||
withTimeout(CAPTCHA_TIMEOUT_MS) {
|
||||
deferred.await().getOrThrow()
|
||||
}
|
||||
} finally {
|
||||
isCaptchaPending = false
|
||||
pendingResult.set(null)
|
||||
pendingIntentToStart = null
|
||||
clearCaptchaNotification(context)
|
||||
try {
|
||||
activeActivity?.finish()
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "Error finishing activity: ${e.message}")
|
||||
}
|
||||
activeActivity = null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun notifyResult(result: Result<String>) {
|
||||
val deferred = pendingResult.getAndSet(null) ?: return
|
||||
if (!deferred.isCompleted) {
|
||||
deferred.complete(result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class ManlCaptchaActivity : ComponentActivity() {
|
||||
private val interceptorJSCode = """
|
||||
(function() {
|
||||
if (window.__wdtt_interceptor_installed) return;
|
||||
window.__wdtt_interceptor_installed = true;
|
||||
|
||||
const origFetch = window.fetch;
|
||||
window.fetch = async function() {
|
||||
const args = arguments;
|
||||
const url = args[0] || '';
|
||||
if (typeof url === 'string' && url.includes('captchaNotRobot.check')) {
|
||||
const response = await origFetch.apply(this, args);
|
||||
const clone = response.clone();
|
||||
try {
|
||||
const data = await clone.json();
|
||||
if (data.response && data.response.success_token) {
|
||||
window.WdttCaptcha.onSuccess(data.response.success_token);
|
||||
} else if (data.error) {
|
||||
window.WdttCaptcha.onError(JSON.stringify(data.error));
|
||||
}
|
||||
} catch(e) {}
|
||||
return response;
|
||||
}
|
||||
return origFetch.apply(this, args);
|
||||
};
|
||||
|
||||
const origXHROpen = XMLHttpRequest.prototype.open;
|
||||
const origXHRSend = XMLHttpRequest.prototype.send;
|
||||
XMLHttpRequest.prototype.open = function(method, url) {
|
||||
this._wdtt_url = url;
|
||||
return origXHROpen.apply(this, arguments);
|
||||
};
|
||||
XMLHttpRequest.prototype.send = function() {
|
||||
const xhr = this;
|
||||
if (xhr._wdtt_url && xhr._wdtt_url.includes('captchaNotRobot.check')) {
|
||||
xhr.addEventListener('load', function() {
|
||||
try {
|
||||
const data = JSON.parse(xhr.responseText);
|
||||
if (data.response && data.response.success_token) {
|
||||
window.WdttCaptcha.onSuccess(data.response.success_token);
|
||||
} else if (data.error) {
|
||||
window.WdttCaptcha.onError(JSON.stringify(data.error));
|
||||
}
|
||||
} catch(e) {}
|
||||
});
|
||||
}
|
||||
return origXHRSend.apply(this, arguments);
|
||||
};
|
||||
})();
|
||||
""".trimIndent()
|
||||
|
||||
private val hideElementsJSCode = """
|
||||
(function() {
|
||||
// Перехватываем клик по нативному крестику ВК, чтобы закрывать Android Activity и останавливать туннель
|
||||
document.addEventListener('click', function(e) {
|
||||
if (e.target.closest('.vkc__ModalCardBase-module__dismiss')) {
|
||||
window.WdttCaptcha.onCancelAndStop();
|
||||
}
|
||||
});
|
||||
|
||||
const style = document.createElement('style');
|
||||
style.innerHTML = `
|
||||
/* Скрываем серый фон, лого, id, ссылку и кнопку АУДИО (крестик ВК оставляем!) */
|
||||
.vkc__VisuallyHiddenModalOverlay-module__host,
|
||||
.vkc__ModalOverlay-module__host,
|
||||
.vkc__KaleidoscopeScreen-module__logoBlock,
|
||||
.vkc__KaleidoscopeScreen-module__captchaId,
|
||||
.vkc__SliderCaptcha-module__descriptionLink,
|
||||
.vkc__SliderCaptcha-module__changeTypeButton {
|
||||
display: none !important;
|
||||
}
|
||||
|
||||
/* Основной фон вокруг окна - прозрачный прозрачным, убираем тени */
|
||||
body, html, .vkc__ModalCard-module__host, .vkc__AppRoot-module__host, .vkui__root {
|
||||
background: transparent !important;
|
||||
box-shadow: none !important;
|
||||
}
|
||||
|
||||
/* Сама карточка (окно) - фон чёрный */
|
||||
.vkc__ModalCardBase-module__container {
|
||||
background: #000000 !important;
|
||||
box-shadow: none !important;
|
||||
}
|
||||
|
||||
/* Стилизуем крестик ВК: левее, меньше, красный */
|
||||
.vkc__ModalCardBase-module__dismiss {
|
||||
color: #ef4444 !important;
|
||||
transform: scale(0.8) translateX(-12px) !important;
|
||||
}
|
||||
.vkc__ModalCardBase-module__dismiss svg {
|
||||
fill: #ef4444 !important;
|
||||
}
|
||||
|
||||
/* Текст "Обновить" и описание капчи делаем белыми */
|
||||
.vkc__RefreshButton-module__text,
|
||||
.vkc__SliderCaptcha-module__description {
|
||||
color: #ffffff !important;
|
||||
}
|
||||
|
||||
/* Поле (трек), где нужно потянуть вправо - делаем белым */
|
||||
.vkc__SwipeButton-module__track {
|
||||
background-color: #ffffff !important;
|
||||
}
|
||||
|
||||
/* Текст "Потяните вправо" внутри трека - делаем синим */
|
||||
.vkc__SwipeButton-module__track span {
|
||||
color: #0000FF !important;
|
||||
}
|
||||
`;
|
||||
document.head.appendChild(style);
|
||||
})();
|
||||
""".trimIndent()
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
ManlCaptchaWebViewManager.activeActivity = this
|
||||
MainActivity.isForeground = true // Если появилось само окно капчи, мы тоже считаемся в фореграунде
|
||||
val redirectUri = intent.getStringExtra("redirectUri") ?: return finish()
|
||||
|
||||
setContent {
|
||||
MaterialTheme(colorScheme = if (isSystemInDarkTheme()) darkColorScheme() else lightColorScheme()) {
|
||||
Box(modifier = Modifier.fillMaxSize()) {
|
||||
Column(
|
||||
modifier = Modifier.align(Alignment.Center),
|
||||
horizontalAlignment = Alignment.CenterHorizontally
|
||||
) {
|
||||
var isLoading by rememberSaveable { mutableStateOf(true) }
|
||||
|
||||
Box {
|
||||
Surface(
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
color = Color.Transparent,
|
||||
tonalElevation = 0.dp,
|
||||
shadowElevation = 0.dp
|
||||
) {
|
||||
AndroidView(
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
factory = { ctx ->
|
||||
WebView(ctx).apply {
|
||||
setBackgroundColor(android.graphics.Color.TRANSPARENT)
|
||||
layoutParams = ViewGroup.LayoutParams(
|
||||
ViewGroup.LayoutParams.MATCH_PARENT,
|
||||
ViewGroup.LayoutParams.MATCH_PARENT
|
||||
)
|
||||
settings.apply {
|
||||
javaScriptEnabled = true
|
||||
domStorageEnabled = true
|
||||
databaseEnabled = true
|
||||
mediaPlaybackRequiresUserGesture = false
|
||||
loadWithOverviewMode = true
|
||||
useWideViewPort = true
|
||||
blockNetworkLoads = false
|
||||
cacheMode = WebSettings.LOAD_DEFAULT // Включаем кэш для моментальной загрузки!
|
||||
userAgentString = "Mozilla/5.0 (Linux; Android 13; Mobile) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36"
|
||||
}
|
||||
|
||||
addJavascriptInterface(object {
|
||||
@JavascriptInterface
|
||||
fun onSuccess(token: String) {
|
||||
Log.d("ManlCaptchaWV", "Token received")
|
||||
ManlCaptchaWebViewManager.notifyResult(Result.success(token))
|
||||
finish()
|
||||
}
|
||||
@JavascriptInterface
|
||||
fun onError(err: String) {
|
||||
Log.e("ManlCaptchaWV", "Error: $err")
|
||||
ManlCaptchaWebViewManager.notifyResult(Result.failure(Exception("VK Captcha error: ${'$'}err")))
|
||||
finish()
|
||||
}
|
||||
@JavascriptInterface
|
||||
fun onCancelAndStop() {
|
||||
Log.d("ManlCaptchaWV", "User clicked VK Close. Stopping tunnel.")
|
||||
TunnelManager.stop()
|
||||
ManlCaptchaWebViewManager.notifyResult(Result.failure(Exception("Cancelled and stopped by user")))
|
||||
finish()
|
||||
}
|
||||
}, "WdttCaptcha")
|
||||
|
||||
webViewClient = object : WebViewClient() {
|
||||
override fun onPageStarted(view: WebView?, url: String?, favicon: android.graphics.Bitmap?) {
|
||||
super.onPageStarted(view, url, favicon)
|
||||
view?.evaluateJavascript(interceptorJSCode, null)
|
||||
}
|
||||
override fun onPageFinished(view: WebView?, url: String?) {
|
||||
super.onPageFinished(view, url)
|
||||
view?.evaluateJavascript(interceptorJSCode, null)
|
||||
view?.evaluateJavascript(hideElementsJSCode, null)
|
||||
isLoading = false
|
||||
}
|
||||
}
|
||||
webChromeClient = WebChromeClient()
|
||||
loadUrl(redirectUri)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Индикатор загрузки, пока страница белая/прозрачная
|
||||
if (isLoading) {
|
||||
CircularProgressIndicator(
|
||||
modifier = Modifier.align(Alignment.Center).size(48.dp),
|
||||
color = MaterialTheme.colorScheme.primary
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
super.onDestroy()
|
||||
MainActivity.isForeground = false
|
||||
if (ManlCaptchaWebViewManager.activeActivity === this) {
|
||||
ManlCaptchaWebViewManager.activeActivity = null
|
||||
}
|
||||
// Мы НЕ отправляем ошибку здесь!
|
||||
// Если юзер смахнул окно (нажал назад), капча останется висеть в памяти (через пуш).
|
||||
// Ошибка или Успех отправляются только по явным действиям (крестик, решение, или таймаут 5 мин).
|
||||
}
|
||||
}
|
||||
|
||||
class CaptchaCancelReceiver : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
TunnelManager.stop()
|
||||
ManlCaptchaWebViewManager.activeActivity?.finish()
|
||||
val notifMgr = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
|
||||
notifMgr.cancel(9001) // NOTIFICATION_ID
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.content.Context
|
||||
import android.security.keystore.KeyGenParameterSpec
|
||||
import android.security.keystore.KeyProperties
|
||||
import android.util.Base64
|
||||
import java.security.KeyStore
|
||||
import javax.crypto.Cipher
|
||||
import javax.crypto.KeyGenerator
|
||||
import javax.crypto.SecretKey
|
||||
import javax.crypto.spec.GCMParameterSpec
|
||||
|
||||
class SecureStringStore(context: Context) {
|
||||
private val appContext = context.applicationContext
|
||||
|
||||
companion object {
|
||||
private const val KEY_ALIAS = "wdtt.settings.secrets"
|
||||
private const val ANDROID_KEYSTORE = "AndroidKeyStore"
|
||||
private const val TRANSFORMATION = "AES/GCM/NoPadding"
|
||||
private const val GCM_TAG_BITS = 128
|
||||
private const val VERSION_PREFIX = "v1:"
|
||||
}
|
||||
|
||||
private val keyStore: KeyStore by lazy {
|
||||
KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
|
||||
}
|
||||
|
||||
fun encrypt(value: String): String {
|
||||
val cipher = Cipher.getInstance(TRANSFORMATION)
|
||||
cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey())
|
||||
val encrypted = cipher.doFinal(value.toByteArray(Charsets.UTF_8))
|
||||
return VERSION_PREFIX +
|
||||
Base64.encodeToString(cipher.iv, Base64.NO_WRAP) +
|
||||
":" +
|
||||
Base64.encodeToString(encrypted, Base64.NO_WRAP)
|
||||
}
|
||||
|
||||
fun decrypt(value: String?): String? {
|
||||
if (value.isNullOrBlank() || !value.startsWith(VERSION_PREFIX)) return null
|
||||
val payload = value.removePrefix(VERSION_PREFIX)
|
||||
val parts = payload.split(":", limit = 2)
|
||||
if (parts.size != 2) return null
|
||||
|
||||
return runCatching {
|
||||
val iv = Base64.decode(parts[0], Base64.NO_WRAP)
|
||||
val encrypted = Base64.decode(parts[1], Base64.NO_WRAP)
|
||||
val cipher = Cipher.getInstance(TRANSFORMATION)
|
||||
cipher.init(Cipher.DECRYPT_MODE, getOrCreateKey(), GCMParameterSpec(GCM_TAG_BITS, iv))
|
||||
cipher.doFinal(encrypted).toString(Charsets.UTF_8)
|
||||
}.getOrNull()
|
||||
}
|
||||
|
||||
private fun getOrCreateKey(): SecretKey {
|
||||
synchronized(appContext) {
|
||||
val existing = keyStore.getKey(KEY_ALIAS, null) as? SecretKey
|
||||
if (existing != null) return existing
|
||||
|
||||
val generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
|
||||
val spec = KeyGenParameterSpec.Builder(
|
||||
KEY_ALIAS,
|
||||
KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
|
||||
)
|
||||
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
|
||||
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
|
||||
.setKeySize(256)
|
||||
.setRandomizedEncryptionRequired(true)
|
||||
.build()
|
||||
generator.init(spec)
|
||||
return generator.generateKey()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.content.Context
|
||||
import androidx.datastore.preferences.core.MutablePreferences
|
||||
import androidx.datastore.preferences.core.Preferences
|
||||
import androidx.datastore.preferences.core.booleanPreferencesKey
|
||||
import androidx.datastore.preferences.core.edit
|
||||
import androidx.datastore.preferences.core.intPreferencesKey
|
||||
import androidx.datastore.preferences.core.longPreferencesKey
|
||||
import androidx.datastore.preferences.core.stringPreferencesKey
|
||||
import androidx.datastore.preferences.preferencesDataStore
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.launch
|
||||
|
||||
class SettingsStore(context: Context) {
|
||||
private val appContext = context.applicationContext
|
||||
companion object {
|
||||
private val Context.dataStore by preferencesDataStore("settings")
|
||||
private val PEER = stringPreferencesKey("peer")
|
||||
private val VK_HASHES = stringPreferencesKey("vk_hashes")
|
||||
private val SECONDARY_VK_HASH = stringPreferencesKey("secondary_vk_hash")
|
||||
private val WORKERS_PER_HASH = intPreferencesKey("workers_per_hash")
|
||||
private val PROTOCOL = stringPreferencesKey("protocol")
|
||||
private val LISTEN_PORT = intPreferencesKey("listen_port")
|
||||
private val MANUAL_PORTS_ENABLED = booleanPreferencesKey("manual_ports_enabled")
|
||||
private val SERVER_DTLS_PORT = intPreferencesKey("server_dtls_port")
|
||||
private val SERVER_WG_PORT = intPreferencesKey("server_wg_port")
|
||||
private val SNI = stringPreferencesKey("sni")
|
||||
private val NO_DTLS = booleanPreferencesKey("no_dtls")
|
||||
private val NO_DNS = booleanPreferencesKey("no_dns")
|
||||
|
||||
private val USER_AGENT = stringPreferencesKey("user_agent")
|
||||
|
||||
private val DEPLOY_IP = stringPreferencesKey("deploy_ip")
|
||||
private val DEPLOY_LOGIN = stringPreferencesKey("deploy_login")
|
||||
private val DEPLOY_PASSWORD = stringPreferencesKey("deploy_password")
|
||||
private val DEPLOY_PASSWORD_ENCRYPTED = stringPreferencesKey("deploy_password_encrypted")
|
||||
private val DEPLOY_SSH_PORT = stringPreferencesKey("deploy_ssh_port")
|
||||
private val EXCLUDED_APPS = stringPreferencesKey("excluded_apps")
|
||||
|
||||
private val DETAILED_LOGS = booleanPreferencesKey("detailed_logs")
|
||||
|
||||
// ═══ Пароли и Управление ═══
|
||||
private val CONNECTION_PASSWORD = stringPreferencesKey("connection_password")
|
||||
private val CONNECTION_PASSWORD_ENCRYPTED = stringPreferencesKey("connection_password_encrypted")
|
||||
private val DEPLOY_MAIN_PASSWORD = stringPreferencesKey("deploy_main_password")
|
||||
private val DEPLOY_MAIN_PASSWORD_ENCRYPTED = stringPreferencesKey("deploy_main_password_encrypted")
|
||||
private val DEPLOY_ADMIN_ID = stringPreferencesKey("deploy_admin_id")
|
||||
private val DEPLOY_ADMIN_ID_ENCRYPTED = stringPreferencesKey("deploy_admin_id_encrypted")
|
||||
private val DEPLOY_BOT_TOKEN = stringPreferencesKey("deploy_bot_token")
|
||||
private val DEPLOY_BOT_TOKEN_ENCRYPTED = stringPreferencesKey("deploy_bot_token_encrypted")
|
||||
|
||||
// ═══ Proxy Mode ═══
|
||||
private val PROXY_MODE = stringPreferencesKey("proxy_mode") // "tun" or "socks5"
|
||||
private val PROXY_HOST = stringPreferencesKey("proxy_host")
|
||||
private val PROXY_PORT = intPreferencesKey("proxy_port")
|
||||
|
||||
// ═══ Captcha Solve Mode ═══
|
||||
private val CAPTCHA_MODE = stringPreferencesKey("captcha_mode") // "auto", "wv", or "rjs"
|
||||
private val CAPTCHA_SOLVE_METHOD = stringPreferencesKey("captcha_solve_method") // "manual" or "auto"
|
||||
private val CAPTCHA_WBV_SOLVE_METHOD = stringPreferencesKey("captcha_wbv_solve_method") // "manual" or "auto"
|
||||
|
||||
// ═══ VPN Exclusions Mode ═══
|
||||
private val IS_WHITELIST = booleanPreferencesKey("is_whitelist")
|
||||
|
||||
// ═══ Theme Mode ═══
|
||||
private val THEME_MODE = stringPreferencesKey("theme_mode") // "system", "light", "dark"
|
||||
private val IS_DYNAMIC_COLOR = booleanPreferencesKey("is_dynamic_color")
|
||||
private val THEME_PALETTE = stringPreferencesKey("theme_palette")
|
||||
|
||||
private val UPDATE_LAST_CHECK_AT = longPreferencesKey("update_last_check_at")
|
||||
private val UPDATE_LATEST_VERSION = stringPreferencesKey("update_latest_version")
|
||||
private val UPDATE_LAST_ERROR = stringPreferencesKey("update_last_error")
|
||||
private val UPDATE_CHECK_INTERVAL_HOURS = intPreferencesKey("update_check_interval_hours")
|
||||
private val UPDATE_POSTPONE_UNTIL = longPreferencesKey("update_postpone_until")
|
||||
private val UPDATE_POSTPONE_VERSION = stringPreferencesKey("update_postpone_version")
|
||||
private val UPDATE_DIALOG_LAST_SHOWN_VERSION = stringPreferencesKey("update_dialog_last_shown_version")
|
||||
private val UPDATE_DIALOG_LAST_SHOWN_AT = longPreferencesKey("update_dialog_last_shown_at")
|
||||
private val UPDATE_DIALOG_LAST_ACTION_VERSION = stringPreferencesKey("update_dialog_last_action_version")
|
||||
private val UPDATE_DIALOG_LAST_ACTION = stringPreferencesKey("update_dialog_last_action")
|
||||
private val UPDATE_DIALOG_LAST_ACTION_AT = longPreferencesKey("update_dialog_last_action_at")
|
||||
}
|
||||
|
||||
private val dataStore = appContext.dataStore
|
||||
private val secureStore = SecureStringStore(appContext)
|
||||
|
||||
init {
|
||||
CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
|
||||
migrateSecretsToKeystore()
|
||||
}
|
||||
}
|
||||
|
||||
val peer: Flow<String> = dataStore.data.map { it[PEER] ?: "" }
|
||||
val vkHashes: Flow<String> = dataStore.data.map { it[VK_HASHES] ?: "" }
|
||||
val secondaryVkHash: Flow<String> = dataStore.data.map { it[SECONDARY_VK_HASH] ?: "" }
|
||||
val workersPerHash: Flow<Int> = dataStore.data.map { it[WORKERS_PER_HASH] ?: 16 }
|
||||
val protocol: Flow<String> = dataStore.data.map { it[PROTOCOL] ?: "udp" }
|
||||
val listenPort: Flow<Int> = dataStore.data.map { it[LISTEN_PORT] ?: 9000 }
|
||||
val manualPortsEnabled: Flow<Boolean> = dataStore.data.map { it[MANUAL_PORTS_ENABLED] ?: false }
|
||||
val serverDtlsPort: Flow<Int> = dataStore.data.map { it[SERVER_DTLS_PORT] ?: 56000 }
|
||||
val serverWgPort: Flow<Int> = dataStore.data.map { it[SERVER_WG_PORT] ?: 56001 }
|
||||
val sni: Flow<String> = dataStore.data.map { it[SNI] ?: "" }
|
||||
val noDns: Flow<Boolean> = dataStore.data.map { it[NO_DNS] ?: false }
|
||||
val userAgent: Flow<String> = dataStore.data.map { it[USER_AGENT] ?: "" }
|
||||
|
||||
val deployIp: Flow<String> = dataStore.data.map { it[DEPLOY_IP] ?: "" }
|
||||
val deployLogin: Flow<String> = dataStore.data.map { it[DEPLOY_LOGIN] ?: "" }
|
||||
val deployPassword: Flow<String> = dataStore.data.map {
|
||||
readSecret(it, DEPLOY_PASSWORD_ENCRYPTED, DEPLOY_PASSWORD)
|
||||
}
|
||||
val deploySshPort: Flow<String> = dataStore.data.map { it[DEPLOY_SSH_PORT] ?: "" }
|
||||
val excludedApps: Flow<String> = dataStore.data.map { it[EXCLUDED_APPS] ?: "" }
|
||||
|
||||
val detailedLogs: Flow<Boolean> = dataStore.data.map { it[DETAILED_LOGS] ?: false }
|
||||
|
||||
// ═══ Пароли и Управление ═══
|
||||
val connectionPassword: Flow<String> = dataStore.data.map {
|
||||
readSecret(it, CONNECTION_PASSWORD_ENCRYPTED, CONNECTION_PASSWORD)
|
||||
}
|
||||
val deployMainPassword: Flow<String> = dataStore.data.map {
|
||||
readSecret(it, DEPLOY_MAIN_PASSWORD_ENCRYPTED, DEPLOY_MAIN_PASSWORD)
|
||||
}
|
||||
val deployAdminId: Flow<String> = dataStore.data.map {
|
||||
readSecret(it, DEPLOY_ADMIN_ID_ENCRYPTED, DEPLOY_ADMIN_ID)
|
||||
}
|
||||
val deployBotToken: Flow<String> = dataStore.data.map {
|
||||
readSecret(it, DEPLOY_BOT_TOKEN_ENCRYPTED, DEPLOY_BOT_TOKEN)
|
||||
}
|
||||
|
||||
// ═══ Proxy Mode ═══
|
||||
val proxyMode: Flow<String> = dataStore.data.map { it[PROXY_MODE] ?: "tun" }
|
||||
val proxyHost: Flow<String> = dataStore.data.map { it[PROXY_HOST] ?: "127.0.0.1" }
|
||||
val proxyPort: Flow<Int> = dataStore.data.map { it[PROXY_PORT] ?: 1080 }
|
||||
|
||||
// ═══ Captcha Solve Mode ═══
|
||||
val captchaMode: Flow<String> = dataStore.data.map { it[CAPTCHA_MODE] ?: "auto" }
|
||||
val captchaSolveMethod: Flow<String> = dataStore.data.map { it[CAPTCHA_SOLVE_METHOD] ?: "auto" }
|
||||
val captchaWbvSolveMethod: Flow<String> = dataStore.data.map { it[CAPTCHA_WBV_SOLVE_METHOD] ?: "auto" }
|
||||
|
||||
// ═══ VPN Exclusions Mode ═══
|
||||
val isWhitelist: Flow<Boolean> = dataStore.data.map { it[IS_WHITELIST] ?: false }
|
||||
|
||||
// ═══ Theme Mode ═══
|
||||
val themeMode: Flow<String> = dataStore.data.map { it[THEME_MODE] ?: "system" }
|
||||
val isDynamicColor: Flow<Boolean> = dataStore.data.map { it[IS_DYNAMIC_COLOR] ?: false }
|
||||
val themePalette: Flow<String> = dataStore.data.map { it[THEME_PALETTE] ?: "indigo" }
|
||||
|
||||
val updateLastCheckAt: Flow<Long> = dataStore.data.map { it[UPDATE_LAST_CHECK_AT] ?: 0L }
|
||||
val updateLatestVersion: Flow<String> = dataStore.data.map { it[UPDATE_LATEST_VERSION] ?: "" }
|
||||
val updateLastError: Flow<String> = dataStore.data.map { it[UPDATE_LAST_ERROR] ?: "" }
|
||||
val updateCheckIntervalHours: Flow<Int> = dataStore.data.map { it[UPDATE_CHECK_INTERVAL_HOURS] ?: DEFAULT_UPDATE_CHECK_INTERVAL_HOURS }
|
||||
val updatePostponeUntil: Flow<Long> = dataStore.data.map { it[UPDATE_POSTPONE_UNTIL] ?: 0L }
|
||||
val updatePostponeVersion: Flow<String> = dataStore.data.map { it[UPDATE_POSTPONE_VERSION] ?: "" }
|
||||
val updateDialogLastShownVersion: Flow<String> = dataStore.data.map { it[UPDATE_DIALOG_LAST_SHOWN_VERSION] ?: "" }
|
||||
val updateDialogLastShownAt: Flow<Long> = dataStore.data.map { it[UPDATE_DIALOG_LAST_SHOWN_AT] ?: 0L }
|
||||
val updateDialogLastActionVersion: Flow<String> = dataStore.data.map { it[UPDATE_DIALOG_LAST_ACTION_VERSION] ?: "" }
|
||||
val updateDialogLastAction: Flow<String> = dataStore.data.map { it[UPDATE_DIALOG_LAST_ACTION] ?: "" }
|
||||
val updateDialogLastActionAt: Flow<Long> = dataStore.data.map { it[UPDATE_DIALOG_LAST_ACTION_AT] ?: 0L }
|
||||
|
||||
suspend fun saveThemeMode(mode: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[THEME_MODE] = mode
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveDynamicColor(enabled: Boolean) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[IS_DYNAMIC_COLOR] = enabled
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveThemePalette(palette: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[THEME_PALETTE] = palette
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUpdateState(lastCheckAt: Long, latestVersion: String, error: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[UPDATE_LAST_CHECK_AT] = lastCheckAt
|
||||
prefs[UPDATE_LATEST_VERSION] = latestVersion
|
||||
prefs[UPDATE_LAST_ERROR] = error
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUpdateCheckIntervalHours(hours: Int) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[UPDATE_CHECK_INTERVAL_HOURS] = hours
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUpdatePostpone(version: String, until: Long) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[UPDATE_POSTPONE_VERSION] = version
|
||||
prefs[UPDATE_POSTPONE_UNTIL] = until
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUpdateDialogShown(version: String, shownAt: Long) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[UPDATE_DIALOG_LAST_SHOWN_VERSION] = version
|
||||
prefs[UPDATE_DIALOG_LAST_SHOWN_AT] = shownAt
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUpdateDialogAction(version: String, action: String, actedAt: Long) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[UPDATE_DIALOG_LAST_ACTION_VERSION] = version
|
||||
prefs[UPDATE_DIALOG_LAST_ACTION] = action
|
||||
prefs[UPDATE_DIALOG_LAST_ACTION_AT] = actedAt
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun save(
|
||||
peer: String,
|
||||
vkHashes: String,
|
||||
secondaryVkHash: String,
|
||||
workersPerHash: Int,
|
||||
protocol: String,
|
||||
listenPort: Int,
|
||||
sni: String = "",
|
||||
noDns: Boolean = false
|
||||
) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[PEER] = peer
|
||||
prefs[VK_HASHES] = vkHashes
|
||||
prefs[SECONDARY_VK_HASH] = secondaryVkHash
|
||||
prefs[WORKERS_PER_HASH] = workersPerHash
|
||||
prefs[PROTOCOL] = protocol
|
||||
prefs[LISTEN_PORT] = listenPort
|
||||
prefs[SNI] = sni
|
||||
prefs[NO_DNS] = noDns
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveManualPortsEnabled(enabled: Boolean) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[MANUAL_PORTS_ENABLED] = enabled
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun savePorts(serverDtlsPort: Int, serverWgPort: Int, listenPort: Int) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[SERVER_DTLS_PORT] = serverDtlsPort
|
||||
prefs[SERVER_WG_PORT] = serverWgPort
|
||||
prefs[LISTEN_PORT] = listenPort
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveUserAgent(ua: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[USER_AGENT] = ua
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveDeploy(ip: String, login: String, pass: String, sshPort: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[DEPLOY_IP] = ip
|
||||
prefs[DEPLOY_LOGIN] = login
|
||||
prefs.putSecret(DEPLOY_PASSWORD_ENCRYPTED, DEPLOY_PASSWORD, pass)
|
||||
prefs[DEPLOY_SSH_PORT] = sshPort
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveExcludedApps(packages: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[EXCLUDED_APPS] = packages
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveDetailedLogs(enabled: Boolean) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[DETAILED_LOGS] = enabled
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Сохранение пароля подключения ═══
|
||||
suspend fun saveConnectionPassword(password: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs.putSecret(CONNECTION_PASSWORD_ENCRYPTED, CONNECTION_PASSWORD, password)
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Сохранение секретов деплоя ═══
|
||||
suspend fun saveDeploySecrets(mainPass: String, adminId: String, botToken: String, sshPort: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs.putSecret(DEPLOY_MAIN_PASSWORD_ENCRYPTED, DEPLOY_MAIN_PASSWORD, mainPass)
|
||||
prefs.putSecret(DEPLOY_ADMIN_ID_ENCRYPTED, DEPLOY_ADMIN_ID, adminId)
|
||||
prefs.putSecret(DEPLOY_BOT_TOKEN_ENCRYPTED, DEPLOY_BOT_TOKEN, botToken)
|
||||
prefs[DEPLOY_SSH_PORT] = sshPort
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Сохранение proxy mode ═══
|
||||
suspend fun saveProxyMode(mode: String, host: String, port: Int) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[PROXY_MODE] = mode
|
||||
prefs[PROXY_HOST] = host
|
||||
prefs[PROXY_PORT] = port
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Сохранение режима обхода капчи ═══
|
||||
suspend fun saveCaptchaMode(mode: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[CAPTCHA_MODE] = mode
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveCaptchaSolveMethod(method: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[CAPTCHA_SOLVE_METHOD] = method
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun saveWbvCaptchaSolveMethod(method: String) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[CAPTCHA_WBV_SOLVE_METHOD] = method
|
||||
if (prefs[CAPTCHA_MODE] == "wv") {
|
||||
prefs[CAPTCHA_SOLVE_METHOD] = method
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Сохранение режима списка (ЧС/БС) ═══
|
||||
suspend fun saveIsWhitelist(enabled: Boolean) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[IS_WHITELIST] = enabled
|
||||
}
|
||||
}
|
||||
|
||||
// Атомарное сохранение обоих параметров для исключения гонки при перезагрузке
|
||||
suspend fun saveExceptionsMode(packages: String, isWhitelist: Boolean) {
|
||||
dataStore.edit { prefs ->
|
||||
prefs[EXCLUDED_APPS] = packages
|
||||
prefs[IS_WHITELIST] = isWhitelist
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun migrateSecretsToKeystore() {
|
||||
dataStore.edit { prefs ->
|
||||
prefs.migrateSecret(DEPLOY_PASSWORD_ENCRYPTED, DEPLOY_PASSWORD)
|
||||
prefs.migrateSecret(CONNECTION_PASSWORD_ENCRYPTED, CONNECTION_PASSWORD)
|
||||
prefs.migrateSecret(DEPLOY_MAIN_PASSWORD_ENCRYPTED, DEPLOY_MAIN_PASSWORD)
|
||||
prefs.migrateSecret(DEPLOY_ADMIN_ID_ENCRYPTED, DEPLOY_ADMIN_ID)
|
||||
prefs.migrateSecret(DEPLOY_BOT_TOKEN_ENCRYPTED, DEPLOY_BOT_TOKEN)
|
||||
}
|
||||
}
|
||||
|
||||
private fun readSecret(
|
||||
prefs: Preferences,
|
||||
encryptedKey: Preferences.Key<String>,
|
||||
legacyKey: Preferences.Key<String>
|
||||
): String {
|
||||
return secureStore.decrypt(prefs[encryptedKey]) ?: prefs[legacyKey] ?: ""
|
||||
}
|
||||
|
||||
private fun MutablePreferences.putSecret(
|
||||
encryptedKey: Preferences.Key<String>,
|
||||
legacyKey: Preferences.Key<String>,
|
||||
value: String
|
||||
) {
|
||||
if (value.isBlank()) {
|
||||
remove(encryptedKey)
|
||||
remove(legacyKey)
|
||||
} else {
|
||||
this[encryptedKey] = secureStore.encrypt(value)
|
||||
remove(legacyKey)
|
||||
}
|
||||
}
|
||||
|
||||
private fun MutablePreferences.migrateSecret(
|
||||
encryptedKey: Preferences.Key<String>,
|
||||
legacyKey: Preferences.Key<String>
|
||||
) {
|
||||
val legacyValue = this[legacyKey]
|
||||
val encryptedValue = this[encryptedKey]
|
||||
if (!encryptedValue.isNullOrBlank()) {
|
||||
remove(legacyKey)
|
||||
return
|
||||
}
|
||||
if (!legacyValue.isNullOrBlank()) {
|
||||
runCatching {
|
||||
this[encryptedKey] = secureStore.encrypt(legacyValue)
|
||||
remove(legacyKey)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,281 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.os.Build
|
||||
import android.app.Activity
|
||||
import androidx.compose.foundation.isSystemInDarkTheme
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Typography
|
||||
import androidx.compose.material3.darkColorScheme
|
||||
import androidx.compose.material3.dynamicLightColorScheme
|
||||
import androidx.compose.material3.lightColorScheme
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.SideEffect
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.lerp
|
||||
import androidx.compose.ui.graphics.toArgb
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.platform.LocalView
|
||||
import androidx.compose.ui.text.TextStyle
|
||||
import androidx.compose.ui.text.font.Font
|
||||
import androidx.compose.ui.text.font.FontFamily
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.core.view.WindowCompat
|
||||
|
||||
// ═══ Inter Font Family ═══
|
||||
val InterFontFamily = FontFamily(
|
||||
Font(R.font.inter_regular, FontWeight.Normal),
|
||||
Font(R.font.inter_medium, FontWeight.Medium),
|
||||
Font(R.font.inter_semibold, FontWeight.SemiBold),
|
||||
Font(R.font.inter_bold, FontWeight.Bold),
|
||||
)
|
||||
|
||||
// ═══ Типография на Inter ═══
|
||||
val WDTTTypography = Typography(
|
||||
displayLarge = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Bold, fontSize = 57.sp, lineHeight = 64.sp),
|
||||
displayMedium = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Bold, fontSize = 45.sp, lineHeight = 52.sp),
|
||||
displaySmall = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Bold, fontSize = 36.sp, lineHeight = 44.sp),
|
||||
headlineLarge = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.SemiBold, fontSize = 32.sp, lineHeight = 40.sp),
|
||||
headlineMedium = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.SemiBold, fontSize = 28.sp, lineHeight = 36.sp),
|
||||
headlineSmall = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.SemiBold, fontSize = 24.sp, lineHeight = 32.sp),
|
||||
titleLarge = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.SemiBold, fontSize = 22.sp, lineHeight = 28.sp),
|
||||
titleMedium = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.SemiBold, fontSize = 16.sp, lineHeight = 24.sp, letterSpacing = 0.15.sp),
|
||||
titleSmall = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Medium, fontSize = 14.sp, lineHeight = 20.sp, letterSpacing = 0.1.sp),
|
||||
bodyLarge = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Normal, fontSize = 16.sp, lineHeight = 24.sp, letterSpacing = 0.5.sp),
|
||||
bodyMedium = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Normal, fontSize = 14.sp, lineHeight = 20.sp, letterSpacing = 0.25.sp),
|
||||
bodySmall = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Normal, fontSize = 12.sp, lineHeight = 16.sp, letterSpacing = 0.4.sp),
|
||||
labelLarge = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Medium, fontSize = 14.sp, lineHeight = 20.sp, letterSpacing = 0.1.sp),
|
||||
labelMedium = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Medium, fontSize = 12.sp, lineHeight = 16.sp, letterSpacing = 0.5.sp),
|
||||
labelSmall = TextStyle(fontFamily = InterFontFamily, fontWeight = FontWeight.Medium, fontSize = 11.sp, lineHeight = 16.sp, letterSpacing = 0.5.sp),
|
||||
)
|
||||
|
||||
// ═══ Светлая палитра — «Раф на кокосовом молоке» ═══
|
||||
private val LightColorScheme = lightColorScheme(
|
||||
primary = Color(0xFF6D4C41),
|
||||
onPrimary = Color(0xFFFFFFFF),
|
||||
primaryContainer = Color(0xFFD7CCC8),
|
||||
onPrimaryContainer = Color(0xFF3E2723),
|
||||
secondary = Color(0xFF8D6E63),
|
||||
onSecondary = Color(0xFFFFFFFF),
|
||||
secondaryContainer = Color(0xFFEFEBE9),
|
||||
onSecondaryContainer = Color(0xFF4E342E),
|
||||
tertiary = Color(0xFF795548),
|
||||
onTertiary = Color(0xFFFFFFFF),
|
||||
tertiaryContainer = Color(0xFFBCAAA4),
|
||||
onTertiaryContainer = Color(0xFF3E2723),
|
||||
background = Color(0xFFF2F0EC),
|
||||
onBackground = Color(0xFF1C1B1A),
|
||||
surface = Color(0xFFFAF8F4),
|
||||
onSurface = Color(0xFF1C1B1A),
|
||||
surfaceVariant = Color(0xFFEFEBE9),
|
||||
onSurfaceVariant = Color(0xFF5D4037),
|
||||
outline = Color(0xFFBCAAA4),
|
||||
outlineVariant = Color(0xFFD7CCC8),
|
||||
error = Color(0xFFBA1A1A),
|
||||
onError = Color(0xFFFFFFFF),
|
||||
errorContainer = Color(0xFFFFDAD6),
|
||||
onErrorContainer = Color(0xFF410002),
|
||||
inverseSurface = Color(0xFF322F2D),
|
||||
inverseOnSurface = Color(0xFFF5F0EB),
|
||||
inversePrimary = Color(0xFFD7CCC8),
|
||||
surfaceTint = Color(0xFF6D4C41),
|
||||
)
|
||||
|
||||
// ═══ Тёмная палитра — «Эспрессо» ═══
|
||||
private val DarkColorScheme = darkColorScheme(
|
||||
primary = Color(0xFFD7CCC8),
|
||||
onPrimary = Color(0xFF3E2723),
|
||||
primaryContainer = Color(0xFF5D4037),
|
||||
onPrimaryContainer = Color(0xFFEFEBE9),
|
||||
secondary = Color(0xFFBCAAA4),
|
||||
onSecondary = Color(0xFF3E2723),
|
||||
secondaryContainer = Color(0xFF4E342E),
|
||||
onSecondaryContainer = Color(0xFFEFEBE9),
|
||||
tertiary = Color(0xFFA1887F),
|
||||
onTertiary = Color(0xFF3E2723),
|
||||
tertiaryContainer = Color(0xFF5D4037),
|
||||
onTertiaryContainer = Color(0xFFEFEBE9),
|
||||
background = Color(0xFF1A1614),
|
||||
onBackground = Color(0xFFEDE0D4),
|
||||
surface = Color(0xFF211D1B),
|
||||
onSurface = Color(0xFFEDE0D4),
|
||||
surfaceVariant = Color(0xFF2C2624),
|
||||
onSurfaceVariant = Color(0xFFD7CCC8),
|
||||
outline = Color(0xFF8D6E63),
|
||||
outlineVariant = Color(0xFF4E342E),
|
||||
error = Color(0xFFFFB4AB),
|
||||
onError = Color(0xFF690005),
|
||||
errorContainer = Color(0xFF93000A),
|
||||
onErrorContainer = Color(0xFFFFDAD6),
|
||||
inverseSurface = Color(0xFFEDE0D4),
|
||||
inverseOnSurface = Color(0xFF322F2D),
|
||||
inversePrimary = Color(0xFF6D4C41),
|
||||
surfaceTint = Color(0xFFD7CCC8),
|
||||
)
|
||||
|
||||
private val IndigoLightColorScheme = lightColorScheme(
|
||||
primary = Color(0xFF5B588D),
|
||||
onPrimary = Color(0xFFFFFFFF),
|
||||
primaryContainer = Color(0xFFE2DFFF),
|
||||
onPrimaryContainer = Color(0xFF1A1744),
|
||||
secondary = Color(0xFF5B588D),
|
||||
onSecondary = Color(0xFFFFFFFF),
|
||||
secondaryContainer = Color(0xFFE2DFFF),
|
||||
onSecondaryContainer = Color(0xFF1A1744),
|
||||
background = Color(0xFFFBF8FF),
|
||||
onBackground = Color(0xFF1B1B1F),
|
||||
surface = Color(0xFFF6F3FA),
|
||||
onSurface = Color(0xFF1B1B1F),
|
||||
surfaceVariant = Color(0xFFE4E1EC),
|
||||
onSurfaceVariant = Color(0xFF47464F),
|
||||
outline = Color(0xFF787680),
|
||||
outlineVariant = Color(0xFFC8C5D0),
|
||||
)
|
||||
|
||||
private val IndigoDarkColorScheme = darkColorScheme(
|
||||
primary = Color(0xFFC4C0FF),
|
||||
onPrimary = Color(0xFF2D2A5B),
|
||||
primaryContainer = Color(0xFF434073),
|
||||
onPrimaryContainer = Color(0xFFE2DFFF),
|
||||
secondary = Color(0xFFC4C0FF),
|
||||
onSecondary = Color(0xFF2D2A5B),
|
||||
secondaryContainer = Color(0xFF434073),
|
||||
onSecondaryContainer = Color(0xFFE2DFFF),
|
||||
background = Color(0xFF131316),
|
||||
onBackground = Color(0xFFE4E1E6),
|
||||
surface = Color(0xFF1B1B1F),
|
||||
onSurface = Color(0xFFC8C5D0),
|
||||
surfaceVariant = Color(0xFF47464F),
|
||||
onSurfaceVariant = Color(0xFFC8C5D0),
|
||||
outline = Color(0xFF918F9A),
|
||||
outlineVariant = Color(0xFF47464F),
|
||||
)
|
||||
|
||||
private val ForestLightColorScheme = lightColorScheme(
|
||||
primary = Color(0xFF5F5D68),
|
||||
onPrimary = Color(0xFFFFFFFF),
|
||||
primaryContainer = Color(0xFFE5E0F0),
|
||||
onPrimaryContainer = Color(0xFF1C1A23),
|
||||
secondary = Color(0xFF5F5D68),
|
||||
onSecondary = Color(0xFFFFFFFF),
|
||||
secondaryContainer = Color(0xFFE5E0F0),
|
||||
onSecondaryContainer = Color(0xFF1C1A23),
|
||||
background = Color(0xFFFCF8FF),
|
||||
onBackground = Color(0xFF1D1B20),
|
||||
surface = Color(0xFFF7F2FA),
|
||||
onSurface = Color(0xFF1D1B20),
|
||||
surfaceVariant = Color(0xFFE6E0E9),
|
||||
onSurfaceVariant = Color(0xFF48454E),
|
||||
outline = Color(0xFF79747E),
|
||||
outlineVariant = Color(0xFFCAC4D0),
|
||||
)
|
||||
|
||||
private val ForestDarkColorScheme = darkColorScheme(
|
||||
primary = Color(0xFFC8C4D3),
|
||||
onPrimary = Color(0xFF312F38),
|
||||
primaryContainer = Color(0xFF474550),
|
||||
onPrimaryContainer = Color(0xFFE5E0F0),
|
||||
secondary = Color(0xFFC8C4D3),
|
||||
onSecondary = Color(0xFF312F38),
|
||||
secondaryContainer = Color(0xFF474550),
|
||||
onSecondaryContainer = Color(0xFFE5E0F0),
|
||||
background = Color(0xFF141318),
|
||||
onBackground = Color(0xFFE6E1E5),
|
||||
surface = Color(0xFF1D1B20),
|
||||
onSurface = Color(0xFFCAC4D0),
|
||||
surfaceVariant = Color(0xFF48454E),
|
||||
onSurfaceVariant = Color(0xFFCAC4D0),
|
||||
outline = Color(0xFF938F99),
|
||||
outlineVariant = Color(0xFF48454E),
|
||||
)
|
||||
|
||||
private fun getAppColorScheme(palette: String, isDark: Boolean): androidx.compose.material3.ColorScheme {
|
||||
return when (palette) {
|
||||
"espresso" -> if (isDark) DarkColorScheme else LightColorScheme
|
||||
"forest" -> if (isDark) ForestDarkColorScheme else ForestLightColorScheme
|
||||
else -> if (isDark) IndigoDarkColorScheme else IndigoLightColorScheme
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Расширенные цвета для кастомных элементов ═══
|
||||
object WDTTColors {
|
||||
// Статус: подключено
|
||||
val connected = Color(0xFF4CAF50)
|
||||
val connectedContainer = Color(0xFF4CAF50).copy(alpha = 0.12f)
|
||||
val onConnected = Color(0xFF1B5E20)
|
||||
|
||||
val connectedDark = Color(0xFF81C784)
|
||||
val connectedContainerDark = Color(0xFF81C784).copy(alpha = 0.15f)
|
||||
val onConnectedDark = Color(0xFFC8E6C9)
|
||||
|
||||
// Статус: предупреждение
|
||||
val warning = Color(0xFFFFA726)
|
||||
val warningDark = Color(0xFFFFCC80)
|
||||
|
||||
// Терминал (логи)
|
||||
val terminalBg = Color(0xFF1A1A2E)
|
||||
val terminalBgDark = Color(0xFF0D0D1A)
|
||||
val terminalText = Color(0xFFE0E0E0)
|
||||
val terminalGreen = Color(0xFF4CAF50)
|
||||
val terminalBlue = Color(0xFF42A5F5)
|
||||
val terminalRed = Color(0xFFEF5350)
|
||||
val terminalYellow = Color(0xFFFFC107)
|
||||
val terminalCounter = Color(0xFF1E88E5)
|
||||
|
||||
// GitHub
|
||||
val github = Color(0xFF24292E)
|
||||
val githubDark = Color(0xFF333C47)
|
||||
|
||||
// Donate
|
||||
val donate = Color(0xFF8B3FFD)
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun WDTTTheme(
|
||||
themeMode: String = "system",
|
||||
dynamicColor: Boolean = false,
|
||||
themePalette: String = "indigo",
|
||||
content: @Composable () -> Unit
|
||||
) {
|
||||
val darkTheme = when (themeMode) {
|
||||
"dark" -> true
|
||||
"light" -> false
|
||||
else -> isSystemInDarkTheme()
|
||||
}
|
||||
|
||||
val colorScheme = when {
|
||||
dynamicColor && !darkTheme && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
|
||||
val context = LocalContext.current
|
||||
dynamicLightColorScheme(context)
|
||||
}
|
||||
else -> getAppColorScheme(themePalette, darkTheme)
|
||||
}
|
||||
|
||||
val view = LocalView.current
|
||||
if (!view.isInEditMode) {
|
||||
SideEffect {
|
||||
val window = (view.context as Activity).window
|
||||
val navigationBarColor = if (darkTheme) {
|
||||
Color.Transparent
|
||||
} else {
|
||||
lerp(colorScheme.background, colorScheme.surface, 0.55f)
|
||||
}
|
||||
window.statusBarColor = Color.Transparent.toArgb()
|
||||
window.navigationBarColor = navigationBarColor.toArgb()
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
|
||||
window.isNavigationBarContrastEnforced = false
|
||||
window.isStatusBarContrastEnforced = false
|
||||
}
|
||||
WindowCompat.getInsetsController(window, view).apply {
|
||||
isAppearanceLightStatusBars = !darkTheme
|
||||
isAppearanceLightNavigationBars = !darkTheme
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MaterialTheme(
|
||||
colorScheme = colorScheme,
|
||||
typography = WDTTTypography,
|
||||
content = content
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,836 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.content.Context
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.flow.update
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.io.File
|
||||
|
||||
import androidx.compose.runtime.Stable
|
||||
|
||||
@Stable
|
||||
data class LogEntry(
|
||||
val key: String,
|
||||
val message: String,
|
||||
val count: Int = 1,
|
||||
val priority: Int = 99, // 0 - Creds, 1 - DTLS, 2 - Ready, 3 - Stats, 99 - Errors/Other
|
||||
val isError: Boolean = false
|
||||
)
|
||||
|
||||
object TunnelManager {
|
||||
// 100% защита от утечек: единый управляемый глобальный Scope
|
||||
val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
|
||||
|
||||
private var process: Process? = null
|
||||
private var readerJob: Job? = null
|
||||
private var watchdogJob: Job? = null
|
||||
private var wgHelper: WireGuardHelper? = null
|
||||
|
||||
// Error counters for circuit breaker
|
||||
private var floodCount = 0
|
||||
private var mismatchCount = 0
|
||||
private var refusedCount = 0
|
||||
private var currentHashErrorCount = 0
|
||||
private var wrapAuthTimeoutCount = 0
|
||||
private var processStartedAtMs = 0L
|
||||
private var lastActiveAtMs = 0L
|
||||
private var activeHashIndex = 0 // 0: primary, 1: secondary
|
||||
private var currentParams: TunnelParams? = null
|
||||
private var lastContext: Context? = null
|
||||
private var forceRegenerateUA = false // принудительная перегенерация UA при ошибках
|
||||
private var currentCaptchaMode = "wv" // режим обхода капчи: "wv" или "rjs"
|
||||
private var currentCaptchaSolveMethod = "auto" // "manual" или "auto"
|
||||
|
||||
val running = MutableStateFlow(false)
|
||||
val logs = MutableStateFlow<List<LogEntry>>(emptyList())
|
||||
val unreadErrorCount = MutableStateFlow(0)
|
||||
val config = MutableStateFlow<String?>(null)
|
||||
val stats = MutableStateFlow("Ожидание данных...")
|
||||
val activeWorkers = MutableStateFlow(0)
|
||||
|
||||
val cooldownSeconds = MutableStateFlow(0)
|
||||
private var cooldownJob: Job? = null
|
||||
|
||||
fun clearUnreadErrors() {
|
||||
unreadErrorCount.value = 0
|
||||
}
|
||||
|
||||
// Добавляем лог с Деплоя
|
||||
fun addDeployErrorLog(message: String) {
|
||||
val hash = message.hashCode().toString()
|
||||
updateLog("deploy_err_$hash", "[ДЕПЛОЙ] $message", 99, true)
|
||||
}
|
||||
|
||||
fun addDeploySuccessLog(message: String) {
|
||||
val hash = message.hashCode().toString() + System.currentTimeMillis()
|
||||
updateLog("deploy_ok_$hash", message, 2, false)
|
||||
}
|
||||
|
||||
private fun updateLog(key: String, message: String, priority: Int, isError: Boolean = false) {
|
||||
if (isError) {
|
||||
val list = logs.value
|
||||
if (list.none { it.key == key }) {
|
||||
unreadErrorCount.value++
|
||||
}
|
||||
}
|
||||
logs.update { currentList ->
|
||||
val current = currentList.toMutableList()
|
||||
val index = current.indexOfFirst { it.key == key }
|
||||
|
||||
if (index != -1) {
|
||||
// Обновляем текст и счётчик НА МЕСТЕ
|
||||
val entry = current[index]
|
||||
current[index] = entry.copy(count = entry.count + 1, message = message, priority = priority, isError = isError)
|
||||
} else {
|
||||
// Новая запись
|
||||
current.add(LogEntry(key, message, 1, priority, isError))
|
||||
}
|
||||
|
||||
// Сортировка: по приоритету (наименьший сверху), затем ошибки
|
||||
// Приоритеты: Основной=1, Капча=5, Готов=10, Статы=100, Ошибки=200
|
||||
val sorted = current.sortedWith(compareBy({ it.priority }, { if (it.isError) 1 else 0 }, { it.key }))
|
||||
|
||||
// Лимит 100 записей
|
||||
if (sorted.size > 100) sorted.takeLast(100) else sorted
|
||||
}
|
||||
}
|
||||
|
||||
fun start(context: Context, params: TunnelParams, isSwitching: Boolean = false) {
|
||||
if (running.value && !isSwitching) return
|
||||
|
||||
val appContext = context.applicationContext // Защита от Memory Leak
|
||||
|
||||
if (!isSwitching) {
|
||||
clearLogs()
|
||||
config.value = null
|
||||
stats.value = "Ожидание данных..."
|
||||
floodCount = 0
|
||||
mismatchCount = 0
|
||||
refusedCount = 0
|
||||
currentHashErrorCount = 0
|
||||
wrapAuthTimeoutCount = 0
|
||||
processStartedAtMs = 0L
|
||||
lastActiveAtMs = 0L
|
||||
activeHashIndex = 0
|
||||
currentParams = params
|
||||
lastContext = appContext
|
||||
forceRegenerateUA = false
|
||||
currentCaptchaMode = params.captchaMode
|
||||
currentCaptchaSolveMethod = params.captchaSolveMethod
|
||||
}
|
||||
|
||||
wgHelper = WireGuardHelper(appContext)
|
||||
|
||||
scope.launch {
|
||||
try {
|
||||
val targetHash = if (activeHashIndex == 0) params.vkHashes else params.secondaryVkHash
|
||||
|
||||
// Robust hash parsing: split by comma, newline, or whitespace
|
||||
val hashList = targetHash
|
||||
.split(Regex("[,\\s\\n]+"))
|
||||
.map { it.trim() }
|
||||
.filter { it.isNotEmpty() }
|
||||
.take(3)
|
||||
|
||||
if (hashList.isEmpty()) {
|
||||
updateLog("hash_error", "Ошибка: Хеш не указан", 99, true)
|
||||
running.value = false
|
||||
return@launch
|
||||
}
|
||||
if (params.connectionPassword.isBlank()) {
|
||||
updateLog("password_error", "Ошибка: пароль подключения не указан", 99, true)
|
||||
running.value = false
|
||||
return@launch
|
||||
}
|
||||
|
||||
val hashCount = hashList.size.coerceIn(1, 3)
|
||||
val totalWorkers = params.workersPerHash.coerceIn(1, 128) // Максимум ограничивается UI (80), но тут ставим хард-лимит побольше на случай запаса
|
||||
|
||||
val hashMode = if (activeHashIndex == 0) "Основной" else "Запасной"
|
||||
updateLog("config_info", "[$hashMode] Хешей=$hashCount, Потоков=$totalWorkers", 1)
|
||||
|
||||
|
||||
// CRITICAL FIX: Use nativeLibraryDir with extractNativeLibs="true"
|
||||
val binaryPath = context.applicationInfo.nativeLibraryDir + "/libclient.so"
|
||||
val binaryFile = File(binaryPath)
|
||||
|
||||
if (!binaryFile.exists()) {
|
||||
updateLog("binary_error", "Ошибка: Бинарный файл не найден", 99, true)
|
||||
return@launch
|
||||
}
|
||||
|
||||
val cmd = mutableListOf(
|
||||
binaryPath,
|
||||
"-peer", params.peer,
|
||||
"-vk", hashList.joinToString(","),
|
||||
"-n", totalWorkers.toString(),
|
||||
"-listen", "127.0.0.1:${params.port}"
|
||||
)
|
||||
|
||||
val androidId = android.provider.Settings.Secure.getString(context.contentResolver, android.provider.Settings.Secure.ANDROID_ID) ?: "unknown"
|
||||
cmd.add("-device-id")
|
||||
cmd.add(androidId)
|
||||
|
||||
cmd.add("-password")
|
||||
cmd.add(params.connectionPassword)
|
||||
|
||||
// Captcha mode: wv или rjs
|
||||
cmd.add("-captcha-mode")
|
||||
cmd.add(params.captchaMode)
|
||||
|
||||
val pb = ProcessBuilder(cmd)
|
||||
pb.directory(context.filesDir) // Устанавливаем рабочую директорию
|
||||
pb.redirectErrorStream(true)
|
||||
|
||||
// Set LD_LIBRARY_PATH
|
||||
val env = pb.environment()
|
||||
env["LD_LIBRARY_PATH"] = context.applicationInfo.nativeLibraryDir
|
||||
|
||||
process = pb.start()
|
||||
processStartedAtMs = System.currentTimeMillis()
|
||||
wrapAuthTimeoutCount = 0
|
||||
lastActiveAtMs = 0L
|
||||
running.value = true
|
||||
startLogReader()
|
||||
startWatchdog(appContext, params)
|
||||
|
||||
} catch (e: Exception) {
|
||||
updateLog("critical_start_error", "Критическая ошибка запуска: ${e.message}", 99, true)
|
||||
e.printStackTrace()
|
||||
running.value = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun startLogReader() {
|
||||
readerJob = scope.launch {
|
||||
val reader = process?.inputStream?.bufferedReader() ?: return@launch
|
||||
var collectingConfig = false
|
||||
val configBuilder = StringBuilder()
|
||||
|
||||
try {
|
||||
var lastResetTime = System.currentTimeMillis()
|
||||
|
||||
reader.forEachLine { line ->
|
||||
// Периодический сброс счетчиков ошибок (раз в 60 сек)
|
||||
val now = System.currentTimeMillis()
|
||||
if (now - lastResetTime > 60000) {
|
||||
refusedCount = 0
|
||||
floodCount = 0
|
||||
mismatchCount = 0
|
||||
currentHashErrorCount = 0
|
||||
lastResetTime = now
|
||||
}
|
||||
|
||||
// Чистим лог от даты из Go (например, "2023/10/24 12:34:56.123456 [ВОРКЕР...")
|
||||
val msgPrefixReplaced = line.replace(Regex("^\\d{4}/\\d{2}/\\d{2}\\s\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?\\s"), "")
|
||||
val lineTrim = msgPrefixReplaced.trim()
|
||||
|
||||
val isError = lineTrim.contains("Ошибка", true) || lineTrim.contains("error", true) || lineTrim.contains("FAIL", true) || lineTrim.contains("timeout", true) || lineTrim.contains("refused", true) || lineTrim.contains("FATAL_AUTH", true)
|
||||
|
||||
// 0. FATAL AUTH — мгновенная остановка
|
||||
if (lineTrim.contains("FATAL_AUTH")) {
|
||||
val isWrapHandshakeTimeout = lineTrim.contains("DTLS timeout", true) ||
|
||||
lineTrim.contains("WRAP_AUTH_TIMEOUT", true)
|
||||
if (isWrapHandshakeTimeout) {
|
||||
if (activeWorkers.value > 0) {
|
||||
wrapAuthTimeoutCount = 0
|
||||
updateLog(
|
||||
"wrap_timeout_recovered",
|
||||
"[WRAP] Один поток не прошёл handshake, активных=${activeWorkers.value}; повторяем",
|
||||
50,
|
||||
true
|
||||
)
|
||||
} else {
|
||||
wrapAuthTimeoutCount++
|
||||
updateLog(
|
||||
"wrap_timeout_wait",
|
||||
"[WRAP] Handshake не подтвердился, проверяем пароль/сеть ($wrapAuthTimeoutCount)",
|
||||
50,
|
||||
true
|
||||
)
|
||||
}
|
||||
return@forEachLine
|
||||
}
|
||||
|
||||
val reason = when {
|
||||
lineTrim.contains("неверный пароль") -> "Неверный пароль подключения"
|
||||
lineTrim.contains("истёк") -> "Срок действия пароля истёк"
|
||||
lineTrim.contains("другому устройству") -> "Пароль привязан к другому устройству"
|
||||
else -> "Ошибка авторизации"
|
||||
}
|
||||
handleCriticalError("\uD83D\uDD12 $reason. Воркеры остановлены.")
|
||||
return@forEachLine
|
||||
}
|
||||
|
||||
// 0a. WRAP auth timeout — не фатально для отдельного воркера.
|
||||
// Критичным считаем только ситуацию, когда за стартовое окно не поднялся ни один поток.
|
||||
if (lineTrim.contains("WRAP_AUTH_TIMEOUT", true)) {
|
||||
if (activeWorkers.value > 0) {
|
||||
wrapAuthTimeoutCount = 0
|
||||
updateLog(
|
||||
"wrap_timeout_recovered",
|
||||
"[WRAP] Один поток не прошёл handshake, активных=${activeWorkers.value}; повторяем",
|
||||
50,
|
||||
true
|
||||
)
|
||||
} else {
|
||||
wrapAuthTimeoutCount++
|
||||
updateLog(
|
||||
"wrap_timeout_wait",
|
||||
"[WRAP] Handshake не подтвердился, проверяем пароль/сеть ($wrapAuthTimeoutCount)",
|
||||
50,
|
||||
true
|
||||
)
|
||||
}
|
||||
return@forEachLine
|
||||
}
|
||||
|
||||
// 0b. CAPTCHA_SOLVE — запрос от Go для WBV-режима.
|
||||
if (lineTrim.startsWith("CAPTCHA_SOLVE|")) {
|
||||
val payload = lineTrim.substringAfter("CAPTCHA_SOLVE|")
|
||||
val parts = payload.split("|", limit = 3)
|
||||
when (parts.size) {
|
||||
3 -> {
|
||||
val requestMode = parts[0]
|
||||
val redirectUri = parts[1]
|
||||
val sessionToken = parts[2]
|
||||
scope.launch {
|
||||
handleCaptchaSolve(requestMode, redirectUri, sessionToken)
|
||||
}
|
||||
}
|
||||
2 -> {
|
||||
val redirectUri = parts[0]
|
||||
val sessionToken = parts[1]
|
||||
scope.launch {
|
||||
handleCaptchaSolve("selected", redirectUri, sessionToken)
|
||||
}
|
||||
}
|
||||
else -> {
|
||||
writeCaptchaResult("error:invalid CAPTCHA_SOLVE format")
|
||||
}
|
||||
}
|
||||
return@forEachLine
|
||||
}
|
||||
|
||||
// 1. ПРЕДОХРАНИТЕЛЬ (Circuit Breaker)
|
||||
if (isError) {
|
||||
when {
|
||||
lineTrim.contains("Flood control", true) -> {
|
||||
floodCount++
|
||||
if (floodCount >= 5) {
|
||||
handleCriticalError("Flood Control (ВК ограничил ваш IP). Попробуйте позже.")
|
||||
return@forEachLine
|
||||
}
|
||||
}
|
||||
lineTrim.contains("ip mismatch", true) -> {
|
||||
mismatchCount++
|
||||
if (mismatchCount >= 5) {
|
||||
handleCriticalError("IP Mismatch (IP утерян). Попробуйте переподключиться.")
|
||||
return@forEachLine
|
||||
}
|
||||
}
|
||||
lineTrim.contains("connection refused", true) || lineTrim.contains("timeout", true) -> {
|
||||
// Огромный лимит, потому что каждый воркер кидает эту ошибку при смене сети
|
||||
refusedCount++
|
||||
if (refusedCount >= 400) {
|
||||
handleCriticalError("Критическое отсутствие сети (400+ таймаутов). Отключение.")
|
||||
return@forEachLine
|
||||
}
|
||||
}
|
||||
lineTrim.contains("9000") || lineTrim.contains("Call not found", true) -> {
|
||||
currentHashErrorCount++
|
||||
// Нужно больше попыток, так как 1 воркер может спамить
|
||||
if (currentHashErrorCount >= 10) {
|
||||
handleHashError()
|
||||
return@forEachLine
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Статистика (Обновляемая строка)
|
||||
if (lineTrim.contains("[СТАТИСТИКА]")) {
|
||||
val msg = lineTrim.substringAfter("[СТАТИСТИКА]").trim()
|
||||
stats.value = msg
|
||||
|
||||
val match = Regex("Активных:\\s*(\\d+)").find(msg)
|
||||
if (match != null) {
|
||||
val active = match.groupValues[1].toIntOrNull() ?: 0
|
||||
activeWorkers.value = active
|
||||
if (active > 0) {
|
||||
lastActiveAtMs = now
|
||||
wrapAuthTimeoutCount = 0
|
||||
}
|
||||
}
|
||||
|
||||
updateLog("stats", "[СТАТИСТИКА] $msg", 3, false)
|
||||
return@forEachLine
|
||||
}
|
||||
|
||||
// 2. Этапы подключения и Ошибки
|
||||
when {
|
||||
|
||||
// ═══ Авто-оркестратор капчи ═══
|
||||
lineTrim.contains("[КАПЧА] AUTO:") -> {
|
||||
var text = lineTrim.substringAfter("[КАПЧА] AUTO:").trim()
|
||||
text = text.replace(Regex("\\s*\\([^)]+\\)\\s*"), " ").trim()
|
||||
|
||||
val isErr = text.contains("ошибка", true) ||
|
||||
text.contains("timeout", true) ||
|
||||
text.contains("не решил", true)
|
||||
val stableKey = when {
|
||||
text.contains("старт") -> "captcha_auto_1"
|
||||
text.contains("Go v2") && text.contains("2 попыт") -> "captcha_auto_2"
|
||||
text.contains("WBV Auto попытка") -> "captcha_auto_3"
|
||||
text.contains("финальная") -> "captcha_auto_4"
|
||||
text.contains("ручной WebView") -> "captcha_auto_5"
|
||||
text.contains("решил") || text.contains("решила") -> "captcha_auto_done"
|
||||
else -> "captcha_auto_${text.take(18).hashCode()}"
|
||||
}
|
||||
updateLog(stableKey, "[КАПЧА AUTO] $text", 5, isErr)
|
||||
}
|
||||
|
||||
// ═══ RJS капча логи: [КАПЧА RJS] со стабильными ключами-шагами ═══
|
||||
lineTrim.contains("[КАПЧА] RJS:") -> {
|
||||
// Удаляем тайминги и лишние скобки: (123мс), (diff=2), (общее время...)
|
||||
var text = lineTrim.substringAfter("[КАПЧА] RJS:").trim()
|
||||
text = text.replace(Regex("\\s*\\([^)]+\\)\\s*"), " ").trim()
|
||||
|
||||
val stableKey = when {
|
||||
text.contains("Загрузка") || text.contains("fetch") -> "captcha_rjs_1"
|
||||
text.contains("PoW") -> "captcha_rjs_2"
|
||||
text.contains("осматривает") || text.contains("человек") -> "captcha_rjs_3"
|
||||
text.contains("captchaNotRobot") || text.contains("Отправка") -> "captcha_rjs_4"
|
||||
text.contains("endSession") -> "captcha_rjs_5"
|
||||
text.contains("решена") -> "captcha_rjs_6"
|
||||
else -> "captcha_rjs_${text.take(15).hashCode()}"
|
||||
}
|
||||
updateLog(stableKey, "[КАПЧА RJS] $text", 5, false)
|
||||
}
|
||||
|
||||
// ═══ WV капча логи от Go: [КАПЧА WBV] со стабильными ключами ═══
|
||||
lineTrim.contains("[КАПЧА] WBV:") -> {
|
||||
var text = lineTrim.substringAfter("[КАПЧА] WBV:").trim()
|
||||
text = text.replace(Regex("\\s*\\([^)]+\\)\\s*"), " ").trim()
|
||||
|
||||
val isErr = text.contains("Ошибка")
|
||||
val stableKey = when {
|
||||
text.contains("Запрос") -> "captcha_wv_step_2" // Step 2 (после создания WV)
|
||||
text.contains("Токен") -> "captcha_wv_step_5" // Step 5 (перед уничтожением)
|
||||
isErr -> "captcha_wv_err"
|
||||
else -> "captcha_wv_go_other"
|
||||
}
|
||||
updateLog(stableKey, "[КАПЧА WBV] $text", 5, isErr)
|
||||
}
|
||||
|
||||
lineTrim.contains("Старт") || lineTrim.contains("Ожидайте") ->
|
||||
updateLog("creds_start", "[ВК] Получение учетных данных...", 2, false)
|
||||
lineTrim.contains("Креды получены") ->
|
||||
updateLog("creds_lifetime", lineTrim, 2, false)
|
||||
lineTrim.contains("Креды OK") || lineTrim.contains("Первые креды") ->
|
||||
updateLog("creds_ok", "[ВК] Учетные данные проверены ✓", 2, false)
|
||||
lineTrim.contains("Решаю VK Smart Captcha") ->
|
||||
updateLog("captcha_start", "[КАПЧА] Решение капчи...", 5, false)
|
||||
lineTrim.contains("Smart Captcha решена") ->
|
||||
updateLog("captcha_done", "[КАПЧА] Капча решена ✓", 5, false)
|
||||
lineTrim.contains("капча не решена") || lineTrim.contains("ошибка решения капчи") ->
|
||||
updateLog("captcha_failed", "[КАПЧА] Ошибка решения капчи", 5, true)
|
||||
lineTrim.contains("[WRAP]") -> {
|
||||
val text = lineTrim.substringAfter("[WRAP]").trim()
|
||||
updateLog("wrap_status", "[WRAP] $text", 1, false)
|
||||
}
|
||||
lineTrim.contains("[TURN]") -> {
|
||||
val text = lineTrim.substringAfter("[TURN]").trim()
|
||||
val turnError = text.contains("Ошибка", true) ||
|
||||
text.contains("не удалось", true) ||
|
||||
text.contains("неполный ответ", true)
|
||||
updateLog("turn_${text.take(32).hashCode()}", "[TURN] $text", 2, turnError)
|
||||
}
|
||||
lineTrim.contains("Relay:") ->
|
||||
updateLog("dtls_start", "[DTLS] Рукопожатие (Handshake)...", 1, false)
|
||||
lineTrim.contains("DTLS ОК") ->
|
||||
updateLog("dtls_ok", "[DTLS] Соединение установлено ✓", 1, false)
|
||||
lineTrim.contains("Активна ✓") ->
|
||||
updateLog("ready", "[READY] Туннель готов к работе ✓", 2, false)
|
||||
|
||||
// Ошибки (в конец)
|
||||
isError -> {
|
||||
// Формируем уникальный ключ ошибки на основе её типа (группируем по типу ошибки)
|
||||
val errorKey = when {
|
||||
lineTrim.contains("lookup login.vk.ru", true) -> "err_vk_dns"
|
||||
lineTrim.contains("connection refused") -> "err_conn_refused"
|
||||
lineTrim.contains("timeout") -> "err_timeout"
|
||||
lineTrim.contains("кредов") -> "err_creds"
|
||||
lineTrim.contains("DTLS") -> "err_dtls"
|
||||
else -> "general_error_" + lineTrim.take(15).hashCode()
|
||||
}
|
||||
val errorMessage = if (errorKey == "err_vk_dns") {
|
||||
"[СЕТЬ] DNS до VK недоступен: login.vk.ru"
|
||||
} else {
|
||||
lineTrim
|
||||
}
|
||||
updateLog(errorKey, errorMessage, 99, true)
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Обработка конфига (Скрываем от пользователя)
|
||||
if (line.contains("╔") && line.contains("WireGuard")) {
|
||||
collectingConfig = true
|
||||
configBuilder.clear()
|
||||
return@forEachLine
|
||||
} else if (collectingConfig) {
|
||||
if (line.contains("╚")) {
|
||||
collectingConfig = false
|
||||
val configStr = configBuilder.toString().trim()
|
||||
config.value = configStr
|
||||
|
||||
scope.launch(Dispatchers.Main) {
|
||||
try {
|
||||
wgHelper?.startTunnel(configStr)
|
||||
} catch (e: Exception) {
|
||||
updateLog("vpn_start_error", "Ошибка запуска VPN: ${e.readableMessage()}", 99, true)
|
||||
}
|
||||
}
|
||||
} else if (line.contains("║")) {
|
||||
val content = line.replace("║", "").trim()
|
||||
if (content.isNotEmpty()) {
|
||||
configBuilder.appendLine(content)
|
||||
}
|
||||
}
|
||||
return@forEachLine
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
updateLog("sys_error", "Процесс остановлен: ${e.message}", -1, true)
|
||||
} finally {
|
||||
running.value = false
|
||||
process = null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleCriticalError(message: String) {
|
||||
updateLog("circuit_breaker", "[СТОП] $message", -1, true)
|
||||
stop()
|
||||
}
|
||||
|
||||
private fun handleHashError() {
|
||||
val params = currentParams ?: return
|
||||
val context = lastContext ?: return
|
||||
|
||||
currentHashErrorCount = 0
|
||||
forceRegenerateUA = true // Перегенерируем UA при следующих ошибках
|
||||
|
||||
if (params.secondaryVkHash.isNotEmpty() && activeHashIndex == 0) {
|
||||
updateLog("hash_switch", "Основной хеш мертв. Переключение на запасной...", 50, true)
|
||||
activeHashIndex = 1
|
||||
stopOnlyProcess()
|
||||
start(context, params, isSwitching = true)
|
||||
} else {
|
||||
val msg = if (activeHashIndex == 1) "Запасной хеш тоже мертв. Отключение." else "Хеш умер, запасного нет. Отключение."
|
||||
handleCriticalError(msg)
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== WATCHDOG ====================
|
||||
// Проверяет, жив ли Go-процесс. Если умер — перезапускает.
|
||||
// Если процесс жив, но 0 воркеров уже 30 сек — тоже перезапуск (зомби).
|
||||
private fun startWatchdog(context: Context, params: TunnelParams) {
|
||||
watchdogJob?.cancel()
|
||||
watchdogJob = scope.launch {
|
||||
var zeroWorkersSince = 0L
|
||||
delay(10_000) // Даём 10 сек на старт
|
||||
while (isActive && running.value) {
|
||||
val proc = process
|
||||
if (proc == null || !proc.isAlive) {
|
||||
// Go-процесс мёртв!
|
||||
updateLog("watchdog", "⚠ Процесс упал. Перезапуск...", 50, true)
|
||||
activeWorkers.value = 0
|
||||
forceRegenerateUA = true
|
||||
killProcess()
|
||||
delay(2000)
|
||||
if (running.value) {
|
||||
start(context, params, isSwitching = true)
|
||||
}
|
||||
return@launch // startWatchdog будет перезапущен из start()
|
||||
}
|
||||
|
||||
// Детекция зомби: процесс жив, но 0 воркеров
|
||||
val workers = activeWorkers.value
|
||||
if (workers <= 0) {
|
||||
if (zeroWorkersSince == 0L) {
|
||||
zeroWorkersSince = System.currentTimeMillis()
|
||||
} else if (
|
||||
wrapAuthTimeoutCount >= 3 &&
|
||||
processStartedAtMs > 0L &&
|
||||
System.currentTimeMillis() - processStartedAtMs > 30_000 &&
|
||||
lastActiveAtMs == 0L &&
|
||||
!ManlCaptchaWebViewManager.isCaptchaPending
|
||||
) {
|
||||
handleCriticalError("\uD83D\uDD12 Неверный пароль подключения или несовместимый WRAP. Воркеры остановлены.")
|
||||
return@launch
|
||||
} else if (System.currentTimeMillis() - zeroWorkersSince > 90_000 && !ManlCaptchaWebViewManager.isCaptchaPending) {
|
||||
updateLog("watchdog", "⚠ Зомби-процесс (0 воркеров 90с). Перезапуск...", 50, true)
|
||||
forceRegenerateUA = true
|
||||
killProcess()
|
||||
delay(2000)
|
||||
if (running.value) {
|
||||
start(context, params, isSwitching = true)
|
||||
}
|
||||
return@launch
|
||||
}
|
||||
} else {
|
||||
zeroWorkersSince = 0L
|
||||
}
|
||||
|
||||
delay(5_000)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun restartTransport() {
|
||||
val params = currentParams ?: return
|
||||
val context = lastContext ?: return
|
||||
updateLog("network_restart", "[СЕТЬ] Перезапуск транспорта из-за смены сети...", 50, false)
|
||||
killProcess() // Только убиваем процесс, running не трогаем!
|
||||
scope.launch {
|
||||
delay(1500)
|
||||
start(context, params, isSwitching = true)
|
||||
}
|
||||
}
|
||||
|
||||
fun pause() {
|
||||
if (!running.value) return
|
||||
killProcess() // Не ставим running=false, чтоб сервис не умер
|
||||
activeWorkers.value = 0
|
||||
}
|
||||
|
||||
fun resume() {
|
||||
if (currentParams != null && lastContext != null) {
|
||||
scope.launch {
|
||||
start(lastContext!!, currentParams!!, isSwitching = true)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Убивает процесс без изменения running
|
||||
private fun killProcess() {
|
||||
watchdogJob?.cancel()
|
||||
readerJob?.cancel()
|
||||
val proc = process
|
||||
process = null
|
||||
if (proc != null) {
|
||||
try { proc.destroy() } catch (_: Exception) {}
|
||||
// Даём 500мс на graceful shutdown
|
||||
try { proc.waitFor(500, java.util.concurrent.TimeUnit.MILLISECONDS) } catch (_: Exception) {}
|
||||
if (proc.isAlive) {
|
||||
try { proc.destroyForcibly() } catch (_: Exception) {}
|
||||
try { proc.waitFor(1000, java.util.concurrent.TimeUnit.MILLISECONDS) } catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun stopOnlyProcess() {
|
||||
killProcess()
|
||||
running.value = false
|
||||
}
|
||||
|
||||
private fun log(message: String) {
|
||||
updateLog("internal_${message.hashCode()}", message, 50, false)
|
||||
}
|
||||
|
||||
fun stop() {
|
||||
scope.launch(Dispatchers.Main) {
|
||||
wgHelper?.stopTunnel()
|
||||
}
|
||||
killProcess()
|
||||
running.value = false
|
||||
activeWorkers.value = 0
|
||||
currentParams = null
|
||||
ManlCaptchaWebViewManager.cancelCaptcha()
|
||||
}
|
||||
|
||||
// Suspend-версия: гарантирует что процесс мёртв и порт свободен
|
||||
suspend fun stopAndWait() {
|
||||
// Сначала останавливаем WireGuard и ждём завершения
|
||||
withContext(Dispatchers.Main) {
|
||||
wgHelper?.stopTunnel()
|
||||
}
|
||||
withContext(Dispatchers.IO) {
|
||||
killProcess()
|
||||
running.value = false
|
||||
activeWorkers.value = 0
|
||||
currentParams = null
|
||||
ManlCaptchaWebViewManager.cancelCaptcha()
|
||||
// Ждём освобождения порта 9000 (до 3 секунд)
|
||||
repeat(30) {
|
||||
try {
|
||||
java.net.ServerSocket(9000, 1, java.net.InetAddress.getByName("127.0.0.1")).use { it.close() }
|
||||
return@withContext // Порт свободен!
|
||||
} catch (_: Exception) {
|
||||
delay(100)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun reloadWireGuard() {
|
||||
if (running.value) {
|
||||
scope.launch {
|
||||
wgHelper?.reloadTunnel()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== CAPTCHA SOLVER (WebView Mode) ====================
|
||||
|
||||
/**
|
||||
* Вызывается при получении CAPTCHA_SOLVE от Go-процесса.
|
||||
* auto: одна короткая скрытая попытка для Go-оркестратора.
|
||||
* manual: сразу видимый WebView.
|
||||
* selected: старое поведение из UI, когда пользователь сам выбрал режим.
|
||||
* Результат ВСЕГДА отправляется обратно в Go через writeCaptchaResult.
|
||||
*/
|
||||
private suspend fun handleCaptchaSolve(requestMode: String, redirectUri: String, sessionToken: String) {
|
||||
val ctx = lastContext ?: run {
|
||||
writeCaptchaResult("error:context is null")
|
||||
return
|
||||
}
|
||||
val mode = requestMode.lowercase()
|
||||
|
||||
try {
|
||||
val token = when (mode) {
|
||||
"auto" -> solveSingleAutoWebViewCaptcha(redirectUri, sessionToken)
|
||||
"manual" -> {
|
||||
updateLog("captcha_wv_step_1", "[КАПЧА WBV] Создание ручного WebView...", 5, false)
|
||||
ManlCaptchaWebViewManager.solveCaptchaAsync(ctx, redirectUri, sessionToken)
|
||||
}
|
||||
else -> {
|
||||
if (currentCaptchaSolveMethod == "auto") {
|
||||
solveAutoWebViewCaptcha(ctx, redirectUri, sessionToken)
|
||||
} else {
|
||||
updateLog("captcha_wv_step_1", "[КАПЧА WBV] Создание ручного WebView...", 5, false)
|
||||
ManlCaptchaWebViewManager.solveCaptchaAsync(ctx, redirectUri, sessionToken)
|
||||
}
|
||||
}
|
||||
}
|
||||
updateLog("captcha_wv_step_4", "[КАПЧА WBV] Капча решена ✓", 5, false)
|
||||
writeCaptchaResult(token)
|
||||
} catch (e: IllegalStateException) {
|
||||
val errorMsg = e.message ?: "WV state error"
|
||||
updateLog("captcha_wv_err", "[КАПЧА WBV] $errorMsg", 5, true)
|
||||
writeCaptchaResult("error:$errorMsg")
|
||||
} catch (e: kotlinx.coroutines.TimeoutCancellationException) {
|
||||
updateLog("captcha_wv_err", "[КАПЧА WBV] Таймаут WebView", 5, true)
|
||||
writeCaptchaResult("error:timeout")
|
||||
} catch (e: kotlin.coroutines.cancellation.CancellationException) {
|
||||
updateLog("captcha_wv_err", "[КАПЧА WBV] Отменено", 5, true)
|
||||
writeCaptchaResult("error:cancelled")
|
||||
} catch (e: Exception) {
|
||||
val errorMsg = e.message ?: "${e::class.simpleName}"
|
||||
if (errorMsg != "tunnel stopped") {
|
||||
updateLog("captcha_wv_err", "[КАПЧА WBV] Ошибка — $errorMsg", 5, true)
|
||||
}
|
||||
writeCaptchaResult("error:$errorMsg")
|
||||
}
|
||||
|
||||
// WebView уничтожен в finally блоке соответствующего менеджера.
|
||||
updateLog("captcha_wv_step_6", "[КАПЧА WBV] WebView уничтожен", 5, false)
|
||||
}
|
||||
|
||||
private suspend fun solveSingleAutoWebViewCaptcha(
|
||||
redirectUri: String,
|
||||
sessionToken: String
|
||||
): String {
|
||||
updateLog("captcha_wv_step_1", "[КАПЧА WBV] Авто WebView попытка 10с...", 5, false)
|
||||
return CaptchaWebViewManager.solveCaptchaAsync(redirectUri, sessionToken) { step ->
|
||||
updateLog("captcha_wv_auto_step", "[КАПЧА WBV] $step", 5, false)
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun solveAutoWebViewCaptcha(
|
||||
ctx: Context,
|
||||
redirectUri: String,
|
||||
sessionToken: String
|
||||
): String {
|
||||
for (attempt in 1..2) {
|
||||
updateLog("captcha_wv_step_1", "[КАПЧА WBV] Авто WebView попытка $attempt/2...", 5, false)
|
||||
try {
|
||||
return CaptchaWebViewManager.solveCaptchaAsync(redirectUri, sessionToken) { step ->
|
||||
updateLog("captcha_wv_auto_step", "[КАПЧА WBV] $step", 5, false)
|
||||
}
|
||||
} catch (e: kotlinx.coroutines.TimeoutCancellationException) {
|
||||
updateLog("captcha_wv_timeout_$attempt", "[КАПЧА WBV] Авто таймаут 10с ($attempt/2)", 5, attempt == 2)
|
||||
if (attempt == 2) {
|
||||
updateLog("captcha_wv_fallback", "[КАПЧА WBV] 2 таймаута авто, открыт ручной WebView", 5, false)
|
||||
return ManlCaptchaWebViewManager.solveCaptchaAsync(ctx, redirectUri, sessionToken)
|
||||
}
|
||||
} catch (e: IllegalStateException) {
|
||||
if (e.message == CaptchaWebViewManager.ERROR_SLIDER_DETECTED) {
|
||||
updateLog("captcha_wv_fallback", "[КАПЧА WBV] Обнаружен слайдер, открыт ручной WebView", 5, false)
|
||||
return ManlCaptchaWebViewManager.solveCaptchaAsync(ctx, redirectUri, sessionToken)
|
||||
}
|
||||
throw e
|
||||
}
|
||||
}
|
||||
return ManlCaptchaWebViewManager.solveCaptchaAsync(ctx, redirectUri, sessionToken)
|
||||
}
|
||||
|
||||
/**
|
||||
* Записывает результат решения капчи в stdin Go-процесса.
|
||||
*/
|
||||
private fun writeCaptchaResult(result: String) {
|
||||
val proc = process
|
||||
if (proc == null || !proc.isAlive) return
|
||||
try {
|
||||
val line = "CAPTCHA_RESULT|$result\n"
|
||||
proc.outputStream.write(line.toByteArray(Charsets.UTF_8))
|
||||
proc.outputStream.flush()
|
||||
} catch (e: Exception) {
|
||||
updateLog("captcha_write_err", "[КАПЧА] Ошибка записи: ${e.message}", 200, true)
|
||||
}
|
||||
}
|
||||
|
||||
fun clearLogs() {
|
||||
logs.value = emptyList()
|
||||
activeWorkers.value = 0
|
||||
}
|
||||
|
||||
fun startCooldown(seconds: Int) {
|
||||
cooldownJob?.cancel()
|
||||
cooldownSeconds.value = seconds
|
||||
cooldownJob = scope.launch(Dispatchers.Main) {
|
||||
while (cooldownSeconds.value > 0) {
|
||||
delay(1000)
|
||||
cooldownSeconds.update { it - 1 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun Throwable.readableMessage(): String {
|
||||
val text = message ?: localizedMessage
|
||||
return if (text.isNullOrBlank()) this::class.java.simpleName else "${this::class.java.simpleName}: $text"
|
||||
}
|
||||
}
|
||||
|
||||
data class TunnelParams(
|
||||
val peer: String,
|
||||
val vkHashes: String,
|
||||
val secondaryVkHash: String = "",
|
||||
val workersPerHash: Int,
|
||||
val port: Int,
|
||||
val sni: String = "",
|
||||
val connectionPassword: String = "",
|
||||
val protocol: String = "udp",
|
||||
val captchaMode: String = "auto", // "auto", "wv" или "rjs"
|
||||
val captchaSolveMethod: String = "auto" // "manual" или "auto"
|
||||
)
|
||||
@@ -0,0 +1,378 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.app.Service
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.ServiceInfo
|
||||
import android.net.ConnectivityManager
|
||||
import android.net.Network
|
||||
import android.net.NetworkCapabilities
|
||||
import android.net.NetworkRequest
|
||||
import android.net.wifi.WifiManager
|
||||
import android.os.Build
|
||||
import android.os.IBinder
|
||||
import android.os.PowerManager
|
||||
import android.util.Log
|
||||
import androidx.core.app.NotificationCompat
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
|
||||
private const val TUNNEL_NOTIFICATION_CHANNEL_ID = "wdtt_tunnel_v4"
|
||||
private const val TUNNEL_NOTIFICATION_ID = 1
|
||||
|
||||
class TunnelService : Service() {
|
||||
private var wakeLock: PowerManager.WakeLock? = null
|
||||
private var wifiLock: WifiManager.WifiLock? = null
|
||||
private var updateJob: Job? = null
|
||||
private var lastNotificationText: String? = null
|
||||
|
||||
// Network Monitoring
|
||||
private var connectivityManager: ConnectivityManager? = null
|
||||
private var networkCallback: ConnectivityManager.NetworkCallback? = null
|
||||
private var lastNetworkChangeTime = 0L
|
||||
private val activeNetworks = mutableSetOf<Network>()
|
||||
private var isTunnelPaused = false
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
createNotificationChannel()
|
||||
// Сразу берем лок при создании
|
||||
acquireWakeLock()
|
||||
setupNetworkCallback()
|
||||
}
|
||||
|
||||
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
||||
if (intent == null) {
|
||||
restoreTunnel()
|
||||
return START_STICKY
|
||||
}
|
||||
|
||||
when (intent.action) {
|
||||
"START" -> {
|
||||
val notification = createNotification("Запуск...")
|
||||
startPersistentForeground(notification)
|
||||
|
||||
val params = TunnelParams(
|
||||
peer = intent.getStringExtra("peer") ?: "",
|
||||
vkHashes = intent.getStringExtra("vk_hashes") ?: "",
|
||||
secondaryVkHash = intent.getStringExtra("secondary_vk_hash") ?: "",
|
||||
workersPerHash = intent.getIntExtra("workers_per_hash", 16),
|
||||
port = intent.getIntExtra("port", 9000),
|
||||
sni = intent.getStringExtra("sni") ?: "",
|
||||
connectionPassword = intent.getStringExtra("connection_password") ?: "",
|
||||
protocol = intent.getStringExtra("protocol") ?: "udp",
|
||||
captchaMode = sanitizeCaptchaMode(intent.getStringExtra("captcha_mode")),
|
||||
captchaSolveMethod = intent.getStringExtra("captcha_solve_method") ?: "auto"
|
||||
)
|
||||
startTunnel(params)
|
||||
}
|
||||
"STOP" -> stopTunnel()
|
||||
"DEPLOY_START" -> {
|
||||
val notification = createNotification("Установка на сервер...", "DEPLOY_CANCEL", "Отменить")
|
||||
startPersistentForeground(notification)
|
||||
acquireWakeLock()
|
||||
}
|
||||
"DEPLOY_CANCEL" -> {
|
||||
com.wdtt.client.DeployManager.writeError("[!] ❌ Установка отменена пользователем")
|
||||
com.wdtt.client.DeployManager.stopDeploy("error: Отменена пользователем")
|
||||
stopForeground(STOP_FOREGROUND_REMOVE)
|
||||
}
|
||||
"DEPLOY_STOP" -> {
|
||||
if (!TunnelManager.running.value) {
|
||||
stopTunnel()
|
||||
} else {
|
||||
updateNotification("Туннель активен")
|
||||
}
|
||||
}
|
||||
}
|
||||
return START_STICKY
|
||||
}
|
||||
|
||||
private fun restoreTunnel() {
|
||||
val notification = createNotification("Восстановление соединения...")
|
||||
startPersistentForeground(notification)
|
||||
|
||||
val appContext = applicationContext
|
||||
TunnelManager.scope.launch {
|
||||
try {
|
||||
val store = SettingsStore(appContext)
|
||||
val basePeer = store.peer.first()
|
||||
val manualPortsEnabled = store.manualPortsEnabled.first()
|
||||
val serverDtlsPort = if (manualPortsEnabled) store.serverDtlsPort.first() else 56000
|
||||
val peerWithPort = if (basePeer.isBlank() || basePeer.contains(":")) basePeer else "$basePeer:$serverDtlsPort"
|
||||
val params = TunnelParams(
|
||||
peer = peerWithPort,
|
||||
vkHashes = store.vkHashes.first(),
|
||||
secondaryVkHash = store.secondaryVkHash.first(),
|
||||
workersPerHash = store.workersPerHash.first(),
|
||||
port = store.listenPort.first(),
|
||||
sni = store.sni.first(),
|
||||
connectionPassword = store.connectionPassword.first(),
|
||||
captchaMode = sanitizeCaptchaMode(store.captchaMode.first()),
|
||||
captchaSolveMethod = store.captchaSolveMethod.first()
|
||||
)
|
||||
if (params.peer.isNotEmpty() && params.vkHashes.isNotEmpty()) {
|
||||
launch(Dispatchers.Main) {
|
||||
startTunnel(params)
|
||||
}
|
||||
} else {
|
||||
launch(Dispatchers.Main) {
|
||||
stopTunnel()
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
launch(Dispatchers.Main) {
|
||||
stopTunnel()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun startTunnel(params: TunnelParams) {
|
||||
updateNotification("Подключение...")
|
||||
acquireWakeLock()
|
||||
acquireWifiLock()
|
||||
|
||||
// Подготавливаем CaptchaWebViewManager (не создаёт WebView — просто сохраняет контекст)
|
||||
// Вызываем всегда — дёшево, а WebView создаётся на лету при каждом запросе капчи
|
||||
CaptchaWebViewManager.onTunnelStart(applicationContext)
|
||||
|
||||
TunnelManager.start(this, params)
|
||||
startStatsUpdater()
|
||||
}
|
||||
|
||||
private fun stopTunnel() {
|
||||
updateJob?.cancel()
|
||||
|
||||
// Уничтожаем текущий WebView (если капча решается) и чистим контекст
|
||||
CaptchaWebViewManager.onTunnelStop()
|
||||
|
||||
TunnelManager.stop()
|
||||
releaseWakeLock()
|
||||
releaseWifiLock()
|
||||
stopForeground(STOP_FOREGROUND_REMOVE)
|
||||
stopSelf()
|
||||
}
|
||||
|
||||
private fun setupNetworkCallback() {
|
||||
connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
|
||||
activeNetworks.clear()
|
||||
|
||||
networkCallback = object : ConnectivityManager.NetworkCallback() {
|
||||
override fun onAvailable(network: Network) {
|
||||
super.onAvailable(network)
|
||||
val wasEmpty = activeNetworks.isEmpty()
|
||||
activeNetworks.add(network)
|
||||
if (wasEmpty) {
|
||||
if (isTunnelPaused) {
|
||||
isTunnelPaused = false
|
||||
Log.d("TunnelService", "Сеть появилась, возобновляем туннель")
|
||||
TunnelManager.resume()
|
||||
updateNotification("Подключение...")
|
||||
} else {
|
||||
handleNetworkChange()
|
||||
}
|
||||
} else {
|
||||
handleNetworkChange()
|
||||
}
|
||||
}
|
||||
|
||||
override fun onLost(network: Network) {
|
||||
super.onLost(network)
|
||||
activeNetworks.remove(network)
|
||||
if (activeNetworks.isEmpty() && TunnelManager.running.value && !isTunnelPaused) {
|
||||
isTunnelPaused = true
|
||||
Log.d("TunnelService", "Сеть потеряна, приостанавливаем туннель")
|
||||
TunnelManager.pause()
|
||||
updateNotification("Ожидание сети (Фоновый сон)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ВАЖНО: Слушаем только реальные (не VPN) сети с доступом в интернет.
|
||||
// Иначе интерфейс VPN (tun0) считается активной сетью, и при "Режиме полёта" activeNetworks не падает до 0.
|
||||
val request = NetworkRequest.Builder()
|
||||
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
|
||||
.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)
|
||||
.build()
|
||||
|
||||
connectivityManager?.registerNetworkCallback(request, networkCallback!!)
|
||||
}
|
||||
|
||||
private fun handleNetworkChange() {
|
||||
val now = System.currentTimeMillis()
|
||||
if (now - lastNetworkChangeTime < 5000) return
|
||||
lastNetworkChangeTime = now
|
||||
|
||||
if (TunnelManager.running.value && !isTunnelPaused) {
|
||||
Log.d("TunnelService", "Сеть изменилась, мягкий перезапуск Go-клиента")
|
||||
TunnelManager.restartTransport()
|
||||
}
|
||||
}
|
||||
|
||||
private fun sanitizeCaptchaMode(mode: String?): String {
|
||||
return when (mode?.lowercase()) {
|
||||
"auto" -> "auto"
|
||||
"rjs" -> "rjs"
|
||||
"wv" -> "wv"
|
||||
else -> "auto"
|
||||
}
|
||||
}
|
||||
|
||||
private fun acquireWakeLock() {
|
||||
if (wakeLock?.isHeld == true) return
|
||||
val pm = getSystemService(POWER_SERVICE) as PowerManager
|
||||
wakeLock = pm.newWakeLock(
|
||||
PowerManager.PARTIAL_WAKE_LOCK,
|
||||
"wdtt:tunnel_cpu"
|
||||
).apply {
|
||||
setReferenceCounted(false)
|
||||
acquire()
|
||||
}
|
||||
}
|
||||
|
||||
@Suppress("DEPRECATION")
|
||||
private fun acquireWifiLock() {
|
||||
if (wifiLock?.isHeld == true) return
|
||||
val wm = applicationContext.getSystemService(WIFI_SERVICE) as WifiManager
|
||||
|
||||
// Используем WIFI_MODE_FULL_LOW_LATENCY для Android 10+,
|
||||
// это предотвращает отключение радиомодуля при выключенном экране
|
||||
val mode = if (Build.VERSION.SDK_INT >= 29) {
|
||||
WifiManager.WIFI_MODE_FULL_LOW_LATENCY
|
||||
} else {
|
||||
WifiManager.WIFI_MODE_FULL_HIGH_PERF
|
||||
}
|
||||
|
||||
wifiLock = wm.createWifiLock(mode, "wdtt:wifi_perf").apply {
|
||||
setReferenceCounted(false)
|
||||
acquire()
|
||||
}
|
||||
}
|
||||
|
||||
private fun releaseWakeLock() {
|
||||
if (wakeLock?.isHeld == true) {
|
||||
wakeLock?.release()
|
||||
}
|
||||
wakeLock = null
|
||||
}
|
||||
|
||||
private fun releaseWifiLock() {
|
||||
if (wifiLock?.isHeld == true) {
|
||||
wifiLock?.release()
|
||||
}
|
||||
wifiLock = null
|
||||
}
|
||||
|
||||
private fun startStatsUpdater() {
|
||||
updateJob?.cancel()
|
||||
updateJob = TunnelManager.scope.launch(Dispatchers.Main) {
|
||||
delay(1000)
|
||||
while (isActive) {
|
||||
if (!TunnelManager.running.value && !isTunnelPaused) {
|
||||
// Туннель полностью остановлен (не на паузе) — убиваем сервис
|
||||
stopSelf()
|
||||
break
|
||||
}
|
||||
if (!isTunnelPaused) {
|
||||
updateNotification(buildTunnelNotificationText())
|
||||
}
|
||||
delay(2000)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun buildTunnelNotificationText(): String {
|
||||
val statsText = TunnelManager.stats.value.trim()
|
||||
return when {
|
||||
statsText.isEmpty() -> "Туннель активен"
|
||||
statsText == "Ожидание данных..." -> "Туннель активен"
|
||||
else -> statsText
|
||||
}
|
||||
}
|
||||
|
||||
private fun createNotificationChannel() {
|
||||
val channel = NotificationChannel(
|
||||
TUNNEL_NOTIFICATION_CHANNEL_ID,
|
||||
"WDTT Туннель",
|
||||
NotificationManager.IMPORTANCE_LOW
|
||||
).apply {
|
||||
description = "Уведомление о работе туннеля"
|
||||
setShowBadge(false)
|
||||
// ВАЖНО: Разрешаем показывать на экране блокировки
|
||||
lockscreenVisibility = Notification.VISIBILITY_PUBLIC
|
||||
setSound(null, null)
|
||||
enableVibration(false)
|
||||
}
|
||||
getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
|
||||
}
|
||||
|
||||
private fun createNotification(text: String, actionName: String = "STOP", actionTitle: String = "Отключить"): Notification {
|
||||
val openIntent = PendingIntent.getActivity(
|
||||
this, 0,
|
||||
Intent(this, MainActivity::class.java),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
|
||||
)
|
||||
|
||||
val stopIntent = PendingIntent.getService(
|
||||
this, if (actionName == "STOP") 1 else 2,
|
||||
Intent(this, TunnelService::class.java).apply { action = actionName },
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
|
||||
)
|
||||
|
||||
return NotificationCompat.Builder(this, TUNNEL_NOTIFICATION_CHANNEL_ID)
|
||||
.setContentTitle("WDTT")
|
||||
.setContentText(text)
|
||||
.setSmallIcon(R.drawable.ic_stat_connected)
|
||||
.setOngoing(true)
|
||||
.setLocalOnly(true)
|
||||
.setContentIntent(openIntent)
|
||||
.addAction(R.drawable.ic_stop, actionTitle, stopIntent)
|
||||
.setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_DEFAULT)
|
||||
// ВАЖНО: Делаем уведомление публичным (видимым на локскрине)
|
||||
.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
|
||||
// Категория SERVICE помогает системе понять важность
|
||||
.setCategory(NotificationCompat.CATEGORY_SERVICE)
|
||||
.setOnlyAlertOnce(true) // Не издавать звук и не будить экран при обновлении статистики!
|
||||
.setSilent(true) // Делаем тихим само уведомление
|
||||
.setShowWhen(false)
|
||||
.setUsesChronometer(false)
|
||||
.setWhen(0L)
|
||||
.setPriority(NotificationCompat.PRIORITY_LOW)
|
||||
.build()
|
||||
}
|
||||
|
||||
private fun startPersistentForeground(notification: Notification) {
|
||||
if (Build.VERSION.SDK_INT >= 34) {
|
||||
startForeground(TUNNEL_NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE)
|
||||
} else {
|
||||
startForeground(TUNNEL_NOTIFICATION_ID, notification)
|
||||
}
|
||||
}
|
||||
|
||||
private fun updateNotification(text: String) {
|
||||
if (lastNotificationText == text) return
|
||||
lastNotificationText = text
|
||||
val notification = createNotification(text)
|
||||
getSystemService(NotificationManager::class.java).notify(TUNNEL_NOTIFICATION_ID, notification)
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
super.onDestroy()
|
||||
networkCallback?.let {
|
||||
connectivityManager?.unregisterNetworkCallback(it)
|
||||
}
|
||||
stopTunnel()
|
||||
}
|
||||
|
||||
override fun onBind(intent: Intent?): IBinder? = null
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.os.Build
|
||||
import kotlin.random.Random
|
||||
|
||||
/**
|
||||
* Генерирует реалистичный User-Agent на основе информации об устройстве.
|
||||
* Включает случайные вариации версий браузеров и мелкие опечатки для уникальности.
|
||||
*/
|
||||
object UserAgentGenerator {
|
||||
|
||||
private val chromeVersions = listOf(120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131)
|
||||
private val firefoxVersions = listOf(120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130)
|
||||
private val edgeVersions = listOf(120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130)
|
||||
private val yaBrowserVersions = listOf("24.1", "24.2", "24.3", "24.4", "24.5", "24.6", "24.7", "24.8", "24.9", "24.10", "24.11", "24.12")
|
||||
private val operaVersions = listOf(106, 107, 108, 109, 110, 111, 112, 113, 114, 115)
|
||||
|
||||
/**
|
||||
* Генерирует User-Agent для текущего устройства.
|
||||
* @param seed опциональный seed для детерминированной генерации (на основе device ID)
|
||||
*/
|
||||
fun generate(seed: Long? = null): String {
|
||||
val rng = seed?.let { Random(it) } ?: Random.Default
|
||||
|
||||
val androidVersion = Build.VERSION.RELEASE
|
||||
val deviceModel = Build.MODEL ?: "Unknown"
|
||||
|
||||
val androidPlatform = "Linux; Android $androidVersion; $deviceModel"
|
||||
|
||||
val chromeVersion = chromeVersions[rng.nextInt(chromeVersions.size)]
|
||||
val patchVersion = rng.nextInt(0, 99)
|
||||
val fullChromeVersion = "$chromeVersion.0.$patchVersion.0"
|
||||
|
||||
val browserType = rng.nextInt(100)
|
||||
|
||||
return when {
|
||||
// 60% — обычный Chrome на Android
|
||||
browserType < 60 -> {
|
||||
"Mozilla/5.0 ($androidPlatform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$fullChromeVersion Mobile Safari/537.36"
|
||||
}
|
||||
// 15% — Chrome на десктопе (имитация)
|
||||
browserType < 75 -> {
|
||||
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$fullChromeVersion Safari/537.36"
|
||||
}
|
||||
// 8% — Yandex Browser
|
||||
browserType < 83 -> {
|
||||
val yaVer = yaBrowserVersions[rng.nextInt(yaBrowserVersions.size)]
|
||||
val yaPatch = rng.nextInt(0, 9)
|
||||
"Mozilla/5.0 ($androidPlatform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$chromeVersion.0.$patchVersion.0 YaBrowser/$yaVer.$yaPatch Yowser/2.5 Mobile Safari/537.36"
|
||||
}
|
||||
// 7% — Firefox
|
||||
browserType < 90 -> {
|
||||
val ffVersion = firefoxVersions[rng.nextInt(firefoxVersions.size)]
|
||||
"Mozilla/5.0 ($androidPlatform; rv:$ffVersion.0) Gecko/20100101 Firefox/$ffVersion.0"
|
||||
}
|
||||
// 5% — Edge
|
||||
browserType < 95 -> {
|
||||
val edgeVersion = edgeVersions[rng.nextInt(edgeVersions.size)]
|
||||
"Mozilla/5.0 ($androidPlatform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$fullChromeVersion Mobile Safari/537.36 EdgA/$edgeVersion.0.${rng.nextInt(0, 99)}.${rng.nextInt(0, 99)}"
|
||||
}
|
||||
// 5% — Opera
|
||||
else -> {
|
||||
val operaVersion = operaVersions[rng.nextInt(operaVersions.size)]
|
||||
"Mozilla/5.0 ($androidPlatform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/$fullChromeVersion Mobile Safari/537.36 OPR/$operaVersion.0.${rng.nextInt(0, 99)}"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Генерирует детерминированный UA на основе device ID.
|
||||
* Один и тот же device ID всегда даёт одинаковый UA.
|
||||
*/
|
||||
fun generateForDevice(deviceId: String): String {
|
||||
val seed = deviceId.hashCode().toLong() and 0xFFFFFFFFL
|
||||
return generate(seed)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.app.Application
|
||||
import android.content.Context
|
||||
import com.wireguard.android.backend.GoBackend
|
||||
|
||||
class WdttApplication : Application() {
|
||||
@Volatile
|
||||
private var backendInstance: GoBackend? = null
|
||||
|
||||
val backend: GoBackend
|
||||
get() = getBackend(this)
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
DeployManager.init(this)
|
||||
}
|
||||
|
||||
fun getBackend(context: Context): GoBackend {
|
||||
return backendInstance ?: synchronized(this) {
|
||||
backendInstance ?: GoBackend(context.applicationContext).also { backendInstance = it }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
package com.wdtt.client
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.net.VpnService
|
||||
import android.util.Log
|
||||
import com.wireguard.android.backend.GoBackend
|
||||
import com.wireguard.android.backend.Tunnel
|
||||
import com.wireguard.config.Config
|
||||
import com.wireguard.config.Interface
|
||||
import com.wireguard.config.Peer
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.io.ByteArrayInputStream
|
||||
|
||||
class WireGuardHelper(context: Context) {
|
||||
private val appContext = context.applicationContext
|
||||
private val backend = (appContext as WdttApplication).getBackend(context)
|
||||
|
||||
private companion object {
|
||||
val wgMutex = Mutex()
|
||||
var sharedTunnel: WgTunnel? = null
|
||||
}
|
||||
|
||||
class WgTunnel : Tunnel {
|
||||
override fun getName() = "wdtt"
|
||||
override fun onStateChange(newState: Tunnel.State) {}
|
||||
}
|
||||
|
||||
suspend fun startTunnel(configString: String) = wgMutex.withLock {
|
||||
startTunnelLocked(configString)
|
||||
}
|
||||
|
||||
private suspend fun startTunnelLocked(configString: String) = withContext(Dispatchers.IO) {
|
||||
try {
|
||||
if (VpnService.prepare(appContext) != null) {
|
||||
throw IllegalStateException("VPN-разрешение не выдано")
|
||||
}
|
||||
|
||||
ensureGoBackendServiceStarted()
|
||||
|
||||
sharedTunnel?.let { existingTunnel ->
|
||||
try {
|
||||
backend.setState(existingTunnel, Tunnel.State.DOWN, null)
|
||||
} catch (e: Exception) {
|
||||
Log.w("WG", "Failed to stop previous tunnel before restart: ${e.readableMessage()}")
|
||||
}
|
||||
sharedTunnel = null
|
||||
delay(150)
|
||||
}
|
||||
|
||||
val parsedConfig = Config.parse(ByteArrayInputStream(configString.toByteArray(Charsets.UTF_8)))
|
||||
|
||||
val builder = Interface.Builder()
|
||||
.parseAddresses(parsedConfig.`interface`.addresses.joinToString(", ") { it.toString() })
|
||||
|
||||
if (parsedConfig.`interface`.dnsServers.isNotEmpty()) {
|
||||
builder.parseDnsServers(parsedConfig.`interface`.dnsServers.joinToString(", ") { it.hostAddress ?: "" })
|
||||
}
|
||||
if (parsedConfig.`interface`.listenPort.isPresent) {
|
||||
builder.parseListenPort(parsedConfig.`interface`.listenPort.get().toString())
|
||||
}
|
||||
if (parsedConfig.`interface`.mtu.isPresent) {
|
||||
val serverMtu = parsedConfig.`interface`.mtu.get()
|
||||
// Используем серверное значение, но не менее 1280 для мобильных сетей
|
||||
builder.parseMtu(serverMtu.coerceAtLeast(1280).toString())
|
||||
} else {
|
||||
builder.parseMtu("1280")
|
||||
}
|
||||
builder.parsePrivateKey(parsedConfig.`interface`.keyPair.privateKey.toBase64())
|
||||
|
||||
// 1. Пакеты, которые всегда исключаются (наше приложение, ВК)
|
||||
// 2. Получаю настройки пользователя
|
||||
val settingsStore = SettingsStore(appContext)
|
||||
val savedExcluded = settingsStore.excludedApps.first()
|
||||
|
||||
val userSelected = savedExcluded.split(",").filter { it.isNotEmpty() }.toSet()
|
||||
|
||||
// В обоих режимах (ЧС и БС) мы технически используем Blacklist (Checked = Excluded),
|
||||
// так как пользователю удобнее логика "снимите галочку, чтобы приложение пошло в туннель".
|
||||
// Разница только в описании и начальном состоянии списка (пустой/полный).
|
||||
val excluded = mutableSetOf(appContext.packageName, "com.vkontakte.android", "com.vk.calls")
|
||||
excluded.addAll(userSelected)
|
||||
val installedExcluded = excluded.filter { it.isInstalledPackage() }.toSet()
|
||||
if (installedExcluded.isNotEmpty()) {
|
||||
builder.excludeApplications(installedExcluded)
|
||||
}
|
||||
|
||||
val newInterface = builder.build()
|
||||
|
||||
val peerBuilder = Peer.Builder()
|
||||
val firstPeer = parsedConfig.peers.firstOrNull()
|
||||
?: throw IllegalStateException("WireGuard config has no peer")
|
||||
firstPeer.let { peer ->
|
||||
peerBuilder.parsePublicKey(peer.publicKey.toBase64())
|
||||
if (peer.preSharedKey.isPresent) peerBuilder.parsePreSharedKey(peer.preSharedKey.get().toBase64())
|
||||
if (peer.endpoint.isPresent) peerBuilder.parseEndpoint(peer.endpoint.get().toString())
|
||||
if (peer.persistentKeepalive.isPresent) peerBuilder.parsePersistentKeepalive(peer.persistentKeepalive.get().toString())
|
||||
}
|
||||
// Override AllowedIPs
|
||||
peerBuilder.parseAllowedIPs("0.0.0.0/0")
|
||||
|
||||
val finalConfig = Config.Builder()
|
||||
.setInterface(newInterface)
|
||||
.addPeer(peerBuilder.build())
|
||||
.build()
|
||||
|
||||
val nextTunnel = WgTunnel()
|
||||
setTunnelUpWithRetry(nextTunnel, finalConfig)
|
||||
sharedTunnel = nextTunnel
|
||||
Log.d("WG", "WireGuard tunnel started successfully")
|
||||
} catch (e: Exception) {
|
||||
val detailed = "WireGuard start failed: ${e.readableMessage()}; ${configString.describeWireGuardConfig()}"
|
||||
Log.e("WG", detailed)
|
||||
e.printStackTrace()
|
||||
throw IllegalStateException(detailed, e)
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun reloadTunnel() = wgMutex.withLock {
|
||||
withContext(Dispatchers.IO) {
|
||||
val currentTunnel = sharedTunnel ?: return@withContext
|
||||
try {
|
||||
val configFlow = TunnelManager.config.first() ?: return@withContext
|
||||
backend.setState(currentTunnel, Tunnel.State.DOWN, null)
|
||||
sharedTunnel = null
|
||||
delay(150)
|
||||
startTunnelLocked(configFlow)
|
||||
Log.d("WG", "WireGuard tunnel reloaded for new exceptions")
|
||||
} catch (e: Exception) {
|
||||
Log.e("WG", "Failed to reload WireGuard: ${e.readableMessage()}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun stopTunnel() = wgMutex.withLock {
|
||||
withContext(Dispatchers.IO) {
|
||||
try {
|
||||
sharedTunnel?.let {
|
||||
backend.setState(it, Tunnel.State.DOWN, null)
|
||||
sharedTunnel = null
|
||||
Log.d("WG", "WireGuard tunnel stopped")
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
Log.e("WG", "Failed to stop WireGuard: ${e.readableMessage()}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun ensureGoBackendServiceStarted() {
|
||||
withContext(Dispatchers.Main) {
|
||||
runCatching {
|
||||
val intent = Intent(appContext, GoBackend.VpnService::class.java)
|
||||
appContext.startService(intent)
|
||||
}.onFailure {
|
||||
Log.w("WG", "GoBackend service warmup failed: ${it.readableMessage()}")
|
||||
}
|
||||
}
|
||||
delay(300)
|
||||
}
|
||||
|
||||
private suspend fun setTunnelUpWithRetry(nextTunnel: WgTunnel, finalConfig: Config) {
|
||||
var lastError: Exception? = null
|
||||
repeat(3) { attempt ->
|
||||
try {
|
||||
backend.setState(nextTunnel, Tunnel.State.UP, finalConfig)
|
||||
return
|
||||
} catch (e: Exception) {
|
||||
lastError = e
|
||||
Log.w("WG", "WireGuard UP attempt ${attempt + 1}/3 failed: ${e.readableMessage()}")
|
||||
runCatching { backend.setState(nextTunnel, Tunnel.State.DOWN, null) }
|
||||
ensureGoBackendServiceStarted()
|
||||
delay(250L * (attempt + 1))
|
||||
}
|
||||
}
|
||||
throw lastError ?: IllegalStateException("WireGuard UP failed")
|
||||
}
|
||||
|
||||
private fun Throwable.readableMessage(): String {
|
||||
val text = message ?: localizedMessage
|
||||
return if (text.isNullOrBlank()) this::class.java.simpleName else "${this::class.java.simpleName}: $text"
|
||||
}
|
||||
|
||||
private fun String.isInstalledPackage(): Boolean {
|
||||
return runCatching {
|
||||
appContext.packageManager.getPackageInfo(this, 0)
|
||||
true
|
||||
}.getOrDefault(false)
|
||||
}
|
||||
|
||||
private fun String.describeWireGuardConfig(): String {
|
||||
val lines = lineSequence().map { it.trim() }.filter { it.isNotEmpty() }.toList()
|
||||
val hasInterface = lines.any { it.equals("[Interface]", ignoreCase = true) }
|
||||
val hasPeer = lines.any { it.equals("[Peer]", ignoreCase = true) }
|
||||
val hasPrivateKey = lines.any { it.startsWith("PrivateKey", ignoreCase = true) }
|
||||
val hasPublicKey = lines.any { it.startsWith("PublicKey", ignoreCase = true) }
|
||||
val hasAddress = lines.any { it.startsWith("Address", ignoreCase = true) }
|
||||
val endpoint = lines.firstOrNull { it.startsWith("Endpoint", ignoreCase = true) }
|
||||
?.substringAfter("=", "")
|
||||
?.trim()
|
||||
?.take(80)
|
||||
?: "none"
|
||||
return "config lines=${lines.size}, interface=$hasInterface, peer=$hasPeer, privateKey=$hasPrivateKey, publicKey=$hasPublicKey, address=$hasAddress, endpoint=$endpoint"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import androidx.compose.foundation.BorderStroke
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.ColumnScope
|
||||
import androidx.compose.foundation.layout.PaddingValues
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.lerp
|
||||
import androidx.compose.ui.graphics.luminance
|
||||
import androidx.compose.ui.unit.dp
|
||||
|
||||
@Composable
|
||||
private fun appSectionCardColor(): Color {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val isDark = colors.background.luminance() < 0.22f
|
||||
return if (isDark) {
|
||||
lerp(colors.surface, colors.surfaceVariant, 0.10f)
|
||||
} else {
|
||||
lerp(colors.surface, colors.surfaceVariant, 0.28f)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun appSectionCardBorderColor(): Color {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val isDark = colors.background.luminance() < 0.22f
|
||||
return if (isDark) {
|
||||
colors.outlineVariant.copy(alpha = 0.26f)
|
||||
} else {
|
||||
colors.outlineVariant.copy(alpha = 0.24f)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun AppSectionCard(
|
||||
modifier: Modifier = Modifier,
|
||||
contentPadding: PaddingValues = PaddingValues(horizontal = 18.dp, vertical = 18.dp),
|
||||
verticalArrangement: Arrangement.Vertical = Arrangement.spacedBy(16.dp),
|
||||
content: @Composable ColumnScope.() -> Unit
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(28.dp),
|
||||
color = appSectionCardColor(),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
border = BorderStroke(1.dp, appSectionCardBorderColor()),
|
||||
shadowElevation = if (MaterialTheme.colorScheme.background.luminance() < 0.22f) 2.dp else 10.dp,
|
||||
tonalElevation = if (MaterialTheme.colorScheme.background.luminance() < 0.22f) 0.dp else 2.dp,
|
||||
modifier = modifier.fillMaxWidth()
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(contentPadding),
|
||||
verticalArrangement = verticalArrangement,
|
||||
content = content
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Update
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedButton
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.compose.ui.window.Dialog
|
||||
import androidx.compose.ui.window.DialogProperties
|
||||
import com.wdtt.client.AppReleaseInfo
|
||||
import com.wdtt.client.RemoteVersionSource
|
||||
|
||||
@Composable
|
||||
fun AppUpdateDialog(
|
||||
release: AppReleaseInfo,
|
||||
onPostpone: () -> Unit,
|
||||
onUpdate: () -> Unit
|
||||
) {
|
||||
val isTagOnly = release.source == RemoteVersionSource.Tag
|
||||
val title = if (isTagOnly) "Найден новый tag" else "Доступно обновление"
|
||||
val description = if (isTagOnly) {
|
||||
"На GitHub обнаружен более новый tag ${release.versionTag}. Похоже, опубликованный release ещё не догнал его."
|
||||
} else {
|
||||
"Вышла новая версия приложения ${release.versionTag}. Можно открыть страницу релиза и обновиться вручную."
|
||||
}
|
||||
|
||||
Dialog(
|
||||
onDismissRequest = {},
|
||||
properties = DialogProperties(
|
||||
usePlatformDefaultWidth = false,
|
||||
dismissOnBackPress = false,
|
||||
dismissOnClickOutside = false
|
||||
)
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(28.dp),
|
||||
color = MaterialTheme.colorScheme.surface,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
tonalElevation = 8.dp,
|
||||
modifier = Modifier.fillMaxWidth(0.92f)
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 22.dp, vertical = 20.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(14.dp)
|
||||
) {
|
||||
Row(verticalAlignment = Alignment.CenterVertically) {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Update,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(20.dp)
|
||||
)
|
||||
Spacer(Modifier.width(10.dp))
|
||||
Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||
Text(
|
||||
text = title,
|
||||
style = MaterialTheme.typography.titleMedium,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.primary
|
||||
)
|
||||
Text(
|
||||
text = release.versionTag,
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
fontWeight = FontWeight.SemiBold,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Text(
|
||||
text = description,
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
lineHeight = 20.sp
|
||||
)
|
||||
|
||||
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.35f))
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
OutlinedButton(
|
||||
onClick = onPostpone,
|
||||
modifier = Modifier
|
||||
.weight(1f)
|
||||
.height(50.dp),
|
||||
shape = RoundedCornerShape(22.dp)
|
||||
) {
|
||||
Text("Позже", fontWeight = FontWeight.SemiBold)
|
||||
}
|
||||
|
||||
Button(
|
||||
onClick = onUpdate,
|
||||
modifier = Modifier
|
||||
.weight(1f)
|
||||
.height(50.dp),
|
||||
shape = RoundedCornerShape(22.dp)
|
||||
) {
|
||||
Text("Обновить", fontWeight = FontWeight.Bold)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,912 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.os.Build
|
||||
import androidx.compose.animation.core.animateFloatAsState
|
||||
import androidx.compose.animation.core.tween
|
||||
import androidx.compose.foundation.BorderStroke
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.CheckCircle
|
||||
import androidx.compose.material.icons.filled.CloudUpload
|
||||
import androidx.compose.material.icons.filled.Close
|
||||
import androidx.compose.material.icons.filled.Delete
|
||||
import androidx.compose.material.icons.filled.Key
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import com.wdtt.client.TunnelService
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import com.jcraft.jsch.ChannelExec
|
||||
import com.jcraft.jsch.ChannelSftp
|
||||
import com.jcraft.jsch.JSch
|
||||
import com.jcraft.jsch.Session
|
||||
import com.wdtt.client.DeployManager
|
||||
import com.wdtt.client.SettingsStore
|
||||
import com.wdtt.client.TunnelManager
|
||||
import com.wdtt.client.WDTTColors
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.io.File
|
||||
import java.io.FileOutputStream
|
||||
import java.util.Properties
|
||||
|
||||
private const val CMD_TIMEOUT = 900000L // 15 minutes
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun DeployTab() {
|
||||
val context = LocalContext.current
|
||||
val scope = rememberCoroutineScope()
|
||||
val settingsStore = remember { SettingsStore(context) }
|
||||
|
||||
LaunchedEffect(Unit) { DeployManager.init(context) }
|
||||
|
||||
val savedIp by settingsStore.deployIp.collectAsStateWithLifecycle(initialValue = "")
|
||||
val savedLogin by settingsStore.deployLogin.collectAsStateWithLifecycle(initialValue = "")
|
||||
val savedPassword by settingsStore.deployPassword.collectAsStateWithLifecycle(initialValue = "")
|
||||
|
||||
var ip by remember { mutableStateOf("") }
|
||||
var login by remember { mutableStateOf("") }
|
||||
var password by remember { mutableStateOf("") }
|
||||
|
||||
val savedMainPass by settingsStore.deployMainPassword.collectAsStateWithLifecycle(initialValue = "")
|
||||
val savedAdminId by settingsStore.deployAdminId.collectAsStateWithLifecycle(initialValue = "")
|
||||
val savedBotToken by settingsStore.deployBotToken.collectAsStateWithLifecycle(initialValue = "")
|
||||
val savedSshPort by settingsStore.deploySshPort.collectAsStateWithLifecycle(initialValue = "22")
|
||||
val savedManualPorts by settingsStore.manualPortsEnabled.collectAsStateWithLifecycle(initialValue = false)
|
||||
val savedServerDtlsPort by settingsStore.serverDtlsPort.collectAsStateWithLifecycle(initialValue = 56000)
|
||||
val savedServerWgPort by settingsStore.serverWgPort.collectAsStateWithLifecycle(initialValue = 56001)
|
||||
|
||||
var showSecretsDialog by remember { mutableStateOf(false) }
|
||||
var showUninstallDialog by remember { mutableStateOf(false) }
|
||||
|
||||
var showSuccessBanner by rememberSaveable { mutableStateOf(false) }
|
||||
var successCountdown by rememberSaveable { mutableIntStateOf(5) }
|
||||
|
||||
LaunchedEffect(showSuccessBanner) {
|
||||
if (showSuccessBanner) {
|
||||
while (successCountdown > 0) {
|
||||
kotlinx.coroutines.delay(1000)
|
||||
successCountdown--
|
||||
}
|
||||
showSuccessBanner = false
|
||||
}
|
||||
}
|
||||
|
||||
val isDeploying by DeployManager.isDeploying.collectAsStateWithLifecycle()
|
||||
val deployProgress by DeployManager.deployProgress.collectAsStateWithLifecycle()
|
||||
val currentStep by DeployManager.currentStep.collectAsStateWithLifecycle()
|
||||
|
||||
LaunchedEffect(savedIp) { if (savedIp.isNotEmpty()) ip = savedIp }
|
||||
LaunchedEffect(savedLogin) { if (savedLogin.isNotEmpty()) login = savedLogin }
|
||||
LaunchedEffect(savedPassword) { if (savedPassword.isNotEmpty()) password = savedPassword }
|
||||
val animatedProgress by animateFloatAsState(
|
||||
targetValue = deployProgress,
|
||||
animationSpec = tween(durationMillis = 1200, easing = androidx.compose.animation.core.FastOutSlowInEasing),
|
||||
label = "progress"
|
||||
)
|
||||
|
||||
Column(
|
||||
modifier = Modifier.fillMaxSize().padding(16.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
Text(
|
||||
"Настройки сервера",
|
||||
style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold),
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
|
||||
// ═══ Поля ввода в Card ═══
|
||||
AppSectionCard(
|
||||
contentPadding = PaddingValues(16.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
OutlinedTextField(
|
||||
value = ip,
|
||||
onValueChange = {
|
||||
ip = it.filter { c -> !c.isWhitespace() }
|
||||
scope.launch { settingsStore.saveDeploy(ip, login, password, savedSshPort) }
|
||||
},
|
||||
label = { Text("IP сервера или домен (без порта)") },
|
||||
placeholder = { Text("1.2.3.4 (без порта)") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
enabled = !isDeploying,
|
||||
)
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
OutlinedTextField(
|
||||
value = login,
|
||||
onValueChange = {
|
||||
login = it.filter { c -> !c.isWhitespace() }
|
||||
scope.launch { settingsStore.saveDeploy(ip, login, password, savedSshPort) }
|
||||
},
|
||||
label = { Text("Логин") },
|
||||
placeholder = { Text("root") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.weight(1f),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
enabled = !isDeploying,
|
||||
)
|
||||
OutlinedTextField(
|
||||
value = password,
|
||||
onValueChange = {
|
||||
password = it.filter { c -> !c.isWhitespace() }
|
||||
scope.launch { settingsStore.saveDeploy(ip, login, password, savedSshPort) }
|
||||
},
|
||||
label = { Text("Пароль SSH") },
|
||||
placeholder = { Text("password") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.weight(1f),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
enabled = !isDeploying,
|
||||
)
|
||||
}
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
"Ручное управление портами",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
fontWeight = FontWeight.Medium,
|
||||
modifier = Modifier.weight(1f),
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Switch(
|
||||
checked = savedManualPorts,
|
||||
enabled = !isDeploying,
|
||||
onCheckedChange = { enabled ->
|
||||
scope.launch { settingsStore.saveManualPortsEnabled(enabled) }
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
if (showSecretsDialog) {
|
||||
DeploySecretsDialog(
|
||||
settingsStore = settingsStore,
|
||||
initialMainPass = savedMainPass,
|
||||
initialAdminId = savedAdminId,
|
||||
initialBotToken = savedBotToken,
|
||||
initialSshPort = savedSshPort,
|
||||
manualPortsEnabled = savedManualPorts,
|
||||
initialServerDtlsPort = savedServerDtlsPort.toString(),
|
||||
initialServerWgPort = savedServerWgPort.toString(),
|
||||
onSaved = { _, _ -> },
|
||||
onDismiss = { showSecretsDialog = false }
|
||||
)
|
||||
}
|
||||
|
||||
// ═══ Прогресс ═══
|
||||
if (isDeploying) {
|
||||
AppSectionCard(
|
||||
contentPadding = PaddingValues(16.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(8.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
text = currentStep,
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
fontWeight = FontWeight.Medium,
|
||||
color = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.weight(1f),
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis
|
||||
)
|
||||
Text(
|
||||
text = "${(animatedProgress * 100).toInt()}%",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
}
|
||||
LinearProgressIndicator(
|
||||
progress = { animatedProgress },
|
||||
modifier = Modifier.fillMaxWidth().height(8.dp).clip(RoundedCornerShape(4.dp)),
|
||||
color = MaterialTheme.colorScheme.primary,
|
||||
trackColor = MaterialTheme.colorScheme.surfaceVariant,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// ═══ Кнопки ═══
|
||||
val deploySecretsMissing = savedMainPass.isBlank()
|
||||
OutlinedButton(
|
||||
onClick = { showSecretsDialog = true },
|
||||
modifier = Modifier.fillMaxWidth().height(48.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
colors = ButtonDefaults.outlinedButtonColors(
|
||||
containerColor = if (deploySecretsMissing) MaterialTheme.colorScheme.errorContainer else MaterialTheme.colorScheme.surface,
|
||||
contentColor = if (deploySecretsMissing) MaterialTheme.colorScheme.onErrorContainer else MaterialTheme.colorScheme.onSurface
|
||||
),
|
||||
border = BorderStroke(
|
||||
1.dp,
|
||||
if (deploySecretsMissing) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.outline.copy(alpha = 0.5f)
|
||||
)
|
||||
) {
|
||||
Icon(Icons.Default.Key, null, Modifier.size(18.dp))
|
||||
Spacer(Modifier.width(8.dp))
|
||||
Text(
|
||||
if (savedManualPorts) "Секреты (BOT, Пароли, Порты)" else "Секреты (BOT, Пароли)",
|
||||
fontWeight = FontWeight.SemiBold
|
||||
)
|
||||
}
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
Button(
|
||||
onClick = {
|
||||
if (ip.isBlank() || password.isBlank() || savedMainPass.isBlank()) return@Button
|
||||
val effectiveLogin = if (login.isBlank()) "root" else login
|
||||
val effectiveDtlsPort = if (savedManualPorts) savedServerDtlsPort.coerceIn(1, 65535) else 56000
|
||||
val effectiveWgPort = if (savedManualPorts) savedServerWgPort.coerceIn(1, 65535) else 56001
|
||||
val appContext = context.applicationContext
|
||||
DeployManager.scope.launch {
|
||||
try {
|
||||
DeployManager.startDeploy()
|
||||
val intent = Intent(appContext, TunnelService::class.java).apply { action = "DEPLOY_START" }
|
||||
if (Build.VERSION.SDK_INT >= 26) appContext.startForegroundService(intent)
|
||||
else appContext.startService(intent)
|
||||
|
||||
val success = performDeploy(
|
||||
context = appContext,
|
||||
host = ip, user = effectiveLogin, pass = password, port = savedSshPort.toIntOrNull() ?: 22,
|
||||
mainPass = savedMainPass, adminId = savedAdminId, botToken = savedBotToken,
|
||||
dtlsPort = effectiveDtlsPort, wgPort = effectiveWgPort,
|
||||
onProgress = { p, s -> DeployManager.updateProgress(p, s) }
|
||||
)
|
||||
if (success) {
|
||||
successCountdown = 5
|
||||
showSuccessBanner = true
|
||||
}
|
||||
} finally {
|
||||
try { appContext.startService(Intent(appContext, TunnelService::class.java).apply { action = "DEPLOY_STOP" }) } catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
},
|
||||
modifier = Modifier.weight(1f).height(50.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
colors = ButtonDefaults.buttonColors(contentColor = MaterialTheme.colorScheme.onPrimary),
|
||||
enabled = !isDeploying && ip.isNotBlank() && password.isNotBlank() && savedMainPass.isNotBlank()
|
||||
) {
|
||||
if (isDeploying) {
|
||||
CircularProgressIndicator(modifier = Modifier.size(18.dp), color = MaterialTheme.colorScheme.onPrimary, strokeWidth = 2.dp)
|
||||
} else {
|
||||
Icon(Icons.Default.CloudUpload, null, Modifier.size(18.dp))
|
||||
}
|
||||
Spacer(Modifier.width(8.dp))
|
||||
Text(if (isDeploying) "Установка..." else "Установить", fontWeight = FontWeight.Bold)
|
||||
}
|
||||
|
||||
Button(
|
||||
onClick = {
|
||||
if (ip.isBlank() || password.isBlank()) return@Button
|
||||
showUninstallDialog = true
|
||||
},
|
||||
modifier = Modifier.weight(1f).height(50.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
colors = ButtonDefaults.buttonColors(
|
||||
containerColor = MaterialTheme.colorScheme.error,
|
||||
contentColor = MaterialTheme.colorScheme.onError
|
||||
),
|
||||
enabled = !isDeploying && ip.isNotBlank() && password.isNotBlank()
|
||||
) {
|
||||
Icon(Icons.Default.Delete, null, Modifier.size(18.dp))
|
||||
Spacer(Modifier.width(8.dp))
|
||||
Text("Удалить", fontWeight = FontWeight.Bold)
|
||||
}
|
||||
}
|
||||
|
||||
if (showUninstallDialog) {
|
||||
UninstallConfirmDialog(
|
||||
onDismiss = { showUninstallDialog = false },
|
||||
onConfirm = {
|
||||
showUninstallDialog = false
|
||||
val effectiveLogin = if (login.isBlank()) "root" else login
|
||||
val effectiveDtlsPort = if (savedManualPorts) savedServerDtlsPort.coerceIn(1, 65535) else 56000
|
||||
val effectiveWgPort = if (savedManualPorts) savedServerWgPort.coerceIn(1, 65535) else 56001
|
||||
DeployManager.scope.launch {
|
||||
try {
|
||||
DeployManager.startDeploy()
|
||||
performUninstall(
|
||||
host = ip, user = effectiveLogin, pass = password, port = savedSshPort.toIntOrNull() ?: 22,
|
||||
dtlsPort = effectiveDtlsPort, wgPort = effectiveWgPort,
|
||||
onProgress = { p, s -> DeployManager.updateProgress(p, s) }
|
||||
)
|
||||
} catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
Spacer(modifier = Modifier.weight(1f))
|
||||
|
||||
// ═══ Success Banner ═══
|
||||
if (showSuccessBanner) {
|
||||
Surface(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
color = WDTTColors.connected.copy(alpha = 0.12f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
border = BorderStroke(1.dp, WDTTColors.connected.copy(alpha = 0.4f))
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.padding(16.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Icon(Icons.Default.CheckCircle, contentDescription = null, tint = WDTTColors.connected)
|
||||
Spacer(Modifier.width(8.dp))
|
||||
Text(
|
||||
text = "Деплой успешно завершен ($successCountdown)",
|
||||
color = WDTTColors.connected,
|
||||
fontWeight = FontWeight.Bold,
|
||||
style = MaterialTheme.typography.bodyMedium
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== SSH ====================
|
||||
|
||||
private class SSHClient(private val session: Session, private val pass: String) {
|
||||
|
||||
fun exec(command: String, timeout: Long = CMD_TIMEOUT): String {
|
||||
if (!session.isConnected) {
|
||||
DeployManager.writeError("SSH exec: сессия разорвана перед командой: ${command.take(80)}")
|
||||
return "error: session is down"
|
||||
}
|
||||
|
||||
var channel: ChannelExec? = null
|
||||
val result = StringBuilder()
|
||||
|
||||
return try {
|
||||
channel = session.openChannel("exec") as ChannelExec
|
||||
val cmd = if (command.contains("sudo") && !command.contains("sudo -S")) {
|
||||
command.replace("sudo ", "sudo -S ")
|
||||
} else command
|
||||
|
||||
channel.setCommand(cmd)
|
||||
val outStream = channel.outputStream
|
||||
val input = channel.inputStream
|
||||
val err = channel.errStream
|
||||
channel.connect(15000)
|
||||
|
||||
if (cmd.contains("sudo -S")) {
|
||||
outStream.write("$pass\n".toByteArray())
|
||||
outStream.flush()
|
||||
}
|
||||
|
||||
val reader = input.bufferedReader()
|
||||
val errReader = err.bufferedReader()
|
||||
val startTime = System.currentTimeMillis()
|
||||
val progressRegex = Regex("^WDTT_PROGRESS\\|(\\d+\\.?\\d*)\\|(.+)$")
|
||||
|
||||
while (!channel.isClosed || reader.ready() || errReader.ready()) {
|
||||
if (System.currentTimeMillis() - startTime > timeout) {
|
||||
DeployManager.writeError("SSH timeout (${timeout/1000}s): ${command.take(80)}")
|
||||
try { channel.disconnect() } catch (_: Exception) {}
|
||||
return "error: timeout"
|
||||
}
|
||||
|
||||
if (reader.ready()) {
|
||||
val line = reader.readLine()
|
||||
if (line != null) {
|
||||
val match = progressRegex.find(line.trim())
|
||||
if (match != null) {
|
||||
val p = match.groupValues[1].toFloatOrNull() ?: 0f
|
||||
DeployManager.updateProgress(p, match.groupValues[2])
|
||||
} else if (!line.contains("WDTT_PROGRESS")) {
|
||||
val clean = line.replace(Regex("\u001B\\[[;\\d]*m"), "")
|
||||
result.appendLine(clean)
|
||||
if (clean.contains("[✗]") || clean.contains("FAIL") ||
|
||||
(clean.contains("error", true) && !clean.contains("2>/dev/null"))) {
|
||||
DeployManager.writeError("REMOTE: $clean")
|
||||
TunnelManager.addDeployErrorLog("REMOTE: $clean")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (errReader.ready()) {
|
||||
val line = errReader.readLine()
|
||||
if (line != null && !line.contains("password for")) {
|
||||
val clean = line.replace(Regex("\u001B\\[[;\\d]*m"), "")
|
||||
result.appendLine(clean)
|
||||
if (clean.isNotBlank() && !clean.startsWith("Warning:")) {
|
||||
DeployManager.writeError("STDERR: $clean")
|
||||
TunnelManager.addDeployErrorLog("STDERR: $clean")
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!reader.ready() && !errReader.ready()) Thread.sleep(100)
|
||||
}
|
||||
|
||||
result.toString()
|
||||
} catch (e: Exception) {
|
||||
DeployManager.writeError("SSH exec error: ${e.message} | cmd: ${command.take(80)}")
|
||||
TunnelManager.addDeployErrorLog("SSH exec error: ${e.message}")
|
||||
"error: ${e.message}"
|
||||
} finally {
|
||||
try { channel?.disconnect() } catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
|
||||
fun upload(localFile: File, remotePath: String) {
|
||||
if (!session.isConnected) {
|
||||
DeployManager.writeError("SSH upload: сессия разорвана")
|
||||
throw Exception("Session is down")
|
||||
}
|
||||
var sftp: ChannelSftp? = null
|
||||
try {
|
||||
sftp = session.openChannel("sftp") as ChannelSftp
|
||||
sftp.connect(15000)
|
||||
sftp.put(localFile.absolutePath, remotePath)
|
||||
} catch (e: Exception) {
|
||||
DeployManager.writeError("SFTP upload error: ${e.message} | file: ${localFile.name}")
|
||||
throw e
|
||||
} finally {
|
||||
try { sftp?.disconnect() } catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun createSSHSession(host: String, user: String, pass: String, port: Int = 22): Session {
|
||||
val jsch = JSch()
|
||||
val session = jsch.getSession(user, host, port)
|
||||
session.setPassword(pass)
|
||||
session.setConfig(Properties().apply {
|
||||
put("StrictHostKeyChecking", "no")
|
||||
put("ServerAliveInterval", "10")
|
||||
put("ServerAliveCountMax", "6")
|
||||
put("ConnectTimeout", "15000")
|
||||
put("PreferredAuthentications", "password,keyboard-interactive")
|
||||
})
|
||||
session.connect(20000)
|
||||
return session
|
||||
}
|
||||
|
||||
private fun shellQuote(value: String): String {
|
||||
return "'" + value.replace("'", "'\"'\"'") + "'"
|
||||
}
|
||||
|
||||
private fun rootCommand(command: String): String {
|
||||
val quoted = shellQuote(command)
|
||||
return "if command -v sudo >/dev/null 2>&1; then sudo bash -c $quoted; " +
|
||||
"elif [ \"\$(id -u)\" = \"0\" ]; then bash -c $quoted; " +
|
||||
"else echo 'error: root privileges required and sudo not found'; exit 1; fi"
|
||||
}
|
||||
|
||||
private fun File.containsBinaryToken(token: String): Boolean {
|
||||
val data = readBytes()
|
||||
val needle = token.toByteArray()
|
||||
if (needle.isEmpty() || data.size < needle.size) return false
|
||||
for (i in 0..data.size - needle.size) {
|
||||
var matched = true
|
||||
for (j in needle.indices) {
|
||||
if (data[i + j] != needle[j]) {
|
||||
matched = false
|
||||
break
|
||||
}
|
||||
}
|
||||
if (matched) return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
private fun isUnsafeLegacyServerAsset(serverFile: File): Boolean {
|
||||
return serverFile.containsBinaryToken("/etc/wireguard") ||
|
||||
(serverFile.containsBinaryToken("wg0") && !serverFile.containsBinaryToken("wdtt0"))
|
||||
}
|
||||
|
||||
// ==================== Deploy ====================
|
||||
|
||||
private suspend fun performDeploy(
|
||||
context: Context,
|
||||
host: String, user: String, pass: String, port: Int,
|
||||
mainPass: String, adminId: String, botToken: String,
|
||||
dtlsPort: Int, wgPort: Int,
|
||||
onProgress: (Float, String) -> Unit
|
||||
): Boolean = withContext(Dispatchers.IO) {
|
||||
var session: Session? = null
|
||||
try {
|
||||
onProgress(0.02f, "Подключение...")
|
||||
session = createSSHSession(host, user, pass, port)
|
||||
DeployManager.activeSession = session
|
||||
val ssh = SSHClient(session, pass)
|
||||
|
||||
onProgress(0.05f, "Подготовка файлов...")
|
||||
val passArg = if (mainPass.isNotBlank()) "-password \"$mainPass\" " else ""
|
||||
val adminArg = if (adminId.isNotBlank()) "-admin \"$adminId\" " else ""
|
||||
val botArg = if (botToken.isNotBlank()) "-bot-token \"$botToken\" " else ""
|
||||
val args = "$passArg$adminArg$botArg".trim()
|
||||
|
||||
val scriptFile = File(context.cacheDir, "deploy.sh")
|
||||
val serverFile = File(context.cacheDir, "server")
|
||||
try {
|
||||
context.assets.open("deploy.sh").use { inp -> FileOutputStream(scriptFile).use { out -> inp.copyTo(out) } }
|
||||
context.assets.open("server").use { inp -> FileOutputStream(serverFile).use { out -> inp.copyTo(out) } }
|
||||
} catch (e: Exception) {
|
||||
DeployManager.writeError("Assets extraction failed: ${e.message}")
|
||||
DeployManager.stopDeploy("Ошибка: файлы не найдены в assets")
|
||||
return@withContext false
|
||||
}
|
||||
if (isUnsafeLegacyServerAsset(serverFile)) {
|
||||
scriptFile.delete()
|
||||
serverFile.delete()
|
||||
DeployManager.writeError("Unsafe legacy server asset: найдено wg0 или /etc/wireguard. Нужна пересборка server под wdtt0 и /etc/wdtt.")
|
||||
DeployManager.stopDeploy("Нужна пересборка server asset")
|
||||
return@withContext false
|
||||
}
|
||||
|
||||
onProgress(0.06f, "Загрузка на сервер...")
|
||||
ssh.upload(scriptFile, "/tmp/deploy.sh")
|
||||
ssh.upload(serverFile, "/tmp/wdtt-server")
|
||||
scriptFile.delete()
|
||||
serverFile.delete()
|
||||
|
||||
onProgress(0.08f, "Установка...")
|
||||
val output = ssh.exec(
|
||||
rootCommand("env WDTT_ARGS=${shellQuote(args)} WDTT_DTLS_PORT=$dtlsPort WDTT_WG_PORT=$wgPort WDTT_SSH_PORT=$port bash /tmp/deploy.sh"),
|
||||
timeout = CMD_TIMEOUT
|
||||
)
|
||||
|
||||
if (output.contains("✅") || output.contains("Деплой успешно") || output.contains("active")) {
|
||||
DeployManager.stopDeploy("success")
|
||||
TunnelManager.addDeploySuccessLog("Деплой успешно завершен. Сервис активен.")
|
||||
return@withContext true
|
||||
} else if (output.contains("error:")) {
|
||||
DeployManager.writeError("Deploy script output contains error")
|
||||
DeployManager.stopDeploy("Ошибка выполнения скрипта (см. errors.log)")
|
||||
return@withContext false
|
||||
} else {
|
||||
DeployManager.stopDeploy("success")
|
||||
TunnelManager.addDeploySuccessLog("Деплой завершён. (Проверьте подключение)")
|
||||
return@withContext true
|
||||
}
|
||||
|
||||
} catch (e: Exception) {
|
||||
DeployManager.writeError("Deploy critical: ${e.message}\n${e.stackTraceToString().take(500)}")
|
||||
DeployManager.stopDeploy("Ошибка: ${e.message?.take(100)}")
|
||||
return@withContext false
|
||||
} finally {
|
||||
try { session?.disconnect() } catch (_: Exception) {}
|
||||
DeployManager.activeSession = null
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ==================== Uninstall ====================
|
||||
|
||||
private suspend fun performUninstall(
|
||||
host: String, user: String, pass: String, port: Int,
|
||||
dtlsPort: Int, wgPort: Int,
|
||||
onProgress: (Float, String) -> Unit
|
||||
) = withContext(Dispatchers.IO) {
|
||||
var session: Session? = null
|
||||
try {
|
||||
onProgress(0.05f, "Подключение...")
|
||||
session = createSSHSession(host, user, pass, port)
|
||||
DeployManager.activeSession = session
|
||||
val ssh = SSHClient(session, pass)
|
||||
|
||||
onProgress(0.15f, "Остановка сервиса...")
|
||||
ssh.exec(
|
||||
rootCommand(
|
||||
"systemctl unmask wdtt 2>/dev/null || true; " +
|
||||
"systemctl stop wdtt 2>/dev/null || true; " +
|
||||
"systemctl disable wdtt 2>/dev/null || true; " +
|
||||
"rm -f /etc/systemd/system/wdtt.service; " +
|
||||
"systemctl daemon-reload 2>/dev/null || true"
|
||||
),
|
||||
timeout = 15000L
|
||||
)
|
||||
|
||||
onProgress(0.30f, "Удаление через deploy.sh...")
|
||||
ssh.exec(rootCommand("[ -f /tmp/deploy.sh ] && env WDTT_DTLS_PORT=$dtlsPort WDTT_WG_PORT=$wgPort WDTT_SSH_PORT=$port bash /tmp/deploy.sh uninstall 2>/dev/null || true"), timeout = 30000L)
|
||||
|
||||
onProgress(0.45f, "Удаление бинарника...")
|
||||
ssh.exec(rootCommand("pkill -x wdtt-server 2>/dev/null || true; rm -f /usr/local/bin/wdtt-server"), timeout = 10000L)
|
||||
|
||||
onProgress(0.60f, "Очистка firewall...")
|
||||
ssh.exec(
|
||||
rootCommand(
|
||||
"if command -v iptables >/dev/null 2>&1; then " +
|
||||
"for i in 1 2 3 4 5; do " +
|
||||
"for iface in $(ls /sys/class/net 2>/dev/null || true); do " +
|
||||
"iptables -t nat -D POSTROUTING -s 10.66.66.0/24 -o \"${'$'}iface\" -m comment --comment WDTT_MANAGED -j MASQUERADE 2>/dev/null || true; " +
|
||||
"done; " +
|
||||
"iptables -D INPUT -p udp --dport $dtlsPort -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D INPUT -p udp --dport $wgPort -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D INPUT -p udp --dport 56000 -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D INPUT -p udp --dport 56001 -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D INPUT -p tcp --dport $port -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D INPUT -p tcp --dport 22 -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D FORWARD -i wdtt0 -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"iptables -D FORWARD -o wdtt0 -m comment --comment WDTT_MANAGED -j ACCEPT 2>/dev/null || true; " +
|
||||
"done; fi; " +
|
||||
"if command -v nft >/dev/null 2>&1; then " +
|
||||
"nft delete table ip wdtt 2>/dev/null || true; " +
|
||||
"nft delete table inet wdtt 2>/dev/null || true; " +
|
||||
"nft delete table inet wdtt_mangle 2>/dev/null || true; " +
|
||||
"fi"
|
||||
),
|
||||
timeout = 15000L
|
||||
)
|
||||
|
||||
onProgress(0.75f, "Удаление WDTT-интерфейса...")
|
||||
ssh.exec(
|
||||
rootCommand(
|
||||
"ip link show wdtt0 >/dev/null 2>&1 && ip link del wdtt0 2>/dev/null || true; " +
|
||||
"[ -d /etc/wdtt ] && find /etc/wdtt -mindepth 1 -maxdepth 1 ! -name passwords.json -exec rm -rf {} + 2>/dev/null || true; " +
|
||||
"[ -f /etc/wdtt/passwords.json ] && chmod 600 /etc/wdtt/passwords.json 2>/dev/null || true"
|
||||
),
|
||||
timeout = 10000L
|
||||
)
|
||||
|
||||
onProgress(0.90f, "Очистка sysctl...")
|
||||
ssh.exec(rootCommand("rm -f /etc/sysctl.d/99-wdtt.conf; sysctl --system >/dev/null 2>&1 || true"), timeout = 15000L)
|
||||
|
||||
onProgress(1.0f, "Готово!")
|
||||
DeployManager.stopDeploy("success")
|
||||
|
||||
} catch (e: Exception) {
|
||||
DeployManager.writeError("Uninstall error: ${e.message}")
|
||||
DeployManager.stopDeploy("Ошибка: ${e.message?.take(100)}")
|
||||
} finally {
|
||||
try { session?.disconnect() } catch (_: Exception) {}
|
||||
DeployManager.activeSession = null
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== Dialogs ====================
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun DeploySecretsDialog(
|
||||
settingsStore: SettingsStore,
|
||||
initialMainPass: String,
|
||||
initialAdminId: String,
|
||||
initialBotToken: String,
|
||||
initialSshPort: String,
|
||||
manualPortsEnabled: Boolean,
|
||||
initialServerDtlsPort: String,
|
||||
initialServerWgPort: String,
|
||||
onSaved: (String, String) -> Unit,
|
||||
onDismiss: () -> Unit
|
||||
) {
|
||||
val scope = rememberCoroutineScope()
|
||||
var passInput by rememberSaveable { mutableStateOf(initialMainPass) }
|
||||
var adminIdInput by rememberSaveable { mutableStateOf(initialAdminId) }
|
||||
var botTokenInput by rememberSaveable { mutableStateOf(initialBotToken) }
|
||||
var sshPortInput by rememberSaveable { mutableStateOf(if (initialSshPort.isBlank()) "22" else initialSshPort) }
|
||||
var dtlsPortInput by rememberSaveable { mutableStateOf(initialServerDtlsPort.ifBlank { "56000" }) }
|
||||
var wgPortInput by rememberSaveable { mutableStateOf(initialServerWgPort.ifBlank { "56001" }) }
|
||||
|
||||
fun normalizePort(value: String, fallback: String): String {
|
||||
return value.toIntOrNull()?.takeIf { it in 1..65535 }?.toString() ?: fallback
|
||||
}
|
||||
|
||||
androidx.compose.ui.window.Dialog(onDismissRequest = onDismiss) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = MaterialTheme.colorScheme.surface,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
tonalElevation = 8.dp
|
||||
) {
|
||||
Column(modifier = Modifier.padding(24.dp).fillMaxWidth().verticalScroll(rememberScrollState())) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text("Секреты Деплоя", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
|
||||
IconButton(onClick = onDismiss) {
|
||||
Icon(Icons.Default.Close, contentDescription = "Закрыть")
|
||||
}
|
||||
}
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
|
||||
OutlinedTextField(
|
||||
value = passInput,
|
||||
onValueChange = { passInput = it },
|
||||
label = { Text("Задайте пароль туннеля (любой)") },
|
||||
placeholder = { Text("Придумайте надежный пароль") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp)
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
HorizontalDivider()
|
||||
Spacer(Modifier.height(8.dp))
|
||||
Text("Телеграм бот для управления", color = MaterialTheme.colorScheme.primary, fontWeight = FontWeight.SemiBold)
|
||||
Spacer(Modifier.height(8.dp))
|
||||
|
||||
OutlinedTextField(
|
||||
value = adminIdInput,
|
||||
onValueChange = { adminIdInput = it },
|
||||
label = { Text("ID Админа (Опционально)") },
|
||||
placeholder = { Text("ID из @getmyid_bot") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
|
||||
keyboardType = androidx.compose.ui.text.input.KeyboardType.Number
|
||||
)
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(8.dp))
|
||||
|
||||
OutlinedTextField(
|
||||
value = botTokenInput,
|
||||
onValueChange = { botTokenInput = it },
|
||||
label = { Text("Токен Бота (Опционально)") },
|
||||
placeholder = { Text("Токен от BotFather") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp)
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
HorizontalDivider()
|
||||
Spacer(Modifier.height(8.dp))
|
||||
Text("SSH Порт", color = MaterialTheme.colorScheme.primary, fontWeight = FontWeight.SemiBold)
|
||||
Spacer(Modifier.height(8.dp))
|
||||
|
||||
OutlinedTextField(
|
||||
value = sshPortInput,
|
||||
onValueChange = { sshPortInput = it.filter(Char::isDigit).take(5) },
|
||||
label = { Text("Порт для деплоя SSH") },
|
||||
placeholder = { Text("22") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
|
||||
keyboardType = androidx.compose.ui.text.input.KeyboardType.Number
|
||||
)
|
||||
)
|
||||
|
||||
if (manualPortsEnabled) {
|
||||
Spacer(Modifier.height(16.dp))
|
||||
HorizontalDivider()
|
||||
Spacer(Modifier.height(8.dp))
|
||||
Text("Порты сервера", color = MaterialTheme.colorScheme.primary, fontWeight = FontWeight.SemiBold)
|
||||
Spacer(Modifier.height(8.dp))
|
||||
OutlinedTextField(
|
||||
value = dtlsPortInput,
|
||||
onValueChange = { dtlsPortInput = it.filter(Char::isDigit).take(5) },
|
||||
label = { Text("Порт DTLS сервера") },
|
||||
placeholder = { Text("56000") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
|
||||
keyboardType = androidx.compose.ui.text.input.KeyboardType.Number
|
||||
)
|
||||
)
|
||||
Spacer(Modifier.height(8.dp))
|
||||
OutlinedTextField(
|
||||
value = wgPortInput,
|
||||
onValueChange = { wgPortInput = it.filter(Char::isDigit).take(5) },
|
||||
label = { Text("Порт WireGuard сервера") },
|
||||
placeholder = { Text("56001") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
|
||||
keyboardType = androidx.compose.ui.text.input.KeyboardType.Number
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
Spacer(Modifier.height(24.dp))
|
||||
Button(
|
||||
onClick = {
|
||||
val finalPort = if (sshPortInput.isBlank()) "22" else sshPortInput
|
||||
val finalDtls = normalizePort(dtlsPortInput, "56000")
|
||||
val finalWg = normalizePort(wgPortInput, "56001")
|
||||
scope.launch {
|
||||
settingsStore.saveDeploySecrets(passInput, adminIdInput, botTokenInput, finalPort)
|
||||
settingsStore.savePorts(finalDtls.toInt(), finalWg.toInt(), settingsStore.listenPort.first())
|
||||
onSaved(finalDtls, finalWg)
|
||||
onDismiss()
|
||||
}
|
||||
},
|
||||
modifier = Modifier.fillMaxWidth().height(48.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
enabled = passInput.isNotBlank(),
|
||||
colors = ButtonDefaults.buttonColors(contentColor = MaterialTheme.colorScheme.onPrimary)
|
||||
) { Text("Сохранить", fontWeight = FontWeight.SemiBold) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun UninstallConfirmDialog(onDismiss: () -> Unit, onConfirm: () -> Unit) {
|
||||
var confirmText by remember { mutableStateOf("") }
|
||||
val isConfirmed = confirmText.trim().lowercase() == "да"
|
||||
|
||||
androidx.compose.ui.window.Dialog(onDismissRequest = onDismiss) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = MaterialTheme.colorScheme.surface,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
tonalElevation = 8.dp
|
||||
) {
|
||||
Column(modifier = Modifier.padding(24.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
|
||||
Text(
|
||||
"Удаление WDTT с сервера",
|
||||
style = MaterialTheme.typography.titleLarge,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.error
|
||||
)
|
||||
Text(
|
||||
"Будут удалены: бинарник, systemd-сервис, бот, конфигурация WDTT и только помеченные правила firewall/NAT для WDTT.\n\nЭто действие необратимо.",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
OutlinedTextField(
|
||||
value = confirmText,
|
||||
onValueChange = { confirmText = it },
|
||||
label = { Text("Введите «да» для подтверждения") },
|
||||
singleLine = true,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
colors = OutlinedTextFieldDefaults.colors(
|
||||
focusedBorderColor = MaterialTheme.colorScheme.error,
|
||||
unfocusedBorderColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
|
||||
)
|
||||
)
|
||||
Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||
OutlinedButton(
|
||||
onClick = onDismiss, modifier = Modifier.weight(1f).height(48.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
colors = ButtonDefaults.outlinedButtonColors(contentColor = MaterialTheme.colorScheme.onSurface)
|
||||
) { Text("Отмена") }
|
||||
Button(
|
||||
onClick = onConfirm, modifier = Modifier.weight(1f).height(48.dp),
|
||||
shape = RoundedCornerShape(16.dp), enabled = isConfirmed,
|
||||
colors = ButtonDefaults.buttonColors(
|
||||
containerColor = MaterialTheme.colorScheme.error,
|
||||
contentColor = MaterialTheme.colorScheme.onError
|
||||
)
|
||||
) {
|
||||
Icon(Icons.Default.Delete, null, Modifier.size(18.dp))
|
||||
Spacer(Modifier.width(6.dp))
|
||||
Text("Удалить", fontWeight = FontWeight.Bold)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,297 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import android.content.pm.PackageManager
|
||||
import androidx.compose.foundation.Image
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.isSystemInDarkTheme
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.lazy.rememberLazyListState
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Search
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.ImageBitmap
|
||||
import androidx.compose.ui.graphics.asImageBitmap
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextAlign
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.core.graphics.drawable.toBitmap
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import com.wdtt.client.SettingsStore
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
|
||||
import androidx.compose.runtime.Stable
|
||||
|
||||
@Stable
|
||||
data class AppItem(
|
||||
val name: String,
|
||||
val packageName: String,
|
||||
val icon: ImageBitmap?
|
||||
)
|
||||
|
||||
object AppCache {
|
||||
var cachedList: List<AppItem>? = null
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun ExceptionsTab() {
|
||||
val context = LocalContext.current.applicationContext
|
||||
val scope = rememberCoroutineScope()
|
||||
val settingsStore = remember { SettingsStore(context) }
|
||||
|
||||
val savedExcluded by settingsStore.excludedApps.collectAsStateWithLifecycle(initialValue = "")
|
||||
val selectedPackages = remember(savedExcluded) {
|
||||
savedExcluded.split(",").filter { it.isNotEmpty() }.toSet()
|
||||
}
|
||||
|
||||
var appsList by remember { mutableStateOf<List<AppItem>>(AppCache.cachedList ?: emptyList()) }
|
||||
var isLoading by remember { mutableStateOf(AppCache.cachedList == null) }
|
||||
var searchQuery by remember { mutableStateOf("") }
|
||||
|
||||
val isWhitelist by settingsStore.isWhitelist.collectAsStateWithLifecycle(initialValue = false)
|
||||
|
||||
// Load Apps
|
||||
LaunchedEffect(Unit) {
|
||||
if (AppCache.cachedList != null) return@LaunchedEffect
|
||||
isLoading = true
|
||||
withContext(Dispatchers.IO) {
|
||||
val list = mutableListOf<AppItem>()
|
||||
val pm = context.packageManager
|
||||
val installedApps = pm.getInstalledApplications(PackageManager.GET_META_DATA)
|
||||
|
||||
installedApps.forEach { app ->
|
||||
if (app.packageName != context.packageName &&
|
||||
!app.packageName.contains("vkontakte") &&
|
||||
!app.packageName.contains("vk.calls")) {
|
||||
list.add(AppItem(
|
||||
name = app.loadLabel(pm).toString(),
|
||||
packageName = app.packageName,
|
||||
icon = app.loadIcon(pm)?.toBitmap()?.asImageBitmap()
|
||||
))
|
||||
}
|
||||
}
|
||||
appsList = list.sortedBy { it.name.lowercase() }
|
||||
AppCache.cachedList = appsList
|
||||
}
|
||||
isLoading = false
|
||||
}
|
||||
|
||||
val filteredApps by remember {
|
||||
derivedStateOf {
|
||||
if (searchQuery.isBlank()) appsList
|
||||
else appsList.filter {
|
||||
it.name.contains(searchQuery, ignoreCase = true) ||
|
||||
it.packageName.contains(searchQuery, ignoreCase = true)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Column(modifier = Modifier.fillMaxSize().padding(horizontal = 16.dp)) {
|
||||
// Header
|
||||
Text(
|
||||
"Исключения приложений",
|
||||
style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold),
|
||||
color = MaterialTheme.colorScheme.onSurface,
|
||||
modifier = Modifier.padding(top = 16.dp, bottom = 4.dp)
|
||||
)
|
||||
|
||||
// Search Bar
|
||||
OutlinedTextField(
|
||||
value = searchQuery,
|
||||
onValueChange = { searchQuery = it },
|
||||
placeholder = { Text("Поиск приложений...", fontSize = 14.sp) },
|
||||
modifier = Modifier.fillMaxWidth().padding(top = 12.dp).height(52.dp),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
leadingIcon = { Icon(Icons.Default.Search, null, modifier = Modifier.size(20.dp)) },
|
||||
singleLine = true,
|
||||
)
|
||||
|
||||
Spacer(modifier = Modifier.height(14.dp))
|
||||
|
||||
// Mode Toggle
|
||||
AppSectionCard(
|
||||
modifier = Modifier.padding(bottom = 12.dp),
|
||||
contentPadding = PaddingValues(horizontal = 16.dp, vertical = 12.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(0.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.SpaceBetween
|
||||
) {
|
||||
Column(modifier = Modifier.weight(1f).padding(end = 12.dp)) {
|
||||
Text(
|
||||
"Режим исключений",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
fontWeight = FontWeight.Medium,
|
||||
fontSize = 14.sp,
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Text(
|
||||
if (isWhitelist) "БС: Неотмеченные приложения добавляются в туннель"
|
||||
else "ЧС: Выбранные приложения исключаются из туннеля",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontSize = 11.sp,
|
||||
lineHeight = 14.sp
|
||||
)
|
||||
}
|
||||
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
ModeChip("ЧС", !isWhitelist) {
|
||||
if (isWhitelist) {
|
||||
scope.launch {
|
||||
val all = appsList.map { it.packageName }.toSet()
|
||||
val inverted = all - selectedPackages
|
||||
settingsStore.saveExceptionsMode(inverted.joinToString(","), false)
|
||||
delay(300)
|
||||
com.wdtt.client.TunnelManager.reloadWireGuard()
|
||||
}
|
||||
}
|
||||
}
|
||||
ModeChip("БС", isWhitelist) {
|
||||
if (!isWhitelist) {
|
||||
scope.launch {
|
||||
val all = appsList.map { it.packageName }.toSet()
|
||||
val inverted = all - selectedPackages
|
||||
settingsStore.saveExceptionsMode(inverted.joinToString(","), true)
|
||||
delay(300)
|
||||
com.wdtt.client.TunnelManager.reloadWireGuard()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// List
|
||||
if (isLoading) {
|
||||
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
|
||||
CircularProgressIndicator()
|
||||
}
|
||||
} else {
|
||||
val listState = rememberLazyListState()
|
||||
LazyColumn(
|
||||
state = listState,
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
contentPadding = PaddingValues(bottom = 16.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(8.dp)
|
||||
) {
|
||||
items(filteredApps, key = { it.packageName }) { app ->
|
||||
val isSelected = selectedPackages.contains(app.packageName)
|
||||
|
||||
AppRow(
|
||||
app = app,
|
||||
isSelected = isSelected,
|
||||
onClick = {
|
||||
val newList = if (isSelected) {
|
||||
selectedPackages - app.packageName
|
||||
} else {
|
||||
selectedPackages + app.packageName
|
||||
}
|
||||
scope.launch {
|
||||
settingsStore.saveExcludedApps(newList.joinToString(","))
|
||||
com.wdtt.client.TunnelManager.reloadWireGuard()
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ModeChip(label: String, selected: Boolean, onClick: () -> Unit) {
|
||||
FilterChip(
|
||||
selected = selected,
|
||||
onClick = onClick,
|
||||
label = {
|
||||
Box(modifier = Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
|
||||
Text(
|
||||
label,
|
||||
fontWeight = if (selected) FontWeight.Bold else FontWeight.Medium,
|
||||
color = if (selected) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurface,
|
||||
textAlign = TextAlign.Center
|
||||
)
|
||||
}
|
||||
},
|
||||
modifier = Modifier.width(64.dp),
|
||||
shape = RoundedCornerShape(12.dp),
|
||||
colors = FilterChipDefaults.filterChipColors(
|
||||
selectedContainerColor = MaterialTheme.colorScheme.primary,
|
||||
selectedLabelColor = MaterialTheme.colorScheme.onPrimary,
|
||||
containerColor = MaterialTheme.colorScheme.surfaceVariant,
|
||||
labelColor = MaterialTheme.colorScheme.onSurface
|
||||
),
|
||||
border = FilterChipDefaults.filterChipBorder(
|
||||
enabled = true,
|
||||
selected = selected,
|
||||
borderColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.4f),
|
||||
selectedBorderColor = MaterialTheme.colorScheme.primary
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun AppRow(app: AppItem, isSelected: Boolean, onClick: () -> Unit) {
|
||||
Surface(
|
||||
onClick = onClick,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
shape = RoundedCornerShape(16.dp),
|
||||
color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
tonalElevation = if (isSelected) 4.dp else 0.dp
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.padding(12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
if (app.icon != null) {
|
||||
Image(
|
||||
bitmap = app.icon,
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(40.dp).clip(RoundedCornerShape(8.dp))
|
||||
)
|
||||
} else {
|
||||
Box(modifier = Modifier.size(40.dp).background(Color.Gray, RoundedCornerShape(8.dp)))
|
||||
}
|
||||
|
||||
Spacer(Modifier.width(16.dp))
|
||||
|
||||
Column(modifier = Modifier.weight(1f)) {
|
||||
Text(
|
||||
text = app.name,
|
||||
style = MaterialTheme.typography.bodyLarge,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface,
|
||||
maxLines = 1
|
||||
)
|
||||
Text(
|
||||
text = app.packageName,
|
||||
style = MaterialTheme.typography.labelSmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
maxLines = 1
|
||||
)
|
||||
}
|
||||
|
||||
Checkbox(
|
||||
checked = isSelected,
|
||||
onCheckedChange = null,
|
||||
colors = CheckboxDefaults.colors(checkedColor = MaterialTheme.colorScheme.primary)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,305 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import androidx.compose.animation.AnimatedVisibility
|
||||
import androidx.compose.animation.core.Spring
|
||||
import androidx.compose.animation.core.animateFloatAsState
|
||||
import androidx.compose.animation.core.spring
|
||||
import androidx.compose.animation.fadeIn
|
||||
import androidx.compose.animation.fadeOut
|
||||
import androidx.compose.animation.scaleIn
|
||||
import androidx.compose.animation.scaleOut
|
||||
import androidx.compose.foundation.gestures.detectDragGestures
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.border
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.draw.scale
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.ui.layout.onGloballyPositioned
|
||||
import androidx.compose.ui.platform.LocalConfiguration
|
||||
import androidx.compose.ui.platform.LocalDensity
|
||||
import androidx.compose.ui.res.painterResource
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.IntOffset
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import com.wdtt.client.R
|
||||
import android.os.Build
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
@Composable
|
||||
fun FloatingToolbar(
|
||||
currentTheme: String,
|
||||
onThemeChange: (String) -> Unit,
|
||||
isDynamicColor: Boolean,
|
||||
onDynamicColorChange: (Boolean) -> Unit,
|
||||
currentPalette: String,
|
||||
onPaletteChange: (String) -> Unit,
|
||||
modifier: Modifier = Modifier
|
||||
) {
|
||||
val configuration = LocalConfiguration.current
|
||||
val density = LocalDensity.current
|
||||
val screenHeightPx = remember(configuration.screenHeightDp, density) {
|
||||
with(density) { configuration.screenHeightDp.dp.toPx() }
|
||||
}
|
||||
val screenWidthPx = remember(configuration.screenWidthDp, density) {
|
||||
with(density) { configuration.screenWidthDp.dp.toPx() }
|
||||
}
|
||||
|
||||
var offsetY by rememberSaveable { mutableFloatStateOf(-1f) }
|
||||
var isRightSide by rememberSaveable { mutableStateOf(true) }
|
||||
var isExpanded by rememberSaveable { mutableStateOf(false) }
|
||||
var tabHeightPx by remember { mutableFloatStateOf(0f) }
|
||||
var panelHeightPx by remember { mutableFloatStateOf(0f) }
|
||||
|
||||
val tabWidthDp = 42.dp
|
||||
val tabHeightDp = 52.dp
|
||||
val panelWidthDp = 220.dp
|
||||
|
||||
val tabWidthPx = remember(density) { with(density) { tabWidthDp.toPx() } }
|
||||
val fallbackTabHeightPx = remember(density) { with(density) { tabHeightDp.toPx() } }
|
||||
val edgePaddingPx = remember(density) { with(density) { 8.dp.toPx() } }
|
||||
val safeTopPx = WindowInsets.safeDrawing.getTop(density).toFloat()
|
||||
val safeBottomPx = WindowInsets.safeDrawing.getBottom(density).toFloat()
|
||||
val effectiveTabHeightPx = maxOf(tabHeightPx, fallbackTabHeightPx)
|
||||
val floatingHeightPx = if (isExpanded && panelHeightPx > 0f) {
|
||||
maxOf(effectiveTabHeightPx, panelHeightPx)
|
||||
} else {
|
||||
effectiveTabHeightPx
|
||||
}
|
||||
val minOffsetY = safeTopPx + edgePaddingPx
|
||||
val maxOffsetY = (screenHeightPx - safeBottomPx - floatingHeightPx - edgePaddingPx)
|
||||
.coerceAtLeast(minOffsetY)
|
||||
val defaultOffsetY = (screenHeightPx * 0.24f).coerceIn(minOffsetY, maxOffsetY)
|
||||
|
||||
val targetXPx = if (isRightSide) screenWidthPx - tabWidthPx else 0f
|
||||
|
||||
val animatedTabXPx by animateFloatAsState(
|
||||
targetValue = targetXPx,
|
||||
animationSpec = spring(stiffness = Spring.StiffnessLow),
|
||||
label = "tab_shift"
|
||||
)
|
||||
|
||||
LaunchedEffect(minOffsetY, maxOffsetY) {
|
||||
offsetY = if (offsetY < 0f) defaultOffsetY else offsetY.coerceIn(minOffsetY, maxOffsetY)
|
||||
}
|
||||
|
||||
Box(modifier = modifier.fillMaxSize()) {
|
||||
Surface(
|
||||
onClick = { isExpanded = !isExpanded },
|
||||
modifier = Modifier
|
||||
.offset { IntOffset(animatedTabXPx.roundToInt(), offsetY.roundToInt()) }
|
||||
.onGloballyPositioned { coordinates ->
|
||||
tabHeightPx = coordinates.size.height.toFloat()
|
||||
}
|
||||
.pointerInput(minOffsetY, maxOffsetY) {
|
||||
detectDragGestures(
|
||||
onDrag = { change, dragAmount ->
|
||||
change.consume()
|
||||
offsetY = (offsetY + dragAmount.y).coerceIn(minOffsetY, maxOffsetY)
|
||||
}
|
||||
)
|
||||
},
|
||||
shape = if (isRightSide)
|
||||
RoundedCornerShape(topStart = 14.dp, bottomStart = 14.dp)
|
||||
else
|
||||
RoundedCornerShape(topEnd = 14.dp, bottomEnd = 14.dp),
|
||||
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.9f),
|
||||
shadowElevation = 6.dp,
|
||||
tonalElevation = 4.dp,
|
||||
) {
|
||||
Box(
|
||||
modifier = Modifier.size(tabWidthDp, tabHeightDp),
|
||||
contentAlignment = Alignment.Center
|
||||
) {
|
||||
Icon(
|
||||
painter = painterResource(id = R.drawable.ic_palette),
|
||||
contentDescription = "Тема",
|
||||
modifier = Modifier.size(22.dp),
|
||||
tint = MaterialTheme.colorScheme.onPrimaryContainer
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
AnimatedVisibility(
|
||||
visible = isExpanded,
|
||||
enter = fadeIn(),
|
||||
exit = fadeOut(),
|
||||
modifier = Modifier.offset {
|
||||
val panelWidthPx = with(density) { panelWidthDp.toPx() }
|
||||
val gap = with(density) { 8.dp.toPx() }
|
||||
val panelX = if (isRightSide) {
|
||||
(targetXPx - panelWidthPx - gap).roundToInt()
|
||||
} else {
|
||||
(tabWidthPx + gap).roundToInt()
|
||||
}
|
||||
IntOffset(panelX, offsetY.roundToInt())
|
||||
}
|
||||
) {
|
||||
Surface(
|
||||
modifier = Modifier.onGloballyPositioned { coordinates ->
|
||||
panelHeightPx = coordinates.size.height.toFloat()
|
||||
},
|
||||
shape = RoundedCornerShape(32.dp),
|
||||
color = MaterialTheme.colorScheme.surface,
|
||||
shadowElevation = 8.dp,
|
||||
tonalElevation = 4.dp,
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier.padding(12.dp).width(panelWidthDp - 24.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(4.dp)
|
||||
) {
|
||||
Text(
|
||||
"Тема",
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontWeight = FontWeight.SemiBold,
|
||||
modifier = Modifier.padding(start = 4.dp, bottom = 4.dp)
|
||||
)
|
||||
|
||||
ThemeOption(
|
||||
icon = R.drawable.ic_auto,
|
||||
label = "Системная",
|
||||
selected = currentTheme == "system",
|
||||
onClick = { onThemeChange("system"); isExpanded = false }
|
||||
)
|
||||
ThemeOption(
|
||||
icon = R.drawable.ic_light_mode,
|
||||
label = "Светлая",
|
||||
selected = currentTheme == "light",
|
||||
onClick = { onThemeChange("light"); isExpanded = false }
|
||||
)
|
||||
ThemeOption(
|
||||
icon = R.drawable.ic_dark_mode,
|
||||
label = "Тёмная",
|
||||
selected = currentTheme == "dark",
|
||||
onClick = { onThemeChange("dark"); isExpanded = false }
|
||||
)
|
||||
|
||||
HorizontalDivider(
|
||||
modifier = Modifier.padding(vertical = 4.dp),
|
||||
color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f)
|
||||
)
|
||||
|
||||
val supportsDynamicColor = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
|
||||
val showDynamicColorOn = isDynamicColor && supportsDynamicColor
|
||||
val showPalettes = !showDynamicColorOn
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
"Динамические",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
fontWeight = FontWeight.Medium,
|
||||
color = if (supportsDynamicColor) {
|
||||
MaterialTheme.colorScheme.onSurfaceVariant
|
||||
} else {
|
||||
MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f)
|
||||
}
|
||||
)
|
||||
Switch(
|
||||
checked = showDynamicColorOn,
|
||||
onCheckedChange = { onDynamicColorChange(it) },
|
||||
enabled = supportsDynamicColor,
|
||||
modifier = Modifier.scale(0.8f)
|
||||
)
|
||||
}
|
||||
|
||||
AnimatedVisibility(visible = showPalettes) {
|
||||
Column {
|
||||
HorizontalDivider(
|
||||
modifier = Modifier.padding(vertical = 4.dp),
|
||||
color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.5f)
|
||||
)
|
||||
Text(
|
||||
"Палитра",
|
||||
style = MaterialTheme.typography.labelSmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(bottom = 6.dp, start = 4.dp)
|
||||
)
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.SpaceEvenly
|
||||
) {
|
||||
PaletteCircle("indigo", 0xFF5B588D, currentPalette, onPaletteChange)
|
||||
PaletteCircle("forest", 0xFF5F5D68, currentPalette, onPaletteChange)
|
||||
PaletteCircle("espresso", 0xFF6D4C41, currentPalette, onPaletteChange)
|
||||
}
|
||||
Spacer(modifier = Modifier.height(6.dp))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ThemeOption(
|
||||
icon: Int,
|
||||
label: String,
|
||||
selected: Boolean,
|
||||
onClick: () -> Unit
|
||||
) {
|
||||
Surface(
|
||||
onClick = onClick,
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = if (selected) MaterialTheme.colorScheme.primaryContainer
|
||||
else MaterialTheme.colorScheme.surface,
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 10.dp),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(10.dp)
|
||||
) {
|
||||
Icon(
|
||||
painter = painterResource(id = icon),
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(18.dp),
|
||||
tint = if (selected) MaterialTheme.colorScheme.primary
|
||||
else MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
Text(
|
||||
text = label,
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
fontWeight = if (selected) FontWeight.Bold else FontWeight.Normal,
|
||||
color = if (selected) MaterialTheme.colorScheme.primary
|
||||
else MaterialTheme.colorScheme.onSurface,
|
||||
fontSize = 13.sp
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun PaletteCircle(
|
||||
paletteId: String,
|
||||
colorHex: Long,
|
||||
selectedId: String,
|
||||
onClick: (String) -> Unit
|
||||
) {
|
||||
val isSelected = paletteId == selectedId
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(30.dp)
|
||||
.clip(CircleShape)
|
||||
.background(Color(colorHex))
|
||||
.clickable { onClick(paletteId) }
|
||||
.then(
|
||||
if (isSelected) Modifier.border(3.dp, MaterialTheme.colorScheme.primary, CircleShape)
|
||||
else Modifier
|
||||
)
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,902 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import android.content.ClipData
|
||||
import android.content.ClipboardManager
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.os.Build
|
||||
import android.widget.Toast
|
||||
import androidx.compose.animation.AnimatedVisibility
|
||||
import androidx.compose.animation.core.animateFloatAsState
|
||||
import androidx.compose.animation.expandVertically
|
||||
import androidx.compose.animation.fadeIn
|
||||
import androidx.compose.animation.fadeOut
|
||||
import androidx.compose.animation.shrinkVertically
|
||||
import androidx.compose.foundation.BorderStroke
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.ColumnScope
|
||||
import androidx.compose.foundation.layout.PaddingValues
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.defaultMinSize
|
||||
import androidx.compose.foundation.layout.fillMaxHeight
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.heightIn
|
||||
import androidx.compose.foundation.layout.offset
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.layout.width
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.shape.GenericShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.ArrowForward
|
||||
import androidx.compose.material.icons.automirrored.filled.HelpOutline
|
||||
import androidx.compose.material.icons.filled.Close
|
||||
import androidx.compose.material.icons.filled.Code
|
||||
import androidx.compose.material.icons.filled.ContentCopy
|
||||
import androidx.compose.material.icons.filled.Favorite
|
||||
import androidx.compose.material.icons.filled.Info
|
||||
import androidx.compose.material.icons.filled.KeyboardArrowDown
|
||||
import androidx.compose.material.icons.filled.Person
|
||||
import androidx.compose.material.icons.filled.Update
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.ButtonDefaults
|
||||
import androidx.compose.material3.FilledTonalIconButton
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.draw.rotate
|
||||
import androidx.compose.ui.graphics.Brush
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.Shape
|
||||
import androidx.compose.ui.graphics.luminance
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.res.painterResource
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextAlign
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.compose.ui.window.Dialog
|
||||
import androidx.compose.ui.window.DialogProperties
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import com.wdtt.client.BuildConfig
|
||||
import com.wdtt.client.R
|
||||
import com.wdtt.client.SettingsStore
|
||||
import com.wdtt.client.UPDATE_DIALOG_ACTION_POSTPONED
|
||||
import com.wdtt.client.UPDATE_DIALOG_ACTION_UPDATE
|
||||
import com.wdtt.client.WDTTColors
|
||||
import com.wdtt.client.fetchLatestReleaseInfo
|
||||
import com.wdtt.client.isNewerVersion
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlin.math.PI
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.min
|
||||
import kotlin.math.sin
|
||||
|
||||
private const val ReleasesUrl = "https://github.com/amurcanov/proxy-turn-vk-android/releases"
|
||||
private const val IssuesUrl = "https://github.com/amurcanov/proxy-turn-vk-android/issues/new"
|
||||
private const val DeveloperProfileUrl = "https://github.com/amurcanov"
|
||||
private const val RepositoryUrl = "https://github.com/amurcanov/proxy-turn-vk-android"
|
||||
private const val DonateUrl = ""
|
||||
private val DonateActionButtonColor = Color(0xFF00AEA5)
|
||||
|
||||
private val browserPackages = listOf(
|
||||
"com.android.chrome",
|
||||
"com.google.android.googlequicksearchbox",
|
||||
"org.mozilla.firefox",
|
||||
"com.yandex.browser",
|
||||
"ru.yandex.searchplugin",
|
||||
"com.yandex.browser.lite",
|
||||
"com.opera.browser",
|
||||
"com.opera.mini.native",
|
||||
"com.microsoft.emmx",
|
||||
"com.brave.browser",
|
||||
"com.duckduckgo.mobile.android",
|
||||
"com.sec.android.app.sbrowser",
|
||||
"com.vivaldi.browser",
|
||||
"com.kiwibrowser.browser",
|
||||
)
|
||||
|
||||
private val Android16BlobShape: Shape = GenericShape { size, _ ->
|
||||
val centerX = size.width / 2f
|
||||
val centerY = size.height / 2f
|
||||
val outerRadius = min(size.width, size.height) / 2f
|
||||
val innerRadius = outerRadius * 0.92f
|
||||
val points = 14
|
||||
|
||||
for (i in 0 until points * 2) {
|
||||
val angle = (-PI / 2.0) + (i * PI / points)
|
||||
val radius = if (i % 2 == 0) outerRadius else innerRadius
|
||||
val x = centerX + (radius * cos(angle)).toFloat()
|
||||
val y = centerY + (radius * sin(angle)).toFloat()
|
||||
if (i == 0) moveTo(x, y) else lineTo(x, y)
|
||||
}
|
||||
close()
|
||||
}
|
||||
|
||||
private fun openUrlInBrowser(context: Context, url: String) {
|
||||
try {
|
||||
val pm = context.packageManager
|
||||
val uri = Uri.parse(url)
|
||||
for (pkg in browserPackages) {
|
||||
val intent = Intent(Intent.ACTION_VIEW, uri).apply {
|
||||
addCategory(Intent.CATEGORY_BROWSABLE)
|
||||
setPackage(pkg)
|
||||
}
|
||||
if (intent.resolveActivity(pm) != null) {
|
||||
context.startActivity(intent)
|
||||
return
|
||||
}
|
||||
}
|
||||
val intent = Intent(Intent.ACTION_VIEW, uri).apply { addCategory(Intent.CATEGORY_BROWSABLE) }
|
||||
if (intent.resolveActivity(pm) != null) context.startActivity(intent)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun InfoTab() {
|
||||
val context = LocalContext.current
|
||||
val scope = rememberCoroutineScope()
|
||||
val settingsStore = remember { SettingsStore(context) }
|
||||
val currentVersion = remember { "v${BuildConfig.VERSION_NAME.removePrefix("v")}" }
|
||||
var isCheckingUpdates by remember { mutableStateOf(false) }
|
||||
var pendingManualRelease by remember { mutableStateOf<com.wdtt.client.AppReleaseInfo?>(null) }
|
||||
var showHelpDialog by remember { mutableStateOf(false) }
|
||||
var showDonateDialog by remember { mutableStateOf(false) }
|
||||
var actionsExpanded by rememberSaveable { mutableStateOf(true) }
|
||||
var projectExpanded by rememberSaveable { mutableStateOf(true) }
|
||||
val updateLatestVersion by settingsStore.updateLatestVersion.collectAsStateWithLifecycle(initialValue = "")
|
||||
val updateLastError by settingsStore.updateLastError.collectAsStateWithLifecycle(initialValue = "")
|
||||
val updateStatus = remember(isCheckingUpdates, updateLatestVersion, updateLastError, currentVersion) {
|
||||
when {
|
||||
isCheckingUpdates -> "Проверяем GitHub releases..."
|
||||
updateLatestVersion.isNotBlank() && isNewerVersion(currentVersion, updateLatestVersion) ->
|
||||
"На GitHub доступна версия $updateLatestVersion"
|
||||
updateLatestVersion.isNotBlank() -> "Последняя версия: $updateLatestVersion"
|
||||
updateLastError.isNotBlank() -> "Последняя проверка завершилась ошибкой"
|
||||
else -> "Проверить GitHub вручную"
|
||||
}
|
||||
}
|
||||
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.fillMaxWidth()
|
||||
.padding(start = 16.dp, end = 16.dp, top = 0.dp, bottom = 28.dp)
|
||||
.verticalScroll(rememberScrollState()),
|
||||
verticalArrangement = Arrangement.spacedBy(16.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.height(48.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
text = "Информация",
|
||||
style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold),
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
}
|
||||
|
||||
InfoHeroCard(currentVersion = currentVersion, onSupportClick = { showDonateDialog = true })
|
||||
|
||||
ExpandableSectionCard(
|
||||
title = "Действия",
|
||||
itemCount = "4 пункта",
|
||||
expanded = actionsExpanded,
|
||||
onToggle = { actionsExpanded = !actionsExpanded },
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Info,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
InfoActionTile(
|
||||
title = "Поднять вопрос",
|
||||
subtitle = "Открыть GitHub issue",
|
||||
modifier = Modifier.weight(1f),
|
||||
onClick = { openUrlInBrowser(context, IssuesUrl) },
|
||||
icon = {
|
||||
Icon(
|
||||
painter = painterResource(id = R.drawable.ic_github),
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(20.dp),
|
||||
tint = MaterialTheme.colorScheme.onPrimaryContainer
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
InfoActionTile(
|
||||
title = "Собрать отчёт",
|
||||
subtitle = "Android, ABI, версия, устройство",
|
||||
modifier = Modifier.weight(1f),
|
||||
onClick = {
|
||||
val clipboard = context.getSystemService(ClipboardManager::class.java)
|
||||
clipboard?.setPrimaryClip(ClipData.newPlainText("WDTT Report", buildSupportReport()))
|
||||
Toast.makeText(context, "Отчёт сформирован и скопирован", Toast.LENGTH_SHORT).show()
|
||||
},
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.ContentCopy,
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(20.dp),
|
||||
tint = MaterialTheme.colorScheme.onPrimaryContainer
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
WideActionTile(
|
||||
title = "Справка",
|
||||
subtitle = "Коротко про VPN, исключения, капчу и запуск",
|
||||
onClick = { showHelpDialog = true },
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.AutoMirrored.Filled.HelpOutline,
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(20.dp),
|
||||
tint = MaterialTheme.colorScheme.onPrimaryContainer
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
WideActionTile(
|
||||
title = "Проверить обновления",
|
||||
subtitle = updateStatus,
|
||||
onClick = {
|
||||
if (isCheckingUpdates) return@WideActionTile
|
||||
isCheckingUpdates = true
|
||||
scope.launch {
|
||||
val checkedAt = System.currentTimeMillis()
|
||||
val release = fetchLatestReleaseInfo(currentVersion)
|
||||
val latest = release?.versionTag
|
||||
settingsStore.saveUpdateState(
|
||||
lastCheckAt = checkedAt,
|
||||
latestVersion = latest ?: "",
|
||||
error = if (release == null) "Не удалось проверить" else ""
|
||||
)
|
||||
isCheckingUpdates = false
|
||||
|
||||
if (release == null) {
|
||||
val message = if (updateLatestVersion.isNotBlank()) {
|
||||
"Не удалось проверить. Последняя известная версия: $updateLatestVersion"
|
||||
} else {
|
||||
"Не удалось проверить обновления"
|
||||
}
|
||||
Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
|
||||
return@launch
|
||||
}
|
||||
|
||||
if (isNewerVersion(currentVersion, release.versionTag)) {
|
||||
settingsStore.saveUpdateDialogShown(release.versionTag, checkedAt)
|
||||
pendingManualRelease = release
|
||||
} else {
|
||||
Toast.makeText(
|
||||
context,
|
||||
"У вас уже последняя версия: ${release.versionTag}",
|
||||
Toast.LENGTH_SHORT
|
||||
).show()
|
||||
}
|
||||
}
|
||||
},
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Update,
|
||||
contentDescription = null,
|
||||
modifier = Modifier.size(20.dp),
|
||||
tint = MaterialTheme.colorScheme.onPrimaryContainer
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
pendingManualRelease?.let { release ->
|
||||
AppUpdateDialog(
|
||||
release = release,
|
||||
onPostpone = {
|
||||
pendingManualRelease = null
|
||||
Toast.makeText(context, "Обновление отложено на 24 часа.", Toast.LENGTH_SHORT).show()
|
||||
scope.launch {
|
||||
val now = System.currentTimeMillis()
|
||||
settingsStore.saveUpdatePostpone(
|
||||
version = release.versionTag,
|
||||
until = now + 24L * 60L * 60L * 1000L
|
||||
)
|
||||
settingsStore.saveUpdateDialogAction(
|
||||
version = release.versionTag,
|
||||
action = UPDATE_DIALOG_ACTION_POSTPONED,
|
||||
actedAt = now
|
||||
)
|
||||
}
|
||||
},
|
||||
onUpdate = {
|
||||
pendingManualRelease = null
|
||||
scope.launch {
|
||||
settingsStore.saveUpdateDialogAction(
|
||||
version = release.versionTag,
|
||||
action = UPDATE_DIALOG_ACTION_UPDATE,
|
||||
actedAt = System.currentTimeMillis()
|
||||
)
|
||||
openUrlInBrowser(context, release.releaseUrl)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
ExpandableSectionCard(
|
||||
title = "О проекте",
|
||||
itemCount = "3 ссылки",
|
||||
expanded = projectExpanded,
|
||||
onToggle = { projectExpanded = !projectExpanded },
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Code,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
) {
|
||||
ProjectLinkRow(
|
||||
title = "Автор Android-версии",
|
||||
subtitle = "GitHub профиль amurcanov",
|
||||
onClick = { openUrlInBrowser(context, DeveloperProfileUrl) },
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Person,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
ProjectLinkRow(
|
||||
title = "Репозиторий WDTT",
|
||||
subtitle = "Исходники и релизы приложения",
|
||||
onClick = { openUrlInBrowser(context, RepositoryUrl) },
|
||||
icon = {
|
||||
Icon(
|
||||
painter = painterResource(id = R.drawable.ic_github),
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
ProjectLinkRow(
|
||||
title = "Актуальные релизы",
|
||||
subtitle = "Страница загрузки APK",
|
||||
onClick = { openUrlInBrowser(context, ReleasesUrl) },
|
||||
icon = {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Update,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.primary,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
Spacer(modifier = Modifier.height(20.dp))
|
||||
}
|
||||
|
||||
if (showHelpDialog) ImportantInfoDialog(onDismiss = { showHelpDialog = false })
|
||||
if (showDonateDialog) DonateDialog(onDismiss = { showDonateDialog = false })
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun InfoHeroCard(currentVersion: String, onSupportClick: () -> Unit) {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val isDark = colors.background.luminance() < 0.22f
|
||||
val heroBrush = remember(colors.primaryContainer, colors.secondaryContainer, colors.surfaceVariant) {
|
||||
Brush.linearGradient(
|
||||
listOf(
|
||||
colors.primaryContainer,
|
||||
colors.secondaryContainer,
|
||||
colors.surfaceVariant
|
||||
)
|
||||
)
|
||||
}
|
||||
val glassColor = if (isDark) colors.surface.copy(alpha = 0.46f) else Color.White.copy(alpha = 0.54f)
|
||||
val glassBorder = colors.outlineVariant.copy(alpha = if (isDark) 0.50f else 0.32f)
|
||||
|
||||
Surface(
|
||||
shape = RoundedCornerShape(32.dp),
|
||||
color = Color.Transparent,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
shadowElevation = 10.dp,
|
||||
tonalElevation = 0.dp
|
||||
) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.clip(RoundedCornerShape(32.dp))
|
||||
.background(heroBrush)
|
||||
.padding(22.dp)
|
||||
) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.align(Alignment.TopEnd)
|
||||
.offset(x = 30.dp, y = (-34).dp)
|
||||
.size(138.dp)
|
||||
.clip(Android16BlobShape)
|
||||
.background(colors.primary.copy(alpha = 0.10f))
|
||||
)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.align(Alignment.BottomEnd)
|
||||
.offset(x = 26.dp, y = 30.dp)
|
||||
.size(112.dp)
|
||||
.clip(Android16BlobShape)
|
||||
.background(colors.secondary.copy(alpha = 0.12f))
|
||||
)
|
||||
|
||||
Column(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
verticalArrangement = Arrangement.spacedBy(18.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.spacedBy(10.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
HeroMetaPill(
|
||||
text = "WDTT",
|
||||
containerColor = glassColor,
|
||||
borderColor = glassBorder,
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
HeroMetaPill(
|
||||
text = currentVersion,
|
||||
containerColor = colors.primary.copy(alpha = if (isDark) 0.18f else 0.10f),
|
||||
borderColor = colors.primary.copy(alpha = if (isDark) 0.22f else 0.14f),
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
}
|
||||
|
||||
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
Text(
|
||||
text = "WDTT VPN Tunnel",
|
||||
style = MaterialTheme.typography.headlineSmall.copy(
|
||||
fontWeight = FontWeight.Black,
|
||||
fontSize = 30.sp,
|
||||
lineHeight = 34.sp
|
||||
),
|
||||
color = colors.onSurface
|
||||
)
|
||||
Text(
|
||||
text = "Android-клиент для TURN/VK туннеля с WireGuard, капчей и управлением сервером.",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = colors.onSurfaceVariant,
|
||||
lineHeight = 21.sp
|
||||
)
|
||||
}
|
||||
|
||||
Button(
|
||||
onClick = onSupportClick,
|
||||
shape = RoundedCornerShape(22.dp),
|
||||
colors = ButtonDefaults.buttonColors(
|
||||
containerColor = DonateActionButtonColor,
|
||||
contentColor = Color.White
|
||||
),
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.height(54.dp)
|
||||
) {
|
||||
Icon(Icons.Default.Favorite, contentDescription = null, modifier = Modifier.size(18.dp))
|
||||
Spacer(modifier = Modifier.width(8.dp))
|
||||
Text("Поддержать проект", fontWeight = FontWeight.Bold, fontSize = 15.sp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun HeroMetaPill(
|
||||
text: String,
|
||||
containerColor: Color,
|
||||
borderColor: Color,
|
||||
modifier: Modifier = Modifier
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(18.dp),
|
||||
color = containerColor,
|
||||
border = BorderStroke(1.dp, borderColor),
|
||||
modifier = modifier
|
||||
) {
|
||||
Text(
|
||||
text = text,
|
||||
modifier = Modifier.padding(horizontal = 12.dp, vertical = 9.dp),
|
||||
style = MaterialTheme.typography.labelLarge,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface,
|
||||
textAlign = TextAlign.Center
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ExpandableSectionCard(
|
||||
title: String,
|
||||
itemCount: String,
|
||||
expanded: Boolean,
|
||||
onToggle: () -> Unit,
|
||||
icon: @Composable () -> Unit,
|
||||
content: @Composable ColumnScope.() -> Unit
|
||||
) {
|
||||
val arrowRotation by animateFloatAsState(
|
||||
targetValue = if (expanded) 180f else 0f,
|
||||
label = "section_arrow_rotation"
|
||||
)
|
||||
|
||||
AppSectionCard(
|
||||
contentPadding = PaddingValues(horizontal = 18.dp, vertical = 18.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.clip(RoundedCornerShape(24.dp))
|
||||
.clickable(onClick = onToggle)
|
||||
.padding(vertical = 2.dp),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Surface(shape = RoundedCornerShape(18.dp), color = MaterialTheme.colorScheme.primaryContainer) {
|
||||
Box(modifier = Modifier.size(40.dp), contentAlignment = Alignment.Center) { icon() }
|
||||
}
|
||||
|
||||
Column(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.Center) {
|
||||
Text(
|
||||
text = title,
|
||||
style = MaterialTheme.typography.titleMedium,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
}
|
||||
|
||||
MetaChip(text = itemCount)
|
||||
|
||||
Icon(
|
||||
imageVector = Icons.Default.KeyboardArrowDown,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier
|
||||
.size(24.dp)
|
||||
.rotate(arrowRotation)
|
||||
)
|
||||
}
|
||||
|
||||
AnimatedVisibility(
|
||||
visible = expanded,
|
||||
enter = expandVertically() + fadeIn(),
|
||||
exit = shrinkVertically() + fadeOut()
|
||||
) {
|
||||
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.30f))
|
||||
content()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun MetaChip(text: String) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(14.dp),
|
||||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.88f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface
|
||||
) {
|
||||
Text(
|
||||
text = text,
|
||||
modifier = Modifier.padding(horizontal = 10.dp, vertical = 7.dp),
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
fontWeight = FontWeight.SemiBold,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun InfoActionTile(
|
||||
title: String,
|
||||
subtitle: String,
|
||||
modifier: Modifier = Modifier,
|
||||
onClick: () -> Unit,
|
||||
icon: @Composable () -> Unit
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.70f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
modifier = modifier
|
||||
.clip(RoundedCornerShape(24.dp))
|
||||
.clickable(onClick = onClick)
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.heightIn(min = 116.dp)
|
||||
.padding(16.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(12.dp)
|
||||
) {
|
||||
Surface(shape = RoundedCornerShape(16.dp), color = MaterialTheme.colorScheme.primaryContainer) {
|
||||
Box(modifier = Modifier.size(40.dp), contentAlignment = Alignment.Center) { icon() }
|
||||
}
|
||||
|
||||
Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
|
||||
Text(
|
||||
title,
|
||||
style = MaterialTheme.typography.titleSmall,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Text(
|
||||
text = subtitle,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
lineHeight = 18.sp
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun WideActionTile(
|
||||
title: String,
|
||||
subtitle: String,
|
||||
onClick: () -> Unit,
|
||||
icon: @Composable () -> Unit
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.70f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.clip(RoundedCornerShape(24.dp))
|
||||
.clickable(onClick = onClick)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 16.dp, vertical = 15.dp),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Surface(shape = RoundedCornerShape(16.dp), color = MaterialTheme.colorScheme.primaryContainer) {
|
||||
Box(modifier = Modifier.size(40.dp), contentAlignment = Alignment.Center) { icon() }
|
||||
}
|
||||
|
||||
Column(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) {
|
||||
Text(
|
||||
title,
|
||||
style = MaterialTheme.typography.titleSmall,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Text(
|
||||
text = subtitle,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
lineHeight = 18.sp
|
||||
)
|
||||
}
|
||||
|
||||
Icon(
|
||||
imageVector = Icons.AutoMirrored.Filled.ArrowForward,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ProjectLinkRow(
|
||||
title: String,
|
||||
subtitle: String,
|
||||
onClick: () -> Unit,
|
||||
icon: @Composable () -> Unit
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(24.dp),
|
||||
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.64f),
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.clip(RoundedCornerShape(24.dp))
|
||||
.clickable(onClick = onClick)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 16.dp, vertical = 14.dp),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Surface(shape = RoundedCornerShape(16.dp), color = MaterialTheme.colorScheme.primaryContainer) {
|
||||
Box(
|
||||
modifier = Modifier.defaultMinSize(minWidth = 40.dp, minHeight = 40.dp),
|
||||
contentAlignment = Alignment.Center
|
||||
) {
|
||||
icon()
|
||||
}
|
||||
}
|
||||
|
||||
Column(modifier = Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
|
||||
Text(
|
||||
title,
|
||||
style = MaterialTheme.typography.titleSmall,
|
||||
fontWeight = FontWeight.Bold,
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Text(
|
||||
text = subtitle,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
lineHeight = 18.sp
|
||||
)
|
||||
}
|
||||
|
||||
Icon(
|
||||
imageVector = Icons.AutoMirrored.Filled.ArrowForward,
|
||||
contentDescription = null,
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.size(18.dp)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun DonateDialog(onDismiss: () -> Unit) {
|
||||
val context = LocalContext.current
|
||||
Dialog(
|
||||
onDismissRequest = onDismiss,
|
||||
properties = DialogProperties(usePlatformDefaultWidth = false)
|
||||
) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(32.dp),
|
||||
color = MaterialTheme.colorScheme.surface,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface,
|
||||
tonalElevation = 10.dp,
|
||||
shadowElevation = 14.dp,
|
||||
modifier = Modifier.fillMaxWidth(0.92f)
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 24.dp, vertical = 22.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(20.dp)
|
||||
) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(10.dp)
|
||||
) {
|
||||
Text(
|
||||
text = "Поддержка проекта",
|
||||
style = MaterialTheme.typography.titleLarge,
|
||||
fontWeight = FontWeight.Black,
|
||||
color = MaterialTheme.colorScheme.onSurface,
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
FilledTonalIconButton(onClick = onDismiss) {
|
||||
Icon(Icons.Default.Close, contentDescription = "Закрыть")
|
||||
}
|
||||
}
|
||||
|
||||
Text(
|
||||
text = "Если приложение реально помогает, можно поддержать Android-версию проекта.",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
textAlign = TextAlign.Center,
|
||||
lineHeight = 20.sp
|
||||
)
|
||||
|
||||
Button(
|
||||
onClick = { openUrlInBrowser(context, DonateUrl) },
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.height(62.dp),
|
||||
shape = RoundedCornerShape(22.dp),
|
||||
colors = ButtonDefaults.buttonColors(
|
||||
containerColor = WDTTColors.donate,
|
||||
contentColor = Color.White
|
||||
)
|
||||
) {
|
||||
Icon(
|
||||
painter = painterResource(id = R.drawable.ic_yoomoney),
|
||||
contentDescription = "ЮMoney",
|
||||
tint = Color.Unspecified,
|
||||
modifier = Modifier
|
||||
.width(126.dp)
|
||||
.height(28.dp)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun buildSupportReport(): String {
|
||||
val androidVersion = Build.VERSION.RELEASE ?: "?"
|
||||
val sdkInt = Build.VERSION.SDK_INT
|
||||
val primaryAbi = Build.SUPPORTED_ABIS.firstOrNull().orEmpty().ifBlank { "unknown" }
|
||||
val supportedAbis = Build.SUPPORTED_ABIS.joinToString().ifBlank { "unknown" }
|
||||
val manufacturer = Build.MANUFACTURER.orEmpty().ifBlank { "unknown" }
|
||||
val brand = Build.BRAND.orEmpty().ifBlank { "unknown" }
|
||||
val model = Build.MODEL.orEmpty().ifBlank { "unknown" }
|
||||
val device = Build.DEVICE.orEmpty().ifBlank { "unknown" }
|
||||
val product = Build.PRODUCT.orEmpty().ifBlank { "unknown" }
|
||||
val hardware = Build.HARDWARE.orEmpty().ifBlank { "unknown" }
|
||||
val board = Build.BOARD.orEmpty().ifBlank { "unknown" }
|
||||
val romDisplay = Build.DISPLAY.orEmpty().ifBlank { "unknown" }
|
||||
val buildId = Build.ID.orEmpty().ifBlank { "unknown" }
|
||||
val buildFingerprint = Build.FINGERPRINT.orEmpty().ifBlank { "unknown" }
|
||||
val buildType = Build.TYPE.orEmpty().ifBlank { "unknown" }
|
||||
val socManufacturer = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
||||
Build.SOC_MANUFACTURER.orEmpty().ifBlank { "unknown" }
|
||||
} else {
|
||||
"n/a"
|
||||
}
|
||||
val socModel = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
||||
Build.SOC_MODEL.orEmpty().ifBlank { "unknown" }
|
||||
} else {
|
||||
"n/a"
|
||||
}
|
||||
|
||||
return buildString {
|
||||
appendLine("Версия приложения: ${BuildConfig.VERSION_NAME}")
|
||||
appendLine("Андроид: $androidVersion (SDK $sdkInt)")
|
||||
appendLine("Устройство: $manufacturer / $brand / $model")
|
||||
appendLine("Код устройства: $device")
|
||||
appendLine("Продукт: $product")
|
||||
appendLine("ABI: $primaryAbi")
|
||||
appendLine("Все ABI: $supportedAbis")
|
||||
appendLine("SoC: $socManufacturer / $socModel")
|
||||
appendLine("Hardware: $hardware")
|
||||
appendLine("Board: $board")
|
||||
appendLine("ROM: $romDisplay")
|
||||
appendLine("Build ID: $buildId")
|
||||
appendLine("Build type: $buildType")
|
||||
appendLine("Fingerprint: $buildFingerprint")
|
||||
}.trim()
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
package com.wdtt.client.ui
|
||||
|
||||
import android.content.ClipData
|
||||
import android.content.ClipboardManager
|
||||
import android.content.Context
|
||||
import android.widget.Toast
|
||||
import androidx.compose.animation.core.*
|
||||
import androidx.compose.foundation.isSystemInDarkTheme
|
||||
import androidx.compose.foundation.layout.*
|
||||
import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.lazy.rememberLazyListState
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.ContentCopy
|
||||
import androidx.compose.material.icons.filled.Delete
|
||||
import androidx.compose.material3.*
|
||||
import androidx.compose.runtime.*
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.graphics.graphicsLayer
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.text.font.FontFamily
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import com.wdtt.client.LogEntry
|
||||
import com.wdtt.client.TunnelManager
|
||||
import com.wdtt.client.WDTTColors
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun LogsTab() {
|
||||
val context = LocalContext.current
|
||||
val currentLogs by TunnelManager.logs.collectAsStateWithLifecycle()
|
||||
val listState = rememberLazyListState()
|
||||
|
||||
Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
|
||||
// Toolbar
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
"Лог событий",
|
||||
style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold),
|
||||
color = MaterialTheme.colorScheme.onSurface
|
||||
)
|
||||
Row {
|
||||
IconButton(onClick = { TunnelManager.clearLogs() }) {
|
||||
Icon(Icons.Default.Delete, contentDescription = "Clear", tint = MaterialTheme.colorScheme.primary)
|
||||
}
|
||||
IconButton(onClick = {
|
||||
val text = currentLogs.joinToString("\n") { "${it.message} (x${it.count})" }
|
||||
val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
|
||||
val clip = ClipData.newPlainText("WDTT Logs", text)
|
||||
clipboard.setPrimaryClip(clip)
|
||||
Toast.makeText(context, "Скопировано", Toast.LENGTH_SHORT).show()
|
||||
}) {
|
||||
Icon(Icons.Default.ContentCopy, contentDescription = "Copy", tint = MaterialTheme.colorScheme.primary)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Logs container — адаптивный к теме
|
||||
val isDark = isSystemInDarkTheme()
|
||||
val terminalBg = if (isDark) WDTTColors.terminalBgDark else WDTTColors.terminalBg
|
||||
|
||||
Card(
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
colors = CardDefaults.cardColors(containerColor = terminalBg),
|
||||
shape = RoundedCornerShape(20.dp),
|
||||
elevation = CardDefaults.cardElevation(defaultElevation = 6.dp)
|
||||
) {
|
||||
LazyColumn(
|
||||
state = listState,
|
||||
modifier = Modifier.fillMaxSize().padding(12.dp),
|
||||
contentPadding = PaddingValues(bottom = 12.dp)
|
||||
) {
|
||||
items(currentLogs, key = { it.key }) { entry ->
|
||||
LogLine(entry)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun LogLine(entry: LogEntry) {
|
||||
val color = when {
|
||||
entry.isError -> WDTTColors.terminalRed
|
||||
entry.priority <= 2 -> WDTTColors.terminalGreen
|
||||
entry.priority == 3 -> WDTTColors.terminalBlue
|
||||
else -> WDTTColors.terminalText
|
||||
}
|
||||
|
||||
var trigger by remember { mutableIntStateOf(0) }
|
||||
LaunchedEffect(entry.count) { trigger++ }
|
||||
|
||||
val animatedScale by animateFloatAsState(
|
||||
targetValue = if (trigger > 0) 1.15f else 1.0f,
|
||||
animationSpec = spring(dampingRatio = Spring.DampingRatioMediumBouncy),
|
||||
label = "scale",
|
||||
finishedListener = { trigger = 0 }
|
||||
)
|
||||
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Surface(
|
||||
color = WDTTColors.terminalCounter.copy(alpha = 0.2f),
|
||||
shape = RoundedCornerShape(12.dp),
|
||||
modifier = Modifier
|
||||
.defaultMinSize(minWidth = 24.dp, minHeight = 24.dp)
|
||||
.graphicsLayer(scaleX = animatedScale, scaleY = animatedScale)
|
||||
) {
|
||||
Box(
|
||||
contentAlignment = Alignment.Center,
|
||||
modifier = Modifier.padding(horizontal = 6.dp)
|
||||
) {
|
||||
Text(
|
||||
text = "${entry.count}",
|
||||
color = WDTTColors.terminalBlue,
|
||||
fontSize = 10.sp,
|
||||
fontWeight = FontWeight.Bold,
|
||||
maxLines = 1
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Spacer(modifier = Modifier.width(12.dp))
|
||||
|
||||
Text(
|
||||
text = entry.message,
|
||||
color = color,
|
||||
fontSize = 13.sp,
|
||||
fontFamily = FontFamily.Monospace,
|
||||
fontWeight = if (entry.isError) FontWeight.Bold else FontWeight.Normal,
|
||||
lineHeight = 18.sp,
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,22 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:aapt="http://schemas.android.com/aapt"
|
||||
android:width="20dp"
|
||||
android:height="23dp"
|
||||
android:viewportWidth="69"
|
||||
android:viewportHeight="80">
|
||||
<path
|
||||
android:fillType="nonZero"
|
||||
android:pathData="M34.8586103,46.5882227 L29.4383109,46.5882227 C29.1227896,46.5896404 28.8214241,46.4709816 28.6091788,46.2617625 C28.3969336,46.0525435 28.2937566,45.7724279 28.325313,45.4910942 L28.8039021,40.6038855 C28.8504221,40.0844231 29.3353656,39.684617 29.9168999,39.6862871 L35.3371993,39.6862871 C35.6527206,39.6848694 35.9540862,39.8035282 36.1663314,40.0127473 C36.3785767,40.2219663 36.4817536,40.5020819 36.4501972,40.7834156 L35.9716081,45.6706244 C35.9250881,46.1900867 35.4401446,46.5898928 34.8586103,46.5882227 Z M35.7273704,37.0196078 L30.2062624,37.0196078 C29.5964177,37.0196078 29.1020408,36.5436108 29.1020408,35.9564386 L30.6037822,19.445421 C30.6711655,18.9085577 31.1463683,18.5059261 31.7080038,18.5098321 L37.2291117,18.5098321 C37.8389565,18.5098321 38.3333333,18.9858292 38.3333333,19.5730013 L36.7874231,36.0946506 C36.71732,36.6114677 36.2684318,37.0031485 35.7273704,37.0196078 Z M68.1907868,17.7655375 C68.7783609,18.4477209 69.0654113,19.3359027 68.9874243,20.2304671 L66.8294442,44.7595227 C66.7602449,45.5618649 66.4022166,46.3125114 65.8210422,46.8737509 L48.1740082,63.9078173 C47.5440361,64.5136721 46.7011436,64.8515656 45.8244317,64.849701 L27.0379034,64.849701 L10.5001116,80 L11.780782,64.8396809 L3.37070981,64.8396809 C2.42614186,64.8404154 1.52467299,64.4469919 0.886144518,63.7553546 C0.247616048,63.0637173 -0.0692823639,62.1374374 0.0127313353,61.2024067 L5.14549723,3.00601995 C5.32162283,1.29571214 6.77326374,-0.00377492304 8.50347571,8.23911697e-06 L51.3303063,8.23911697e-06 C52.3155567,-0.000274507348 53.2515294,0.428127083 53.8916472,1.17235281 L68.1907868,17.7655375 Z M55.1118136,40.0801644 L56.4832402,24.9398854 C56.5364472,24.0422509 56.2238954,23.1611024 55.6160145,22.4949959 L47.548799,13.2364798 C46.9095165,12.5050105 45.982605,12.084699 45.0076261,12.0841753 L19.5958971,12.0841753 C17.8656851,12.0803922 16.4140442,13.3798792 16.2379186,15.090187 L13.2127128,49.1583198 C13.1430685,50.0904539 13.4642119,51.0097453 14.1001037,51.6985265 C14.7359954,52.3873077 15.6300918,52.7843324 16.5706913,52.795594 L41.5588914,52.795594 C42.4258216,52.7976549 43.2601656,52.4674704 43.8882999,51.8737504 L54.1034116,42.2044127 C54.6867718,41.6406314 55.0449815,40.8860452 55.1118136,40.0801644 Z">
|
||||
<aapt:attr name="android:fillColor">
|
||||
<gradient
|
||||
android:startX="60.16"
|
||||
android:startY="0"
|
||||
android:endX="8.835"
|
||||
android:endY="80"
|
||||
android:type="linear">
|
||||
<item android:offset="0" android:color="#F59C07"/>
|
||||
<item android:offset="1" android:color="#F57507"/>
|
||||
</gradient>
|
||||
</aapt:attr>
|
||||
</path>
|
||||
</vector>
|
||||
@@ -0,0 +1,10 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="20dp"
|
||||
android:height="23dp"
|
||||
android:viewportWidth="69"
|
||||
android:viewportHeight="80">
|
||||
<path
|
||||
android:fillColor="#000000"
|
||||
android:fillType="nonZero"
|
||||
android:pathData="M34.8586103,46.5882227 L29.4383109,46.5882227 C29.1227896,46.5896404 28.8214241,46.4709816 28.6091788,46.2617625 C28.3969336,46.0525435 28.2937566,45.7724279 28.325313,45.4910942 L28.8039021,40.6038855 C28.8504221,40.0844231 29.3353656,39.684617 29.9168999,39.6862871 L35.3371993,39.6862871 C35.6527206,39.6848694 35.9540862,39.8035282 36.1663314,40.0127473 C36.3785767,40.2219663 36.4817536,40.5020819 36.4501972,40.7834156 L35.9716081,45.6706244 C35.9250881,46.1900867 35.4401446,46.5898928 34.8586103,46.5882227 Z M35.7273704,37.0196078 L30.2062624,37.0196078 C29.5964177,37.0196078 29.1020408,36.5436108 29.1020408,35.9564386 L30.6037822,19.445421 C30.6711655,18.9085577 31.1463683,18.5059261 31.7080038,18.5098321 L37.2291117,18.5098321 C37.8389565,18.5098321 38.3333333,18.9858292 38.3333333,19.5730013 L36.7874231,36.0946506 C36.71732,36.6114677 36.2684318,37.0031485 35.7273704,37.0196078 Z M68.1907868,17.7655375 C68.7783609,18.4477209 69.0654113,19.3359027 68.9874243,20.2304671 L66.8294442,44.7595227 C66.7602449,45.5618649 66.4022166,46.3125114 65.8210422,46.8737509 L48.1740082,63.9078173 C47.5440361,64.5136721 46.7011436,64.8515656 45.8244317,64.849701 L27.0379034,64.849701 L10.5001116,80 L11.780782,64.8396809 L3.37070981,64.8396809 C2.42614186,64.8404154 1.52467299,64.4469919 0.886144518,63.7553546 C0.247616048,63.0637173 -0.0692823639,62.1374374 0.0127313353,61.2024067 L5.14549723,3.00601995 C5.32162283,1.29571214 6.77326374,-0.00377492304 8.50347571,8.23911697e-06 L51.3303063,8.23911697e-06 C52.3155567,-0.000274507348 53.2515294,0.428127083 53.8916472,1.17235281 L68.1907868,17.7655375 Z M55.1118136,40.0801644 L56.4832402,24.9398854 C56.5364472,24.0422509 56.2238954,23.1611024 55.6160145,22.4949959 L47.548799,13.2364798 C46.9095165,12.5050105 45.982605,12.084699 45.0076261,12.0841753 L19.5958971,12.0841753 C17.8656851,12.0803922 16.4140442,13.3798792 16.2379186,15.090187 L13.2127128,49.1583198 C13.1430685,50.0904539 13.4642119,51.0097453 14.1001037,51.6985265 C14.7359954,52.3873077 15.6300918,52.7843324 16.5706913,52.795594 L41.5588914,52.795594 C42.4258216,52.7976549 43.2601656,52.4674704 43.8882999,51.8737504 L54.1034116,42.2044127 C54.6867718,41.6406314 55.0449815,40.8860452 55.1118136,40.0801644 Z"/>
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="1024"
|
||||
android:viewportHeight="1024">
|
||||
<path
|
||||
android:fillColor="#FFFFFF"
|
||||
android:pathData="M511.6 76.3C264.3 76.2 64 276.4 64 523.5 64 718.9 189.3 885 363.8 946c23.5 5.9 19.9-10.8 19.9-22.2v-77.5c-135.7 15.9-141.2-73.9-150.3-88.9C215 726 171.5 718 184.5 703c30.9-15.9 62.4 4 98.9 57.9 26.4 39.1 77.9 32.5 104 26 5.7-23.5 17.9-44.5 34.7-60.8-140.6-25.2-199.2-111-199.2-213 0-49.5 16.3-95 48.3-131.7-20.4-60.5 1.9-112.3 4.9-120 58.1-5.2 118.5 41.6 123.2 45.3 33-8.9 70.7-13.6 112.9-13.6 42.4 0 80.2 4.9 113.5 13.9 11.3-8.6 67.3-48.8 121.3-43.9 2.9 7.7 24.7 58.3 5.5 118 32.4 36.8 48.9 82.7 48.9 132.3 0 102.2-59 188.1-200 212.9a127.5 127.5 0 0 1 38.1 91v112.5c.8 9 0 17.9 15 17.9 177.1-59.7 304.6-227 304.6-424.1 0-247.2-200.4-447.3-447.5-447.3z"/>
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="#FFFFFFFF"
|
||||
android:pathData="M12,1L3,5v6c0,5.55 3.84,10.74 9,12c5.16,-1.26 9,-6.45 9,-12V5L12,1zM12,21.8C7.68,20.62 4.5,16.03 4.5,11V6l7.5,-3.32L19.5,6v5C19.5,16.03 16.32,20.62 12,21.8z"/>
|
||||
</vector>
|
||||
@@ -0,0 +1,9 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="24dp"
|
||||
android:height="24dp"
|
||||
android:viewportWidth="24"
|
||||
android:viewportHeight="24">
|
||||
<path
|
||||
android:fillColor="#FFFFFFFF"
|
||||
android:pathData="M6,6h12v12H6z"/>
|
||||
</vector>
|
||||
@@ -0,0 +1,25 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="138dp"
|
||||
android:height="30dp"
|
||||
android:viewportWidth="92"
|
||||
android:viewportHeight="20">
|
||||
<path
|
||||
android:pathData="M33.9287 15.222H36.2782V9.5425C36.2782 8.34 37.1107 7.9145 37.9247 7.9145C38.8127 7.9145 39.4047 8.4695 39.4047 9.5425V15.222H41.7542V9.5425C41.7542 8.3215 42.5867 7.9145 43.4007 7.9145C44.2887 7.9145 44.8807 8.4695 44.8807 9.5425V15.222H47.2302V9.3575C47.2302 6.9895 45.7502 5.75 43.9187 5.75C42.6977 5.75 41.8282 6.305 41.1622 7.119C40.5702 6.2125 39.6082 5.75 38.5167 5.75C37.5177 5.75 36.7592 6.194 36.1672 6.86L36.0377 5.9535H33.9287V15.222Z"
|
||||
android:fillColor="#FFFFFF"/>
|
||||
<path
|
||||
android:pathData="M53.9553 5.75C51.1063 5.75 49.0157 7.8035 49.0157 10.5785C49.0157 13.372 51.1063 15.407 53.9553 15.407C56.8043 15.407 58.8948 13.372 58.8948 10.5785C58.8948 7.8035 56.8043 5.75 53.9553 5.75ZM53.9553 7.9145C55.4538 7.9145 56.4342 8.9875 56.4342 10.5785C56.4342 12.188 55.4538 13.261 53.9553 13.261C52.4568 13.261 51.4577 12.188 51.4577 10.5785C51.4577 8.9875 52.4568 7.9145 53.9553 7.9145Z"
|
||||
android:fillColor="#FFFFFF"/>
|
||||
<path
|
||||
android:pathData="M60.8838 15.222H63.2333V10.005C63.2333 8.451 64.3063 7.933 65.2868 7.933C66.3783 7.933 67.1553 8.636 67.1553 10.005V15.222H69.5048V9.635C69.5048 7.082 67.8398 5.75 65.8603 5.75C64.8243 5.75 63.8808 6.1385 63.1408 6.8785L63.0113 5.9535H60.8838V15.222Z"
|
||||
android:fillColor="#FFFFFF"/>
|
||||
<path
|
||||
android:pathData="M76.1941 15.407C78.4326 15.407 80.0421 14.3525 80.5971 12.5025L78.4141 12.0585C78.1181 12.8355 77.4151 13.372 76.1941 13.372C74.8621 13.372 73.9186 12.743 73.6966 11.3H80.5786C80.6526 10.9485 80.6896 10.5785 80.6896 10.2455C80.6896 7.563 78.8026 5.75 76.0831 5.75C73.2711 5.75 71.2916 7.822 71.2916 10.634C71.2916 13.3905 73.1231 15.407 76.1941 15.407ZM76.0831 7.6925C77.2671 7.6925 78.0256 8.34 78.2291 9.5055H73.7706C74.1036 8.2845 75.0101 7.6925 76.0831 7.6925Z"
|
||||
android:fillColor="#FFFFFF"/>
|
||||
<path
|
||||
android:pathData="M81.2328 5.9535L85.2103 15.1665L83.6193 19.292H86.0428L91.1673 5.9535H88.6698L86.4313 12.2065L83.8413 5.9535H81.2328Z"
|
||||
android:fillColor="#FFFFFF"/>
|
||||
<path
|
||||
android:pathData="M8.23663 9.97273C8.25147 4.47884 12.7503 0 18.4037 0C24.002 0 28.6351 4.49367 28.5708 10C28.5708 15.5063 24.002 20 18.4037 20C12.8145 20 8.25158 15.5841 8.23663 10.0274V17.4683H4.6331L0 2.91138H8.23663V9.97273ZM14.6071 10C14.6071 12.0253 16.3445 13.7342 18.4037 13.7342C20.5272 13.7342 22.2002 12.0253 22.2002 10C22.2002 7.97469 20.4628 6.26582 18.4037 6.26582C16.3445 6.26582 14.6071 7.97469 14.6071 10Z"
|
||||
android:fillColor="#FFFFFF"
|
||||
android:fillType="evenOdd"/>
|
||||
</vector>
|
||||
@@ -0,0 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<background android:drawable="@color/ic_launcher_background"/>
|
||||
<foreground android:drawable="@mipmap/ic_launcher_foreground"/>
|
||||
</adaptive-icon>
|
||||
@@ -0,0 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<background android:drawable="@color/ic_launcher_background"/>
|
||||
<foreground android:drawable="@mipmap/ic_launcher_foreground"/>
|
||||
</adaptive-icon>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 9.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 5.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 59 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 326 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 52 KiB |
@@ -0,0 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<color name="ic_launcher_background">#1E1E1E</color>
|
||||
</resources>
|
||||
@@ -0,0 +1,7 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<style name="Theme.WDTTClient" parent="android:Theme.Material.Light.NoActionBar">
|
||||
<item name="android:statusBarColor">@android:color/transparent</item>
|
||||
<item name="android:navigationBarColor">@android:color/transparent</item>
|
||||
</style>
|
||||
</resources>
|
||||
Reference in New Issue
Block a user