Forem: Anurag Jayaraman

Develop a Cryptocurrency Tracker on Android

Anurag Jayaraman — Fri, 09 Jul 2021 11:50:31 +0000

This guest post on the Applozic blog was written by Mr. Dennis Muasya. His specialty lies in designing and developing advanced applications for the Android platform. You can check out his personal website or find him on Twitter.

Introduction

A cryptocurrency is a form of digital currency that uses cryptography, and its creation and transfer are based on open-source code. Cryptocurrencies had an initial boom in 2009 when Satoshi Nakamoto established the first cryptocurrency, Bitcoin. Since then it has become one of the most valuable types of cryptocurrencies accepted as payment for goods or services worldwide from businesses such as Amazon to Subway sandwich shops! There are now hundreds of types of cryptocurrencies available to trade online. Some popular ones include Ethereum, Ripple XRP (Ripple), Litecoin LTC (LiteCoin), Monero XMR (Monero), Dash DASH (Dash), and more.

In this age of the digital world, money is constantly changing and what has been popular in recent years are now being replaced by more advanced technologies. The payment industry especially feels these effects with how many people use cryptocurrencies for payments instead of traditional currencies backed up by governments. Japan, alone among other countries such as Venezuela who have also legalized it to some degree alongside others like Switzerland who offer cryptocurrency debit cards that provides access to both Bitcoin or Ethereum funds from your crypto wallet whether you're at home on a laptop or abroad using an ATM card connected over Bluetooth wireless technology without going through any banks whatsoever if they even exist where you currently happen to be located when wanting cash transactions back down south across borders not just domestically but internationally too while fiat currency can't

In this article, we will create a Bitcoin Tracker App Project in Android using Java and XML. Using a Bitcoin API, the application will display current Bitcoin rates in various regions. There are numerous free APIs accessible, and we will be using CoinMarketCap's API for this project. The API will return a JSON file, which we will parse to meet our requirements. In this app, there will be only one activity. A sample GIF is provided below to give you an idea of what we'll be doing in this article. Why should we confine ourselves to only code? Why not broaden it to include everyday utility chores for us?

In light of this, I've created the app to demonstrate the capabilities of tracking different cryptocurrencies in real-time on Android smartphones.

App Preview

It's usually a good idea to have a visual and practical understanding of what you're doing and how it works, so check out the image below to see how this app works:

Screenshots of the CryptoTracker Android app

The GitHub repository for this project can be found here.

Glossary

Cryptocurrency is a digitized medium of trade that uses encryption techniques to regulate the generation of units and verify transactions as well as control the transfer of digital currencies. It's impossible to counterfeit, so it has become an attractive currency for many people who are wary of their local economy or want more privacy in their financial dealings. Today, there are over 1,000 different varieties of cryptocurrency in use, with Bitcoin being the most popular by far.

The CoinMarketCap API is an open-source project that provides a simple interface for retrieving market data. The API supports 38 exchanges, with more coming soon. Bitcoin (BTC), Ethereum (ETH), Bitcoin Cash (BCH), Ripple (XRP), Litecoin (LTC), and many other cryptocurrencies are currently supported. A list of all the coins can be found on this page.

If you are an Android developer and need to get cryptocurrency prices, the CoinMarketCap API is a great place to start. With this API, you can pull data from multiple exchanges and aggregators in one call. This enables developers to build apps that compare cryptocurrencies across markets or display pricing graphs over time for any currency pair.

Steps:

Before we start developing, it's a good idea to go over the technologies we'll be using so you don't become confused as we go.

Retrofit is a Java and Android-based REST client. It makes retrieving and uploading JSON (or other structured data) using a RESTful web service extremely simple.
RecyclerView – Android layouts for better content organization on the screenCreate a new Android Studio project named "CryptoTracker." If you're just getting started, go to any of my prior tutorials on how to set up a new AS project.

After you've done creating a new project, install the technology's dependencies.
Install the dependencies for the technologies we discussed after you've finished building a new project. Add the following to your app-level build.gradle file:

Step 1: Adding required dependencies

We'll add the following libraries:

To handle REST-API requests, use OKHttp.
GSon is a tool for quickly parsing and converting JSON data.
Image fetching and caching in asynchronous mode have been retrofitted (essentially making this project doable in under 30 minutes).

Add the following dependencies to the project-level build to get started:

dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation 'com.android.support:appcompat-v7:28.0.0-rc01'
   implementation "com.android.support:support-core-utils:28.0.0-rc01"
   implementation 'com.android.support.constraint:constraint-layout:1.1.2'
   implementation 'com.android.support:recyclerview-v7:28.0.0-rc01'
   implementation 'com.google.code.gson:gson:2.8.2'


   implementation('com.squareup.retrofit2:retrofit:2.1.0') {
       exclude module: 'okhttp'
   }
   implementation 'com.squareup.retrofit2:converter-gson:2.3.0'
   implementation 'com.squareup.okhttp3:logging-interceptor:3.9.1'
   implementation 'com.squareup.okhttp3:okhttp:3.10.0'
}

