Android平台：自研应用间私有文件共享实现方案咨询

Great question! For your use case—sharing GB-sized files between your Xamarin.Forms apps on Android, while keeping them locked to only your apps and ensuring they get deleted when all related apps are uninstalled—there are two robust, Android-native approaches that fit exactly what you need. Let’s dive into them:

1. Shared User ID (UID) + Internal Storage #

This is a straightforward, legacy-friendly approach that works across most Android versions.

How it works: #

• All your Android apps declare the same sharedUserId in their AndroidManifest.xml. Apps with the same shared UID run under the same Linux user account, which means they can directly access each other's internal storage directories (normally private to a single app).
• Pick one app as the "host" to store all shared files, or even create a tiny helper app dedicated just for file storage.
• Auto-cleanup bonus: When the last app using that shared UID is uninstalled, Android automatically deletes all internal storage associated with that UID—perfect for your requirement.

Implementation Steps: #

1. Add the sharedUserId attribute to every one of your Android app's manifest files:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.yourcompany.photoshare"
    android:sharedUserId="com.yourcompany.yoursharedgroup">
    <!-- Rest of your manifest code -->
</manifest>

2. From any of your apps, access the host app's internal storage using createPackageContext:

// In Xamarin.Android, get the host app context
var hostContext = Android.App.Application.Context.CreatePackageContext("com.yourcompany.hostapp", Android.Content.PackageContextFlags.IgnoreSecurity);
var sharedFilesDir = hostContext.FilesDir;
// Now you can read/write files directly in sharedFilesDir

Notes: #

• All apps must be signed with the same keystore (which they should be, since they're your apps).
• This ties your apps together tightly—changing the shared UID later will break compatibility, so choose a stable ID upfront.

2. Scoped Storage + Signature-Locked Content Provider (Modern Approach) #

For Android 10 (API 29) and above, this is the recommended method, as it aligns with scoped storage best practices while maintaining privacy and auto-cleanup.

How it works: #

• One app acts as the "file host," storing shared files in its app-specific directory (either internal storage or scoped external storage—both are private to the host app by default).
• Create a custom ContentProvider in the host app that exposes these files to other apps.
• Access to this provider is restricted using signature-level permissions, meaning only apps signed with your keystore can interact with it.
• Auto-cleanup: When the host app is uninstalled, all files in its app-specific directories are deleted automatically.

Implementation Steps: #

1. Host App Setup:

   • Define a signature-only permission in the host's manifest:

   <permission android:name="com.yourcompany.sharedfiles.ACCESS_PERMISSION"
       android:protectionLevel="signature" />
   

   • Declare the ContentProvider, requiring the above permission:

   <provider
       android:name=".SharedFileProvider"
       android:authorities="com.yourcompany.sharedfiles.provider"
       android:exported="true"
       android:grantUriPermissions="true"
       android:permission="com.yourcompany.sharedfiles.ACCESS_PERMISSION">
   </provider>
   

   • Implement the SharedFileProvider class (inheriting from ContentProvider in Xamarin.Android) to handle file operations like OpenFile() or Query() for client apps.

2. Client Apps Setup:

   • Add the permission to each client app's manifest:

   <uses-permission android:name="com.yourcompany.sharedfiles.ACCESS_PERMISSION" />
   

   • Use ContentResolver to interact with the host's provider, e.g., to open a file:

   var uri = Android.Net.Uri.Parse("content://com.yourcompany.sharedfiles.provider/myphoto.jpg");
   var stream = Android.App.Application.Context.ContentResolver.OpenInputStream(uri);
   // Use the stream to read the file
   

Which Approach to Choose? #

• Shared UID: Best if you need compatibility with older Android versions (pre-API 29) or want direct, simple file access without extra layers.
• Content Provider: Preferred for modern Android (API 29+), as it follows scoped storage guidelines, is more flexible, and doesn't tightly couple your apps.

Both methods ensure that only your apps can access the shared files, and handle auto-cleanup when appropriate—exactly what you're looking for!

内容的提问来源于stack exchange，提问作者Chris Vergaray