Currently visible screen (#1581)

* added method for getting the currently visible screen ID. Can be useful to decide if logic should be applied according to screen visibility, for example: set buttons/title dynamically, or even determine that you don’t need to show the same screen again if it’s the current one that’s showing

* Implement getCurrentlyVisibleScreenId on Android

Can be used statically:
Navigation.getCurrentlyVisibleScreenId() - returns the unique screen
instance id

With a navigator instance:
await this.props.navigator.screenIsCurrentlyVisible() - resolves a
promise that checks if the current screen is visible

android/app/src/main/java/com/reactnativenavigation/bridge/NavigationReactModule.java

     public void isAppLaunched(Promise promise) {
         NavigationCommandsHandler.isAppLaunched(promise);
     }
+
+    @ReactMethod
+    public void getCurrentlyVisibleScreenId(Promise promise) {
+        NavigationCommandsHandler.getCurrentlyVisibleScreenId(promise);
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/Modal.java

         layout.selectTopTabByTabIndex(screenInstanceId, index);
     }
 
+    String getCurrentlyVisibleScreenId() {
+        return layout.getCurrentlyVisibleScreenId();
+    }
+
     interface OnModalDismissedListener {
         void onModalDismissed(Modal modal);
     }

android/app/src/main/java/com/reactnativenavigation/controllers/ModalController.java

             modal.selectTopTabByScreen(screenInstanceId);
         }
     }
+
+    String getCurrentlyVisibleScreenId() {
+        return stack.peek().getCurrentlyVisibleScreenId();
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationActivity.java

     public void showContextualMenu(String screenInstanceId, ContextualMenuParams params, Callback onButtonClicked) {
         if (modalController.isShowing()) {
             modalController.showContextualMenu(screenInstanceId, params, onButtonClicked);
-        } else
-        {
+        } else {
             layout.showContextualMenu(screenInstanceId, params, onButtonClicked);
         }
     }
             mPermissionListener = null;
         }
     }
+
+    public String getCurrentlyVisibleScreenId() {
+        return modalController.isShowing() ? modalController.getCurrentlyVisibleScreenId() : layout.getCurrentlyVisibleScreenId();
+    }
 }

android/app/src/main/java/com/reactnativenavigation/controllers/NavigationCommandsHandler.java

 import android.content.Intent;
 import android.os.Bundle;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.WritableMap;
 import com.reactnativenavigation.NavigationApplication;
 import com.reactnativenavigation.params.ActivityParams;
 import com.reactnativenavigation.params.ContextualMenuParams;
         final boolean isAppLaunched = SplashActivity.isResumed || NavigationActivity.currentActivity != null;
         promise.resolve(isAppLaunched);
     }
+
+    public static void getCurrentlyVisibleScreenId(final Promise promise) {
+        final NavigationActivity currentActivity = NavigationActivity.currentActivity;
+        if (currentActivity == null) {
+            promise.resolve("");
+            return;
+        }
+        NavigationApplication.instance.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                WritableMap map = Arguments.createMap();
+                map.putString("screenId", currentActivity.getCurrentlyVisibleScreenId());
+                promise.resolve(map);
+            }
+        });
+    }
 }

android/app/src/main/java/com/reactnativenavigation/layouts/BottomTabsLayout.java

         }
     }
 
+    @Override
+    public String getCurrentlyVisibleScreenId() {
+        return getCurrentScreen().getScreenInstanceId();
+    }
+
     @Override
     public void selectTopTabByTabIndex(String screenInstanceId, int index) {
         for (int i = 0; i < bottomTabs.getItemsCount(); i++) {

android/app/src/main/java/com/reactnativenavigation/layouts/Layout.java

     void selectTopTabByScreen(String screenInstanceId);
 
     void updateScreenStyle(String screenInstanceId, Bundle styleParams);
+
+    String getCurrentlyVisibleScreenId();
 }

android/app/src/main/java/com/reactnativenavigation/layouts/SingleScreenLayout.java

         stack.updateScreenStyle(screenInstanceId, styleParams);
     }
 