Step 2: Adding permissions to the manifest

To use the above libraries, we must add the following permission to our AndroidManifest.xml:

   <uses-permission android:name="android.permission.INTERNET" />

Step 3: Creating the activity_main.xml file

In our layout format, we must first add the activity main.xml. This is the location where all of our models will be placed. Because this will span my entire operation, I've set the width and height to match_parent. You have the option of selecting the measurements that best suit your requirements. We're utilizing a RecyclerView, as you may have observed, so we'll need to develop a layout for the RecyclerView Item.

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   tools:context=".MainActivity">

   <android.support.v7.widget.RecyclerView
       android:id="@+id/my_recycler_view"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:scrollbars="vertical" />

</android.support.constraint.ConstraintLayout>

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on Applozic blog for you to continue with your development!

Click here to learn how to:

Create the crypto_list_item.xml file
Create the MainActivity.java file
Create the CryptoListAdapter.java file
See your app in action!

Firebase: Start up your base or fire up your own servers?

Anurag Jayaraman — Wed, 30 Jun 2021 13:17:54 +0000

This article was originally published on Applozic Blog.

If you clicked this article because of the word "Firebase", you have probably been a part of a mobile application development lifecycle at some point in your life. Some of the services offered by Firebase like Firebase Cloud Messaging (FCM), Firebase Dynamic Links, Firebase Remote Config have become synonymous with the features they implement in your applications. At my current organization, Applozic, FCM is used for push notifications for Android applications built on our platform. At a global level, Firebase is currently among one of the top app development platforms relied upon by developers across the globe.

That said, Firebase's offerings in the Backend-as-a-Service(BaaS) space are not the be all, end all in terms of application development. In this article, I would like to explore some of the features as well as shortcomings application developers have encountered with Firebase, and whether your application might be better suited with your own backend solution.

What is Firebase?

Firebase helps you develop high-quality apps, grow your user base, and earn more money. Each feature works independently, and they work even better together.
https://firebase.google.com/use-cases

Firebase is a mobile application development platform from Google with powerful features for developing, handling, and enhancing highly functional and versatile web, Android, and iOS platform applications.

Firebase categorizes its services and by creating solutions of these three main problems for developers:

Build : Accelerate and scale app development without managing infrastructure
Release & Monitor : Release applications with confidence and monitor their performance and stability in realtime.
Engage : Boost engagement with rich analytics, A/B testing, and messaging campaigns

Firebase's ideal customer

Firebase Use Cases page has some interesting application use-cases which cover some of their more popular offerings and how these services solved a business problem or boosted the customer retention after onboarding. Of course, these are the high visibility success stories where businesses were profitable and Firebase helped them take the next step in their development journey. You can find their showcase use cases here.

To understand what type of customer would benefit the most from Firebase services, let's take a look at their current pricing plan, and see how George (a fictional character) created an application using Firebase.

Building the basics for your app

George woke up from bed with a great idea for an app and wanted to implement the minimum viable product to make sure the idea gets implemented. Firebase offered George unique services with dedicated APIs that helped with the initial setup of creating a database, managing authentication, storage, messaging, testing, etc., without ever having to understand what is going on in the backend.

The phrase "pace over perfection" is best suited for use cases like this, where the priority is to get a feature implemented over worrying about the nitty-gritty of implementation and since George used only the Free plan, he was able to get an application shipped in minimum possible time.

Firebase pricing plans comparison

A month has passed since George released his app, and he is happy with its success. The app has over 10,000 downloads on mobile and people are using and re-using the app at a moderate level. Everything is great on the public side of the picture.

Storage Constraints

Behind the scenes though, the application is reaching its quotas on most of the services. George's app has a lot of inbuilt messaging capabilities and users are sending rich messages (GIFs, emoticons, and animated features) and attaching files in one to one conversations and that is fulfilling his Cloud Storage quota rapidly.

Free plan vs Paid plan for Firebase Cloud Storage

George considers moving his storage solution to a more cost efficient service like AWS S3, but finds out that due to a Vendor lock-in, he cannot simply migrate from Google Cloud Storage without having to completely rebuild how the app functions.

Security Constraints

As the number of users increase, George wants to implement phone authentication as a security measure but finds that the quota for Firebase authentication has already reached its limit, and he needs to either scale up to the paid plan or not implement this feature.

Free plan vs Paid plan for Firebase Authentication

Customization Constraints

Seeing the increasing challenges in maintaining his app in a free to download version, George wants to implement a few exclusive features which then he can ship as a paid app for regular users. He wants to implement customized API calls that will utilize the Realtime Database(RTDB) to provide the users with accurate data. However, Firebase APIs are non-customizable and the quotas for the RTDBs are constraining the ability to onboard new users or implement new features.

Free plan vs Paid plan for Firebase RTDB

Point of no return

The time has arrived for George to make a decision regarding the app's future. To ensure his app keeps functioning, he has to take one of the following decisions:

Move to the paid plan by sourcing investment and giving up partial/full control over his app.
Move to the paid plan by monetizing his app and asking users to pay to use the service.
Move away from Firebase services and create a robust backend and storage solution that can withstand scalability without causing disastrous financial repercussions.

Solution 1 and 2 might be good for the short term if the practicality of cost can be solved by George. However, unless George is able to scale up his development efforts and gain a lot more users for his app, these solutions are not going to help in the long term.

Solution 3, while being the most suitable for the long term, is not viable from the perspective of development or immediate implementation.

So who exactly is the ideal customer for Firebase?

If you are just starting your app development journey, Firebase and its services are a great place to start implementing a minimum viable product.
If you are an Enterprise with oodles of funding and already use the Google Cloud platform, Firebase complements your application with robust APIs and services.
If you are somewhere in between, Firebase might not be the correct solution for you!

What developers say

Multiple articles on blogs and users across social media sites like Reddit, Twitter have opined their views on Firebase, and I have tried my best to summarize them here.

Costs increase exponentially based on data usage

As we saw in George's case, Firebase's current pricing plans are suitable for the initial development of an app (free plan using less data) or enterprise level customers (high cost high value). While Firebase does offer a free plan, but that comes with hard quotas and restrictions that might hinder your application's usage.

Works only with NoSQL Databases

Firebase offers two database options - Firestore and Firebase Realtime Database. Both of these have a NoSQL structure, and there is no option to use a relational database.

This becomes a big problem when a developer wants to migrate some or all of their services to other providers and since Firebase uses JSON to store data, there is almost no easy way to be able to migrate from the existing database.

Comparison between SQL and NoSQL

Firebase can be geo restricted

Firebase is a subdomain of Google, and their official website is https://firebase.google.com, the services can be blocked in any country by a domain ban. This means that if George wanted to publish his app in a country where Google cannot be accessed, he will have to rebuild his core infrastructure to something that is available in that country.

You can find the list of active disruptions to Google on this page.

Vendor Lock In

Developing an application using a non open source tool set can be frustrating when you want to add a certain feature or migrate to another service, but due to incompatibility, you are forced to stay with the same service, sometimes at a higher price or lower quality of service. This is called "Vendor Lock In", and it is a prominent detriment in complex applications which use multiple services.

Conclusion

If you are in the beginning stages of your app development journey, and your app can be considered "small" - it doesn’t require complex data queries and relies on real-time updates, Firebase is one of the most robust and cost efficient BaaS that you can utilize.

However, as the complexity of your app grows and there is an acute need for customization, high volume data transfers, better data structuring for analysis and querying, Firebase loses its sheen. As a developer, it would be more efficient to create your own backend or build upon existing IaaS platforms.

Have you used Firebase services and what prompted you to use/leave Firebase in search of a solution? If you have ever developed using Firebase, do share your experience as a comment below!

Learn how to set up your Android application with Firebase in 4 easy steps!

Applozic Android SDK Tutorial 4 – Push Notifications using Firebase

Anurag Jayaraman for Applozic Inc ・ Jun 30 '21

#android #tutorial #firebase #applozic

Applozic Android SDK Tutorial 4 – Push Notifications using Firebase

Anurag Jayaraman — Wed, 30 Jun 2021 12:58:03 +0000

This tutorial is Part 4 of a multi-part series covering Applozic Android SDK integration into an Android app.

Our goal is to learn the following steps in this tutorial:

Create FCM key for your app in Firebase
Enable FCM notifications from Applozic dashboard
Integrate Firebase handler in your app
Process the received notifications

You can download the sample Android chat app from Applozic GitHub.

💡 If you already have FCM set up for your app, move directly to Step 2.

Firebase and FCM key

💡 FCM (Firebase Cloud Messaging) was previously called GCM (Google Cloud Messaging).

To learn more about Firebase's features and use cases, check out my dev.to post:

Firebase: Start up your base or fire up your own servers?

Anurag Jayaraman ・ Jun 30 '21 ・ 8 min read

#firebase #opinion #startup #technology

Generate FCM key in Firebase

Firebase Main Screen

In your project dashboard, click on the "Settings" icon > "Project settings".

Project settings

Go to the "Cloud Messaging" tab.

Cloud Messaging tabs

The "Server key" and the "Sender ID" are your private credentials.
Leave this tab open and proceed to the next step.

Server key location

Set up FCM Notifications

The Server key is an API key that is a unique string used to route requests to your Firebase project when interacting with Firebase and Google services.

Your FCM credentials are unique to the project you have created, so keep them secure and do not share them with anyone.

Update FCM Server key in Applozic Dashboard.

Go to your Appl ozic Dashboard. Click on "Settings".

Settings in Applozic Dashboard

Click on "Chat" > "Notifications".

Notification tab under Chat

Click "Add Credentials" under FCM and paste the "Server Key" from Firebase credentials.

Add FCM Credentials

Voila! Your app is set up for use with FCM.

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration!

Click here to learn how to:

