react-native-pdf-jsi 2.2.8 → 3.0.0

package/android/src/main/java/org/wonday/pdf/FileDownloader.java

@@ -0,0 +1,292 @@
+package org.wonday.pdf;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.util.Log;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * FileDownloader - Native module for downloading files to public storage using MediaStore API
+ * Ensures files are immediately visible in file managers
+ */
+public class FileDownloader extends ReactContextBaseJavaModule {
+    private static final String TAG = "FileDownloader";
+    private static final String FOLDER_NAME = "PDFDemoApp";
+    private static final String NOTIFICATION_CHANNEL_ID = "pdf_exports";
+    private final ReactApplicationContext reactContext;
+
+    public FileDownloader(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        createNotificationChannel();
+    }
+    
+    /**
+     * Create notification channel for export notifications (Android O+)
+     */
+    private void createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            CharSequence name = "PDF Exports";
+            String description = "Notifications for PDF export operations";
+            int importance = NotificationManager.IMPORTANCE_DEFAULT;
+            NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, name, importance);
+            channel.setDescription(description);
+            
+            NotificationManager notificationManager = reactContext.getSystemService(NotificationManager.class);
+            if (notificationManager != null) {
+                notificationManager.createNotificationChannel(channel);
+                Log.i(TAG, "📱 [NOTIFICATION] Channel created");
+            }
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "FileDownloader";
+    }
+
+    /**
+     * Download file to public Downloads folder using MediaStore API
+     * 
+     * @param sourcePath Path to source file in app's cache
+     * @param fileName Name for the downloaded file
+     * @param mimeType MIME type (application/pdf, image/png, image/jpeg)
+     * @param promise Promise to resolve with public file path
+     */
+    @ReactMethod
+    public void downloadToPublicFolder(String sourcePath, String fileName, String mimeType, Promise promise) {
+        try {
+            Log.i(TAG, "📥 [DOWNLOAD] START - file: " + fileName + ", type: " + mimeType);
+            Log.i(TAG, "📁 [SOURCE] " + sourcePath);
+
+            // Verify source file exists
+            File sourceFile = new File(sourcePath);
+            if (!sourceFile.exists()) {
+                Log.e(TAG, "❌ [ERROR] Source file not found: " + sourcePath);
+                promise.reject("FILE_NOT_FOUND", "Source file not found: " + sourcePath);
+                return;
+            }
+
+            Log.i(TAG, "📁 [SOURCE] File exists, size: " + sourceFile.length() + " bytes");
+
+            String publicPath;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                // Android 10+ - Use MediaStore API (Scoped Storage)
+                publicPath = downloadUsingMediaStore(sourceFile, fileName, mimeType);
+            } else {
+                // Android 9 and below - Use legacy public directory
+                publicPath = downloadUsingLegacyStorage(sourceFile, fileName);
+            }
+
+            Log.i(TAG, "✅ [DOWNLOAD] SUCCESS - " + publicPath);
+            
+            // Show notification with "Open Folder" action
+            showDownloadNotification(1, fileName);
+            
+            promise.resolve(publicPath);
+
+        } catch (Exception e) {
+            Log.e(TAG, "❌ [DOWNLOAD] ERROR", e);
+            promise.reject("DOWNLOAD_ERROR", e.getMessage());
+        }
+    }
+
+    /**
+     * Download using MediaStore API (Android 10+)
+     */
+    private String downloadUsingMediaStore(File sourceFile, String fileName, String mimeType) throws Exception {
+        Log.i(TAG, "📱 [MEDIASTORE] Using MediaStore API for Android 10+");
+
+        ContentResolver resolver = reactContext.getContentResolver();
+        
+        // Set up content values
+        ContentValues values = new ContentValues();
+        values.put(MediaStore.Downloads.DISPLAY_NAME, fileName);
+        values.put(MediaStore.Downloads.MIME_TYPE, mimeType);
+        values.put(MediaStore.Downloads.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS + "/" + FOLDER_NAME);
+        values.put(MediaStore.Downloads.IS_PENDING, 1); // Mark as pending while writing
+
+        Log.i(TAG, "📁 [MEDIASTORE] Creating entry in MediaStore...");
+        
+        // Insert into MediaStore
+        Uri uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, values);
+        
+        if (uri == null) {
+            throw new Exception("Failed to create MediaStore entry");
+        }
+
+        Log.i(TAG, "📁 [MEDIASTORE] URI created: " + uri.toString());
+        Log.i(TAG, "📥 [COPY] Copying file content...");
+
+        // Copy file content
+        try (InputStream in = new FileInputStream(sourceFile);
+             OutputStream out = resolver.openOutputStream(uri)) {
+            
+            if (out == null) {
+                throw new Exception("Failed to open output stream");
+            }
+
+            byte[] buffer = new byte[8192];
+            int bytesRead;
+            long totalBytes = 0;
+
+            while ((bytesRead = in.read(buffer)) != -1) {
+                out.write(buffer, 0, bytesRead);
+                totalBytes += bytesRead;
+            }
+
+            Log.i(TAG, "✅ [COPY] Copied " + totalBytes + " bytes");
+        }
+
+        // Mark as complete (no longer pending)
+        values.clear();
+        values.put(MediaStore.Downloads.IS_PENDING, 0);
+        resolver.update(uri, values, null, null);
+
+        Log.i(TAG, "✅ [MEDIASTORE] File published successfully");
+
+        // Return user-friendly path
+        String publicPath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+                + "/" + FOLDER_NAME + "/" + fileName;
+        
+        return publicPath;
+    }
+
+    /**
+     * Download using legacy storage (Android 9 and below)
+     */
+    private String downloadUsingLegacyStorage(File sourceFile, String fileName) throws Exception {
+        Log.i(TAG, "📱 [LEGACY] Using legacy storage for Android 9 and below");
+
+        // Get public Downloads directory
+        File downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
+        File appFolder = new File(downloadsDir, FOLDER_NAME);
+
+        // Create folder if needed
+        if (!appFolder.exists()) {
+            boolean created = appFolder.mkdirs();
+            Log.i(TAG, "📁 [LEGACY] Folder created: " + created);
+        }
+
+        File destFile = new File(appFolder, fileName);
+        Log.i(TAG, "📁 [LEGACY] Destination: " + destFile.getAbsolutePath());
+        Log.i(TAG, "📥 [COPY] Copying file...");
+
+        // Copy file
+        try (InputStream in = new FileInputStream(sourceFile);
+             OutputStream out = new java.io.FileOutputStream(destFile)) {
+            
+            byte[] buffer = new byte[8192];
+            int bytesRead;
+            long totalBytes = 0;
+
+            while ((bytesRead = in.read(buffer)) != -1) {
+                out.write(buffer, 0, bytesRead);
+                totalBytes += bytesRead;
+            }
+
+            Log.i(TAG, "✅ [COPY] Copied " + totalBytes + " bytes");
+        }
+
+        // Trigger media scanner for legacy devices
+        android.media.MediaScannerConnection.scanFile(
+            reactContext,
+            new String[]{destFile.getAbsolutePath()},
+            new String[]{getMimeType(fileName)},
+            null
+        );
+
+        Log.i(TAG, "✅ [LEGACY] Media scanner notified");
+
+        return destFile.getAbsolutePath();
+    }
+
+    /**
+     * Get MIME type from file extension
+     */
+    private String getMimeType(String fileName) {
+        if (fileName.endsWith(".pdf")) {
+            return "application/pdf";
+        } else if (fileName.endsWith(".png")) {
+            return "image/png";
+        } else if (fileName.endsWith(".jpeg") || fileName.endsWith(".jpg")) {
+            return "image/jpeg";
+        }
+        return "application/octet-stream";
+    }
+    
+    /**
+     * Show notification after successful download with "Open Folder" action
+     * @param fileCount Number of files downloaded
+     * @param fileName Name of the file (used for notification text)
+     */
+    private void showDownloadNotification(int fileCount, String fileName) {
+        try {
+            Log.i(TAG, "📱 [NOTIFICATION] Showing notification for " + fileCount + " file(s)");
+            
+            // Create intent to open Downloads/PDFDemoApp folder
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            Uri folderUri = Uri.parse("content://com.android.externalstorage.documents/document/primary:Download/" + FOLDER_NAME);
+            intent.setDataAndType(folderUri, "resource/folder");
+            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            
+            // Create pending intent with FLAG_IMMUTABLE for Android 12+
+            PendingIntent pendingIntent = PendingIntent.getActivity(
+                reactContext, 
+                0, 
+                intent, 
+                Build.VERSION.SDK_INT >= Build.VERSION_CODES.M 
+                    ? PendingIntent.FLAG_IMMUTABLE 
+                    : 0
+            );
+            
+            // Build notification
+            String contentText = fileCount + " file(s) saved to Downloads/" + FOLDER_NAME;
+            NotificationCompat.Builder builder = new NotificationCompat.Builder(reactContext, NOTIFICATION_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.ic_menu_save)
+                .setContentTitle("✅ Export Complete")
+                .setContentText(contentText)
+                .setStyle(new NotificationCompat.BigTextStyle().bigText(contentText))
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                .setContentIntent(pendingIntent)
+                .setAutoCancel(true)
+                .addAction(android.R.drawable.ic_menu_view, "Open Folder", pendingIntent);
+            
+            // Show notification
+            NotificationManagerCompat notificationManager = NotificationManagerCompat.from(reactContext);
+            notificationManager.notify(1001, builder.build());
+            
+            Log.i(TAG, "✅ [NOTIFICATION] Notification shown successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "❌ [NOTIFICATION] Failed to show notification", e);
+            // Don't throw - notification is non-critical
+        }
+    }
+}
+
+
+
+
+

