Introduction

Home screen widgets are broadcast receivers that provide interactive components. They are primarily used on the Android home screen. They typically display some kind of data and allow the user to perform actions with them. For example, a widget can display a short summary of new emails and if the user selects an email, it could start the email application with the selected email.

Views are also called widgets in android so we’ll use the term “Home Screen Widgets”

Home Screen Widgets doesn’t use original Views object but they uses a special type of view called Remote Views.

Remote views have less functionality than the original Java Views.

Remote Views can support these types of views. i.e. AnalogClock, Button, Chronometer, ImageButton, ImageView, ProgressBar and TextView.

As of Android 3.0 more views are available: GridView, ListView, StackView, ViewFlipper, and AdapterViewFlipper. These adapter views require that you define a collection view widget.

Layout for Home Screen Widget is provided by a broadcast receiver, which will inflate a view into Remote Views type.

Implementation

1: Create a new project in Android Studio by navigating to

File->New->Project

2: Create a layout for your home screen widget named app_widget_layout by navigating to res->layout->New and place the below code.

<?xml version=”1.0" encoding=”utf-8"?>

<LinearLayout 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”>

<ImageView

android:id=”@+id/app_widget_image”

android:layout_width=”match_parent”

android:layout_height=”match_parent”

android:layout_weight=”1"

android:src=”@mipmap/ic_launcher “ />

<TextView

android:id=”@+id/app_widget_text”

android:layout_width=”match_parent”

android:layout_height=”match_parent”

android:layout_weight=”1"

android:gravity=”center”

android:padding=”10dp”

android:text=”Default Text “

android:textSize=”14sp”

android:textStyle=”bold” />

<Button

android:id=”@+id/app_widget_button”

android:layout_width=”match_parent”

android:layout_height=”match_parent”

android:layout_weight=”1"

android:background=”@color/colorPrimary”

android:paddingLeft=”5dp”

android:paddingRight=”5dp”

android:text=”Refresh “

android:textSize=”12sp” />

</LinearLayout>

3. Now create new java class naming AppDataWidget.java that extend AppWidgetProvider. AppWidgetProvider has methods that are called when the app widget is updated, deleted, enabled and disabled among others. For our implementation, we only override onUpdate(), because it is the method called whenever the widget is added to a host.

package com.codegradients.homescreenwidget;

import android.app.PendingIntent;

import android.appwidget.AppWidgetManager;

import android.appwidget.AppWidgetProvider;

import android.content.Context;

import android.content.Intent;

import android.content.SharedPreferences;

import android.view.View;

import android.widget.RemoteViews;

import org.json.JSONException;

import org.json.JSONObject;

import java.util.Random;

public class AppDataWidget extends AppWidgetProvider {

private static final String[] refreshStrings = {“Continue Using the Widget.”, “Data Loaded.”, “Done is being loading.”, “No new data found.”, “Refreshed successfully.”};

@Override

public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {

// There may be multiple widgets active, so update all of them

for (int appWidgetId : appWidgetIds) {

updateAppWidget(context, appWidgetManager, appWidgetId);

}

}

public void updateAppWidget(final Context context, final AppWidgetManager appWidgetManager, final int appWidgetId) {

//get random text from refreshStrings

String stringText = refreshStrings[new Random().nextInt(refreshStrings.length)];

// Create an Intent to launch MainActivity

Intent intent = new Intent(context, MainActivity.class);

PendingIntent pendingIntent = PendingIntent.getActivity(context,

0, intent, 0);

// Create an Intent to Refresh MyWidgetProvider

Intent intent1 = new Intent(context, AppDataWidget.class);

intent1.setAction(AppWidgetManager.ACTION_APPWIDGET_UPDATE);

intent1.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetId);

PendingIntent pendingIntent1 = PendingIntent.getBroadcast(context,

0, intent1, 0);

// Get the layout for the App Widget and attach an on-click listener

// to the button and imageview

RemoteViews remoteViews = new RemoteViews(context.getPackageName(),

R.layout.app_widget_layout);

//set the random text

remoteViews.setTextViewText(R.id.app_widget_text, stringText);

//set pending intent1 to action button to refresh Widget

remoteViews.setOnClickPendingIntent(R.id.app_widget_button, pendingIntent1);

//set the pending intent to open MainActivity

remoteViews.setOnClickPendingIntent(R.id.app_widget_image, pendingIntent);

// Tell the AppWidgetManager to perform an update on the current app widget

appWidgetManager.updateAppWidget(appWidgetId, remoteViews);

}

}