Integrate FCM in your application
Process the received notifications

Applozic Android SDK Tutorial 3 - Chat Conversations

Anurag Jayaraman — Wed, 30 Jun 2021 09:32:10 +0000

Introduction

This tutorial is Part 3 of a multi-part series covering Applozic Android SDK integration into an Android app.

Our goal is to learn the following steps in this tutorial:

Launch Conversation list screen
Create individual chat thread
Create group chat thread
Create context based chat thread
Delete chat threads

You can download the sample Android chat app from Applozic GitHub.

Conversation screen

To give you an idea of what the conversation screen would look like in the final app, take a look at the screenshot below.

Android Conversation screen

To get started with such a conversation screen, add the following code:

Intent intent = new Intent(this, ConversationActivity.class);            
startActivity(intent);

You can set this to activate as soon as the user opens the conversation screen.

Individual Chat

From the main conversation screen, the user can choose to launch either an individual conversation thread or a group chat thread.

An individual chat screen will look like this:

Individual chat screen

For starting individual conversation thread, set "userId" in intent:

Intent intent = new Intent(this, ConversationActivity.class);            
intent.putExtra(ConversationUIService.USER_ID, "receiveruserid123");   
intent.putExtra(ConversationUIService.DISPLAY_NAME, "Receiver display name"); 
//to display the title.
intent.putExtra(ConversationUIService.TAKE_ORDER,true); 
//Skip chat list on back press 
startActivity(intent);

Group Chat

A group conversation contains multiple users that can send and receive messages. Internally, a group conversation is referred to as a channel.

Applozic supports multiple group types that serve different purposes.

Value	Name	Description
1	Private Group	Private groups are not accessible to contacts other than the ones present in the group. Only group admin can add/remove members in the group. You can create private groups to facilitate close, WhatsApp style interactions. For example, doctor-patient chats.
2	Public Group	Users will be able to search and join Public groups. Any group member can add/remove members in this group. For example, Public groups can be used to create area-wise communities in a social app where users can search their area's community and join.
5	Broadcast Group	A message can be sent to several contacts at once. Messages sent in the broadcast group are received by the members of the group as one-to-one chat thread. Only the sender can see the broadcast group. The broadcast group works on a similar behavior as that of WhatsApp broadcasts.
6	Open Group	Used for free-flowing chats such as live streaming chats, live event chats etc. You need not add any members to this group. All users present on the chat screen will receive messages via MQTT (publish/subscribe pattern). Push notifications are not supported in Open groups.
7	GroupOfTwo	Used for the purpose where dealers are selling products and any particular user wants to chat about multiple products with the same dealer. At that time, it is required to show two different chat threads in the conversation history as the context (product) of the chats is different.
9	Contacts Group	Used for creating Friends/Favorites contact List. These lists can be maintained on the application level and any member of the group can access it. For example, an event management company can use the lists to maintain attendees of an event at one place.
10	Support Group	Best suited for people who want to use Applozic's sister product, Kommunicate. These groups are specifically built for the purpose of customer support chat and may contain multiple team members and chatbots talking to a user.

Table showcasing different group types

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration!

Click here to learn how to:

Create a group chat thread
Create a context based chat thread
Delete chat threads

Android SDK Tutorial 2 – Authentication and Authorization

Anurag Jayaraman — Wed, 16 Jun 2021 20:19:30 +0000

Introduction

This tutorial is Part 2 of a multi-part series covering Applozic Android SDK integration into an Android app.

Our goal is to complete the following steps in this tutorial:

Learn how to generate an access token for your application
Create a User Object
Register/Login the user
Update password for user
Update User Details

What are Authentication and Authorization?

In the simplest terms, we can classify them as:

Authentication: Proving your identity to an entity
Authorization: The ability to interact with an entity

Authentication vs Authorization

Authentication and authorization with APIs have a lot of value, some of them are:

Authenticate that calls to the API are done by registered users only
Maintain a record to track which user is making the requests
Track the total usage of the API calls across users and applications
Notify any user who exceeds their plan limit
Apply different permission levels to different users

Now that we have learnt the need for authentication and authorization, let's get started with the first step in this tutorial.

Generating Access Token

Access Token URL (Authentication URL) is required to ensure your platforms are safe from unauthorized access. This can be configured by the Application admin in Applozic Dashboard for authenticating users from your backend server.

Setup Access Token URL in Dashboard

Login to Applozic Dashboard
Go to Dashboard. Select Application -> Action -> Edit -> Security.
Enter your server URL for authentication in the "Access Token URL" field.

Application screen in Dashboard

Security Tab in Edit Application settings

Note: Configured Access Token URL should accept POST request with data passed as request body in form-url-encoded.

You can now use an API testing tool like Postman to verify your access.

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration!

Click here to learn how to:

Create a User Object
Register/Login the user
Update password and User details

Please leave your feedback and doubts in the comments below!

Applozic Android SDK Tutorial 1 – Setup and Configuration

Anurag Jayaraman — Fri, 11 Jun 2021 09:02:03 +0000

