feat: media viewer added, actions workflow added

Author: bkrajendra

.github/workflows/release.yml

@@ -0,0 +1,138 @@
+name: Build & Release
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write   # needed to create tags and GitHub releases
+
+jobs:
+  release:
+    name: Build and publish release
+    runs-on: ubuntu-latest
+
+    steps:
+      # ── 1. Checkout with full tag history ───────────────────────────
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0        # required to see all existing tags
+
+      # ── 2. Compute the next minor version ───────────────────────────
+      - name: Compute next version
+        id: version
+        run: |
+          git fetch --tags --force
+
+          # Find the latest semver tag (vMAJOR.MINOR.PATCH)
+          LATEST=$(git tag --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -1)
+
+          if [ -z "$LATEST" ]; then
+            # No tags yet — start at v0.1.0
+            NEW_TAG="v0.1.0"
+          else
+            MAJOR=$(echo "$LATEST" | cut -d. -f1 | tr -d 'v')
+            MINOR=$(echo "$LATEST" | cut -d. -f2)
+            NEW_MINOR=$((MINOR + 1))
+            NEW_TAG="v${MAJOR}.${NEW_MINOR}.0"
+          fi
+
+          echo "previous=${LATEST:-none}"
+          echo "tag=$NEW_TAG"
+          echo "tag=$NEW_TAG" >> "$GITHUB_OUTPUT"
+
+      # ── 3. Set up Go ────────────────────────────────────────────────
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod   # honours the 'go' directive in go.mod
+          cache: true
+
+      # ── 4. Build for all platforms ──────────────────────────────────
+      - name: Build binaries
+        env:
+          VERSION: ${{ steps.version.outputs.tag }}
+          LDFLAGS: -s -w -X main.version=${{ steps.version.outputs.tag }}
+        run: |
+          mkdir -p dist
+
+          echo "Building $VERSION …"
+
+          GOOS=windows GOARCH=amd64 go build -ldflags="$LDFLAGS" \
+            -o dist/androidbackup-windows-amd64.exe .
+
+          GOOS=linux GOARCH=amd64 go build -ldflags="$LDFLAGS" \
+            -o dist/androidbackup-linux-amd64 .
+
+          GOOS=linux GOARCH=arm64 go build -ldflags="$LDFLAGS" \
+            -o dist/androidbackup-linux-arm64 .
+
+          GOOS=darwin GOARCH=amd64 go build -ldflags="$LDFLAGS" \
+            -o dist/androidbackup-darwin-amd64 .
+
+          GOOS=darwin GOARCH=arm64 go build -ldflags="$LDFLAGS" \
+            -o dist/androidbackup-darwin-arm64 .
+
+          echo "Built artifacts:"
+          ls -lh dist/
+
+      # ── 5. Collect commit messages for the release body ─────────────
+      - name: Build changelog
+        id: changelog
+        run: |
+          PREV=$(git tag --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -1)
+          if [ -z "$PREV" ]; then
+            LOG=$(git log --oneline | head -20)
+          else
+            LOG=$(git log "${PREV}..HEAD" --oneline)
+          fi
+          # Escape for multiline GitHub output
+          echo "log<<EOF" >> "$GITHUB_OUTPUT"
+          echo "$LOG"     >> "$GITHUB_OUTPUT"
+          echo "EOF"      >> "$GITHUB_OUTPUT"
+
+      # ── 6. Create GitHub release with binaries ──────────────────────
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.version.outputs.tag }}
+          name: ${{ steps.version.outputs.tag }}
+          body: |
+            ## Changes
+            ```
+            ${{ steps.changelog.outputs.log }}
+            ```
+
+            ## Downloads
+
+            | Platform | Architecture | Binary |
+            |----------|--------------|--------|
+            | Windows  | x64          | `androidbackup-windows-amd64.exe` |
+            | Linux    | x64          | `androidbackup-linux-amd64` |
+            | Linux    | ARM64        | `androidbackup-linux-arm64` |
+            | macOS    | x64          | `androidbackup-darwin-amd64` |
+            | macOS    | Apple Silicon| `androidbackup-darwin-arm64` |
+
+            ## Requirements
+            - [ADB (Android Debug Bridge)](https://developer.android.com/tools/releases/platform-tools) must be installed and in your `PATH`
+
+            ## Usage
+            ```
+            # Windows
+            .\androidbackup-windows-amd64.exe
+
+            # Linux / macOS (make executable first)
+            chmod +x androidbackup-linux-amd64
+            ./androidbackup-linux-amd64
+            ```
+            Opens at **http://localhost:8765**
+          files: |
+            dist/androidbackup-windows-amd64.exe
+            dist/androidbackup-linux-amd64
+            dist/androidbackup-linux-arm64
+            dist/androidbackup-darwin-amd64
+            dist/androidbackup-darwin-arm64
+          draft: false
+          prerelease: false
+          make_latest: true

.gitignore

@@ -1 +1,9 @@
-/dist
+# Built binaries
+/dist/
+*.exe
+
+# ADB view cache (temp files pulled for viewer)
+# (lives in %TEMP% on Windows, so not tracked anyway)
+
+# Transfer state
+androidbackup_state.json

README.md

@@ -2,6 +2,8 @@
 
 Copy photos and files from your Android device to your PC via a web interface — with folder browsing, pause/resume transfers, file management, and Wi-Fi ADB support.
 
+![Android Backup screenshot](docs/screen-shot.png)
+
 ---
 
 ## Prerequisites

adb.go

@@ -3,7 +3,9 @@ package main
 import (
 	"bufio"
 	"fmt"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -225,8 +227,66 @@ func RenamePath(serial, oldPath, newPath string) error {
 	return err
 }
 
-// PullFile runs adb pull for a single file. Returns bytes transferred.
+// PullFile runs adb pull for a single file.
 func PullFile(serial, remotePath, localPath string) error {
 	_, err := exec.Command("adb", "-s", serial, "pull", remotePath, localPath).CombinedOutput()
 	return err
 }
+
+// ViewCachePath returns the local cache path for a remote file preview.
+func ViewCachePath(serial, remotePath string) string {
+	cacheDir := filepath.Join(os.TempDir(), "androidbackup_view")
+	_ = os.MkdirAll(cacheDir, 0755)
+	base := filepath.Base(remotePath)
+	return filepath.Join(cacheDir, fmt.Sprintf("%08x_%s", fnvHash(serial+":"+remotePath), sanitizeFilename(base)))
+}
+
+func fnvHash(s string) uint32 {
+	h := uint32(2166136261)
+	for i := 0; i < len(s); i++ {
+		h ^= uint32(s[i])
+		h *= 16777619
+	}
+	return h
+}
+
+func sanitizeFilename(name string) string {
+	var b strings.Builder
+	for _, r := range name {
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '.' || r == '-' || r == '_' {
+			b.WriteRune(r)
+		} else {
+			b.WriteRune('_')
+		}
+	}
+	s := b.String()
+	if len(s) > 80 {
+		s = s[len(s)-80:]
+	}
+	return s
+}
+
+// ExtContentType maps a lowercase file extension (without dot) to a MIME type.
+func ExtContentType(ext string) string {
+	m := map[string]string{
+		"jpg": "image/jpeg", "jpeg": "image/jpeg", "png": "image/png",
+		"gif": "image/gif", "webp": "image/webp", "bmp": "image/bmp",
+		"heic": "image/heic", "heif": "image/heif",
+		"mp4": "video/mp4", "m4v": "video/mp4", "mov": "video/quicktime",
+		"mkv": "video/x-matroska", "avi": "video/x-msvideo", "3gp": "video/3gpp",
+		"webm": "video/webm",
+		"mp3": "audio/mpeg", "aac": "audio/aac", "m4a": "audio/mp4",
+		"ogg": "audio/ogg", "flac": "audio/flac", "wav": "audio/wav",
+		"pdf":  "application/pdf",
+		"txt":  "text/plain; charset=utf-8",
+		"log":  "text/plain; charset=utf-8",
+		"xml":  "text/xml; charset=utf-8",
+		"json": "application/json; charset=utf-8",
+		"csv":  "text/csv; charset=utf-8",
+		"md":   "text/plain; charset=utf-8",
+	}
+	if ct, ok := m[ext]; ok {
+		return ct
+	}
+	return "application/octet-stream"
+}

docs/screen-shot.png

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -138,6 +139,58 @@ func handleLocalBrowse(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, 200, result)
 }
 
+func handleAndroidView(w http.ResponseWriter, r *http.Request) {
+	serial := r.URL.Query().Get("serial")
+	remotePath := r.URL.Query().Get("path")
+	if serial == "" || remotePath == "" {
+		errResp(w, 400, "serial and path required")
+		return
+	}
+
+	ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(remotePath), "."))
+	ct := ExtContentType(ext)
+
+	cachedPath := ViewCachePath(serial, remotePath)
+
+	// Re-pull when caller requests a refresh or file is not in cache
+	if r.URL.Query().Get("refresh") == "1" {
+		_ = os.Remove(cachedPath)
+	}
+	if _, err := os.Stat(cachedPath); os.IsNotExist(err) {
+		if err := PullFile(serial, remotePath, cachedPath); err != nil {
+			errResp(w, 502, "adb pull failed: "+err.Error())
+			return
+		}
+	}
+
+	f, err := os.Open(cachedPath)
+	if err != nil {
+		errResp(w, 500, err.Error())
+		return
+	}
+	defer f.Close()
+
+	stat, _ := f.Stat()
+	w.Header().Set("Content-Type", ct)
+	w.Header().Set("Cache-Control", "no-store")
+	http.ServeContent(w, r, filepath.Base(remotePath), stat.ModTime(), f)
+}
+
+func handleLocalMkdir(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		Path string `json:"path"` // full path of the new folder to create
+	}
+	if err := readBody(r, &body); err != nil || body.Path == "" {
+		errResp(w, 400, "path required")
+		return
+	}
+	if err := os.MkdirAll(body.Path, 0755); err != nil {
+		errResp(w, 500, err.Error())
+		return
+	}
+	writeJSON(w, 200, map[string]string{"path": body.Path})
+}
+
 // ---- device handlers ----
 
 func handleListDevices(w http.ResponseWriter, r *http.Request) {
@@ -245,7 +298,7 @@ func makeTransferHandlers(tm *TransferManager) func(mux *http.ServeMux) {
 		mux.HandleFunc("/api/transfers", func(w http.ResponseWriter, r *http.Request) {
 			switch r.Method {
 			case http.MethodGet:
-				writeJSON(w, 200, tm.List())
+				writeJSON(w, 200, tm.ListSummaries())
 			case http.MethodPost:
 				var body struct {
 					DeviceSerial string `json:"deviceSerial"`
@@ -313,6 +366,23 @@ func makeTransferHandlers(tm *TransferManager) func(mux *http.ServeMux) {
 					return
 				}
 				writeJSON(w, 200, t)
+			case "files":
+				if r.Method != http.MethodGet {
+					errResp(w, 405, "method not allowed")
+					return
+				}
+				q := r.URL.Query()
+				filter := q.Get("filter")
+				offset := 0
+				limit := 100
+				fmt.Sscan(q.Get("offset"), &offset)
+				fmt.Sscan(q.Get("limit"), &limit)
+				result, err := tm.GetFiles(id, filter, offset, limit)
+				if err != nil {
+					errResp(w, 404, err.Error())
+					return
+				}
+				writeJSON(w, 200, result)
 			case "remove":
 				if err := tm.Remove(id); err != nil {
 					errResp(w, 400, err.Error())