feat: card-row device list and brand-aware side panel (#5)

Author: EverythingSuckz

internal/adb/adb.go

@@ -7,6 +7,7 @@ import (
 	"net"
 	"os/exec"
 	"strings"
+	"sync"
 	"time"
 
 	"mirroid/internal/model"
@@ -20,9 +21,10 @@ const (
 
 // Device represents a connected Android device.
 type Device struct {
-	Serial string `json:"serial"`
-	Model  string `json:"model"`
-	Source string `json:"source"` // "usb", "wireless", "mdns"
+	Serial       string `json:"serial"`
+	Model        string `json:"model"`
+	Manufacturer string `json:"manufacturer,omitempty"`
+	Source       string `json:"source"` // "usb", "wireless", "mdns"
 }
 
 // String returns a display-friendly label.
@@ -45,13 +47,24 @@ func isIPPort(serial string) bool {
 
 type Client struct {
 	adbPath string
+
+	propsMu    sync.Mutex
+	propsCache map[string]deviceProps // serial → cached manufacturer/model from getprop
+}
+
+type deviceProps struct {
+	manufacturer string
+	model        string
 }
 
 func NewClient(adbPath string) *Client {
 	if adbPath == "" {
 		adbPath = "adb"
 	}
-	return &Client{adbPath: adbPath}
+	return &Client{
+		adbPath:    adbPath,
+		propsCache: make(map[string]deviceProps),
+	}
 }
 
 // Path returns the configured adb binary path.
@@ -109,7 +122,7 @@ func (c *Client) GetDevices() ([]Device, error) {
 		devices = append(devices, Device{
 			Serial: serial,
 			Model:  devModel,
-			Source:  source,
+			Source: source,
 		})
 	}
 
@@ -134,9 +147,77 @@ func (c *Client) GetDevices() ([]Device, error) {
 			result = append(result, d)
 		}
 	}
+
+	// fetch manufacturer + model per device in parallel; tolerate failures
+	c.fillDeviceProperties(result)
+
 	return result, nil
 }
 
+// fillDeviceProperties populates the Manufacturer field and refreshes Model
+// for each device via getprop, preferring the getprop model (with proper
+// spaces) over `adb devices -l`'s underscore-encoded form. Results are cached
+// per serial since these props don't change at runtime; cache lookups skip the
+// adb roundtrip entirely. Per-device failures are silently ignored.
+func (c *Client) fillDeviceProperties(devices []Device) {
+	var wg sync.WaitGroup
+	for i := range devices {
+		// fast path: cached
+		c.propsMu.Lock()
+		cached, ok := c.propsCache[devices[i].Serial]
+		c.propsMu.Unlock()
+		if ok {
+			if cached.manufacturer != "" {
+				devices[i].Manufacturer = cached.manufacturer
+			}
+			if cached.model != "" {
+				devices[i].Model = cached.model
+			}
+			continue
+		}
+
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			ctx, cancel := context.WithTimeout(context.Background(), adbTimeout)
+			defer cancel()
+			cmd := exec.CommandContext(ctx, c.adbPath, "-s", devices[idx].Serial, "shell",
+				"getprop ro.product.manufacturer; getprop ro.product.model")
+			platform.HideConsole(cmd)
+			out, err := cmd.Output()
+			if err != nil {
+				return
+			}
+			// strip embedded \r (adb on Windows emits \r\n) up front
+			normalized := strings.ReplaceAll(string(out), "\r", "")
+			lines := strings.Split(strings.TrimRight(normalized, "\n"), "\n")
+			var mfr, mdl string
+			if len(lines) > 0 {
+				mfr = strings.TrimSpace(lines[0])
+				if strings.EqualFold(mfr, "unknown") {
+					mfr = "" // treat the literal Android sentinel as missing
+				}
+			}
+			if len(lines) > 1 {
+				mdl = strings.TrimSpace(lines[1])
+				if strings.EqualFold(mdl, "unknown") {
+					mdl = "" // android sentinel; let `adb devices -l` model win
+				}
+			}
+			if mfr != "" {
+				devices[idx].Manufacturer = mfr
+			}
+			if mdl != "" {
+				devices[idx].Model = mdl
+			}
+			c.propsMu.Lock()
+			c.propsCache[devices[idx].Serial] = deviceProps{manufacturer: mfr, model: mdl}
+			c.propsMu.Unlock()
+		}(i)
+	}
+	wg.Wait()
+}
+
 // Pair runs `adb pair <addr> <password>`.
 func (c *Client) Pair(addr, password string) error {
 	ctx, cancel := context.WithTimeout(context.Background(), adbLongTimeout)
@@ -196,4 +277,3 @@ func (c *Client) VerifyConnection(serial string) bool {
 	}
 	return strings.TrimSpace(string(out)) == "ok"
 }
-

internal/icons/brand_colors.go

@@ -0,0 +1,81 @@
+package icons
+
+import (
+	"image/color"
+	"strings"
+)
+
+// brandColors maps Simple Icons slugs to the brand's official hex color.
+// values sourced from simple-icons/data/simple-icons.json.
+var brandColors = map[string]color.NRGBA{
+	"google":   {R: 0x42, G: 0x85, B: 0xF4, A: 0xff},
+	"samsung":  {R: 0x14, G: 0x28, B: 0xA0, A: 0xff},
+	"xiaomi":   {R: 0xFF, G: 0x69, B: 0x00, A: 0xff},
+	"oneplus":  {R: 0xF5, G: 0x01, B: 0x0C, A: 0xff},
+	"huawei":   {R: 0xFF, G: 0x00, B: 0x00, A: 0xff},
+	"lg":       {R: 0xA5, G: 0x00, B: 0x34, A: 0xff},
+	"motorola": {R: 0xE1, G: 0x14, B: 0x0A, A: 0xff},
+	"sony":     {R: 0xFF, G: 0xFF, B: 0xFF, A: 0xff},
+	"oppo":     {R: 0x2D, G: 0x68, B: 0x3D, A: 0xff},
+	"vivo":     {R: 0x41, G: 0x5F, B: 0xFF, A: 0xff},
+	"asus":     {R: 0x00, G: 0x00, B: 0x00, A: 0xff},
+	"honor":    {R: 0x00, G: 0x00, B: 0x00, A: 0xff},
+	"nokia":    {R: 0x00, G: 0x5A, B: 0xFF, A: 0xff},
+	"nothing":  {R: 0x00, G: 0x00, B: 0x00, A: 0xff},
+}
+
+// BrandColor returns the official brand color for the given manufacturer, or
+// (nil, false) if no color is bundled. Lookup matches BrandIcon's rules.
+func BrandColor(manufacturer string) (color.Color, bool) {
+	key := resolveBrandKey(manufacturer)
+	if key == "" {
+		return nil, false
+	}
+	if c, ok := brandColors[key]; ok {
+		return c, true
+	}
+	if alt := firstTokenKey(key); alt != "" {
+		if c, ok := brandColors[alt]; ok {
+			return c, true
+		}
+	}
+	return nil, false
+}
+
+// firstTokenKey returns the prefix of key up to the first space/comma/period,
+// or "" when there is no separator.
+func firstTokenKey(key string) string {
+	if i := strings.IndexAny(key, " ,."); i > 0 {
+		return key[:i]
+	}
+	return ""
+}
+
+// IsLightColor reports whether a color is bright enough that it would
+// disappear against a white background (e.g., Sony's white).
+func IsLightColor(c color.Color) bool {
+	return perceivedBrightness(c) > 0.85
+}
+
+// IsDarkColor reports whether a color is dark enough that it would disappear
+// against a dark-gray background (e.g., Honor's black).
+func IsDarkColor(c color.Color) bool {
+	return perceivedBrightness(c) < 0.05
+}
+
+// IsDarkBackground reports whether the given color is dark enough to warrant
+// dark-theme treatment. Threshold (0.5) tuned for the default Fyne themes.
+func IsDarkBackground(c color.Color) bool {
+	return perceivedBrightness(c) < 0.5
+}
+
+// perceivedBrightness is a fast sRGB-weighted approximation, not WCAG
+// relative luminance — it skips the gamma-to-linear step. Thresholds in
+// IsLightColor / IsDarkColor / IsDarkBackground are tuned against this scale.
+func perceivedBrightness(c color.Color) float64 {
+	nr := color.NRGBAModel.Convert(c).(color.NRGBA)
+	r := float64(nr.R) / 255.0
+	g := float64(nr.G) / 255.0
+	b := float64(nr.B) / 255.0
+	return 0.2126*r + 0.7152*g + 0.0722*b
+}

internal/icons/icons.go

@@ -14,9 +14,49 @@ import (
 	"fyne.io/fyne/v2/theme"
 )
 
-//go:embed svg/*.svg
+//go:embed svg/*.svg svg/brands/*.svg
 var svgFS embed.FS
 
+var brandAliases = map[string]string{
+	"google llc":                   "google",
+	"samsung electronics":          "samsung",
+	"xiaomi communications co ltd": "xiaomi",
+	"redmi":                        "xiaomi",
+	"poco":                         "xiaomi",
+	"oneplus technology":           "oneplus",
+	"motorola mobility":            "motorola",
+	"hmd global":                   "nokia",
+}
+
+func BrandIcon(manufacturer string) fyne.Resource {
+	key := resolveBrandKey(manufacturer)
+	if key == "" {
+		return nil
+	}
+	if b, err := svgFS.ReadFile("svg/brands/" + key + ".svg"); err == nil {
+		return &fyne.StaticResource{StaticName: "brand-" + key + ".svg", StaticContent: b}
+	}
+	if alt := firstTokenKey(key); alt != "" {
+		if b, err := svgFS.ReadFile("svg/brands/" + alt + ".svg"); err == nil {
+			return &fyne.StaticResource{StaticName: "brand-" + alt + ".svg", StaticContent: b}
+		}
+	}
+	return nil
+}
+
+// resolveBrandKey normalizes a manufacturer string to its brand-icon lookup
+// key (lowercased, trimmed, alias-mapped). Returns "" for empty input.
+func resolveBrandKey(manufacturer string) string {
+	key := strings.ToLower(strings.TrimSpace(manufacturer))
+	if key == "" {
+		return ""
+	}
+	if alias, ok := brandAliases[key]; ok {
+		return alias
+	}
+	return key
+}
+
 func mustLoad(name string) *fyne.StaticResource {
 	b, err := svgFS.ReadFile("svg/" + name)
 	if err != nil {
@@ -62,16 +102,33 @@ func NewThemedIcon(res fyne.Resource) fyne.Resource {
 	return &themedStrokeResource{src: res}
 }
 
-// NewTintedIcon substitutes `currentColor` once at construction; use NewThemedIcon when the color should follow the theme.
-// the tint hex is embedded in the resource name so each tinted variant has a
-// unique key in fyne's name-based svg cache.
+var (
+	tintedMu    sync.Mutex
+	tintedCache = make(map[string]*fyne.StaticResource)
+)
+
+// NewTintedIcon substitutes `currentColor` once at construction. Use
+// NewThemedIcon when the color should follow the active theme. Resources are
+// cached per (source name, tint hex) so repeated calls in list bind callbacks
+// don't re-allocate.
 func NewTintedIcon(res fyne.Resource, c color.Color) fyne.Resource {
 	hex := colorToHex(c)
-	content := strings.ReplaceAll(string(res.Content()), "currentColor", hex)
-	return &fyne.StaticResource{
-		StaticName:    res.Name() + "@" + hex,
-		StaticContent: []byte(content),
+	key := res.Name() + "@" + hex
+
+	tintedMu.Lock()
+	if cached, ok := tintedCache[key]; ok {
+		tintedMu.Unlock()
+		return cached
 	}
+	tintedMu.Unlock()
+
+	content := strings.ReplaceAll(string(res.Content()), "currentColor", hex)
+	out := &fyne.StaticResource{StaticName: key, StaticContent: []byte(content)}
+
+	tintedMu.Lock()
+	tintedCache[key] = out
+	tintedMu.Unlock()
+	return out
 }
 
 func colorToHex(c color.Color) string {