Introduction

In this tutorial you will be learning how to integrate the basic functionalities of Applozic Android SDK to get started with your own chat application.

Our goal is to complete the following steps in this tutorial:

Create Applozic account and receive API key
Set up Android Studio
Integrate Applozic Chat SDK in your app
Configure the basic dependencies for your app

You can refer to the Applozic Android SDK documentation here.

Prerequisites

Applozic account (Create your account here) for API/Application Key
Android Studio (latest version)

Create Applozic account

Sign Up

Enter your personal dashboard after signing up for Applozic.

Get your App ID

Go to Settings > Configuration > Install.
Copy the App ID and use it whenever required.

This is your App ID. You can use this as a unique key for your application.

Set up Android Studio

Creating New Project

Create a new project using File ➙ New Project on the top right of the application.

Create a new project

Select "Empty Activity" from the list under "Phone and Tablet"

Select Empty Activity > Next

Rename the project as per your preference. I will name mine as applozic-tutorial-app.
Make sure to set the minimum SDK as Android 6.0.

Add a unique name and set the minimum SDK supported

Wait for your background tasks to complete.

Background tasks

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration!

Click here to learn how to:

Integrate Applozic Chat SDK in your app
Configure the basic dependencies for your app
Configure ProGuard rules

Please leave your feedback and doubts in the comments below!

Real Time updates in your iOS app using Pub/Sub

Anurag Jayaraman — Wed, 26 May 2021 07:31:49 +0000

Introduction

This tutorial will cover how to set up real-time updates for your application using Applozic SDK integrations.

You will learn how to:

Subscribe/unsubscribe to topics and handle callbacks.
Setup typing status indicators in your 1-to-1 and group chats.

In Applozic SDKs, real-time updates are handled by the pub-sub messaging pattern. Let's take a look at some of the basic concepts of what pub-sub means in a messaging paradigm.

The Publish-Subscribe messaging pattern

In a publish-subscribe (often called pub-sub for brevity) architecture, a central source of information called a broker receives and distributes all data in the network. Pub-sub clients can publish data to the broker or subscribe to get data from it—or both.

The important concept to remember in pub-sub is that a communication channel topic is set up between a server and several clients. This channel is represented by a persistent network communication (WebSocket, MQTT, etc.). The intermediary which handles data transfer based on subscriptions is called the broker.

The broker does not store data; it simply moves it from publishers to subscribers. When data comes in from a publisher, the broker promptly sends it off to any client subscribed to that data.

Pub-Sub message flow

This is different from the standard request/response (pull) models in which publishers check if new data has become available. This makes the pub/sub method the most suitable framework for streaming data in real-time. It also means that dynamic networks can be built at scale using pub-sub architecture.

Setting up real-time updates in your application

As a starting point for this tutorial, we are going to consider that you already have a working application and have implemented one of the Applozic Chat SDKs.

You can follow these tutorial articles in case you want to set up your application with the iOS Chat SDK or iOS Voice and Video SDK offered by Applozic.

If you face any difficulties while following this tutorial, you can contact us at support@applozic.com.

Connecting to publish

In order for a subscriber to receive messages on a topic, it needs to be subscribed and also needs a custom security policy to allow the topic to deliver messages to the queue. The following code handles both of these for you, without you ever having to deal with the details around building that custom policy.

Note: Please replace <APP_ID> with your App Id

ApplozicClient *applozicClient = [[ApplozicClient alloc]initWithApplicationKey:@"<APP_ID>" withDelegate:self];

[self.applozicClient subscribeToConversation];

Disconnecting from publish

If you want a subscriber to stop receiving messages on a topic, you can disconnect using the following code.

[self.applozicClient unsubscribeToConversation];
Note: subscribeToConversation and unsubscribeToConversation need to be called in Appdelegate 
and in your VIewController file also where you want callbacks in 
applicationWillEnterForeground or applicationDidEnterBackground

Setting up Typing Status Indicator

Typing indicators allow you to indicate if users are typing messages in a 1-to-1 or group chat. You can trigger a typing event when a user starts typing a message and this will let the user publish their typing status to anyone who has subscribed for the same.

Sending typing status

You can publish your typing status using the code given below.

[self.applozicClient sendTypingStatusForUserId:recieverUserId orForGroupId:channelKey withTyping:isTypingStarted];

Call the above method once a user starts typing in textViewDidChange or stops typing in textViewDidEndEditing.

Argument	Type	Description
recieverUserId	String	Pass recieverUserId in case of 1-to-1 typing status and pass channelKey as nil
channelKey	NSNumber	Pass channelKey in case of group/channel typing status and pass recieverUserId as nil
isTypingStarted	Bool	Pass true or YES in case user started typing Pass false or NO in case user stopped typing

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration!

Click here to learn how to:

Handle the delegate callbacks
Subscribing and Unsubsribing to typing status

Please leave your feedback and doubts in the comments below!

Integrate voice and video chat in your iOS app