4. Now we need to provide AppWidgetProviderInfo metadata that defines additional information, features and data related to the widget. Data such as minimum layout dimensions (width and height), if the widget should be available on the lock screen (Android 4.2 and above), how frequently the widget should be updated, among many others.

We will create a new XML file called app_data_widget_info.xml in res->xml folder

<?xml version=”1.0" encoding=”utf-8"?>

<appwidget-provider xmlns:android=”http://schemas.android.com/apk/res/android"

android:initialKeyguardLayout=”@layout/app_widget_layout”

android:initialLayout=”@layout/app_widget_layout”

android:minWidth=”40dp”

android:minHeight=”40dp”

android:minResizeHeight=”60dp”

android:minResizeWidth=”60dp”

android:previewImage=”@mipmap/ic_launcher”

android:resizeMode=”vertical|horizontal”

android:updatePeriodMillis=”1800000"

android:widgetCategory=”home_screen”></appwidget-provider>

5. The final step is to add the app widget to the AndroidManifest.xml file. Within the <application> </application> element tags, place the below lines.

<! — Declare WidgetProvider →

<receiver android:name=”. AppDataWidget”>

<! — Add APPWIDGET_UPDATE intent filter here to receiver Widget Update →

<intent-filter>

<action android:name=”android.appwidget.action.APPWIDGET_UPDATE” />

</intent-filter>

<! — Add app widget provider info xml in meta data →

<meta-data

android:name=”android.appwidget.provider”

android:resource=”@xml/app_widget_provider_info” />

</receiver>

6. Now run your app and add a widget onto the home screen and test it.

Congratulations. You have done it.

Thanks for reading this article. Do tell us if you liked this article, or you face any problem in implementing it in your project.

Phone number authentication has become popular in the last few years.

Validating identity is incredibly important in mobile development, and assuring new user signups are real human beings is critical. Developers need reliable ways to confirm the identities of their users to prevent security issues.

Well, adding phone number authentication in your app has never been so easier.

Start By Connecting your project to firebase.

Developers can implement verification systems using phone numbers in two main ways: either by calling or by sending an SMS containing a code that the user must input.

Enable Phone Number sign-in for your Firebase project

To be able to authenticate the user by SMS, you must first enable Phone Number sign-in method in your Firebase console and click save

To initialize the Sign-in process, present the user a screen to input his/her phone number. Also note: Alway let the user know they might receive an SMS message for verification and standard rates apply.

Then, pass their phone number to the PhoneAuthProvider.verifyPhoneNumber method to request that Firebase verify the user's phone number. For example,