+    @Override
+    public String getCurrentlyVisibleScreenId() {
+        return stack.peek().getScreenInstanceId();
+    }
+
     @Override
     public void showSlidingOverlay(final SlidingOverlayParams params) {
         slidingOverlaysQueue.add(new SlidingOverlay(this, params));

ios/RCCManager.h

 -(void)registerController:(UIViewController*)controller componentId:(NSString*)componentId componentType:(NSString*)componentType;
 -(id)getControllerWithId:(NSString*)componentId componentType:(NSString*)componentType;
 -(void)unregisterController:(UIViewController*)vc;
+-(NSString*) getIdForController:(UIViewController*)vc;
 
 -(void)clearModuleRegistry;
 

ios/RCCManager.m

 #import "RCCManager.h"
+#import "RCCViewController.h"
 #import <React/RCTBridge.h>
 #import <React/RCTRedBox.h>
 #import <Foundation/Foundation.h>
   return component;
 }
 
+-(NSString*) getIdForController:(UIViewController*)vc
+{
+  if([vc isKindOfClass:[RCCViewController class]])
+  {
+    NSString *controllerId = ((RCCViewController*)vc).controllerId;
+    if(controllerId != nil)
+    {
+      return controllerId;
+    }
+  }
+  
+  for (NSString *key in [self.modulesRegistry allKeys])
+  {
+    NSMutableDictionary *componentsDic = self.modulesRegistry[key];
+    for (NSString *componentID in [componentsDic allKeys])
+    {
+      UIViewController *tmpVc = componentsDic[componentID];
+      if (tmpVc == vc)
+      {
+        return componentID;
+      }
+    }
+  }
+  return nil;
+}
+
 -(void)initBridgeWithBundleURL:(NSURL *)bundleURL
 {
   [self initBridgeWithBundleURL :bundleURL launchOptions:nil];

ios/RCCManagerModule.m

                                                                     completion:^(){ resolve(nil); }];
 }
 
+- (UIViewController *) getVisibleViewControllerFor:(UIViewController *)vc
+{
+    if ([vc isKindOfClass:[UINavigationController class]])
+    {
+        return [self getVisibleViewControllerFor:[((UINavigationController*)vc) visibleViewController]];
+    }
+    else if ([vc isKindOfClass:[UITabBarController class]])
+    {
+        return [self getVisibleViewControllerFor:[((UITabBarController*)vc) selectedViewController]];
+    }
+    else if (vc.presentedViewController)
+    {
+        return [self getVisibleViewControllerFor:vc.presentedViewController];
+    }
+    else
+    {
+        return vc;
+    }
+}
+
+RCT_EXPORT_METHOD(getCurrentlyVisibleScreenId:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    UIViewController *rootVC = [UIApplication sharedApplication].delegate.window.rootViewController;
+    UIViewController *visibleVC = [self getVisibleViewControllerFor:rootVC];
+    NSString *controllerId = [[RCCManager sharedIntance] getIdForController:visibleVC];
+    id result = (controllerId != nil) ? @{@"screenId": controllerId} : nil;
+    resolve(result);
+}
+
 -(BOOL)viewControllerIsModal:(UIViewController*)viewController
 {
     BOOL viewControllerIsModal = (viewController.presentingViewController.presentedViewController == viewController)

ios/RCCNavigationController.m

   
   RCCViewController *viewController = [[RCCViewController alloc] initWithComponent:component passProps:passProps navigatorStyle:navigatorStyle globalProps:globalProps bridge:bridge];
   if (!viewController) return nil;
+  viewController.controllerId = props[@"id"];
   
   NSArray *leftButtons = props[@"leftButtons"];
   if (leftButtons)
     }
     
     RCCViewController *viewController = [[RCCViewController alloc] initWithComponent:component passProps:passProps navigatorStyle:navigatorStyle globalProps:nil bridge:bridge];