Anurag Jayaraman — Wed, 26 May 2021 07:24:38 +0000

Introduction

Applozic's iOS Audio and Video Call SDK provides you with all the necessary components to build a real time chat with voice and video capabilities within your application, and enables you as a developer to implement conversational chat, push notifications, group chat, picture in picture and many more such features!

One of the worldwide effects of Covid-19 and the resulting governmental lockdowns was the acute rise in the need for real time communication across multiple industries. A few major ones, like healthcare, education, and technology support witnessed the birth and rapid growth of first to market applications that catered to the varied needs of the customer. For example, the features offered in telemedicine caused much needed disruption in a field with vital importance on immediate communication.

In this tutorial, we will leverage the Applozic iOS Voice and Video SDK to create a real time chat application that can be used across industries like real time customer support, 1 on 1 telemedicine, personal therapy, etc. With HIPAA compliant security on all your conversations and programmable personalization capabilities to improve customer experiences, Applozic enables you to drive better engagement, increase interactions with your users, and improve your chances of retaining those customers through high-quality video and audio.

Creating your own real time communication app

Applozic Audio-Video Call SDK provides high-quality IP audio and video calls capabilities within your application. With this SDK, your application's users can take part in secure 1-to-1 calls and automate workflows by building reliable conversation systems through voice-calling and video-calling. You can create a standalone application for communication using this SDK, or integrate it with your existing application.

Note: The Voice and Video SDK is a beta product and new features will be added in the upcoming months.

If you face any difficulties while following this tutorial, you can contact us at support@applozic.com.
To check out our cocoapods sample app, click here.

Requirements

Here are some of the dependencies you will need:

Xcode 12.0 or later
CocoaPods 1.9.0 or later
Your project must target iOS 11 or higher

We are assuming the following application is going to be written using Objective-C. For corresponding code in Swift, please check the documentation in our github repository.

Application Setup

To use the Applozic iOS Audio Video SDK and leverage pre-built components that you can easily customize, you can sign up for Applozic and get your APP_ID from the install section of the console.

Installation - Setup the building blocks for audio and video capabilities

Cocoapods

ApplozicAudioVideo is available through CocoaPods.
To install it, setup your Podfile located at /ios/Podfile and add below pod dependency:

source 'https://github.com/CocoaPods/Specs'
use_frameworks!  # Required to add 
platform :ios, '11.0' # Required to add

target 'TARGET_NAME' do
    pod 'ApplozicAudioVideo'  # Required to add 
end

Navigate to YourApp/ios directory from terminal and run the below command:

pod install

Note: If you do not have pod dependency, check out how to get started here.

The Audio-Video Call SDK includes our iOS messaging SDK. If you have added the pod 'Applozic' in your Podfile please remove that and replace it with 'ApplozicAudioVideo'.

Add Permissions

Add permissions for Camera, Photo Library, Microphone, Contacts and Location usage.

Note: We won't be asking the users for these permissions unless they use the respective feature. Due to Apple's requirement, we have to add these permissions if we are using any of their APIs related to Camera, Microphone, etc.

Open Info.plist from /ios/YOUR_PROJECT_NAME/Info.plist file and paste these permissions anywhere inside the <dict> tag.

<key>NSCameraUsageDescription</key>
<string>Allow Camera</string>
<key>NSContactsUsageDescription</key>
<string>Allow Contacts</string>
<key>NSLocationWhenInUseUsageDescription</key>
<string>Allow location sharing!!</string>
<key>NSMicrophoneUsageDescription</key>
<string>Allow MicroPhone</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>Allow Photos</string>
<key>NSPhotoLibraryAddUsageDescription</key>
<string>Allow write access</string>

Setup Application ID

At this step, you should already have signed up for Applozic and obtained your APP_ID.

Open the ALChatManager.h file and replace “applozic-sample-app” with your APP-ID.

#define APPLICATION_ID @"&lt;YOUR_APPLOZIC_APP_ID>"

Once you are at this stage, follow the Applozic documentation to complete the authentication, set up of user profiles and other such basic building blocks of your application.

Continue this Tutorial on Applozic Blog!

We have the detailed tutorial with code snippets available on our blog for you to continue with your integration and configuration.

Click here to learn how to:

Set up Authentication
Add Audio/Video configuration
Set up push notifications
And many other features!

Please leave your feedback and doubts in the comments below!

Set up APNs to deliver instant notifications in your iOS app

Anurag Jayaraman — Mon, 24 May 2021 13:46:17 +0000

This article was first published on Applozic Blog.

Introduction

It's 8 pm and you're tired after a long day of work. You want to order in food but you also need to be on video for the marketing call for the next hour. How do you know when the food has been picked up and delivered without surreptitiously checking your iPhone?

Push Notifications!

The little ding of your phone that reminds you to check it for the latest notification and satiate your fear of missing out (FOMO) on what's going on with the world - did you know that this technology is possible through a technology called APNs?

