This article assumes that you already have basic knowledge about Decompose.

I have found Decompose a great navigation library for both Compose Multiplatform and KMP with native UI so far. It operates on BLoC (Business Logic Component) pattern — those who have worked on Flutter may already know about it. The individual component is responsible for managing the state and events for the corresponding screen similar to viewModels in Android.

Its a common practice in mobile applications to group different flows in separate navigation graphs or storyboards or different modules. Lets assume we have an application with 3 main flows as follows:

1- When user launches app for the first time, he is shown splash and onboarding [Landing Flow]

2- User can login/signup in the app. Should be able to go from onboarding. [Authentication Flow]

3- After login, main app contents are displayed. You can call it Home Screen [Main Flow]

Our requirement is that we should be able to switch between different flows. In order to achieve it via Decompose, each flow will be managed by a NavigationStack inside Parent Component.

According to Documentation,

A component is just a normal class that encapsulates some logic and possibly another (child) components. Every component has its own lifecycle, which is automatically managed by Decompose. So everything encapsulated by a component is scoped.

Consider Landing Component, Auth Component and Main Component as three parent components in same hierarchy managing their own screens and navigation stack. Only one navigation stack can be displayed at a time from the root.

Main Component can be anything — Drawers + Tabs or simple content screens. In the diagram above, I have portrayed the main screen having bottom navigation [tabs].

Implementation

For the sake of brevity, I will explain Landing and Root components. Auth and Main can be created just like Landing. In order to get an idea about bottom navigation content management with Decompose, check their sample especially DefaultRootComponent and RootContent.

Create LandingComponent interface holding navigation state information. Here a sealed class LandingChild is declaring classes for all the screens that will be accessed in the Landing flow. They will hold component information for corresponding screen.

Its implementation will be responsible to manage the navigation for the landing flow and provide Child for the screen requested.

Now lets create a Application Root component having information about main flows of the application. It also contains navigation methods that can be called by Landing and Auth Components in order to request navigation to another stack.

Now here comes the interesting part, how to switch the stacks. In Android or Compose Multiplatform you can do this by:

If you are creating UI layers natively like SwiftUI, Desktop, web etc then each platform needs to implement their own routing mechanism.

Finally, the RootContent can be used as:

What navigation library you are using for your KMP app? You can let me know in the comments.

Happy coding!

View Models are encouraged by Google to share data between fragments in an activity. Although it is a good approach, but easy to be misused if not taken care of.

I am going to highlight two cases which I came across, and think that Shared ViewModels actually created bad code smell and bugs in the code that needed to be refactored later. So if you really want to use in such cases, do think if it is the correct way or there is an alternative.

ViewModel in Single Activity Architecture

Imagine you have an app with single activity architecture. In order to share same data across multiple fragments, you decided to make viewModel shared.

If UserViewModel is declared as shared with activity scope, it becomes a singleton. It is good to keep your viewModel scoped. Both Androidx and Koin facilitates to help you scope them to parent fragment or navigation graph. This will make sure that viewModel is destroyed once scope is no longer valid.

Problematic with Flows

Flows can sometime cause issues if used with shared viewModel.

Suppose, you have a Bottom sheet that shows product variants list against a product. On selection of variant, you emit event, so that caller fragment can know about selection. Please do note that we cannot use sharedViewModel with requireParentFragment in navigation graph, since dialog is treated as a separate fragment.

Here the simplified code shows the loading of data, and passing event to viewModel on selection.

This view model is shared between caller ProductFragment and ProductVariantBottomSheet. On variant selection, ProductFragment is notified of changes via selectedVariant flow.

Here are entities for the reference used in viewModel.

When you go away from ProductVariantBottomSheet, fragment is destroyed but viewModel isn’t. Therefore, if you will show this dialog for another product, it will emit previous value of variantsUiState before new data is fetched. After response is received from API, new data is populated. User will see stale/invalid variants for a while, which will be replaced by fresh ones after few seconds.

This will work if you want to display one time cached data from viewModel. But in case you need to fetch the data every time, it will be bad user experience since user will see its old data temporarily. Or in order to handle such thing, you will have to either clear the UI state of flow or hide the screen contents unless fresh data is loaded. Either way I feel it is escape from a bad practice and not a proper solution.