+    viewController.controllerId = passProps[@"screenInstanceID"];
     
     [self processTitleView:viewController
                      props:actionParams
     NSDictionary *navigatorStyle = actionParams[@"style"];
     
     RCCViewController *viewController = [[RCCViewController alloc] initWithComponent:component passProps:passProps navigatorStyle:navigatorStyle globalProps:nil bridge:bridge];
+    viewController.controllerId = passProps[@"screenInstanceID"];
     
     [self processTitleView:viewController
                      props:actionParams

ios/RCCViewController.h

 
 @property (nonatomic) NSMutableDictionary *navigatorStyle;
 @property (nonatomic) BOOL navBarHidden;
+@property (nonatomic, strong) NSString *controllerId;
 @property (nonatomic, strong) NSString *commandType;
 @property (nonatomic, strong) NSString *timestamp;
 

ios/RCCViewController.m

   if (controller && componentId)
   {
     [[RCCManager sharedInstance] registerController:controller componentId:componentId componentType:type];
+    
+    if([controller isKindOfClass:[RCCViewController class]])
+    {
+      ((RCCViewController*)controller).controllerId = componentId;
+    }
   }
   
   // set background image at root level

src/Navigation.js

   return await platformSpecific.isAppLaunched();
 }
 
+function getCurrentlyVisibleScreenId() {
+  return platformSpecific.getCurrentlyVisibleScreenId();
+}
+
 export default {
   getRegisteredScreen,
+  getCurrentlyVisibleScreenId,
   registerComponent,
   showModal: showModal,
   dismissModal: dismissModal,

src/Screen.js

       Navigation.clearEventHandler(this.navigatorEventID);
     }
   }
+
+  async screenIsCurrentlyVisible() {
+    const res = await Navigation.getCurrentlyVisibleScreenId();
+    if (!res) {
+      return false;
+    }
+    return res.screenId === this.screenInstanceID;
+  }
 }
 
 export default class Screen extends Component {

src/deprecated/controllers/index.js

     }
   },
 
+  ScreenUtils: {
+    getCurrentlyVisibleScreenId: async function() {
+      return await RCCManager.getCurrentlyVisibleScreenId();
+    }
+  },
+
   NavigationToolBarIOS: OriginalReactNative.requireNativeComponent('RCCToolBar', null),
 
   Constants: Constants

src/deprecated/platformSpecificDeprecated.android.js

   return await newPlatformSpecific.isAppLaunched();
 }
 
+async function getCurrentlyVisibleScreenId() {
+  return await newPlatformSpecific.getCurrentlyVisibleScreenId();
+}
+
 export default {
   startTabBasedApp,
   startSingleScreenApp,
   dismissSnackbar,
   showContextualMenu,
   dismissContextualMenu,
-  isAppLaunched
+  isAppLaunched,
+  getCurrentlyVisibleScreenId
 };

src/deprecated/platformSpecificDeprecated.ios.js

 /*eslint-disable*/
 import Navigation from './../Navigation';
-import Controllers, {Modal, Notification} from './controllers';
+import Controllers, {Modal, Notification, ScreenUtils} from './controllers';
 const React = Controllers.hijackReact();
 const {
   ControllerRegistry,
   // Android only
 }
 
+async function getCurrentlyVisibleScreenId() {
+  return await ScreenUtils.getCurrentlyVisibleScreenId();
+}
+
 export default {
   startTabBasedApp,
   startSingleScreenApp,
   navigatorSwitchToTab,
   navigatorToggleNavBar,
   showContextualMenu,
-  dismissContextualMenu
+  dismissContextualMenu,
+  getCurrentlyVisibleScreenId
 };

src/platformSpecific.android.js

   return await NativeReactModule.isAppLaunched();
 }
 
+async function getCurrentlyVisibleScreenId() {
+  return await NativeReactModule.getCurrentlyVisibleScreenId();
+}
+
 module.exports = {
   startApp,
   push,
   showContextualMenu,
   dismissContextualMenu,
   setScreenStyle,
-  isAppLaunched
+  isAppLaunched,
+  getCurrentlyVisibleScreenId
 };