Forem: Applozic Inc

Creating a chat application on Flutter using Applozic

Tejas Amle — Wed, 11 Aug 2021 05:21:50 +0000

Applozic is an amazing platform to create high-quality chat applications that boost your mobile application development.

This service makes the development of chat applications a hassle-free experience by not compromising on the quality and features of the application.

Creating a project

Create a new Flutter project

You could use any Flutter starter kit to generate the scaffold of the project, but for simplicity purposes let’s use the standard Flutter create.

At the time of writing this tutorial, these are the latest Flutter and tooling versions:
Doctor summary (to see all details, run flutter doctor -v): [✓] Flutter (Channel beta, 2.3.0-24.1.pre, on macOS 11.4 20F71 darwin-x64, locale en-IN) [✓] Android toolchain - develop for Android devices (Android SDK version 29.0.2) [✓] Xcode - develop for iOS and macOS [✓] Chrome - develop for the web [✓] Android Studio (version 4.1) [✓] IntelliJ IDEA Ultimate Edition (version 2021.1.3) [✓] VS Code (version 1.57.1) [✓] Connected device (3 available)
Let’s create our bare-bones project by running the following command:

flutter create applozic_example

Installing required dependencies

We would be needing applozic_flutter: ^0.0.4 and flutter_login: ^2.1.0 for the tutorial. To develop your chat application for Flutter and various other frameworks, register for a free trial of Applozic’s chat API.

We use applozic_flutter for the core functionality of the application and flutter_login to scaffold the UI of the login screen quickly.

Please note that the applozic_flutter library hasn’t been migrated to null safety yet, so we cannot build with sound null safety.

name: applozic_example
description: A new Flutter project.

publish_to: "none"

version: 1.0.0+1

environment:
  sdk: ">=2.12.0 <3.0.0"

dependencies:
  flutter:
    sdk: flutter

  cupertino_icons: ^1.0.2
  applozic_flutter: ^0.0.4
  flutter_login: ^2.1.0

dev_dependencies:
  flutter_test:
    sdk: flutter

  flutter_lints: ^1.0.0

flutter:
  uses-material-design: true

Applozic side

Now you could head over to Applozic Console and create a new application.

Once you have created a new application you will have the Application ID you will be needing that.

Integration

Now once we set up everything, we now have the Application ID of the app.

Let’s save our Application ID in a new file, let’s say config.dart

const String appID = 'Your App ID';

We will need the appID during the authentication part.

For further steps on Authentication, setting up login page, and to know how to use several other functionalities, please check out this page.

To check out more such blogs please read on Applozic's Blog Page

Thank you

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!

Adding Rich Messages to your In-App Chat

Akash — Tue, 06 Jul 2021 05:58:34 +0000

So, what exactly is rich messaging?

In some ways, it’s exactly what it sounds like: messaging that is deeper, richer, and more layered. But it’s also much more than that.

Integrating rich messaging into your chat allows you to push something more interactive than just plain text. It allows both parties to share interactive media like images, buttons, and cards seamlessly. In addition, customers can easily interact and respond using rich messaging buttons and even make secure purchases. For example, giving customers the opportunity to view and purchase sandwiches within the chat window led to an increase in Subway’s conversions by 140%.

Rich messaging can simplify interactions with your customers in a significant manner. If your in-app chat isn’t using rich messaging in 2021, you’re definitely missing out!

To add rich messaging and other exciting features to your app, register for a free trial of Applozic's chat API.

Rich messaging using Applozic SDK

In addition to traditional messaging types like text and audio, Applozic also provides a set of messaging options in the form of structured content templates. This article will guide you through creating a structure for sending some types of rich messages.

In order to achieve this behavior, the information must be sent in a structured format that can be included in the metadata of a message. The most common format is JSON (Javascript Object Notation).

Note: Rich message UI is only Supported in Applozic-Android-SDK and Applozic-Swift-SDK.

Identifying a rich message

Rich messages in Applozic can be categorized into 4 types - Buttons, Images, Lists, and Cards. But before we get to them, let's talk about how to identify a rich message in our Applozic-powered chat app.

To send a rich message, we need to add the contentType property into the message's metadata to separate it from normal messages. The value of contentType is 300 for rich messages. Below is the metadata for all rich messages templates:

