react-native-custom-splash 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,278 @@
+# react-native-custom-splash
+
+A custom splash screen module for React Native with native iOS and Android support, fully compatible with Expo.
+
+## Features
+
+- ✅ **Native iOS & Android** splash screens
+- ✅ **Expo compatible** with config plugin
+- ✅ **Customizable** splash images
+- ✅ **Animated transitions** for smooth hiding
+- ✅ **TypeScript** support
+- ✅ **Auto-show** on app launch
+- ✅ **Manual control** with show/hide methods
+
+## Installation
+
+### For Expo Projects
+
+```bash
+npm install react-native-custom-splash
+# or
+yarn add react-native-custom-splash
+```
+
+Add the plugin to your `app.json` or `app.config.js`:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      "react-native-custom-splash"
+    ]
+  }
+}
+```
+
+Then run prebuild:
+
+```bash
+npx expo prebuild
+```
+
+### For Bare React Native Projects
+
+```bash
+npm install react-native-custom-splash
+# or
+yarn add react-native-custom-splash
+```
+
+#### iOS Setup
+
+1. Install pods:
+```bash
+cd ios && pod install && cd ..
+```
+
+2. The module will be automatically linked.
+
+#### Android Setup
+
+1. Add the package to your `MainApplication.kt`:
+
+```kotlin
+import com.rncustomsplash.SplashScreenPackage
+
+// In getPackages() method:
+packages.add(SplashScreenPackage())
+```
+
+2. Show splash in `MainActivity.kt`:
+
+```kotlin
+import com.rncustomsplash.SplashScreenModule
+
+override fun onCreate(savedInstanceState: Bundle?) {
+    SplashScreenModule.show(this)
+    super.onCreate(savedInstanceState)
+}
+```
+
+## Adding Custom Splash Images
+
+### iOS
+
+Add your splash image to your Xcode project:
+1. Open your project in Xcode
+2. Add an image asset named `splash` to your Assets catalog
+3. Or add a `splash.png` file to your project
+
+### Android
+
+Add your splash image to Android resources:
+1. Add `splash.png` (or `splash.jpg`) to `android/app/src/main/res/drawable/`
+2. Or create a drawable resource named `splash`
+
+You can also customize the background color in `android/app/src/main/res/values/colors.xml`:
+
+```xml
+<color name="splash_background">#FFFFFF</color>
+```
+
+## Usage
+
+```typescript
+import SplashScreen from 'react-native-custom-splash';
+import { useEffect } from 'react';
+
+function App() {
+  useEffect(() => {
+    // Hide splash screen after app is ready
+    // The splash screen shows automatically on launch
+    
+    // Simple hide (instant)
+    SplashScreen.hide(false);
+    
+    // Or with animation
+    SplashScreen.hide(true);
+    
+    // You can also show it again
+    // SplashScreen.show();
+  }, []);
+
+  return (
+    // Your app content
+  );
+}
+```
+
+## Example Project
+
+A complete working example is included in the `example/` directory. It demonstrates:
+
+- ✅ Automatic splash screen on launch
+- ✅ Loading progress simulation
+- ✅ Animated hide transitions
+- ✅ Manual show/hide controls
+- ✅ Full TypeScript integration
+
+### Run the Example
+
+```bash
+cd example
+npm install
+npx expo prebuild
+npm run ios  # or npm run android
+```
+
+See [example/README.md](./example/README.md) for detailed instructions.
+
+## API Reference
+
+### `SplashScreen.show()`
+
+Shows the splash screen.
+
+```typescript
+SplashScreen.show();
+```
+
+### `SplashScreen.hide(animated?)`
+
+Hides the splash screen.
+
+**Parameters:**
+- `animated` (boolean, optional): Whether to animate the hide transition. Default: `false`
+
+**Returns:** `Promise<boolean>` - Resolves to `true` if successful
+
+```typescript
+// Hide instantly
+await SplashScreen.hide();
+
+// Hide with fade animation
+await SplashScreen.hide(true);
+```
+
+## Example
+
+```typescript
+import React, { useEffect, useState } from 'react';
+import { View, Text, ActivityIndicator } from 'react-native';
+import SplashScreen from 'react-native-custom-splash';
+
+export default function App() {
+  const [appIsReady, setAppIsReady] = useState(false);
+
+  useEffect(() => {
+    async function prepare() {
+      try {
+        // Load your resources here
+        await loadFonts();
+        await loadData();
+        
+        // Artificially delay for demo
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      } catch (e) {
+        console.warn(e);
+      } finally {
+        setAppIsReady(true);
+      }
+    }
+
+    prepare();
+  }, []);
+
+  useEffect(() => {
+    if (appIsReady) {
+      // Hide splash screen with animation when app is ready
+      SplashScreen.hide(true);
+    }
+  }, [appIsReady]);
+
+  if (!appIsReady) {
+    return null; // Splash screen is visible
+  }
+
+  return (
+    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+      <Text>App is ready!</Text>
+    </View>
+  );
+}
+```
+
+## Troubleshooting
+
+### iOS
+
+**Module not found:**
+- Make sure you ran `pod install` in the `ios/` directory
+- Clean build folder: `cd ios && rm -rf build && cd ..`
+- Rebuild the app
+
+**Splash image not showing:**
+- Verify the image is named `splash` in your Assets catalog
+- Check that the image is added to the target
+
+### Android
+
+**Module not found:**
+- Verify `SplashScreenPackage()` is added to `MainApplication.kt`
+- Clean build: `cd android && ./gradlew clean && cd ..`
+- Rebuild the app
+
+**Splash image not showing:**
+- Check that `splash.png` exists in `res/drawable/`
+- Verify the resource name matches in `splash_screen.xml`
+
+### Expo
+
+**Plugin not working:**
+- Make sure you added the plugin to `app.json`
+- Run `npx expo prebuild --clean`
+- Rebuild the app
+
+## TypeScript
+
+This package includes TypeScript definitions. The module exports the following interface:
+
+```typescript
+interface SplashScreenInterface {
+  show(): void;
+  hide(animated?: boolean): Promise<boolean>;
+}
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Issues
+
+If you encounter any issues, please file them on the GitHub repository.

