CB-10820 Updated version and RELEASENOTES.md for release 3.2.1

The fading logic exposed a race condition in an edge case when the
plugin was repeatedly reinitialized, e.g. when the WebView tries to load
a new URL. To address this, we add a flag to removeSplashScreen() that
allows the fade logic to be bypassed in certain circumstances --
specifically, when hiding the splashscreen due to onPause or onDestroy
events. By hiding it immediately in this scenario, we can avoid any race
conditions due to the fade delay.

github: close #86

.jshintrc

@@ -0,0 +1,16 @@
+{
+    "browser": true
+  , "devel": true
+  , "bitwise": true
+  , "undef": true
+  , "trailing": true
+  , "quotmark": false
+  , "indent": 4
+  , "unused": "vars"
+  , "latedef": "nofunc"
+  , "globals": {
+        "module": false,
+        "exports": false,
+        "require": false
+    }
+}

.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+sudo: false
+node_js:
+  - "4.2"

README.md

@@ -17,11 +17,13 @@
 #         under the License.
 -->
 
+[![Build Status](https://travis-ci.org/apache/cordova-plugin-splashscreen.svg?branch=master)](https://travis-ci.org/apache/cordova-plugin-splashscreen)
+
 # cordova-plugin-splashscreen
 
 This plugin displays and hides a splash screen during application launch.
 
-:warning: Report issues on the [Apache Cordova issue tracker](https://issues.apache.org/jira/issues/?jql=project%20%3D%20CB%20AND%20status%20in%20%28Open%2C%20%22In%20Progress%22%2C%20Reopened%29%20AND%20resolution%20%3D%20Unresolved%20AND%20component%20%3D%20%22Plugin%20Splashscreen%22%20ORDER%20BY%20priority%20DESC%2C%20summary%20ASC%2C%20updatedDate%20DESC)
+Report issues with this plugin on the [Apache Cordova issue tracker][Apache Cordova issue tracker].
 
 ## Installation
 
@@ -66,6 +68,7 @@ In your `config.xml`, you need to add the following preferences:
     <preference name="SplashScreen" value="foo" />
     <preference name="SplashScreenDelay" value="3000" />
     <preference name="SplashMaintainAspectRatio" value="true|false" />
+    <preference name="SplashShowOnlyFirstTime" value="true|false" />
 
 Where foo is the name of the splashscreen file, preferably a 9 patch file. Make sure to add your splashcreen files to your res/xml directory under the appropriate folders. The second parameter represents how long the splashscreen will appear in milliseconds. It defaults to 3000 ms. See [Icons and Splash Screens](http://cordova.apache.org/docs/en/edge/config_ref_images.md.html)
 for more information.
@@ -74,12 +77,14 @@ for more information.
 
 The plugin reloads splash drawable whenever orientation changes, so you can specify different drawables for portrait and landscape orientations.
 
+"SplashShowOnlyFirstTime" preference is also optional and defaults to `true`. When set to `true` splash screen will only appear on application launch. However, if you plan to use `navigator.app.exitApp()` to close application and force splash screen appear on next launch, you should set this property to `false` (this also applies to closing the App with Back button).
+
 ### Browser Quirks
 
 You can use the following preferences in your `config.xml`:
 
     <platform name="browser">
-        <preference name="SplashScreen" value="images/browser/splashscreen.jpg" /> <!-- defaults to "img/logo.png" -->
+        <preference name="SplashScreen" value="/images/browser/splashscreen.jpg" /> <!-- defaults to "/img/logo.png" -->
         <preference name="SplashScreenDelay" value="3000" /> <!-- defaults to "3000" -->
         <preference name="SplashScreenBackgroundColor" value="green" /> <!-- defaults to "#464646" -->
         <preference name="ShowSplashScreen" value="false" /> <!-- defaults to "true" -->
@@ -87,8 +92,9 @@ You can use the following preferences in your `config.xml`:
         <preference name="SplashScreenHeight" value="300" /> <!-- defaults to "200" -->
     </platform>
 
+__Note__: `SplashScreen` value should be absolute in order to work in a sub-page.
 
-### iOS Quirks
+### Android and iOS Quirks
 
 - `FadeSplashScreen` (boolean, defaults to `true`): Set to `false` to
   prevent the splash screen from fading in and out when its display
@@ -103,6 +109,22 @@ You can use the following preferences in your `config.xml`:
 
 Note also that this value used to be seconds, and not milliseconds, so values less than 30 will still be treated as seconds. ( Consider this a deprecated patch that will disapear in some future version. )
 
+_Note_: `FadeSplashScreenDuration` is included into `SplashScreenDelay`, for example if you have `<preference name="SplashScreenDelay" value="3000" />` and `<preference name="FadeSplashScreenDuration" value="1000"/>` defined in `config.xml`:
+
+- 00:00 - splashscreen is shown
+- 00:02 - fading has started
+- 00:03 - splashscreen is hidden
+
+Turning the fading off via `<preference name="FadeSplashScreen" value="false"/>` technically means fading duration to be `0` so that in this example the overall splash delay will still be 3 seconds.
+
+_Note_: This only applies to the app startup - you need to take the fading timeout into account when manually showing/hiding the splashscreen in the code:
+
+```javascript
+navigator.splashscreen.show();
+window.setTimeout(function () {
+    navigator.splashscreen.hide();
+}, splashDuration - fadeDuration);
+```
 
 - `ShowSplashScreenSpinner` (boolean, defaults to `true`): Set to `false`
   to hide the splash-screen spinner.
@@ -148,3 +170,5 @@ event. See [Icons and Splash Screens](http://cordova.apache.org/docs/en/edge/con
 for more information on doing this configuration. For this reason, it is
 unlikely you need to call `navigator.splashscreen.show()` to make the splash
 screen visible for app startup.
+
+[Apache Cordova issue tracker]: https://issues.apache.org/jira/issues/?jql=project%20%3D%20CB%20AND%20status%20in%20%28Open%2C%20%22In%20Progress%22%2C%20Reopened%29%20AND%20resolution%20%3D%20Unresolved%20AND%20component%20%3D%20%22Plugin%20Splashscreen%22%20ORDER%20BY%20priority%20DESC%2C%20summary%20ASC%2C%20updatedDate%20DESC

RELEASENOTES.md

@@ -20,6 +20,30 @@
 -->
 # Release Notes
 
+### 3.2.1 (Mar 09, 2016)
+* CB-10764: Remove emoji in cordova-plugin-splashscreen
+* CB-10650 Non-index content.src causes Splashscreen to be not displayed on ** Browser **
+* CB-10636 Add JSHint for plugins
+* CB-10606 fix deprecation warning for interfaceOrientation on ** iOS **
+* chore: edit package.json license to match SPDX id
+
+### 3.2.0 (Feb 09, 2016)
+* [CB-10422](https://issues.apache.org/jira/browse/CB-10422) Splashscreen displays black screen with no image on Android
+* [CB-10412](https://issues.apache.org/jira/browse/CB-10412) AutoHideSplashScreen "false" isn't taken in account on iOS
+* [CB-9516](https://issues.apache.org/jira/browse/CB-9516) Android SplashScreen - Spinner Does Not Display
+* [CB-9094](https://issues.apache.org/jira/browse/CB-9094) Smarter autohide logic on Android
+* [CB-8396](https://issues.apache.org/jira/browse/CB-8396) Add AutoHideSplashScreen logic to Android's Splashscreen
+
+### 3.1.0 (Jan 15, 2016)
+* CB-9538 Implementing `FadeSplashScreen` feature for **Android**
+* CB-9240 Cordova splash screen plugin **iPad** landscape mode issue
+* CB-10263 Fix splashscreen plugin filenames for Asset Catalog
+* CB-9374 **Android** add `SplashShowOnlyFirstTime` as preference
+* CB-10244 Don't rotate the **iPhone 6 Plus** splash
+* CB-9043 Fix the **ios** splashscreen being deformed on orientation change
+* CB-10079 Splashscreen plugin does not honor `SplashScreenDelay` on **iOS**
+* CB-10231 Fix `FadeSplashScreen` to default to true on **iOS**
+
 ### 3.0.0 (Nov 18, 2015)
 * [CB-10035](https://issues.apache.org/jira/browse/CB-10035) Updated `RELEASENOTES` to be newest to oldest
 * Fixing contribute link.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-splashscreen",
-  "version": "3.0.0",
+  "version": "3.2.1",
   "description": "Cordova Splashscreen Plugin",
   "cordova": {
     "id": "cordova-plugin-splashscreen",
@@ -34,6 +34,10 @@
     "cordova-windows",
     "cordova-tizen"
   ],
+  "scripts": {
+    "test": "npm run jshint",
+    "jshint": "node node_modules/jshint/bin/jshint www && node node_modules/jshint/bin/jshint src && node node_modules/jshint/bin/jshint tests"
+  },
   "engines": [
     {
       "name": "cordova-android",
@@ -41,5 +45,8 @@
     }
   ],
   "author": "Apache Software Foundation",
-  "license": "Apache 2.0"
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "jshint": "^2.6.0"
+  }
 }

plugin.xml

@@ -20,7 +20,7 @@
 
 <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
            id="cordova-plugin-splashscreen"
-      version="3.0.0">
+      version="3.2.1">
     <name>Splashscreen</name>
     <description>Cordova Splashscreen Plugin</description>
     <license>Apache 2.0</license>

src/android/SplashScreen.java

@@ -25,13 +25,20 @@ import android.content.Context;
 import android.content.DialogInterface;
 import android.content.res.Configuration;
 import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
 import android.os.Handler;
 import android.view.Display;
+import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup.LayoutParams;
 import android.view.WindowManager;
+import android.view.animation.Animation;
+import android.view.animation.AlphaAnimation;
+import android.view.animation.DecelerateInterpolator;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.RelativeLayout;
 
 import org.apache.cordova.CallbackContext;
 import org.apache.cordova.CordovaPlugin;
@@ -44,9 +51,11 @@ public class SplashScreen extends CordovaPlugin {
     // Cordova 3.x.x has a copy of this plugin bundled with it (SplashScreenInternal.java).
     // Enable functionality only if running on 4.x.x.
     private static final boolean HAS_BUILT_IN_SPLASH_SCREEN = Integer.valueOf(CordovaWebView.CORDOVA_VERSION.split("\\.")[0]) < 4;
+    private static final int DEFAULT_SPLASHSCREEN_DURATION = 3000;
     private static Dialog splashDialog;
     private static ProgressDialog spinnerDialog;
     private static boolean firstShow = true;
+    private static boolean lastHideAfterDelay; // https://issues.apache.org/jira/browse/CB-9094
 
     /**
      * Displays the splash drawable.
@@ -69,7 +78,7 @@ public class SplashScreen extends CordovaPlugin {
 
     @Override
     protected void pluginInitialize() {
-        if (HAS_BUILT_IN_SPLASH_SCREEN || !firstShow) {
+        if (HAS_BUILT_IN_SPLASH_SCREEN) {
             return;
         }
         // Make WebView invisible while loading URL
@@ -89,9 +98,14 @@ public class SplashScreen extends CordovaPlugin {
         // Save initial orientation.
         orientation = cordova.getActivity().getResources().getConfiguration().orientation;
 
-        firstShow = false;
-        loadSpinner();
-        showSplashScreen(true);
+        if (firstShow) {
+            boolean autoHide = preferences.getBoolean("AutoHideSplashScreen", true);
+            showSplashScreen(autoHide);
+        }
+
+        if (preferences.getBoolean("SplashShowOnlyFirstTime", true)) {
+            firstShow = false;
+        }
     }
 
     /**
@@ -101,13 +115,26 @@ public class SplashScreen extends CordovaPlugin {
         return preferences.getBoolean("SplashMaintainAspectRatio", false);
     }
 
+    private int getFadeDuration () {
+        int fadeSplashScreenDuration = preferences.getBoolean("FadeSplashScreen", true) ?
+            preferences.getInteger("FadeSplashScreenDuration", DEFAULT_SPLASHSCREEN_DURATION) : 0;
+
+        if (fadeSplashScreenDuration < 30) {
+            // [CB-9750] This value used to be in decimal seconds, so we will assume that if someone specifies 10
+            // they mean 10 seconds, and not the meaningless 10ms
+            fadeSplashScreenDuration *= 1000;
+        }
+
+        return fadeSplashScreenDuration;
+    }
+
     @Override
     public void onPause(boolean multitasking) {
         if (HAS_BUILT_IN_SPLASH_SCREEN) {
             return;
         }
         // hide the splash screen to avoid leaking a window
-        this.removeSplashScreen();
+        this.removeSplashScreen(true);
     }
 
     @Override
@@ -116,7 +143,7 @@ public class SplashScreen extends CordovaPlugin {
             return;
         }
         // hide the splash screen to avoid leaking a window
-        this.removeSplashScreen();
+        this.removeSplashScreen(true);
         // If we set this to true onDestroy, we lose track when we go from page to page!
         //firstShow = true;
     }
@@ -135,16 +162,6 @@ public class SplashScreen extends CordovaPlugin {
                     webView.postMessage("splashscreen", "show");
                 }
             });
-        } else if (action.equals("spinnerStart")) {
-            if (!HAS_BUILT_IN_SPLASH_SCREEN) {
-                final String title = args.getString(0);
-                final String message = args.getString(1);
-                cordova.getActivity().runOnUiThread(new Runnable() {
-                    public void run() {
-                        spinnerStart(title, message);
-                    }
-                });
-            }
         } else {
             return false;
         }
@@ -160,17 +177,16 @@ public class SplashScreen extends CordovaPlugin {
         }
         if ("splashscreen".equals(id)) {
             if ("hide".equals(data.toString())) {
-                this.removeSplashScreen();
+                this.removeSplashScreen(false);
             } else {
                 this.showSplashScreen(false);
             }
         } else if ("spinner".equals(id)) {
             if ("stop".equals(data.toString())) {
-                this.spinnerStop();
                 getView().setVisibility(View.VISIBLE);
             }
         } else if ("onReceivedError".equals(id)) {
-            spinnerStop();
+            this.spinnerStop();
         }
         return null;
     }
@@ -190,13 +206,45 @@ public class SplashScreen extends CordovaPlugin {
         }
     }
 
-    private void removeSplashScreen() {
+    private void removeSplashScreen(final boolean forceHideImmediately) {
         cordova.getActivity().runOnUiThread(new Runnable() {
             public void run() {
                 if (splashDialog != null && splashDialog.isShowing()) {
-                    splashDialog.dismiss();
-                    splashDialog = null;
-                    splashImageView = null;
+                    final int fadeSplashScreenDuration = getFadeDuration();
+                    // CB-10692 If the plugin is being paused/destroyed, skip the fading and hide it immediately
+                    if (fadeSplashScreenDuration > 0 && forceHideImmediately == false) {
+                        AlphaAnimation fadeOut = new AlphaAnimation(1, 0);
+                        fadeOut.setInterpolator(new DecelerateInterpolator());
+                        fadeOut.setDuration(fadeSplashScreenDuration);
+
+                        splashImageView.setAnimation(fadeOut);
+                        splashImageView.startAnimation(fadeOut);
+
+                        fadeOut.setAnimationListener(new Animation.AnimationListener() {
+                            @Override
+                            public void onAnimationStart(Animation animation) {
+                                spinnerStop();
+                            }
+
+                            @Override
+                            public void onAnimationEnd(Animation animation) {
+                                if (splashDialog != null && splashDialog.isShowing()) {
+                                    splashDialog.dismiss();
+                                    splashDialog = null;
+                                    splashImageView = null;
+                                }
+                            }
+
+                            @Override
+                            public void onAnimationRepeat(Animation animation) {
+                            }
+                        });
+                    } else {
+                        spinnerStop();
+                        splashDialog.dismiss();
+                        splashDialog = null;
+                        splashImageView = null;
+                    }
                 }
             }
         });
@@ -207,9 +255,14 @@ public class SplashScreen extends CordovaPlugin {
      */
     @SuppressWarnings("deprecation")
     private void showSplashScreen(final boolean hideAfterDelay) {
-        final int splashscreenTime = preferences.getInteger("SplashScreenDelay", 3000);
+        final int splashscreenTime = preferences.getInteger("SplashScreenDelay", DEFAULT_SPLASHSCREEN_DURATION);
         final int drawableId = preferences.getInteger("SplashDrawableId", 0);
 
+        final int fadeSplashScreenDuration = getFadeDuration();
+        final int effectiveSplashDuration = Math.max(0, splashscreenTime - fadeSplashScreenDuration);
+
+        lastHideAfterDelay = hideAfterDelay;
+
         // If the splash dialog is showing don't try to show it again
         if (splashDialog != null && splashDialog.isShowing()) {
             return;
@@ -257,60 +310,57 @@ public class SplashScreen extends CordovaPlugin {
                 splashDialog.setCancelable(false);
                 splashDialog.show();
 
+                if (preferences.getBoolean("ShowSplashScreenSpinner", true)) {
+                    spinnerStart();
+                }
+
                 // Set Runnable to remove splash screen just in case
                 if (hideAfterDelay) {
                     final Handler handler = new Handler();
                     handler.postDelayed(new Runnable() {
                         public void run() {
-                            removeSplashScreen();
+                            if (lastHideAfterDelay) {
+                                removeSplashScreen(false);
+                            }
                         }
-                    }, splashscreenTime);
+                    }, effectiveSplashDuration);
                 }
             }
         });
     }
 
-    /*
-     * Load the spinner
-     */
-    private void loadSpinner() {
-        // If loadingDialog property, then show the App loading dialog for first page of app
-        String loading = null;
-        if (webView.canGoBack()) {
-            loading = preferences.getString("LoadingDialog", null);
-        }
-        else {
-            loading = preferences.getString("LoadingPageDialog", null);
-        }
-        if (loading != null) {
-            String title = "";
-            String message = "Loading Application...";
-
-            if (loading.length() > 0) {
-                int comma = loading.indexOf(',');
-                if (comma > 0) {
-                    title = loading.substring(0, comma);
-                    message = loading.substring(comma + 1);
-                }
-                else {
-                    title = "";
-                    message = loading;
-                }
-            }
-            spinnerStart(title, message);
-        }
-    }
-
-    private void spinnerStart(final String title, final String message) {
+    // Show only spinner in the center of the screen
+    private void spinnerStart() {
         cordova.getActivity().runOnUiThread(new Runnable() {
             public void run() {
                 spinnerStop();
-                spinnerDialog = ProgressDialog.show(webView.getContext(), title, message, true, true,
-                        new DialogInterface.OnCancelListener() {
-                            public void onCancel(DialogInterface dialog) {
-                                spinnerDialog = null;
-                            }
-                        });
+
+                spinnerDialog = new ProgressDialog(webView.getContext());
+                spinnerDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+                    public void onCancel(DialogInterface dialog) {
+                        spinnerDialog = null;
+                    }
+                });
+
+                spinnerDialog.setCancelable(false);
+                spinnerDialog.setIndeterminate(true);
+
+                RelativeLayout centeredLayout = new RelativeLayout(cordova.getActivity());
+                centeredLayout.setGravity(Gravity.CENTER);
+                centeredLayout.setLayoutParams(new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
+
+                ProgressBar progressBar = new ProgressBar(webView.getContext());
+                RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
+                layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
+                progressBar.setLayoutParams(layoutParams);
+
+                centeredLayout.addView(progressBar);
+
+                spinnerDialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
+                spinnerDialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
+
+                spinnerDialog.show();
+                spinnerDialog.setContentView(centeredLayout);
             }
         });
     }

src/blackberry10/index.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+/* global PluginResult */
+
 module.exports = {
     show: function (success, fail, args, env) {
         var result = new PluginResult(args, env);

src/browser/SplashScreenProxy.js

@@ -18,17 +18,18 @@
  * under the License.
  *
 */
+
 // Default parameter values including image size can be changed in `config.xml`
 var splashImageWidth = 170;
 var splashImageHeight = 200;
 var position = { x: 0, y: 0, width: splashImageWidth, height: splashImageHeight }; 
-var splash = null; //
 var localSplash; // the image to display
 var localSplashImage;
 var bgColor = "#464646";
-var imageSrc = 'img/logo.png';
+var imageSrc = '/img/logo.png';
 var splashScreenDelay = 3000; // in milliseconds
 var showSplashScreen = true; // show splashcreen by default
+var cordova = require('cordova');
 var configHelper = cordova.require('cordova/confighelper');
 
 function updateImageLocation() {
@@ -103,7 +104,6 @@ function readPreferencesFromCfg(cfg) {
     } catch(e) {
         var msg = '[Browser][SplashScreen] Error occured on loading preferences from config.xml: ' + JSON.stringify(e);
         console.error(msg);
-        error(msg);
     }
 }
 

src/ios/CDVSplashScreen.h

@@ -23,6 +23,7 @@
 typedef struct {
     BOOL iPhone;
     BOOL iPad;
+    BOOL iPhone4;
     BOOL iPhone5;
     BOOL iPhone6;
     BOOL iPhone6Plus;

src/ios/CDVSplashScreen.m

@@ -156,6 +156,7 @@
     device.iPad = (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad);
     device.iPhone = (UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPhone);
     device.retina = ([mainScreen scale] == 2.0);
+    device.iPhone4 = (device.iPhone && limit == 480.0);
     device.iPhone5 = (device.iPhone && limit == 568.0);
     // note these below is not a true device detect, for example if you are on an
     // iPhone 6/6+ but the app is scaled it will prob set iPhone5 as true, but
@@ -187,7 +188,23 @@
     {
         imageName = @"Default";
     }
-    
+
+    // Add Asset Catalog specific prefixes
+    if ([imageName isEqualToString:@"LaunchImage"])
+    {
+        if (device.iPhone4 || device.iPhone5 || device.iPad) {
+            imageName = [imageName stringByAppendingString:@"-700"];
+        } else if(device.iPhone6) {
+            imageName = [imageName stringByAppendingString:@"-800"];
+        } else if(device.iPhone6Plus) {
+            imageName = [imageName stringByAppendingString:@"-800"];
+            if (currentOrientation == UIInterfaceOrientationPortrait || currentOrientation == UIInterfaceOrientationPortraitUpsideDown)
+            {
+                imageName = [imageName stringByAppendingString:@"-Portrait"];
+            }
+        }
+    }
+
     if (device.iPhone5)
     { // does not support landscape
         imageName = [imageName stringByAppendingString:@"-568h"];
@@ -244,10 +261,47 @@
     return imageName;
 }
 
+- (UIInterfaceOrientation)getCurrentOrientation
+{
+    UIInterfaceOrientation iOrientation = [UIApplication sharedApplication].statusBarOrientation;
+    UIDeviceOrientation dOrientation = [UIDevice currentDevice].orientation;
+
+    bool landscape;
+
+    if (dOrientation == UIDeviceOrientationUnknown || dOrientation == UIDeviceOrientationFaceUp || dOrientation == UIDeviceOrientationFaceDown) {
+        // If the device is laying down, use the UIInterfaceOrientation based on the status bar.
+        landscape = UIInterfaceOrientationIsLandscape(iOrientation);
+    } else {
+        // If the device is not laying down, use UIDeviceOrientation.
+        landscape = UIDeviceOrientationIsLandscape(dOrientation);
+
+        // There's a bug in iOS!!!! http://openradar.appspot.com/7216046
+        // So values needs to be reversed for landscape!
+        if (dOrientation == UIDeviceOrientationLandscapeLeft)
+        {
+            iOrientation = UIInterfaceOrientationLandscapeRight;
+        }
+        else if (dOrientation == UIDeviceOrientationLandscapeRight)
+        {
+            iOrientation = UIInterfaceOrientationLandscapeLeft;
+        }
+        else if (dOrientation == UIDeviceOrientationPortrait)
+        {
+            iOrientation = UIInterfaceOrientationPortrait;
+        }
+        else if (dOrientation == UIDeviceOrientationPortraitUpsideDown)
+        {
+            iOrientation = UIInterfaceOrientationPortraitUpsideDown;
+        }
+    }
+
+    return iOrientation;
+}
+
 // Sets the view's frame and image.
 - (void)updateImage
 {
-    NSString* imageName = [self getImageName:[[UIApplication sharedApplication] statusBarOrientation] delegate:(id<CDVScreenOrientationDelegate>)self.viewController device:[self getCurrentDevice]];
+    NSString* imageName = [self getImageName:[self getCurrentOrientation] delegate:(id<CDVScreenOrientationDelegate>)self.viewController device:[self getCurrentDevice]];
 
     if (![imageName isEqualToString:_curImageName])
     {
@@ -273,7 +327,7 @@
     CGRect imgBounds = (img) ? CGRectMake(0, 0, img.size.width, img.size.height) : CGRectZero;
 
     CGSize screenSize = [self.viewController.view convertRect:[UIScreen mainScreen].bounds fromView:nil].size;
-    UIInterfaceOrientation orientation = self.viewController.interfaceOrientation;
+    UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
     CGAffineTransform imgTransform = CGAffineTransformIdentity;
 
     /* If and only if an iPhone application is landscape-only as per
@@ -281,8 +335,8 @@
      * landscape. In this case the image must be rotated in order to appear
      * correctly.
      */
-    BOOL isIPad = [[UIDevice currentDevice] userInterfaceIdiom] == UIUserInterfaceIdiomPad;
-    if (UIInterfaceOrientationIsLandscape(orientation) && !isIPad)
+    CDV_iOSDevice device = [self getCurrentDevice];
+    if (UIInterfaceOrientationIsLandscape(orientation) && !device.iPhone6Plus && !device.iPad)
     {
         imgTransform = CGAffineTransformMakeRotation(M_PI / 2);
         imgBounds.size = CGSizeMake(imgBounds.size.height, imgBounds.size.width);
@@ -331,17 +385,38 @@
 
         float fadeDuration = fadeSplashScreenDuration == nil ? kSplashScreenDurationDefault : [fadeSplashScreenDuration floatValue];
 
-        if ((fadeSplashScreenValue == nil) || ![fadeSplashScreenValue boolValue])
+        id splashDurationString = [self.commandDelegate.settings objectForKey: [@"SplashScreenDelay" lowercaseString]];
+        float splashDuration = splashDurationString == nil ? kSplashScreenDurationDefault : [splashDurationString floatValue];
+
+        id autoHideSplashScreenValue = [self.commandDelegate.settings objectForKey:[@"AutoHideSplashScreen" lowercaseString]];
+        BOOL autoHideSplashScreen = true;
+
+        if (autoHideSplashScreenValue != nil) {
+            autoHideSplashScreen = [autoHideSplashScreenValue boolValue];
+        }
+
+        if (!autoHideSplashScreen) {
+            // CB-10412 SplashScreenDelay does not make sense if the splashscreen is hidden manually
+            splashDuration = 0;
+        }
+
+
+        if (fadeSplashScreenValue == nil)
+        {
+            fadeSplashScreenValue = @"true";
+        }
+
+        if (![fadeSplashScreenValue boolValue])
         {
             fadeDuration = 0;
         }
-        else if(fadeDuration < 30)
+        else if (fadeDuration < 30)
         {
             // [CB-9750] This value used to be in decimal seconds, so we will assume that if someone specifies 10
             // they mean 10 seconds, and not the meaningless 10ms
             fadeDuration *= 1000;
         }
-        
+
         if (_visible)
         {
             if (_imageView == nil)
@@ -349,26 +424,36 @@
                 [self createViews];
             }
         }
-        else if (fadeDuration == 0)
+        else if (fadeDuration == 0 && splashDuration == 0)
         {
             [self destroyViews];
         }
         else
         {
             __weak __typeof(self) weakSelf = self;
-            [UIView transitionWithView:self.viewController.view
-                            duration:(fadeDuration / 1000)
-                            options:UIViewAnimationOptionTransitionNone
-                            animations:^(void) {
-                                [weakSelf hideViews];
-                            }
-                            completion:^(BOOL finished) {
-                                if (finished) {
-                                    [weakSelf destroyViews];
-                                    // TODO: It might also be nice to have a js event happen here -jm
-                                }
-                            }
-             ];
+            float effectiveSplashDuration;
+
+            if (!autoHideSplashScreen) {
+                effectiveSplashDuration = (fadeDuration) / 1000;
+            } else {
+                effectiveSplashDuration = (splashDuration - fadeDuration) / 1000;
+            }
+
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (uint64_t) effectiveSplashDuration * NSEC_PER_SEC), dispatch_get_main_queue(), CFBridgingRelease(CFBridgingRetain(^(void) {
+                   [UIView transitionWithView:self.viewController.view
+                                   duration:(fadeDuration / 1000)
+                                   options:UIViewAnimationOptionTransitionNone
+                                   animations:^(void) {
+                                       [weakSelf hideViews];
+                                   }
+                                   completion:^(BOOL finished) {
+                                       if (finished) {
+                                           [weakSelf destroyViews];
+                                           // TODO: It might also be nice to have a js event happen here -jm
+                                       }
+                                     }
+                    ];
+            })));
         }
     }
 }

src/ios/CDVViewController+SplashScreen.m

@@ -35,6 +35,13 @@
 - (BOOL)enabledAutorotation
 {
     NSNumber *number =  (NSNumber *)objc_getAssociatedObject(self, @selector(enabledAutorotation));
+
+    // Defaulting to YES to correspond parent CDVViewController behavior
+    if (number == nil)
+    {
+        return YES;
+    }
+
     return [number boolValue];
 }
 

src/tizen/SplashScreenProxy.js

@@ -21,7 +21,7 @@
 
 ( function() {
 
-win = null;
+var win = null;
 
 module.exports = {
     show: function() {

tests/plugin.xml

@@ -20,7 +20,7 @@
 
 <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
     id="cordova-plugin-splashscreen-tests"
-    version="3.0.0">
+    version="3.2.1">
     <name>Cordova Splashscreen Plugin Tests</name>
     <license>Apache 2.0</license>
 

tests/tests.js

@@ -19,18 +19,20 @@
  *
 */
 
-exports.defineAutoTest = function () {
+/* jshint jasmine: true */
+
+exports.defineAutoTests = function () {
     describe('Splashscreen (cordova)', function () {
         it("splashscreen.spec.1 should exist", function () {
             expect(navigator.splashscreen).toBeDefined();
         });
 
-        it("splashscreen.spec.2 exec method should exist", function () {
+        it("splashscreen.spec.2 show method should exist", function () {
             expect(navigator.splashscreen.show).toBeDefined();
             expect(typeof navigator.splashscreen.show).toBe('function');
         });
 
-        it("splashscreen.spec.3 exec method should exist", function () {
+        it("splashscreen.spec.3 hide method should exist", function () {
             expect(navigator.splashscreen.hide).toBeDefined();
             expect(typeof navigator.splashscreen.hide).toBe('function');
         });

www/windows/SplashScreenProxy.js

@@ -20,17 +20,16 @@
 */
 
 /*jslint sloppy:true */
-/*global Windows:true, require, module, window, document, WinJS */
+/*global WinJS */
 
-var cordova = require('cordova'),
-    channel = require('cordova/channel');
+var cordova = require('cordova');
 
 var isPhone = (cordova.platformId == "windows") && WinJS.Utilities.isPhone;
 var isHosted = window.location.protocol.indexOf('http') === 0;
-var localSplash = null;
+var localSplash = null, localSplashImage = null;
 var bgColor = "#464646"; // default backgrond color; TDOO - read it from .appxmanifest
-var splashImageSrc = (isHosted ? "ms-appx-web" : "ms-appx") + ":///images/"
-    + (isPhone ? "splashscreenphone.png" : "splashscreen.png");
+var splashImageSrc = (isHosted ? "ms-appx-web" : "ms-appx") + ":///images/" +
+    (isPhone ? "splashscreenphone.png" : "splashscreen.png");
 
 var SplashScreen = {
     setBGColor: function (cssBGColor) {