How to Make Your App Available Offline
Nowadays, users expect apps to work even when they’re offline. Otherwise, a poor network connection translates into a poor user experience. According to Localytics, 21% of users abandon an app after just one use.Push notificatons, in-app-messaging, and offline mode help to retain users.
Offline mode is a must for delivery apps with GPS navigation, apps for urgent medical assistance, and banking apps.
How to decide on offline features for your app
Unfortunately, there’s no one-size-fits-all approach or magic wand to create the ideal offline mode for your app. You have to do your own homework, but here’s a formula that may help:
- Analyze your workflow, determine your business needs, and translate them into app features.
- Prioritize these features as ones your business can’t live without, ones that are important but not absolutely urgent, and ones that would be nice to have.
- Decide what you want to achieve through your app.
Sharing this information with your developers will help them understand your business goals and suggest the proper technologies for a well-tailored solution. To decide on offline functions, you can use the well-known Eisenhower Decision Matrix. It will help you see what’s important and what isn’t. To fill out the matrix:
- Write down features and interactions that you want to be available offline.
- Interview users to determine how important each feature/interaction is for them.
- Define how difficult it will be to implement each feature.
- Put this information into the matrix and prioritize.
As a result, you’ll have a list of offline features and will be ready to figure out how to implement them.
For example, say you’re considering implementing an offline payment gateway. You can interview users to define how important this feature is for them. Then you can estimate the time and effort to implement it. The position of this feature in the matrix will help you define if it’s worth the trouble.
How to choose technologies for offline mode
The technologies you pick will have a big influence on how your app’s offline mode works. Consider the following when picking technologies:
Frequency of data synchronization. Reconnecting too often might drain a phone’s battery. But if an app synchronizes too seldom, users might miss essential updates. Work with your developers to find a balance. To do that, you’ll have to investigate how often your users can access high-speed internet. If people use your app for work, define which slots in their work schedules are good for downloading data. The better the data connection, the shorter those slots can be.
Data synchronization cycles and time. Data should be prioritized according to business needs. Some data may be updated once a year, while other data needs to be updated a few times a day. You can determine different synchronization cycles for different data according to the needs of the business. The smaller the data packages requiring high-frequency updates, the better. Your app may not need constant data synchronization. If it does, you can sync data at a specific time. For instance, public transport carriers tend to fully synchronize when vehicles are in depots. At any other time, vehicles forward only vital data, such as data on accidents along the route.
Managing changes in shared data.
If users are offline, changes to data can’t be available to other users. This means that several users may work on the same data without seeing how others have modified it. If you can’t avoid such a scenario, focus on exception handling and determining rules for how to deal with those exceptions.
Handling sensitive data.
Private user data can’t be cached at all for security purposes. Downloaded information such as logos and blog posts is stored in a cache folder on a user’s smartphone so it doesn’t need to be downloaded each time the user accesses that content. Any cached information can be viewed by checking the browser’s cache or by pushing the browser’s Back button. This puts sensitive information such as credit card details and usernames at risk. Therefore, make sure sensitive data is not cached.
Method of syncing.
Answer these questions to choose the most appropriate technologies for your offline mode:
– Should data transfer be synchronous or asynchronous?
– Will data be synced automatically or manually?
– Will the app actively ask the server for updates or will the server itself send new data to the app?
Web and mobile apps can be created with local storage/databases and data synchronization. Let’s check out the details of implementing offline mode for web and mobile.
Digging deep into the technical details
There are some differences between implementing offline mode for web and mobile. Let’s take a closer look at the basics of storing and synchronizing data for both web and mobile applications.
Ensuring data sync for web and mobile apps
When an app is used offline, there are many actions and much data you have to sync with the server. This syncing can happen whenever an internet connection is available. For web apps, user actions can be stored in IndexedDB as jobs to sync. As soon as the network is available, these jobs can be processed one by one. With a mobile app, it’s likely you’ll have both client- and server-side storage. Let’s look at the details of data syncing for web and mobile apps.
Offline sync for a web app
When you store offline data in the browser, you have to upload it to the server whenever the network is available. To make sure data syncs properly, do the following:
- Determine the smallest amount of data to store locally.
- Select as little data as possible to transfer from the server to the device.
- Set a trigger to initiate the sync, manually or in the background.
- Configure conflict resolution.
- Identify and prioritize data sets for syncing.
- Indicate the factors that will trigger a sync.
- Establish a balance between sync frequency and battery drain.
- Elaborate the retry mechanism.
- Send a sync status notification to users.
Offline sync for a mobile app
Using an offline app, users can take actions offline and then synchronize changes with a central repository. To do this, your app will need to manage the flow of information between the server and client.
In most cases, offline mode is used in situations when users can edit information on the server-side and on the mobile side. This is the best-case scenario. Even though it may be alluring to create offline apps supporting two-way sync, it’s the most complicated method.
If you support two-way sync, your synchronization logic has to ensure that data is up to date on the mobile and server sides simultaneously.
There are a number of data storage methods to make an app work offline, and they differ for iOS and Android.
The Android platform offers SharedPreferences APIs that can be used for saving a comparatively small amount of primitive data in key-value pairs. Put simply, a SharedPreferences object is a reference to a file with key-value pairs. When using SharedPreferences, you have a key (which is a string) and the value for that key. The value can be a boolean, float, int, long, or string. Android stores all SharedPreferences files as XML files in a private directory. An app may contain various SharedPreferences files. There are methods that can be used for receiving a SharedPreferences object. One of them is used if an app contains a single preference file. The other is used if an app contains more than one preference file or if you want to give a custom name for the SharedPreferences instance.
To implement offline mode for an iOS app, you can use the NSUserDefaults class to save and update users’ preferences. The NSUserDefaults class delivers a programmable interface, allowing an app to customize its behavior according to a user’s preferences. For instance, you can enable users to save a profile picture offline or add a function that automatically saves documents. The app records such preferences in the user defaults system. In such a way, data is cached, helping you avoid opening the user defaults database whenever you need a default value. As this default system is available within your app’s code, any data saved to it will persist across app sessions. When a user closes your app or resets their mobile devices, they still can use the saved information the next time they enter the app.