May be if it’s SharedFlow, you might think to adjust replay values here. But trust me, it will get messier as codebase will grow with bugs.

Recommendation

In order to communicate between fragments, use setFragmentResultListener whenever possible. It’s clean and safe with no side effects discovered so far.

Another Android’s old school approach would be to use repository as a mediator data holder (may be a cold flow) that can cache the value, and emit it to the subscriber when available.

Happy coding!

I was trying a new way of writing runtime permissions on Android. It amazed me how precise the code has become, and you do not need to write hundreds of lines of boilerplate code.

In case you are trying to acquire permission from the user using new ActivityResultLauncher and ActivityResultContracts, you may get the crash mentioned in the title. As a solution, it is necessary to include following dependencies together even if they do not look relevant to each other, yet fixes the crash.

implementation 'androidx.activity:activity-ktx:1.2.0-alpha08'
implementation 'androidx.fragment:fragment:1.3.0-alpha08'

Thanks to Saurabh for pointing out. In case you would like to acquire multiple permissions at a time from the user, you can use the following code:

val multiplePermissions = registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { map ->

//Callback received what we used to get in onRequestPermissionsResult

}

multiplePermissions.launch(arrayOf(
Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE))

Looks cool. Right? Happy Coding!

If you are a person working on legacy Objective C projects like me, you might have to use Swift 3rd party libraries available online. Detecting Swift files in Objective C projects doesn’t work smoothly as expected. Therefore one has to make sure that all the steps have been correctly followed.

Here I am mentioning couple of points that could help you get through the process swiftly.

1. Make sure you uncomment use_frameworks! in pod file.
2. Check in Build settings > Header Search Paths, Pods folder is added as recursive search.

3. Objective-C bridging Header is present in the project and included in Build Settings. If not, then you can simply add a Swift file, Xcode will ask to configure for you. Say Yes!

4. Make sure after installing pods, you clean and compile code once.

5. To access swift file from pod, you have to use:

#import “<Classname>-Swift.h”

For example, if you are using NVActivityIndicatorView, you would end up with:

#import “NVActivityIndicatorView-Swift.h”

Side Note

If you are accessing manually added Swift file in Objective C code, just use:

#import “<YourProjectName>-Swift.h”

You can confirm Filename in Build Settings > Objective-C Generated Interface Header Name.

Happy Coding!

Recently, I integrated push notifications in my react native app using react-native-firebase. I came across many challenges during the process of integration to successful implementation, so I thought to share steps with everyone here.

Note [as of year 2020]: This article is 2 years old. RnFirebase has released a much stable version that supports react native 0.60 along with autolinking. I will recommend to check out their guide first. You can surely follow this tutorial in case you have any concerns. Cheers! 🙂

Create Application On Console

First create an application on Firebase console. Follow steps in Cloud Messaging Section, add iOS and Android apps as per your requirement.

Make sure your google-services.json and GoogleService-Info.plist are placed in correct folders.

Android

Configure gradle files. Please use the latest firebase dependencies available while following this tutorial. You can find official FCM guide here. For your reference, my gradle files are as follows:

iOS

1. In Firebase console, you have to include either APNs Authentication Key or APNs Certificate in Project Settings > Cloud Messaging in order to receive push notifications. Creation of push certificate is out of scope in this tutorial, so here is a nice link for your reference :)

Note: You need two separate push certificates. One for Sandbox Environment (Development Certificate) and other for Production (Distribution Certificate). Both should be uploaded to Firebase Console.

2. Turn on following two capabilities in Xcode. Make sure these are turned on in certificates as well created in step 1.

a) Push Notifications

b) Background Modes - Check only Remote Notifications

Make sure you open <YourProject>.xcworkspace file using Xcode instead of <YourProject>.xcodeproj.

3. Open Podfile and edit its contents as follows:

If you haven’t setup pods before, please follow guide from here. If you face any error, you can check official FCM guide.

Install Firebase Module

Run following command in root folder of your react project.

npm install --save react-native-firebase

You can link firebase node module with native applications using following command:

react-native link react-native-firebase

Here I will be linking firebase node module with native platforms manually without react-native link, since it avoids mess and incomplete bindings most of the times. Moreover, if you are face any issues after linking, you can confirm steps from below that everything is included correctly in native platforms.

Android Setup

1. Edit MainApplication.java:

