android: expand SAF FileOps implementation

This expands the SAF FileOps to implement the refactored FileOps

Updates tailscale/corp#29211

Signed-off-by: kari-ts <[email protected]>

Author: kari-ts

android/src/main/java/com/tailscale/ipn/util/ShareFileHelper.kt

@@ -6,6 +6,7 @@ package com.tailscale.ipn.util
 import android.content.Context
 import android.net.Uri
 import androidx.documentfile.provider.DocumentFile
+import com.tailscale.ipn.ui.util.InputStreamAdapter
 import com.tailscale.ipn.ui.util.OutputStreamAdapter
 import libtailscale.Libtailscale
 import java.io.IOException
@@ -123,6 +124,22 @@ object ShareFileHelper : libtailscale.ShareFileHelper {
     }
   }
 
+  @Throws(IOException::class)
+  override fun deleteFile(uriString: String) {
+    val ctx = appContext ?: throw IOException("DeleteFile: not initialized")
+
+    val uri = Uri.parse(uriString)
+    val doc =
+        DocumentFile.fromSingleUri(ctx, uri)
+            ?: throw IOException("DeleteFile: cannot resolve URI $uriString")
+
+    if (!doc.delete()) {
+      throw IOException("DeleteFile: delete() returned false for $uriString")
+    }
+  }
+
+  override fun treeURI(): String = savedUri ?: throw IllegalStateException("not initialized")
+
   fun generateNewFilename(filename: String): String {
     val dotIndex = filename.lastIndexOf('.')
     val baseName = if (dotIndex != -1) filename.substring(0, dotIndex) else filename
@@ -131,4 +148,51 @@ object ShareFileHelper : libtailscale.ShareFileHelper {
     val uuid = UUID.randomUUID()
     return "$baseName-$uuid$extension"
   }
+
+  fun listPartialFiles(suffix: String): Array<String> {
+    val context = appContext ?: return emptyArray()
+    val rootUri = savedUri ?: return emptyArray()
+    val dir = DocumentFile.fromTreeUri(context, Uri.parse(rootUri)) ?: return emptyArray()
+
+    return dir.listFiles()
+        .filter { it.name?.endsWith(suffix) == true }
+        .mapNotNull { it.name }
+        .toTypedArray()
+  }
+
+  override fun listPartialFilesJSON(suffix: String): String {
+    return listPartialFiles(suffix)
+        .joinToString(prefix = "[\"", separator = "\",\"", postfix = "\"]")
+  }
+
+  override fun openPartialFileReader(name: String): libtailscale.InputStream? {
+    val context = appContext ?: return null
+    val rootUri = savedUri ?: return null
+    val dir = DocumentFile.fromTreeUri(context, Uri.parse(rootUri)) ?: return null
+
+    // We know `name` includes the suffix (e.g. ".<id>.partial"), but the actual
+    // file in SAF might include extra bits, so let's just match by that suffix.
+    // You could also match exactly `endsWith(name)` if the filenames line up
+    val suffix = name.substringAfterLast('.', ".$name") // or hard-code ".partial"
+
+    val file =
+        dir.listFiles().firstOrNull {
+          val fname = it.name ?: return@firstOrNull false
+          // call the String overload explicitly:
+          fname.endsWith(suffix, /*ignoreCase=*/ false)
+        }
+            ?: run {
+              TSLog.d("ShareFileHelper", "no file ending with $suffix in SAF directory")
+              return null
+            }
+
+    TSLog.d("ShareFileHelper", "found SAF file ${file.name}, opening")
+    val inStream =
+        context.contentResolver.openInputStream(file.uri)
+            ?: run {
+              TSLog.d("ShareFileHelper", "openInputStream returned null for ${file.uri}")
+              return null
+            }
+    return InputStreamAdapter(inStream)
+  }
 }

libtailscale/fileops.go

@@ -5,34 +5,72 @@ package libtailscale
 import (
 	"fmt"
 	"io"
+	"net/url"
+	"os"
+	"path"
+
+	"tailscale.com/feature/taildrop"
 )
 
 // AndroidFileOps implements the ShareFileHelper interface using the Android helper.
 type AndroidFileOps struct {
 	helper ShareFileHelper
 }
 
+// compile-time assertion
+var _ taildrop.FileOps = (*AndroidFileOps)(nil)
+
 func NewAndroidFileOps(helper ShareFileHelper) *AndroidFileOps {
 	return &AndroidFileOps{helper: helper}
 }
 
