MandreCompiler-1

Paused

App Files Files Community

sterepando commited on 4 days ago

Commit

5480a7b

verified ·

1 Parent(s): 4e46096

Update Dockerfile

Browse files

Files changed (1) hide show

Dockerfile +210 -67

Dockerfile CHANGED Viewed

@@ -1,10 +1,10 @@
 # --- START OF FILE Dockerfile ---
-FROM golang:latest
-# Обновление и зависимости
-RUN apt-get update && apt-get install -y wget unzip git build-essential python3
-# Настройка Android NDK
 ENV ANDROID_NDK_HOME /opt/android-ndk
 ENV ANDROID_NDK_VERSION r25c
@@ -13,115 +13,258 @@ RUN wget -q https://dl.google.com/android/repository/android-ndk-${ANDROID_NDK_V
     mv android-ndk-${ANDROID_NDK_VERSION} /opt/android-ndk && \
     rm android-ndk-${ANDROID_NDK_VERSION}-linux.zip
 ENV PATH ${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
 WORKDIR /app
-# Настройка Go
-ENV GOTOOLCHAIN=auto
-RUN go mod init vless-client
-# Исправленный код main.go
 RUN cat <<EOF > main.go
 package main
 import "C"
 import (
-	"encoding/base64"
-	"strings"
 	"sync"
-	"github.com/xtls/xray-core/core"
-	"github.com/xtls/xray-core/infra/conf/serial"
-	_ "github.com/xtls/xray-core/main/distro/all"
 )
 var (
-	instance *core.Instance
-	mu       sync.Mutex
 )
-//export StartCore
-func StartCore(configContent *C.char) *C.char {
-	mu.Lock()
-	defer mu.Unlock()
-	if instance != nil {
-		return C.CString("Core already running")
 	}
-	configStr := C.GoString(configContent)
-	// 1. Декодируем JSON в структуру conf.Config
-	confConfig, err := serial.DecodeJSONConfig(strings.NewReader(configStr))
-	if err != nil {
-		return C.CString("Config parse error: " + err.Error())
 	}
-	// 2. !!! ВАЖНО !!! Конвертируем conf.Config в core.Config
-	coreConfig, err := confConfig.Build()
-	if err != nil {
-		return C.CString("Config build error: " + err.Error())
 	}
-	// 3. Создаем инстанс ядра
-	coreInstance, err := core.New(coreConfig)
-	if err != nil {
-		return C.CString("Core create error: " + err.Error())
 	}
-	if err := coreInstance.Start(); err != nil {
-		return C.CString("Core start error: " + err.Error())
 	}
-	instance = coreInstance
-	return C.CString("")
 }
-//export StopCore
-func StopCore() {
 	mu.Lock()
-	defer mu.Unlock()
-	if instance != nil {
-		instance.Close()
-		instance = nil
 	}
 }
-//export Base64Decode
-func Base64Decode(str *C.char) *C.char {
-    data := C.GoString(str)
-    if l := len(data) % 4; l > 0 {
-		data += strings.Repeat("=", 4-l)
 	}
-    decoded, err := base64.StdEncoding.DecodeString(data)
-    if err != nil {
-        decoded, err = base64.URLEncoding.DecodeString(data)
-    }
-    if err != nil {
-        return C.CString("")
-    }
-    return C.CString(string(decoded))
 }
 func main() {}
 EOF
-# Зависимости
-RUN go get -u github.com/xtls/xray-core@latest
-RUN go mod tidy
-# Компиляция
 RUN CGO_ENABLED=1 \
     GOOS=android \
     GOARCH=arm64 \
     CC=aarch64-linux-android33-clang \
-    go build -buildmode=c-shared -o libvless.so main.go
-# Выдача файла
-RUN mkdir /output && mv libvless.so /output/
-WORKDIR /output
-CMD ["python3", "-m", "http.server", "7860"]
 # --- END OF FILE Dockerfile ---

 # --- START OF FILE Dockerfile ---
+FROM golang:1.21
+# 1. Установка необходимых инструментов
+RUN apt-get update && apt-get install -y wget unzip build-essential
+# 2. Настройка Android NDK (нужен для CGO кросс-компиляции)
 ENV ANDROID_NDK_HOME /opt/android-ndk
 ENV ANDROID_NDK_VERSION r25c
     mv android-ndk-${ANDROID_NDK_VERSION} /opt/android-ndk && \
     rm android-ndk-${ANDROID_NDK_VERSION}-linux.zip
+# Добавляем тулчейны в PATH
 ENV PATH ${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
 WORKDIR /app
+# 3. Инициализация Go модуля
+RUN go mod init mandre_server
+# 4. Код сервера на Go (Diff-Streamer)
 RUN cat <<EOF > main.go
 package main
 import "C"
 import (
+	"bytes"
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"net/http"
 	"sync"
+	"time"
+	"unsafe"
+	"github.com/gorilla/websocket"
 )
+// Глобальные переменные
 var (
+	mu          sync.RWMutex
+	prevFrame   *image.RGBA
+	clients     = make(map[*websocket.Conn]bool)
+	broadcast   = make(chan []byte)
+	upgrader    = websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
+	serverStarted bool
 )
+// HTML клиент с Canvas для отрисовки Diff-кадров
+const indexHTML = \`
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Mandre Stream (Delta)</title>
+    <style>
+        body { background: #1a1a1a; color: #eee; display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100vh; margin: 0; font-family: monospace; }
+        canvas { border: 2px solid #444; background: #000; max-width: 100%; max-height: 80vh; }
+        #status { margin-top: 10px; color: #0f0; }
+    </style>
+</head>
+<body>
+    <canvas id="screen"></canvas>
+    <div id="status">Connecting...</div>
+    <script>
+        const canvas = document.getElementById('screen');
+        const ctx = canvas.getContext('2d', { alpha: false }); // Optimizes compositing
+        const status = document.getElementById('status');
+        let ws = new WebSocket("ws://" + location.host + "/ws");
+        ws.binaryType = "arraybuffer";
+        ws.onopen = () => { status.innerText = "Connected (Delta Stream)"; };
+        ws.onclose = () => { status.innerText = "Disconnected"; setTimeout(() => location.reload(), 2000); };
+        ws.onmessage = (event) => {
+            const blob = new Blob([event.data], {type: "image/png"});
+            const url = URL.createObjectURL(blob);
+            const img = new Image();
+            img.onload = () => {
+                // Первый кадр задает размер
+                if (canvas.width !== img.width || canvas.height !== img.height) {
+                    canvas.width = img.width;
+                    canvas.height = img.height;
+                }
+                // РИСУЕМ ПОВЕРХ СТАРОГО (Прозрачные пиксели не затрут старые)
+                ctx.drawImage(img, 0, 0);
+                URL.revokeObjectURL(url);
+            };
+            img.src = url;
+        };
+    </script>
+</body>
+</html>
+\`
+//export StartServer
+func StartServer(port int) {
+	if serverStarted {
+		return
 	}
+	serverStarted = true
+	go func() {
+		http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "text/html")
+			w.Write([]byte(indexHTML))
+		})
+		http.HandleFunc("/ws", handleConnections)
+		addr := fmt.Sprintf(":%d", port)
+		fmt.Printf("[Go] Server starting on %s\n", addr)
+		http.ListenAndServe(addr, nil)
+	}()
+	go handleMessages()
+}
+//export StopServer
+func StopServer() {
+	// В Go сложно корректно остановить http.ListenAndServe без контекста,
+	// но для Android плагина это обычно не критично (процесс убивается).
+	// Можно добавить л��гику закрытия сокетов.
+}
+//export UpdateFrame
+func UpdateFrame(width, height int, rawPtr unsafe.Pointer, length int) {
+	// Превращаем C-pointer в Go slice без копирования (для чтения)
+	// Android Bitmap обычно ARGB_8888 (4 байта на пиксель)
+	rawBytes := unsafe.Slice((*byte)(rawPtr), length)
+	img := image.NewRGBA(image.Rect(0, 0, width, height))
+	// Копируем сырые данные в изображение.
+	// ВНИМАНИЕ: Android Bitmap.copyPixelsToBuffer дает порядок цветов, который может отличаться (RGBA vs ARGB).
+	// Обычно это RGBA. Если цвета перепутаны, поменяем тут.
+	copy(img.Pix, rawBytes)
+	// Генерация Delta-кадра
+	diffImg := generateDelta(img)
+	// Кодируем в PNG (Fastest compression)
+	var buf bytes.Buffer
+	enc := png.Encoder{CompressionLevel: png.NoCompression} // Скорость > Размер, т.к. мы и так шлем только разницу
+	if err := enc.Encode(&buf, diffImg); err == nil {
+		// Отправляем PNG в канал
+		select {
+		case broadcast <- buf.Bytes():
+		default:
+			// Если канал забит, пропускаем кадр (drop frame)
+		}
 	}
+}
+func generateDelta(current *image.RGBA) image.Image {
+	mu.Lock()
+	defer mu.Unlock()
+	// Если это первый кадр или размер изменился - отправляем полный кадр
+	if prevFrame == nil || prevFrame.Bounds() != current.Bounds() {
+		prevFrame = current
+		return current
 	}
+	bounds := current.Bounds()
+	diff := image.NewRGBA(bounds)
+	// Сравниваем пиксели
+	// current.Pix и prevFrame.Pix - это []uint8
+	// Формат RGBA: 4 байта на пиксель
+	totalPixels := len(current.Pix)
+	changed := false
+	// Проходим по байтам. Оптимизация: сравниваем uint32 было бы быстрее, но сложнее с alignment.
+	// Идем шагом 4 (R, G, B, A)
+	for i := 0; i < totalPixels; i += 4 {
+		// Сравниваем 4 байта пикселя
+		if current.Pix[i] != prevFrame.Pix[i] ||     // R
+		   current.Pix[i+1] != prevFrame.Pix[i+1] || // G
+		   current.Pix[i+2] != prevFrame.Pix[i+2] || // B
+		   current.Pix[i+3] != prevFrame.Pix[i+3] {  // A
+			// Пиксель изменился -> копируем его в diff
+			diff.Pix[i] = current.Pix[i]
+			diff.Pix[i+1] = current.Pix[i+1]
+			diff.Pix[i+2] = current.Pix[i+2]
+			diff.Pix[i+3] = current.Pix[i+3] // Alpha 255 (обычно)
+			changed = true
+		} else {
+			// Пиксель НЕ изменился -> делаем прозрачным
+			// В image.NewRGBA по умолчанию всё 0 (Transparent), поэтому ничего писать не надо!
+			// diff.Pix[i+3] = 0 // Уже 0
+		}
 	}
+	// Обновляем предыдущий кадр
+	prevFrame = current
+	if !changed {
+		// Если изменений нет вообще, можно вернуть пустой 1x1 пиксель прозрачный, чтобы не слать лишнее
+		return image.NewRGBA(image.Rect(0, 0, 1, 1))
 	}
+	return diff
 }
+func handleConnections(w http.ResponseWriter, r *http.Request) {
+	ws, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return
+	}
+	defer ws.Close()
 	mu.Lock()
+	clients[ws] = true
+	// При подключении сбрасываем prevFrame, чтобы клиенту пришел полный кадр сразу (force I-frame)
+	prevFrame = nil
+	mu.Unlock()
+	for {
+		// Читаем сообщения (нужно для keep-alive/close), но игнорируем их
+		_, _, err := ws.ReadMessage()
+		if err != nil {
+			mu.Lock()
+			delete(clients, ws)
+			mu.Unlock()
+			break
+		}
 	}
 }
+func handleMessages() {
+	for {
+		pngData := <-broadcast
+		mu.RLock()
+		for client := range clients {
+			err := client.WriteMessage(websocket.BinaryMessage, pngData)
+			if err != nil {
+				client.Close()
+				delete(clients, client)
+			}
+		}
+		mu.RUnlock()
 	}
 }
 func main() {}
 EOF
+# 5. Установка зависимостей (WebSocket)
+RUN go get github.com/gorilla/websocket
+# 6. Компиляция shared library для Android (ARM64)
+# buildmode=c-shared создает .so файл, который Python может загрузить через ctypes
 RUN CGO_ENABLED=1 \
     GOOS=android \
     GOARCH=arm64 \
     CC=aarch64-linux-android33-clang \
+    go build -buildmode=c-shared -o libmandre_server.so main.go
+# 7. Выдача файла
+CMD ["sh", "-c", "mkdir -p /output && cp libmandre_server.so /output/"]
 # --- END OF FILE Dockerfile ---