Apple Push Notification Service (APNs) enable you to deliver remote notifications (also known as push notifications) that push small amounts of data to devices that use your app, even when your app isn’t running.

How does APNs work?

The delivery of remote notifications involves these key components:

Your organization's server (known as the provider server)
Apple Push Notification service (APNs) set up
The user’s device
Your app (running on the user’s device)

Remote notifications begin with your company’s server. You decide which notifications you want to send to your users, and when to send them. When it’s time to send a notification, you generate a request that contains the notification data and a unique identifier for the user’s device. You then forward your request to APNs, which handles the delivery of the notification to the user’s device. Upon receipt of the notification, the operating system on the user’s device handles any user interactions and delivers the notification to your app.

You’re responsible for setting up a provider server (or servers) and for configuring your app to handle notifications on the user’s device. Apple manages everything in between, including the presentation of notifications to the user. You must also have an app running on the user’s device that can communicate with your server and provide necessary information.

What does APNs provide?

APNs provides a mechanism to ensure your app makes every effort to deliver your notifications from your server, and to deliver them with the best user experience:

APNs manages an accredited, encrypted, and persistent IP connection to the user’s device.
APNs allows you to remotely lock/wipe a lost/stolen/compromised device over the air.
APNs can store notifications for a device that’s currently offline. APNs then forwards the stored notifications when the device comes online.
APNs can combine notifications for the same app and display them at once.

What can you use push notifications for?

Display a short text message, called an alert, that draws attention to something new in your app.
Play a notification sound.
Set a badge number on the app’s icon to let the user know there are new items.
Provide actions the user can take without opening the app.
Show a media attachment
And many more such actions!

Now that we have a clear understanding of how we can use APNs in our applications, let's learn about how we can set them up!

Set up APNs in your chat app

In this tutorial, we will be learning how to set up APNs in your application and integrating the remote notification service. For the purpose of this tutorial, we will be using Applozic's iOS SDK offering. Please follow our documentation at GitHub and complete the first two steps in your integration process,

Initial Setup and adding frameworks and permissions.
Registering a user for your application

Configure your app and register it with the APNs

Creating APNs certificates

For Apple to send push notifications to user devices, you need to create an APNs certificate in your Apple developer account.

Visit this link, to create Apple Push Notification service SSL (Sandbox) i.e development certificate.
Visit this link, to create Apple Push Notification service SSL (Sandbox & Production), i.e, distribution certificate.

Note: Supported format for APNs certificate is .p12

Once the certificates are created, you can download them and export the .p12 files with the password for development and distribution certificate usingKeychain Access in Mac.

Upload APNs Certificates

Go to the Applozic console push notification section to upload the APNs development and distribution certificates. The following screenshot is what will be visible on the console for you:

Push Notification screen in Console Dashboard

Adding Capabilities to Your App

On the Xcode project’s Signing & Capabilities tab, Click (+ Capability) to add “Push Notifications”
Next Click (+ Capability) to add "Background modes" enable these options from Background modes:

Background fetch
Remote notifications

After adding these capabilities, your screen should look like this:

Configure the push notification in the Appdelegate file of your project.

Add the below imports in the Appdelegate file

#import <Applozic/Applozic.h>
#import <UserNotifications/UserNotifications.h>

Handling app launch on notification click and register remote notification for APNs

Add the following code in AppDelegate.m class, this function will be called after the app launch to register for push notifications.

// UNUserNotificationCenterDelegate are required for APNs call backs please add this delegate to your AppDelegate file 
@interface AppDelegate () <UNUserNotificationCenterDelegate>

@end


// didFinishLaunchingWithOptions method of your app

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    // checks whether app version is updated/changed then makes server call setting VERSION_CODE
    [ALRegisterUserClientService isAppUpdated];

    // Register APNs and Push kit
    [self registerForNotification];

    // Register for Applozic notification tap actions and network change notifications
    ALAppLocalNotifications *localNotification = [ALAppLocalNotifications appLocalNotificationHandler];
    [localNotification dataConnectionNotificationHandler];

    ALPushNotificationHandler *pushNotificationHandler = [ALPushNotificationHandler shared];
    [pushNotificationHandler dataConnectionNotificationHandler];

    // Override point for customization after application launch.
    NSLog(@"launchOptions: %@", launchOptions);
    if (launchOptions != nil) {
        NSDictionary *dictionary = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];
        if (dictionary != nil) {
            NSLog(@"Launched from push notification: %@", dictionary);
            ALPushNotificationService *pushNotificationService = [[ALPushNotificationService alloc] init];
            BOOL applozicProcessed = [pushNotificationService processPushNotification:dictionary updateUI:[NSNumber numberWithInt:APP_STATE_INACTIVE]];

            //IF not a appplozic notification, process it
            if (!applozicProcessed) {
                //Note: notification for app
            }
        }
    }

    return YES;
}

// Register APNs