package/android/src/main/java/org/wonday/pdf/FileManager.java

@@ -0,0 +1,123 @@
+package org.wonday.pdf;
+
+import android.app.DownloadManager;
+import android.content.Intent;
+import android.net.Uri;
+import android.util.Log;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+/**
+ * FileManager - Native module for file operations like opening folders
+ */
+public class FileManager extends ReactContextBaseJavaModule {
+    private static final String TAG = "FileManager";
+    private static final String FOLDER_NAME = "PDFDemoApp";
+    private final ReactApplicationContext reactContext;
+
+    public FileManager(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "FileManager";
+    }
+
+    /**
+     * Open the Downloads/PDFDemoApp folder in the file manager
+     * Multiple fallback strategies for maximum compatibility
+     */
+    @ReactMethod
+    public void openDownloadsFolder(Promise promise) {
+        try {
+            Log.i(TAG, "📂 [OPEN FOLDER] Attempting to open Downloads/" + FOLDER_NAME);
+            
+            // Strategy 1: Try to open specific Downloads/PDFDemoApp folder
+            try {
+                Intent specificIntent = new Intent(Intent.ACTION_VIEW);
+                Uri folderUri = Uri.parse("content://com.android.externalstorage.documents/document/primary:Download/" + FOLDER_NAME);
+                specificIntent.setDataAndType(folderUri, "resource/folder");
+                specificIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                
+                if (specificIntent.resolveActivity(reactContext.getPackageManager()) != null) {
+                    reactContext.startActivity(specificIntent);
+                    Log.i(TAG, "✅ [OPEN FOLDER] Opened specific folder via DocumentsUI");
+                    promise.resolve(true);
+                    return;
+                }
+            } catch (Exception e) {
+                Log.i(TAG, "📂 [OPEN FOLDER] Strategy 1 failed, trying fallback...");
+            }
+            
+            // Strategy 2: Open Downloads app
+            try {
+                Log.i(TAG, "📂 [OPEN FOLDER] Trying Downloads app");
+                Intent downloadsIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
+                downloadsIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                
+                if (downloadsIntent.resolveActivity(reactContext.getPackageManager()) != null) {
+                    reactContext.startActivity(downloadsIntent);
+                    Log.i(TAG, "✅ [OPEN FOLDER] Opened Downloads app");
+                    promise.resolve(true);
+                    return;
+                }
+            } catch (Exception e) {
+                Log.i(TAG, "📂 [OPEN FOLDER] Strategy 2 failed, trying fallback...");
+            }
+            
+            // Strategy 3: Open Files app with generic CATEGORY_APP_FILES intent
+            try {
+                Log.i(TAG, "📂 [OPEN FOLDER] Trying Files app");
+                Intent filesIntent = new Intent(Intent.ACTION_VIEW);
+                filesIntent.addCategory(Intent.CATEGORY_DEFAULT);
+                filesIntent.setType("resource/folder");
+                filesIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                
+                if (filesIntent.resolveActivity(reactContext.getPackageManager()) != null) {
+                    reactContext.startActivity(filesIntent);
+                    Log.i(TAG, "✅ [OPEN FOLDER] Opened Files app");
+                    promise.resolve(true);
+                    return;
+                }
+            } catch (Exception e) {
+                Log.i(TAG, "📂 [OPEN FOLDER] Strategy 3 failed");
+            }
+            
+            // Strategy 4: Try to launch any file manager using generic intent
+            try {
+                Log.i(TAG, "📂 [OPEN FOLDER] Trying generic file manager");
+                Intent genericIntent = new Intent(Intent.ACTION_GET_CONTENT);
+                genericIntent.setType("*/*");
+                genericIntent.addCategory(Intent.CATEGORY_OPENABLE);
+                genericIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                
+                if (genericIntent.resolveActivity(reactContext.getPackageManager()) != null) {
+                    reactContext.startActivity(Intent.createChooser(genericIntent, "Open File Manager"));
+                    Log.i(TAG, "✅ [OPEN FOLDER] Opened file picker");
+                    promise.resolve(true);
+                    return;
+                }
+            } catch (Exception e) {
+                Log.i(TAG, "📂 [OPEN FOLDER] Strategy 4 failed");
+            }
+            
+            // All strategies failed
+            Log.w(TAG, "⚠️ [OPEN FOLDER] All strategies failed - no file manager available");
+            promise.reject("NO_FILE_MANAGER", "No file manager app available on this device");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "❌ [OPEN FOLDER] ERROR", e);
+            promise.reject("OPEN_FOLDER_ERROR", e.getMessage());
+        }
+    }
+}
+
+
+
+
+