PhoneAuthProvider.OnVerificationStateChangedCallbacks callbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
    @Override
    public void onVerificationCompleted(PhoneAuthCredential phoneAuthCredential) {
        //Detect the SMS Code
        String code = phoneAuthCredential.getSmsCode();

        if (code != null) {
            try {
                //Verify the Code
                verifyVerificationCode(code);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void onVerificationFailed(FirebaseException e) {
        Toast.makeText(OTPVerificationActivity.this, e.getMessage(), Toast.LENGTH_SHORT).show();
        Log.v("Login__", "Error: exception: " + e);
    }

    @Override
    public void onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken forceResendingToken) {
        OTPVerificationActivity.this.verificationId = verificationId;
    }
};

try {
    PhoneAuthProvider.getInstance().verifyPhoneNumber(s, 60, TimeUnit.SECONDS, this, callbacks);
} catch (Exception e) {
    e.printStackTrace();
}

Then, this method will be called when you will receive the verification code

You can also call the method below by taking input from the user and call the function.

public void verifyVerificationCode(String otp) {
    try {
        PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, otp);
        //Sign In The User
        signInWithPhoneAuthCredentials(credential);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Here comes the main method in which we login into the firebase

public void signInWithPhoneAuthCredentials(PhoneAuthCredential credential) {
    auth.signInWithCredential(credential).addOnCompleteListener(new OnCompleteListener<AuthResult>() {
        @Override
        public void onComplete(@NonNull Task<AuthResult> task) {
            if (task.isSuccessful()) {
//The task is successfull. You are now signed in
//navigate to the main activity after signing IN.

            } else {
                if (task.getException() instanceof FirebaseAuthInvalidCredentialsException) {
                    String message = "Invalid Code Entered";
                    avi.setVisibility(View.GONE);
                    continueBtn.setEnabled(true);
                    Toast.makeText(OTPVerificationActivity.this, message, Toast.LENGTH_SHORT).show();
                }
            }

        }
    });

So you are logged in now.

Extra Note

Well, for starters, you will have to add test numbers in the phone auth in firebase auth settings. Like,

But when you release your app to the play store, the firebase will send real authentication codes to your app. To do this, you will have to do this

Firstly, remove all the test numbers from here(shown above)

After that get the AUTH key from the play store app(That you have uploaded just now) and paste it in the Firebase Project Settings in SHA certificate fingerprints as shown below

That’s all. You have successfully implemented Phone Number Authentication in your android App. Congratulations!

Introduction

Biometric authentication is used to authenticate into a system using your biological characters such as the face, fingerprints.

Nowadays mobile devices also provide biometric authentication.

Mobile devices mostly use two biological characters, one is fingerprint and the other is the face.

Let’s talk about biometric authentication in the iPhone.

Until iPhone8 apple provides us only Touch ID using fingerprints of the device owner.

From the launch of the iPhone X apple introduced authentication using Face also. Apple called it Face ID.

Now after iPhone X, every iPhone device contains Face ID.

Implementation

First, open XCode and create a new project. Select the Single View App.

Now go to Project Settings > General, scroll down to the Linked Frameworks and Libraries section. Click on + sign and add LocalAuthentication.framework.

We will create a local method to authenticate a user called startAuthentication()

We will put logic to authenticate a user in this method.

To do this we use two methods:

canEvaluatePolicy method — it will return a Bool indicating if device owner authentication is available or not. In simple words, it will indicate whether the user is enrolled in Biometric authentication or not.

evaluatePolicy method — requests authentication from the user through biometrics or passcode.

This method will automatically check which auth system is available like if Touch ID is available it will use Touch ID, and if Face ID is available then it will start authentication using Face ID.

Note: This method works only on iOS 8.0 or above

It will present an alert if authentication results in success.

func startAuthentication() {

let contet = LAContext()

let reason = “Biometric Authntication testing !! “

var authError: NSError?

if #available(iOS 8.0, macOS 10.12.1, *) {

if contet.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &authError) {

contet.localizedCancelTitle = “Cancel”

contet.localizedFallbackTitle = “”

contet.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, localizedReason: reason) { success, evaluateError in

DispatchQueue.main.async {

if success {

let alert = UIAlertController(title: “Success”, message: “Successfully Authenticated”, preferredStyle: .alert)

alert.addAction(UIAlertAction(title: “Ok”, style: .cancel, handler: nil))

self.present(alert, animated: true, completion: nil)

} else {

// User did not authenticate successfully, look at error and take appropriate action

print(evaluateError?.localizedDescription)

}

}

}

} else {

// Could not evaluate policy; look at authError and present an appropriate message to user

print(“Sorry!!.. Could not evaluate policy.\(authError?.localizedDescription)”)

}

} else {

print(“This feature is not supported.”)

}

}

Thank you for reading. If you have any questions or suggestions, please let me know in the comments.

Android and Flutter, both are the babies of Google. One company managing both the native and cross-platform mobile application development for Android apps. Android application development was started at Android Inc which was bought by Google in 2005. The Flutter project began at Google and the first-ever Flutter SDK was released in 2017.

When it comes to cross-platform mobile application development technology trends, both RN and Flutter are pretty similar in terms of popularity, and both are still quite young (React Native was released in 2015, Flutter in 2018). As of this writing, RN has a bigger community, but given Flutter’s rate of growth, I think it’s safe to say that it will catch up to React Native very soon. It wouldn’t be wrong to say that in the future, the Flutter will be regarded as best platform for cross-platform development.

Things that Flutter have (or will have)

1. One codebase

Flutter supports both Android and iOS mobile platforms, and because it renders everything by itself, it lets you run everything off one codebase.

