Added sound notification assets + build copy files script.

Author: digitalnomad91

assets/sounds/notification.aiff

@@ -0,0 +1,41 @@
+const fs = require("fs-extra");
+const path = require("path");
+
+const SOUNDS_SRC = path.resolve(__dirname, "../assets/sounds");
+const ANDROID_SOUNDS_DEST = path.resolve(
+  __dirname,
+  "../android/app/src/main/res/raw"
+);
+const IOS_SOUNDS_DEST = path.resolve(
+  __dirname,
+  "../ios/CodeBuilderAdmin/Sounds"
+); // Replace "YourAppName"
+
+async function copySounds() {
+  try {
+    // Copy to Android (filter for Android-supported formats)
+    await fs.ensureDir(ANDROID_SOUNDS_DEST);
+    await fs.copy(SOUNDS_SRC, ANDROID_SOUNDS_DEST, {
+      filter: (src) => {
+        const ext = path.extname(src).toLowerCase();
+        return [".mp3", ".wav", ".ogg"].includes(ext); // Android formats
+      },
+    });
+    console.log("✅ Sounds copied to Android");
+
+    // Copy to iOS (filter for iOS-supported formats)
+    await fs.ensureDir(IOS_SOUNDS_DEST);
+    await fs.copy(SOUNDS_SRC, IOS_SOUNDS_DEST, {
+      filter: (src) => {
+        const ext = path.extname(src).toLowerCase();
+        return [".aiff", ".caf", ".wav"].includes(ext); // iOS formats
+      },
+    });
+    console.log("✅ Sounds copied to iOS");
+  } catch (err) {
+    console.error("❌ Error copying sounds:", err);
+    process.exit(1);
+  }
+}
+
+copySounds();

assets/sounds/notification.caf

@@ -2,39 +2,23 @@ const path = require("path");
 const fs = require("fs");
 
 const androidBasePath = path.join(__dirname, "../android/app/src/main");