-(void)registerForNotification
{
    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
    center.delegate = self;
    [center requestAuthorizationWithOptions:(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error)
     {
        if(!error)
        {
            dispatch_async(dispatch_get_main_queue(), ^ {
                [[UIApplication sharedApplication] registerForRemoteNotifications];  // required to get the app to do anything at all about push notifications
                NSLog(@"Push registration success." );
            });
        }
        else
        {
            NSLog(@"Push registration FAILED" );
            NSLog(@"ERROR: %@ - %@", error.localizedFailureReason, error.localizedDescription );
            NSLog(@"SUGGESTIONS: %@ - %@", error.localizedRecoveryOptions, error.localizedRecoverySuggestion );
        }
    }];
}

Sending an APNs device token to Applozic server

Add the below code in your Appdelegate file. If any of these methods already exist then you can copy-paste the relevant code from the below methods.

// APNs device token sending to Applozic

- (void)application:(UIApplication*)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)
deviceToken {

    const unsigned *tokenBytes = [deviceToken bytes];
    NSString *hexToken = [NSString stringWithFormat:@"%08x%08x%08x%08x%08x%08x%08x%08x",
                          ntohl(tokenBytes[0]), ntohl(tokenBytes[1]), ntohl(tokenBytes[2]),
                          ntohl(tokenBytes[3]), ntohl(tokenBytes[4]), ntohl(tokenBytes[5]),
                          ntohl(tokenBytes[6]), ntohl(tokenBytes[7])];

    NSString *apnDeviceToken = hexToken;
    NSLog(@"apnDeviceToken: %@", hexToken);

    if (![[ALUserDefaultsHandler getApnDeviceToken] isEqualToString:apnDeviceToken]) {
        ALRegisterUserClientService *registerUserClientService = [[ALRegisterUserClientService alloc] init];
        [registerUserClientService updateApnDeviceTokenWithCompletion
         :apnDeviceToken withCompletion:^(ALRegistrationResponse
                                          *rResponse, NSError *error) {

            if (error) {
                NSLog(@"%@",error);
                return;
            }
            NSLog(@"Registration response%@", rResponse);
        }];
    }
}

Receiving push notification

Once your app receives notification, pass it to the Applozic handler for chat notification processing.

// UNUserNotificationCenter delegates for chat
- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification*)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
    ALPushNotificationService *pushNotificationService = [[ALPushNotificationService                                                    alloc] init];
    NSDictionary *userInfo = notification.request.content.userInfo;
    NSLog(@"APNS willPresentNotification for userInfo: %@", userInfo);

    if ([pushNotificationService isApplozicNotification:userInfo]) {
        [pushNotificationService notificationArrivedToApplication:[UIApplication sharedApplication] withDictionary:userInfo];
        completionHandler(UNNotificationPresentationOptionNone);
        return;
    }
    completionHandler(UNNotificationPresentationOptionAlert|UNNotificationPresentationOptionBadge|UNNotificationPresentationOptionSound);
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(nonnull UNNotificationResponse* )response withCompletionHandler:(nonnull void (^)(void))completionHandler {


    ALPushNotificationService *pushNotificationService = [[ALPushNotificationService
                                                           alloc] init];
    NSDictionary *userInfo =  response.notification.request.content.userInfo;
    NSLog(@"APNS didReceiveNotificationResponse for userInfo: %@", userInfo);

    if ([pushNotificationService isApplozicNotification:userInfo]) {
        [pushNotificationService notificationArrivedToApplication:[UIApplication sharedApplication] withDictionary:userInfo];
        completionHandler();
        return;
    }
    completionHandler();
}

-(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(nonnull void (^)(UIBackgroundFetchResult))completionHandler{

    NSLog(@"RECEIVED_NOTIFICATION_WITH_COMPLETION :: %@", userInfo);
    ALPushNotificationService *pushNotificationService = [[ALPushNotificationService alloc] init];
    if ([pushNotificationService isApplozicNotification:userInfo]) {
        [pushNotificationService notificationArrivedToApplication:application withDictionary:userInfo];
        completionHandler(UIBackgroundFetchResultNewData);
        return;
    }
    completionHandler(UIBackgroundFetchResultNewData);
}

- (void)applicationWillTerminate:(UIApplication *)application {
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.

    [[ALDBHandler sharedInstance] saveContext];
}

- (void)applicationWillEnterForeground:(UIApplication *)application {
    // Called as part of the transition from the background to the inactive state; here you can undo any of the changes made on entering the background.

    NSLog(@"APP_ENTER_IN_FOREGROUND");
    [application setApplicationIconBadgeNumber:0];
}

Conclusion

We began this article by going over the workings of APNs and how it can be utilized in our applications. We also learnt about what are the requirements in setting up APNs and the different use cases remote notifications provide for an application.

Next, we utilized Applozic's iOS SDK to configure and register an application with APNs. We also added the remote notification and background fetch capabilities in the app.

Finally, we went over the code snippets that will enable you to configure the sending and receiving of push notifications in an application.

As we end this tutorial, you should have a clear understanding of the push notification ecosystem in iOS and leveraging APNs in your applications.

Please leave your feedback and doubts in the comments below!