2. Widget tree

In Flutter, the user interface is built with widgets, small UI building blocks assembled using a technique called Composition. The whole somewhat resembles using React components. There are two sets of widgets available out of the box: Material Design, which is compatible with Google’s design guidelines, and Cupertino, compatible with Apple’s Human Interface Guidelines for iOS.

3. Cross-platform

As already mentioned, the Flutter SDK is a cross-platform tool, that allows us to develop for desktop, mobile, and the Web using a single codebase. Google is still working on support for all platforms, so some features may not be available yet (e.g. the API for desktop is still in development), but it’s possible that Flutter will offer fully cross-platform support quite soon.

4. Pixel rendering

Flutter manages every pixel of the screen, so we can be sure that our widgets will look the same on every device (even the older ones), essentially removing our potential device support woes. This, in turn, allows us to create amazing-looking user interfaces that look exactly the same on both Android and iOS with a single codebase.

5. Hot reload

This is where Flutter truly shines: hot reload feature provides the ability to introduce changes on-the-fly, allowing you to see them immediately during development.

6.Automated Support for Build and Release

Flutter comes with automated support for build and release and a stronger command line support. This makes releasing and updating your mobile app on the Play Store and App Store much, much easier than doing it in the traditional way.

7. Switchable Themes for iOS and Android
Developers have the freedom to pick one among the two separate themes for developing both Android and iOS apps in Flutter. They can choose a Material color for an Android app or some light colors for an iOS app and vice-versa.

No other cross-platform app development technology offers this functionality until now. Choosing the theme choice entirely depends on the developer and client requirements.

Can Flutter dominate over native Android development?

Flutter has just released its first stable releases. Google engineers announced Flutter 1.2 at the Mobile World Conference Conference. They have a strong vision and roadmap. Flutter is also being developed with Fuchsia in mind. We can’t predict the future, but Flutter has the potential to cross all the boundaries.

Flutter seems to be totally different from all the other cross-platform solutions. Futter apps look native and slick just like the native apps.

As an Android developer, you shouldn’t ignore Flutter. We can’t predict the future, but who knows, Flutter might just as well be the first choice for businesses to develop Android apps. There are some potential reasons for that.

Flutter is hot in the market ever since Google announced the first stable release. Looking at the features of Flutter, lots of questions arise.

We’ll make no predictions or guesses here, but it could be the alarming bell for native mobile app developers that something like Flutter might affect their role in the future.

AVPlayerViewController is an object that displays the video content from aa player object providing playback controls also. We can use AVPlayerViewController as a standalone object or embed it into UIView.

How to use AVPlayerViewController in Swift

if let url = URL(string: “https://www.pathtoyourvideo”) {

//initialize video player object

let videoPlayer = AVPlayer(url: url)

let controller = AVPlayerViewController()

controller.player = videoPlayer

present(controller, animated: true) {

// when presentation gets completed play the video

videoPlayer.play()

}

}

Use AVPlayerViewController Within a View

if let url = URL(string: “https://www.pathtoyourvideo”) {

//initialize video player objet

let videoPlayer = AVPlayer(url: url)

let controller = AVPlayerViewController()

controller.player = videoPlayer

//Add AVPlayerViewController as a child of current view controller

self.addChild(controller)

//video_view is a UIView which you have added in your view controller

//change the frame of AVPlayer

controller.view.frame = video_view.bounds

video_view.addSubview(controller.view)

controller.didMove(toParent: self)

//start media player

videoPlayer.play()

}

You can configure different properties of player like if you don’t want to show video player controls you can use

controller.showsPlaybackControls = false

To change video gravity you can use

controller.videoGravity = .resizeAspectFill

Technology seems to be constantly evolving and for worse or better, is making its path towards speed, sophistication, and ease each year. For many years, technology advances at a fast pace and that does not seem to be slowing or stopping down any time soon.

There are many technologies that have already set their benchmark in the industry and only a few more applications are away from becoming the mainstream.

These are some of the future technologies that are going to become an incredible future in the coming years. So, without wasting much of your time, let’s start listing out these technologies one by one.

IoT

IoT is driving business changes by providing the data needed to improve marketing, increase sales, and decrease costs, the report found.