-const javaOrKotlinBasePath = path.join(
+const kotlinBasePath = path.join(
   androidBasePath,
   "java/com/digitalnomad91/codebuilderadmin"
 );
 
 const androidManifestPath = path.join(androidBasePath, "AndroidManifest.xml");
-const mainActivityPathKotlin = path.join(
-  javaOrKotlinBasePath,
-  "MainActivity.kt"
-);
-const serviceKotlinPath = path.join(
-  javaOrKotlinBasePath,
-  "ScreenRecordService.kt"
-);
-
-// Clean up potential duplicate in old java directory
-const oldJavaServicePath = path.join(
-  androidBasePath,
-  "java/com/digitalnomad91/codebuilderadmin/ScreenRecordService.kt"
-);
-if (fs.existsSync(oldJavaServicePath)) {
-  fs.unlinkSync(oldJavaServicePath);
-  console.log("🧹 Removed duplicate service file from java directory");
-}
+const mainActivityPath = path.join(kotlinBasePath, "MainActivity.kt");
+const servicePath = path.join(kotlinBasePath, "ScreenRecordService.kt");
 
 const ensurePermissions = () => {
   if (!fs.existsSync(androidManifestPath)) {
-    console.error("AndroidManifest.xml not found.");
+    console.error("❌ AndroidManifest.xml not found");
     return;
   }
 
   let manifestContent = fs.readFileSync(androidManifestPath, "utf8");
-  const permissions = [
+  const requiredPermissions = [
     "android.permission.RECORD_AUDIO",
     "android.permission.FOREGROUND_SERVICE",
     "android.permission.SYSTEM_ALERT_WINDOW",
@@ -44,148 +28,185 @@ const ensurePermissions = () => {
   ];
 
   let modified = false;
-  permissions.forEach((permission) => {
+  requiredPermissions.forEach((permission) => {
     if (!manifestContent.includes(permission)) {
       manifestContent = manifestContent.replace(
         "</manifest>",
-        `    <uses-permission android:name="${permission}"/>\n</manifest>`
+        `    <uses-permission android:name="${permission}" />\n</manifest>`
       );
       modified = true;
     }
   });
 
   if (modified) {
     fs.writeFileSync(androidManifestPath, manifestContent, "utf8");
-    console.log("✅ AndroidManifest.xml updated with permissions.");
+    console.log("✅ AndroidManifest.xml permissions updated");
   } else {
-    console.log("✅ AndroidManifest.xml has necessary permissions.");
+    console.log("✅ AndroidManifest.xml has required permissions");
   }
 };
 
 const ensureMainActivityModifications = () => {
-  if (!fs.existsSync(mainActivityPathKotlin)) {
-    console.error("❌ MainActivity.kt not found.");
+  if (!fs.existsSync(mainActivityPath)) {
+    console.error("❌ MainActivity.kt not found");
     return;
   }
 
-  let content = fs.readFileSync(mainActivityPathKotlin, "utf8");
+  let content = fs.readFileSync(mainActivityPath, "utf8");
+
+  // Clean up duplicate imports
+  const importsToManage = [
+    "android.os.Bundle",
+    "android.content.Context",
+    "android.content.Intent",
+    "android.media.projection.MediaProjectionManager",
+  ];
+
+  importsToManage.forEach((imp) => {
+    const importRegex = new RegExp(`import ${imp}[\n\r]`, "g");
+    if ((content.match(importRegex) || []).length > 1) {
+      content = content.replace(importRegex, "");
+      content = `import ${imp}\n${content}`;
+    }
+  });
+
+  // Ensure required imports exist
+  const requiredImports = `
+import android.os.Bundle
+import android.content.Context
+import android.content.Intent
+import android.media.projection.MediaProjectionManager
+  `.trim();
+
+  if (!content.includes("MediaProjectionManager")) {
+    content = content.replace(
+      /import com\.facebook\.react\.ReactActivity/,
+      `import com.facebook.react.ReactActivity\n${requiredImports}`
+    );
+  }
+
+  // Injection code with null safety and proper overrides
   const injectionCode = `
     private val SCREEN_RECORD_REQUEST_CODE = 1001
-    private var projectionManager: MediaProjectionManager? = null
+    private lateinit var projectionManager: MediaProjectionManager
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         projectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
     }
 
     fun startScreenRecording() {
-        val intent = projectionManager?.createScreenCaptureIntent()
-        startActivityForResult(intent, SCREEN_RECORD_REQUEST_CODE)
+        val captureIntent = projectionManager.createScreenCaptureIntent()
+        startActivityForResult(captureIntent, SCREEN_RECORD_REQUEST_CODE)
     }
 
     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
         super.onActivityResult(requestCode, resultCode, data)
-        if (requestCode == SCREEN_RECORD_REQUEST_CODE) {
-            val serviceIntent = Intent(this, ScreenRecordService::class.java)
-            serviceIntent.putExtra("RESULT_CODE", resultCode)
-            serviceIntent.putExtra("DATA", data)
-            startForegroundService(serviceIntent)
+        if (requestCode == SCREEN_RECORD_REQUEST_CODE && data != null) {
+            Intent(this, ScreenRecordService::class.java).apply {
+                putExtra("RESULT_CODE", resultCode)
+                putExtra("DATA", data)
+                startForegroundService(this)
+            }
         }
     }
-    `;
-
-  // Add imports if missing
-  if (
-    !content.includes("import android.media.projection.MediaProjectionManager")
-  ) {
-    content = content.replace(
-      "import com.facebook.react.ReactActivity",
-      `import com.facebook.react.ReactActivity
-import android.content.Context
-import android.content.Intent
-import android.media.projection.MediaProjectionManager
-import android.os.Bundle`
-    );
-  }
+  `.trim();
 
   if (!content.includes("SCREEN_RECORD_REQUEST_CODE")) {
+    // Remove any existing duplicate code
+    const duplicateCodePatterns = [
+      /private val SCREEN_RECORD_REQUEST_CODE = \d+/,
+      /override fun onCreate\(.*?\)\s*\{[\s\S]*?\}/,
+      /fun startScreenRecording\(\)\s*\{[\s\S]*?\}/,
+      /override fun onActivityResult\(.*?\)\s*\{[\s\S]*?\}/,
+    ];
+
+    duplicateCodePatterns.forEach((pattern) => {
+      content = content.replace(pattern, "");
+    });
+
+    // Insert new code
     content = content.replace(
-      /class MainActivity : ReactActivity\(\) \{/,
-      `class MainActivity : ReactActivity() {${injectionCode}`
+      /class MainActivity : ReactActivity\(\)\s*\{/,
+      `class MainActivity : ReactActivity() {\n${injectionCode}\n`
     );
-    fs.writeFileSync(mainActivityPathKotlin, content, "utf8");
-    console.log("✅ MainActivity.kt updated.");
+
+    fs.writeFileSync(mainActivityPath, content, "utf8");
+    console.log("✅ MainActivity.kt updated with proper implementations");
   } else {
-    console.log("✅ MainActivity already modified.");
+    console.log("✅ MainActivity already contains correct code");
   }
 };
 
 const ensureScreenRecordService = () => {
-  const serviceDir = path.dirname(serviceKotlinPath);
-  if (!fs.existsSync(serviceDir)) {
-    fs.mkdirSync(serviceDir, { recursive: true });
-    console.log("✅ Created service directory");
+  if (!fs.existsSync(kotlinBasePath)) {
+    fs.mkdirSync(kotlinBasePath, { recursive: true });
   }
 
-  if (!fs.existsSync(serviceKotlinPath)) {
+  if (!fs.existsSync(servicePath)) {
     const serviceCode = `package com.digitalnomad91.codebuilderadmin
 
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.Service
 import android.content.Intent
-import android.media.projection.MediaProjection
 import android.os.Build
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.digitalnomad91.codebuilderadmin.R
 
 class ScreenRecordService : Service() {
-    private val CHANNEL_ID = "ScreenRecordChannel"
-    private var mediaProjection: MediaProjection? = null
+    companion object {
+        const val CHANNEL_ID = "ScreenRecorderChannel"
+    }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        createNotification()
+        createNotificationChannel()
+        startForeground(1, createNotification())
         return START_STICKY
     }
 
-    private fun createNotification() {
+    private fun createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel = NotificationChannel(
                 CHANNEL_ID,
                 "Screen Recording",
                 NotificationManager.IMPORTANCE_LOW
-            )
-            val manager = getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
+            ).apply {
+                description = "Recording screen activity"
+            }
+            (getSystemService(NOTIFICATION_SERVICE) as NotificationManager)
+                .createNotificationChannel(channel)
         }
+    }
 
-        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+    private fun createNotification(): Notification {
+        return NotificationCompat.Builder(this, CHANNEL_ID)
             .setContentTitle("Screen Recording")
-            .setContentText("Your screen is being recorded")
+            .setContentText("Recording in progress")
             .setSmallIcon(R.mipmap.ic_launcher_foreground)
             .build()
-
-        startForeground(1, notification)
     }
 
     override fun onBind(intent: Intent?): IBinder? = null
 }
 `;
-    fs.writeFileSync(serviceKotlinPath, serviceCode, "utf8");
-    console.log("✅ ScreenRecordService.kt created.");
+    fs.writeFileSync(servicePath, serviceCode, "utf8");
+    console.log("✅ ScreenRecordService.kt created");
   } else {
-    console.log("✅ ScreenRecordService.kt exists.");
+    console.log("✅ ScreenRecordService.kt exists");
   }
 };
 
-// Execute all steps
+// Execute all steps with error handling
 try {
+  console.log("\n🚀 Starting screen recording setup...");
   ensurePermissions();
   ensureMainActivityModifications();
   ensureScreenRecordService();
-  console.log("🎉 Screen recording setup completed!");
+  console.log("🎉 Screen recording setup completed successfully!\n");
 } catch (error) {
-  console.error("❌ Setup failed:", error);
+  console.error("\n❌ Setup failed:", error.message);
+  process.exit(1);
 }