package/android/build.gradle

@@ -0,0 +1,52 @@
+buildscript {
+    ext.kotlin_version = '1.8.0'
+    
+    repositories {
+        google()
+        mavenCentral()
+    }
+    
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 33
+    
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0.0"
+    }
+    
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+    
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+    
+    kotlinOptions {
+        jvmTarget = '11'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.rncustomsplash">
+</manifest>

package/android/src/main/java/com/rncustomsplash/SplashScreenModule.kt

@@ -0,0 +1,111 @@
+package com.rncustomsplash
+
+import android.app.Dialog
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.os.Build
+import android.view.View
+import android.view.WindowManager
+import androidx.appcompat.app.AppCompatActivity
+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 com.facebook.react.bridge.UiThreadUtil
+
+class SplashScreenModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        private var splashDialog: Dialog? = null
+        private var isVisible = false
+
+        @JvmStatic
+        fun show(activity: AppCompatActivity) {
+            if (isVisible) return
+
+            UiThreadUtil.runOnUiThread {
+                try {
+                    splashDialog = Dialog(activity, android.R.style.Theme_NoTitleBar_Fullscreen).apply {
+                        setContentView(R.layout.splash_screen)
+                        setCancelable(false)
+                        window?.apply {
+                            setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
+                            
+                            // Make splash screen full screen
+                            setFlags(
+                                WindowManager.LayoutParams.FLAG_FULLSCREEN,
+                                WindowManager.LayoutParams.FLAG_FULLSCREEN
+                            )
+                            
+                            // For API 30+, use WindowInsetsController
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                                setDecorFitsSystemWindows(false)
+                            } else {
+                                @Suppress("DEPRECATION")
+                                decorView.systemUiVisibility = (
+                                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                                    or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                                    or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                                    or View.SYSTEM_UI_FLAG_FULLSCREEN
+                                    or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+                                )
+                            }
+                        }
+                        show()
+                    }
+                    isVisible = true
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    override fun getName(): String {
+        return "SplashScreen"
+    }
+
+    @ReactMethod
+    fun show() {
+        reactApplicationContext.currentActivity?.let { activity ->
+            if (activity is AppCompatActivity) {
+                show(activity)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun hide(animated: Boolean, promise: Promise) {
+        if (!isVisible) {
+            promise.resolve(false)
+            return
+        }
+
+        UiThreadUtil.runOnUiThread {
+            try {
+                splashDialog?.let { dialog ->
+                    if (animated) {
+                        // Add fade out animation
+                        dialog.window?.decorView?.animate()
+                            ?.alpha(0f)
+                            ?.setDuration(300)
+                            ?.withEndAction {
+                                dialog.dismiss()
+                                splashDialog = null
+                                isVisible = false
+                            }
+                            ?.start()
+                    } else {
+                        dialog.dismiss()
+                        splashDialog = null
+                        isVisible = false
+                    }
+                }
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("ERROR", e.message)
+            }
+        }
+    }
+}

package/android/src/main/java/com/rncustomsplash/SplashScreenPackage.kt

@@ -0,0 +1,16 @@
+package com.rncustomsplash
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class SplashScreenPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(SplashScreenModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/res/drawable/splash.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@color/splash_background"/>
+    <item>
+        <!-- This is a placeholder. Users will replace with their own splash image -->
+        <shape android:shape="rectangle">
+            <solid android:color="@color/splash_background"/>
+        </shape>
+    </item>
+</layer-list>

package/android/src/main/res/layout/splash_screen.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/splash_background"
+    android:gravity="center"
+    android:orientation="vertical">
+
+    <ImageView
+        android:id="@+id/splash_image"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:scaleType="centerCrop"
+        android:src="@drawable/splash" />
+
+</LinearLayout>

package/android/src/main/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="splash_background">#FFFFFF</color>
+</resources>

package/ios/SplashScreenModule.m

@@ -0,0 +1,23 @@
+//
+//  SplashScreenModule.m
+//  RNCustomSplash
+//
+//  Bridge for SplashScreenModule
+//
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(SplashScreen, NSObject)
+
+RCT_EXTERN_METHOD(show)
+
+RCT_EXTERN_METHOD(hide:(BOOL)animated
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/SplashScreenModule.swift

@@ -0,0 +1,114 @@
+//
+//  SplashScreenModule.swift
+//  RNCustomSplash
+//
+//  Custom Native Splash Screen Module for iOS
+//
+
+import Foundation
+import UIKit
+import React
+
+@objc(SplashScreen)
+class SplashScreenModule: NSObject {
+  
+  private static var splashWindow: UIWindow?
+  private static var isVisible = false
+  
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+  
+  override init() {
+    super.init()
+    // Show splash automatically when module initializes
+    DispatchQueue.main.async {
+      SplashScreenModule.showSplashScreen()
+    }
+  }
+  
+  private static func showSplashScreen() {
+    guard !isVisible else { return }
+    
+    if let scene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
+      let window = UIWindow(windowScene: scene)
+      window.windowLevel = .alert + 1
+      window.backgroundColor = .white
+      
+      // Create splash view controller
+      let splashVC = UIViewController()
+      splashVC.view.backgroundColor = .white
+      
+      // Try to load splash image from the main bundle
+      // Users should add their splash image to their app's assets
+      if let splashImage = UIImage(named: "splash") {
+        let imageView = UIImageView(image: splashImage)
+        imageView.contentMode = .scaleAspectFill
+        imageView.frame = splashVC.view.bounds
+        imageView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        splashVC.view.addSubview(imageView)
+      } else {
+        // Fallback: show white screen if no splash image is provided
+        if #available(iOS 13.0, *) {
+          splashVC.view.backgroundColor = .systemBackground
+        } else {
+          splashVC.view.backgroundColor = .white
+        }
+      }
+      
+      window.rootViewController = splashVC
+      window.makeKeyAndVisible()
+      
+      splashWindow = window
+      isVisible = true
+    }
+  }
+  
+  @objc
+  func show() {
+    DispatchQueue.main.async {
+      SplashScreenModule.showSplashScreen()
+    }
+  }
+  
+  @objc
+  func hide(_ animated: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      guard SplashScreenModule.isVisible, let window = SplashScreenModule.splashWindow else {
+        resolve(false)
+        return
+      }
+      
+      if animated {
+        UIView.animate(withDuration: 0.3, animations: {
+          window.alpha = 0
+        }) { _ in
+          window.isHidden = true
+          window.rootViewController = nil
+          SplashScreenModule.splashWindow = nil
+          SplashScreenModule.isVisible = false
+          
+          // Ensure the main window becomes key again
+          if let mainWindow = UIApplication.shared.windows.first(where: { $0.rootViewController != nil && $0 != window }) {
+            mainWindow.makeKeyAndVisible()
+          }
+          
+          resolve(true)
+        }
+      } else {
+        window.isHidden = true
+        window.rootViewController = nil
+        SplashScreenModule.splashWindow = nil
+        SplashScreenModule.isVisible = false
+        
+        // Ensure the main window becomes key again
+        if let mainWindow = UIApplication.shared.windows.first(where: { $0.rootViewController != nil && $0 != window }) {
+          mainWindow.makeKeyAndVisible()
+        }
+        
+        resolve(true)
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "react-native-custom-splash",
+    "version": "1.0.0",
+    "description": "A custom splash screen module for React Native with native iOS and Android support, fully compatible with Expo",
+    "main": "src/index.js",
+    "types": "src/index.d.ts",
+    "scripts": {
+        "test": "echo \"No tests yet\"",
+        "prepare": "echo \"Package prepared\""
+    },
+    "keywords": [
+        "react-native",
+        "expo",
+        "splash-screen",
+        "splash",
+        "ios",
+        "android",
+        "native-module"
+    ],
+    "author": "Your Name",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/vijaykishan312/react-native-custom-splash.git"
+    },
+    "peerDependencies": {
+        "react": "*",
+        "react-native": "*",
+        "expo": "*"
+    },
+    "devDependencies": {
+        "@types/react": "^18.0.0",
+        "@types/react-native": "^0.72.0",
+        "typescript": "^5.0.0"
+    },
+    "files": [
+        "src/",
+        "ios/",
+        "android/",
+        "plugin/",
+        "react-native-custom-splash.podspec",
+        "README.md",
+        "LICENSE"
+    ]
+}

package/plugin/src/index.js

@@ -0,0 +1,89 @@
+const {
+    withDangerousMod,
+    withPlugins,
+    withMainActivity,
+    withMainApplication,
+} = require('@expo/config-plugins');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Plugin to add SplashScreenModule to Android
+ */
+const withSplashScreenAndroid = (config) => {
+    // Add package to MainApplication
+    config = withMainApplication(config, async (config) => {
+        const { modResults } = config;
+        let contents = modResults.contents;
+
+        // Add import if not already present
+        if (!contents.includes('import com.rncustomsplash.SplashScreenPackage')) {
+            contents = contents.replace(
+                /(package\s+[\w.]+)/,
+                '$1\nimport com.rncustomsplash.SplashScreenPackage'
+            );
+        }
+
+        // Add package to packages list
+        if (!contents.includes('SplashScreenPackage()')) {
+            contents = contents.replace(
+                /(packages\.apply\s*{[^}]*)/,
+                '$1\n              add(SplashScreenPackage())'
+            );
+        }
+
+        modResults.contents = contents;
+        return config;
+    });
+
+    // Add splash initialization to MainActivity
+    config = withMainActivity(config, async (config) => {
+        const { modResults } = config;
+        let contents = modResults.contents;
+
+        // Add import if not already present
+        if (!contents.includes('import com.rncustomsplash.SplashScreenModule')) {
+            contents = contents.replace(
+                /(package\s+[\w.]+)/,
+                '$1\nimport com.rncustomsplash.SplashScreenModule'
+            );
+        }
+
+        // Add splash show in onCreate
+        if (!contents.includes('SplashScreenModule.show(this)')) {
+            contents = contents.replace(
+                /(override\s+fun\s+onCreate\([^)]*\)\s*{)/,
+                '$1\n    // Show splash screen\n    SplashScreenModule.show(this)\n'
+            );
+        }
+
+        modResults.contents = contents;
+        return config;
+    });
+
+    return config;
+};
+
+/**
+ * Plugin to add SplashScreenModule to iOS
+ */
+const withSplashScreenIOS = (config) => {
+    return withDangerousMod(config, [
+        'ios',
+        async (config) => {
+            // The native files will be linked via CocoaPods
+            // No additional configuration needed here
+            return config;
+        },
+    ]);
+};
+
+/**
+ * Main plugin export
+ */
+module.exports = (config) => {
+    return withPlugins(config, [
+        withSplashScreenAndroid,
+        withSplashScreenIOS,
+    ]);
+};

package/react-native-custom-splash.podspec

@@ -0,0 +1,18 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "../package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RNCustomSplash"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]["url"]
+  s.license      = package["license"]
+  s.authors      = { package["author"] => "" }
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "*.{h,m,mm,swift}"
+  
+  s.dependency "React-Core"
+end

package/src/index.js

@@ -0,0 +1,3 @@
+// JavaScript entry point (transpiled from TypeScript)
+export { default } from './index.tsx';
+export type { SplashScreenInterface } from './index.tsx';

package/src/index.tsx

@@ -0,0 +1,69 @@
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'react-native-custom-splash' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- Run 'pod install' in the ios/ directory\n", default: '' }) +
+  '- Rebuild the app after installing the package\n' +
+  '- If you are using Expo, run npx expo prebuild\n';
+
+// Try both module names for compatibility
+const SplashScreenModule =
+  NativeModules.SplashScreen || NativeModules.SplashScreenModule;
+
+if (!SplashScreenModule) {
+  throw new Error(LINKING_ERROR);
+}
+
+if (__DEV__ && !SplashScreenModule) {
+  console.error(
+    '❌ SplashScreen native module not found!',
+    '\nAvailable modules:',
+    Object.keys(NativeModules).filter((m) => m.includes('Splash'))
+  );
+}
+
+export interface SplashScreenInterface {
+  /**
+   * Show the splash screen
+   */
+  show(): void;
+  
+  /**
+   * Hide the splash screen
+   * @param animated - Whether to animate the hide transition (default: false)
+   * @returns Promise that resolves to true if successful
+   */
+  hide(animated?: boolean): Promise<boolean>;
+}
+
+const SplashScreen: SplashScreenInterface = {
+  show: () => {
+    if (SplashScreenModule?.show) {
+      if (__DEV__) {
+        console.log('📱 Calling SplashScreen.show()');
+      }
+      SplashScreenModule.show();
+    } else {
+      console.warn('⚠️ SplashScreen.show() not available');
+    }
+  },
+  
+  hide: async (animated: boolean = false): Promise<boolean> => {
+    if (SplashScreenModule?.hide) {
+      if (__DEV__) {
+        console.log('📱 Calling SplashScreen.hide(animated:', animated, ')');
+      }
+      try {
+        return await SplashScreenModule.hide(animated);
+      } catch (error) {
+        console.error('❌ Error hiding splash screen:', error);
+        return false;
+      }
+    } else {
+      console.warn('⚠️ SplashScreen.hide() not available');
+      return false;
+    }
+  },
+};
+
+export default SplashScreen;