import io.invertase.firebase.RNFirebasePackage;
import io.invertase.firebase.messaging.RNFirebaseMessagingPackage;                       import io.invertase.firebase.notifications.RNFirebaseNotificationsPackage;

@Override
protected List<ReactPackage> getPackages() {
  return Arrays.<ReactPackage>asList(
 new MainReactPackage(),
 new RNFirebasePackage(),
 new RNFirebaseMessagingPackage(),
 new RNFirebaseNotificationsPackage()
 );                               
}

2. Add these lines in settings.gradle

include ':react-native-firebase'                       project(':react-native-firebase').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-firebase/android')

3. In app build gradle, add dependency:

dependencies {
   compile(project(':react-native-firebase')) {   
       transitive = false
   }
   // ... other dependencies listed
}

Sync gradle. You should be good to go for Android. At this point, we can quickly test notification on Android Device from Firebase Console.

Make sure your application is in background while testing, so that Firebase can automatically deliver to notification tray.

To test on console:

a) Go to Cloud Messaging section on left Pane.

b) Click on Send your first message.

c) Enter text, Select your app in User Segment and click Send Message button. You should be able to receive notification.

iOS Setup

1. In Project Navigator, right click Libraries > Add Files To <YourProject>. Navigate to <YourProject>/node_modules/react-native-firebase/ios/. Select RNFirebase.xcodeproj and click Add button.

1. Go to Build Phases. Click on the “+” under “Link Binary With Libraries” to add a new library. Add UserNotifications.framework. This framework is required since iOS 10 for push notifications handling.
2. Again click “+”, select libRNFirebase.a and add it. If you are unable to find it, clean and build project.
3. Go to Build Settings, find Header Search Path, double click its value and press “+” button. Add following line there:

$(SRCROOT)/../node_modules/react-native-firebase/ios/RNFirebase

Use “Cmd +Shift + Enter + K” keys to clear cache and then build project. Now firebase dependencies should be recognized by xcode.

4. In AppDelegate:

Receive Push Notifications

Now lets code the most awaited part… Receiving Notifications! 😉

Handling Permissions

Before app can get any notifications, it is crucial to ask permission from user specially in iOS. If user didn’t allow your app to receive notifications, it can never get any unless user explicitly change it from Settings.

Open main component of your React Native app, from where basically routing starts i.e. App.js. Modify file as per the snippets below.

1. In componentDidMount, we check if user has granted permission to receive push notifications.
2. If permission hasn’t been granted to our app, request user in requestPermission method. If permission is successfully assigned, proceed towards token fetch, otherwise gracefully ignore the fact.
3. If token was fetched earlier, it can be retrieved from AsyncStorage. If no token is found, request Firebase and save it in AsyncStorage.

Listening Notifications

We are now ready to listen push notification events. Before proceeding, you should know about different types of notifications supported by Firebase.

• Notification-only messages: These are display messages that are automatically handled by Firebase SDK. Notifications are thrown to device tray.
• Notification + optional data messages: These are also handled by Firebase SDK. Only difference here is when user taps on notification, your app receives payload associated with that notification.
• Data only messages: These types of notifications are handled exclusively by app. No notification is thrown on device tray unless app explicitly does so. In iOS, these types of notifications are also termed as ‘Silent Push Notifications’.

For more details, you can read from here.

Add these lines in App.js.

I hope comments would be enough to explain all scenarios. You should be now able to receive notifications on both platforms.

In iOS, you need to test on Device to receive notifications. iOS Simulator doesn’t support Push Notifications currently.

In Android, if you want to test on emulator, you need to install Google Play Services package.

React-native-firebase is a nice wrapper over Firebase for react native. However, there are few points you should know:

1. In Android, if you tap on notification when app is killed, this library won’t be able to catch title and body of notification. Therefore these attributes will be undefined in showAlert function. As a solution, you should also send title and body in data payload of notification.
2. To this date, Silent Push Notifications on iOS are not supported by this library. I have already opened an issue on their repository.
3. To listen for data message notifications while the app is in background or killed in Android, you need to implement Headless JS functionality. For details, please refer to this link.

Hope this tutorial saves your time and make FCM integration easy in react native. If it helps you in anyway, don’t forget to clap! Thanks :)

References:

• React Native Firebase - Simple Firebase integration for React Native
• invertase/react-native-firebase-docs