“Everybody in the technology world, as well as many consumers, is hearing the term Internet of Things,” Frank Raimondi, a member of the CompTIA Emerging Technology Community leadership group who works in the strategic channel and business development for Chargifi, said in a press release.

However, “to say it’s confusing and overwhelming is an understatement,” he added. “IoT may mean many things to many people, but it can clearly mean incremental or new business to a channel partner if they start adding relevant IoT solutions with their existing and new customers. More importantly, they don’t have to start over from scratch.”

An IoT ecosystem consists of web-enabled smart devices that use embedded processors, sensors and communication hardware to collect, send and act on data they acquire from their environments. IoT Devices share the sensor data they collect by connecting to an IoT gateway or other edge devices where data is either sent to the cloud to be analyzed or analyzed locally. Sometimes, these devices communicate with other related devices and act on the information they get from one another. The devices do most of the work without human intervention, although people can interact with the devices — for instance, to set them up, give them instructions or access the data.

The connectivity, networking and communication protocols used with these web-enabled devices largely depend on the specific IoT applications deployed.

Artificial Intelligence (AI)

AI is already significantly impacting the way customers interact with businesses via intelligent websites and bots, and these tools are becoming increasingly commoditized and integrated into daily work, the report noted. “The largest impacts across all industries — from retail to healthcare, hospitality to finance — are felt when AI improves data security, decision-making speed and accuracy, and employee output and training,” Maddy Martin, community vice chair and head of growth and education for Smith.ai, said in the release. “With more capable staff, better-qualified sales leads, more efficient issue resolution, and systems that feed actual data back in for future process and product improvements, companies employing AI technologies can use resources with far greater efficiency. Best of all, as investment and competition increase in the AI realm, costs are reduced.”

Some industry experts believe that the term artificial intelligence is too closely linked to popular culture, causing the general public to have unrealistic fears about artificial intelligence and improbable expectations about how it will change the workplace and life in general. Researchers and marketers hope the label augmented intelligence, which has a more neutral connotation, will help people understand that AI will simply improve products and services, not replace the humans that use them

Automation

Along with Artificial Intelligence, Machine Learning, Robots, and Deep Learning, automation has moved quite ahead in the production lines. From packing the product boxes to delivering the items at the doors of the customers, automation seems to be one of the most awaited technologies of the year 2020. The users only need to configure the tool and define the process. In other industries, automation is greatly improving productivity, saving time and cutting costs.

Automation is evolving quickly and business intelligence in applications is a new form of high-quality automation. In the technology domain, the impact of automation is increasing rapidly, both in the software/hardware and machine layer. However, despite advances in automation, some manual intervention is always advised, even if the tool can perform most of the tasks.

Food, medical, beverage & customer service will also become further automated and streamlined by the time 2020 hits.

Robotics

Robotics is automating routine processes by using machines to make businesses faster, less expensive, and more efficient, the report found.

Robotic engineers are designing the next generation of robots to look, feel and act more human, to make it easier for us to warm up to a cold machine.

Realistic looking hair and skin with embedded sensors will allow robots to react naturally in their environment. For example, a robot that senses your touch on the shoulder and turns to greet you.

The rapidly developing relationship between humans and robots is so complex that it has spawned its own field, known as human-robot interaction. The overarching challenge is this: It’s easy enough to adapt robots to get along with humans — make them soft and give them a sense of touch — but it’s another issue entirely to train humans to get along with the machines. With Tug the hospital robot, for example, doctors and nurses learn to treat it like a grandparent — get the hell out of its way and help it get unstuck if you have to.

The brain behind the beauty will be the key to turning a realistic looking machine into a life-like a robot. AI plays a pivotal role in successful human/robot interaction.

Biometrics

Biometrics — including the face, fingerprint, and retina scans — are becoming mainstream methods for verifying identity. These methods will form the secure foundation for solutions delivered by IT companies moving forward, CompTIA said.

Your face is going to become your technology partner by the year 2020. This technology came into light when the iPhone X launched one of the best facial recognition software.

The stability of the biometric factor can also be important to the acceptance of the factor. Fingerprints do not change over a lifetime, while facial appearance can change drastically with age, illness or other factors.

In the future, with the help of this technology, the software development companies will be using this technology for developing a series of applications. By 2020, you will be able to unlock your house, car, etc., with the help of facial technology.