{
    "contentType":"300"
}

Apart from the content type, each rich message also has a templateId, which is different for different types of rich messages. The data of the rich message must be passed onto its payload. We will examine the payload for some types of rich messages as we discuss them in detail.

Here is how a rich message is generally structured:

{
    "message": "click on the buttons",
    "metadata": {
        "contentType": "300",//the content type is 300 for rich messages
        "templateId": "x",//x is a integer which differs for different types of rich messages
        "payload": "{//data pertaining to the rich message }"
    }
}

Here are the different types of rich messages you can use in Applozic:

Buttons
1. Link Buttons
2. Submit Buttons
3. Suggested Replies
Images
List
Cards
1. Generic Card
2. Card Carousel

In this article, we’ll be examining the implementation of suggested replies, images, and generic cards into our chat application

Suggested Reply Button

Suggested Replies provide a way to send some common replies to messages with just a click, without having to type them out manually.

To render suggested replies on the UI, we need to send 2 fields in the payload:

title: display name for the button.
message: A message that would be sent as a reply.

Here is a sample payload for suggested replies:

"payload": [{
   "title": "Yes",
   "message": "Cool! send me more."
   },
   {
   "title": "No",
   "message": "Not at all",
   }
}]

On clicking the button, a message would be sent with the text from the message property of the payload. To get the click outside the SDK you can use the following code. For Android, you will need to implement the ALRichMessageListener.

public class SampleApplication extends Application implements ALRichMessageListener//this can also be an activity or a fragment
{
  
   @Override
    public void onAction(Context context, String action, Message message, Object object) {
        if("Click" == action){
              String text = (String) object;//object will be the message text from the button
          //message will be applozic message object
          }   
    }
}

Here is the sample JSON for suggested replies:

{
  "to": "userid",  
  // or
  // "groupId" : "groupId",
  "message": "Do you want more updates?",
    "metadata": {
        "contentType": "300",
        "templateId": "6",
        "payload": "[{\"title\": \"Yes\",\"message\": \"Cool! send me more.\"},         {\"title\": \"No\",\"message\": \"Not at all\"}]"
    }
}

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:

Add images in chat
Use Generic card templates
Add lists in chat
Use card carousels in chat

Building a WhatsApp clone from scratch using Flutter

Akash — Fri, 02 Jul 2021 15:05:58 +0000

According to Statista, around 2.77 billion mobile phone users accessed over-the-top messaging to communicate in 2020, and this figure is poised to reach three billion users in 2022. Of these, WhatsApp was the most popular mobile messenger app worldwide with over 2 billion users, mainly due to its first-mover advantage and user-friendly interface.

However, due to concerns over the recent updates to WhatsApp’s privacy policies, many users and businesses are on the lookout for alternatives. Check out our previous blog post to learn more about the security implications of WhatsApp’s policy updates.

Thanks to Applzozic’s intuitive chat SDKs and platform APIs, it‘s pretty easy to build your own chat alternative to WhatsApp! Before we delve into the code, let’s discuss the framework that we’ll use to implement our chat messenger app.

Why Flutter?

Launched by Google in 2018, Flutter is a free and open-source SDK for developing high-performing mobile, web, and desktop applications from a single codebase.

An exciting feature of Flutter is its layered structure that enables developers to build highly customizable and attractive apps with much lower time and effort, without compromising on performance. Moreover, experimenting new features and debugging errors is much faster in Flutter due to its hot reload feature that reflects instant changes in the codebase within milliseconds

Even though Flutter is a relatively new cross-platform app development framework compared to established contemporaries like React Native, many companies have started to migrate to Flutter due to its higher performance and flexible UI.

Do note that we’ll only be delving into the code implementation of the app’s chat functionality using Applozic Flutter SDK in this article - here’s a simple tutorial on creating a UI for the app using Flutter.

Creating a new application and setting up dependencies

flutter.dev has a comprehensive starter tutorial on creating your first application using Flutter. Once you are ready to integrate using the Applozic SDK, follow these steps:

I. Installation

Add the following dependency in your pubspec.yaml file:

dependencies:
  # other dependencies
applozic_flutter: ^0.0.4

2. Install the package as shown below:

flutter pub get

3. Import the applozic_flutter in your .dart file to use the methods from Applozic:

import 'package:applozic_flutter/applozic_flutter.dart';

II. Authentication

Login

Create an Applozic user object, and pass it to the login() function as shown below:

dynamic user = {
      'applicationId': "<APPLICATION_ID>",   //Mandatory
      'userId': userId.text,                 //Mandatory
      'displayName': displayName.text,
      'password': password.text,
      'authenticationTypeId': 1              //Mandatory
  };

ApplozicFlutter.login(user).then((response) {
      print("Login success : " + response)
    }).catchError((error, stack) =>
      print("Error while logging in : " + error.toString()));

Please keep in mind that once the user is logged in, a new login is permitted only after the user logs out. Use this code to check if the user is already logged in:

ApplozicFlutter.isLoggedIn().then((isLoggedIn) {
        if (isLoggedIn) {
          //The user is logged in
         } esle {
          //The user is not logged in
         }
     });

Update logged in user details

You can update the logged in user details as given below:

  dynamic user = {
                    'displayName': '<New name>'
                    'imageLink': '<New Image URL>'
                  }

  ApplozicFlutter.updateUserDetail(user)
                        .then(
                            (value) => print("User details updated : " + value))
                        .catchError((e, s) => print(
                            "Unable to update user details : " + e.toString()));

Get logged in userID

You can get the userID of the logged in user as given below:

  ApplozicFlutter.getLoggedInUserId().then((userId) {
      print("Logged in userId : " + userId);
    }).catchError((error, stack) {
      print("User get error : " + error);
   });

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:

Set up push notifications in your application
Launch the Conversation screen and start messaging!

Please leave your feedback and doubts in the comments below.

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

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.

💡 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

SDK vs API - What's the Difference?

Akash — Thu, 17 Jun 2021 09:18:29 +0000

Hello everyone! I'm Akash from Applozic, and today we'll take a look at what SDKs and APIs are, and how they differ from each other.

So, what is an SDK?

SDK stands for Software Development Kit. It is a collection of software development tools in one installable package. They facilitate the app development process.

So an SDK contains:

Documents
Code samples
APIs
Code libraries

Let’s now summarize how SDK works.

SDKs work with specific programming languages. They are easy to use because the goal is to make the jobs of developers easier, and save developers from writing code for already existing functionalities

Let’s have a look at some examples of SDK:

A good example is Android SDK - they have all the elements needed to create the app such as sample source code, debugger, required libraries, amongst other things.
Another example is Cloud SDK for Google Cloud Platforms - these contain tools that you need to manage applications and software in a Google Cloud Platform. Cloud SDK is a set of tools, including gcloud, gsutil, and bq command-line tools, client libraries & local emulators for developing with Google Cloud.

So we now know what an SDK is, let's move on to APIs. What exactly is an API?

APIs, which stand for Application Programming Interfaces, make the software development process easy by permitting a seamless and secure data transfer between two apps. It also helps to improve the exchange of functionality between two applications. So in essence, APIs allow two applications to talk to each other, relaying data from one end to another.

Let’s review some examples of APIs:

Login with Facebook When using websites, you can often find the option to log in using your Facebook account. It means that the website uses Facebook Login API to integrate their service and help users skip the sign-up process.
Third-Party Payments You can often see the payment options of PayPal, Apple Pay, or Google Pay. It means that the payment system integrates these services through API.

So, what are the key differences between SDKs and APIs?

Even though both concepts are indeed overlapped and interrelated, let's differentiate their purposes:

An SDK is the toolbox you need to build applications while and API establishes communication between two applications;
An SDK may contain APIs, but APIs cannot contain SDKs;
SDKs are easy to use and faster to integrate while APIs don’t have code libraries and are easy to modify;
SDKs contain all you need to communicate with another software and all you need to build software while APIs deliver a request from one app to another software and deliver a response back to the requesting app;
Developers always use an SDK to build apps, but APIs only come in when there is a need to have external communication with other platforms.

In fact, APIs and SDKs are both solution-bringers to developers, but each one is special in its way.

So, is the difference clear now? If you have any doubts or queries about APIs or SDKs, feel free to drop a comment in the comment section below!

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!