-func (ops *AndroidFileOps) OpenFileURI(filename string) string {
-	return ops.helper.OpenFileURI(filename)
+func (ops *AndroidFileOps) OpenWriter(partialStr, dest string, offset int64, perm os.FileMode) (io.WriteCloser, string, error) {
+	if offset != 0 {
+		return nil, "", fmt.Errorf("resume unsupported in SAF mode")
+	}
+	partial := dest + partialStr
+	wc := ops.helper.OpenFileWriter(partial)
+	if wc == nil {
+		return nil, "", fmt.Errorf("OpenFileWriter returned nil for %q", dest)
+	}
+	uri := ops.helper.OpenFileURI(partial)
+	return wc, uri, nil
 }
 
-func (ops *AndroidFileOps) OpenFileWriter(filename string) (io.WriteCloser, string, error) {
-	uri := ops.helper.OpenFileURI(filename)
-	outputStream := ops.helper.OpenFileWriter(filename)
-	if outputStream == nil {
-		return nil, uri, fmt.Errorf("failed to open SAF output stream for %s", filename)
+func (ops *AndroidFileOps) Base(pathOrURI string) string {
+	if u, err := url.Parse(pathOrURI); err == nil && u.Scheme != "" {
+		return path.Base(u.Path)
 	}
-	return outputStream, uri, nil
+	return path.Base(pathOrURI)
 }
 
-func (ops *AndroidFileOps) RenamePartialFile(partialUri, targetDirUri, targetName string) (string, error) {
-	newURI := ops.helper.RenamePartialFile(partialUri, targetDirUri, targetName)
+func (ops *AndroidFileOps) Join(dir, name string) string {
+	return ops.helper.OpenFileURI(name)
+}
+
+func (ops *AndroidFileOps) Remove(baseName string) error {
+	uri := ops.helper.OpenFileURI(baseName)
+	return ops.helper.DeleteFile(uri)
+}
+
+func (ops *AndroidFileOps) Rename(partialURI, finalName string) (string, error) {
+	tree := ops.helper.TreeURI()
+	newURI := ops.helper.RenamePartialFile(partialURI, tree, finalName)
 	if newURI == "" {
-		return "", fmt.Errorf("failed to rename partial file via SAF")
+		return "", fmt.Errorf("SAF rename failed")
 	}
 	return newURI, nil
 }
+
+func (ops *AndroidFileOps) OpenReader(name string) (io.ReadCloser, error) {
+	in := ops.helper.OpenPartialFileReader(name)
+	if in == nil {
+		return nil, fmt.Errorf("OpenPartialFileReader returned nil for %q", name)
+	}
+	// adapt the gobind InputStream to an io.ReadCloser
+	return adaptInputStream(in), nil
+}
+
+func (ops *AndroidFileOps) IsDirect() bool {
+	return false
+}

libtailscale/interfaces.go

@@ -183,6 +183,14 @@ type ShareFileHelper interface {
 	// RenamePartialFile takes SAF URIs and a target file name,
 	// and returns the new SAF URI and an error.
 	RenamePartialFile(partialUri string, targetDirUri string, targetName string) string
+
+	ListPartialFilesJSON(suffix string) string
+
+	OpenPartialFileReader(name string) InputStream
+
+	DeleteFile(uriString string) error
+
+	TreeURI() string
 }
 
 // The below are global callbacks that allow the Java application to notify Go

libtailscale/localapi.go

@@ -230,27 +230,6 @@ func (r *Response) Flush() {
 	})
 }
 
-func adaptInputStream(in InputStream) io.ReadCloser {
-	if in == nil {
-		return nil
-	}
-	r, w := io.Pipe()
-	go func() {
-		defer w.Close()
-		for {
-			b, err := in.Read()
-			if err != nil {
-				log.Printf("error reading from inputstream: %s", err)
-			}
-			if b == nil {
-				return
-			}
-			w.Write(b)
-		}
-	}()
-	return r
-}
-
 // Below taken from Go stdlib
 var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
 

libtailscale/streamutil.go

@@ -0,0 +1,32 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package libtailscale
+
+import (
+	"io"
+	"log"
+)
+
+// adaptInputStream wraps a libtailscale.InputStream into an io.ReadCloser.
+// It launches a goroutine to stream reads into a pipe.
+func adaptInputStream(in InputStream) io.ReadCloser {
+	if in == nil {
+		return nil
+	}
+	r, w := io.Pipe()
+	go func() {
+		defer w.Close()
+		for {
+			b, err := in.Read()
+			if err != nil {
+				log.Printf("error reading from inputstream: %s", err)
+			}
+			if b == nil {
+				return
+			}
+			w.Write(b)
+		}
+	}()
+	return r
+}