#Passwordless Facebook login | Explore Tumblr posts and blogs

sotatekglobal · 3 years ago

Text

Catch Up With 5 UX Trends In Software Development

In the Software Development process, designing UX is one of the most essential stages, which somehow determines the customers’ and digital users’ satisfaction. In the COVID-19 pandemic, when social distancing and work-from-home is preferred, people tend to spend more time at home, hence more time surfing through thousands of webs and mobile apps. Therefore, to become outstanding to the users, it is a must for Software Providers to catch up with the latest trends in UX Design to meet their users’ needs. So, what are the current UX trends? Let’s follow this blog to catch up with the Top 05 Trends 2022!

1. Passwordless Login

It can’t be denied that passwords can be a real headache. Normally, a standard password must contain some numbers, letters, and special characters. Meanwhile, digital users have at least 30 apps on their phones so creating as well as remembering all of their passwords is a challenging task, not only for the elderly but also for the younger generation. Worse still, when they forget the password, it is really frustrating to go through various steps to reset. A survey has claimed that more than half of people forget their passwords immediately after resetting them while 65% have to note their password to their phones in order not to forget it the next time. In such circumstances, passwordless login and authentication have existed to become one of the popular UX Trends recently.

Passwordless login is used to describe some identity verification methods that no longer rely on passwords, such as biometric authentication (fingerprints, facial recognition), one-time password (OTP), PIN or log in through another mobile app (Gmail, social media). Compared to passwords which can be hard to remember, easy to be stolen, the aforementioned methods of modern login are a safe and user-friendly approach. Integrating the passwordless login in your Software Development can bring about the customers’ satisfaction as well as prompt them to come back to your app again and again.

Some examples of passwordless login which no longer rely on passwords.

2. Advanced Personalized Experience

With the abundance of content, mobile apps, and websites to access nowadays, the one which can personalize each individual experience by offering personalized suggestions or meeting accessibility guidelines would definitely receive a positive response from the users. According to Accenture, 33% of customers abandoned a business relationship last year because personalization was lacking. Therefore, personalized UX design is really a powerful and essential tool.

To be more specific, personalization focuses on some criteria, such as location base (recommendations based on the users’ current destination), demographics (information about a personal age, gender, education level, nationality, ethnicity, or religion), and behavioral data (information about a person's online behavior). UX designers will then make full use of such statistics to create an experience and journey based on exactly what people expect, need, or want. Some examples of successful UX personalization can be the films appearing on our Netflix suggestions, the ads on Instagram, and Facebook feeds, etc.

3. Responding To The Metaverse As Among The Upcoming UX Trends

Almost people are getting used to the phrase “Metaverse”, whose frequent usage is increasing recently, especially when Facebook changed its company name to Meta. Nike and Adidas have also officially entered the Metaverse with NFT Virtual Shoes. Known as a virtual world, the Metaverse has been developed using technological elements such as AR, VR, and video, in which users live. Following the popularity of Metaverse, the UX designs also need to be upgraded in order to create an immersive experience instead of only concentrating on how fast a task can be completed.

Moreover, the advancement in Virtual Reality (VR) and Augmented Reality (AR) also fosters this trend in the year 2022. With Metaverse, VR, AR, people can make their own avatar, create their 3D version, and meet others in “another world”. The UX designers, therefore, are urgent to shift their design innovation to adapt to the new era of virtual interaction.

4. Air Gesture

Although Apple has adopted the touch gestures control to their iOS (double tap, one finger circular, two-finger swipe up,...), a new UX trend - air gesture - is promising to take this technology to the next level. Air Gesture Control is known as a touchless mechanism to allow users to operate their devices with their bodies and air movements. Waving, pinching, opening the palms, sliding, and swiping are all examples of actions that can be initiated. For instance, mobile users can make a palm gesture in front of the camera in order to take a selfie. In the year 2022, when the COVID-19 pandemic still spreads over the globe, touchless interactions seem to gain more popularity, and therefore, the air gesture can be dominated at the top list of UX trends.

Air Gesture Control is a touchless mechanism to allow users to operate their devices with their bodies and air movements.

5. Adaptable Design For New Types Of Screen

In the cutting-edge area, new gadget devices have launched annually, with various screen sizes, from small to medium and large ones, as well as various types, such as foldable and tablets. The popularity of such appliances requires the Software Providers to come up with a larger number of designs for all form factors, as well as responsiveness based on layout and components across devices. For example, Google has begun to alter and optimize its design methods to meet these new demands. To not get left behind, it is likely that other businesses will soon follow this UX trend in 2022.

6. Final Thoughts: Getting Started With The Latest UX Trends

To sum up, above are the top 5 UX Trends that can be dominated in this year 2022. If you follow those trends, you are likely to have an incredible UX design for your Web & Mobile App, which then helps your businesses and brands enhance the workflow, retain existing customers and even attract new ones.

Are you looking for IT Professionals to adopt the latest trends in UX design? SotaTek, a leading Software Outsourcing Company in Vietnam, can be your wise choice. With 600+ top-notch IT consultants and developers, we can provide our worldwide clients with full-cycle services that cover all aspects of end-to-end Software Engineering, such as Web & Mobile App Development with strong UI/UX design, Software Testing, and Quality Assurance. Regardless of your industry: Finance, Health Care, F&B, Education, Media & Entertainment, etc, SotaTek can be your trusted IT Partner. So, leave us a message and let our partnership start from the time now!

#uxdesign #software development

0 notes

versatileitsol · 4 years ago

Text

Top 8 UI / UX design trends for Mobile Apps

The top 8 UI / UX design trends for mobile apps in 2020:

1. Full screen smartphones

Most phones lacked boundaries and had a rounded bottom. It also changes the GUI. This will challenge programmers to use fast components of the smartphone user experience and the architecture of mobile devices.

In addition, the iPhone no longer has the keys on the home page and Android phones do not have buttons on the screen to make room for the content displayed. Navigation is based on a display for a cleaner screen which can also be the face of a designer. This is an important initiative for consumers to develop new skills. Therefore, visual cues should be added or adjusted to help them know the dynamics.

2. Dark themes

A few years ago, the dark theme was also very popular. Apple has been invaluable in this direction by releasing a Mojave update that could automatically set a dark theme for its support apps. On top of that, they launched an iOS update that offers similar functionality in dark mode.

Obscure UI styles will develop in 2020. Beyond the surface appeal - one of the biggest advantages is that dark looks with sufficient contrast can reduce eye pressure for some people. Gmail is one of the big new dark remedy apps that launched the alternative again in September.

3. 3D graphics and animations

Animation and 3D graphics are nothing new in user interface design. Its frequency has increased in several product categories in recent years. These products have been used in particular by AR and VR applications for elements such as viewing furniture in real rooms. Another recent example is the availability of 360 degree products that have become popular on many Ecommerce websites.

If the architecture of the user interface is to be highly visible, 3D graphics are a perfect way to do this. The animation provides an interface with visual appeal. Although these effects take longer than 2D iterations and require a specific set of abilities, in situations where they are added to the overall user interface, they are worth the extra time.

4. Device independent experience

Everyone is buying more mobile apps. Statista estimates there will be around 6.58 networked devices per human worldwide by 2020. This changes the way people navigate information. It is normal to switch from one device to another.

Often, programmers think outside the box, because the "have a screen" and "portable" classes are not enough. Consulting the customer experience is a much more effective result in creating a product that the computer does not care about. In this way, however, users would have a smooth user interface.

5. Unique micro-interactions

Micro-interactions are an integral part of any successful digital product design. But it is still overlooked by many Mobile Application design companies.

In addition to this, micro-interactions give users additional information and perspectives. This can include things like color variations to display various conditions, immersive graphics, and haptic smartphone input. Micro-interactions, however, can also facilitate the concept of practical to exceptional.

6. Experience without password

The exact recovery of passwords becomes more complicated with the daily use of many applications. The Intel Security Survey 2016 reveals that at least once a week, 37% of users lose their password. Passwordless authentication strategies are expected to be more widespread in 2020.

There are several forms of passwordless authentication that are already used in various smartphone applications. For example, biometric authentication (facial recognition or fingerprint). In addition, the one-time password used in eBay and the login link used in Medium are also called short-term passwords.

7. Storytelling

One of the best is in the development of being able to tell great stories about digital experiences. The print itself will form a strong pyramid for the image. A very important part of the user interface, it plays an important role in creating an excellent user experience. Creating UI / UX design trends and practices per se in 2020 - Text style is not enough.

Ad writing has been and will continue to be one of the most critical aspects for better user interaction in the coming year. Although this style absorbs the interest of the user, the plot focuses on the brand as it allows them to feel like part of the story. This, in effect, only prevents users from scanning the content.

8. Voice interactions

Once voice communications take place in the realm of science fiction. Today, smartphones have changed everything, making voice contact not only possible but also the norm. Allowing users to engage with the software with voice commands opens up a world of product interactivity.

If a consumer can receive voice instructions, they can use a smartphone in circumstances where touch interfaces are unsafe or ineffective - such as following a recipe, driving, or following an educational program. The voice interface is not unique, but the first versions were approximate and, for the most part, did not work well.

Conclusion:

With all the new developments mentioned above, it is important to note that the designer's objective will remain the same: to use modern strategies and technologies to improve the lives of consumers.

When evaluating a particular model, consider it to have the best user experience possible in light of the benefits it provides to users.

If you find the post useful and worth sharing, don’t forget to share it on Twitter, Facebook, and Google Plus!

Facebook https://bit.ly/2U2YvE3

Instagram https://bit.ly/2TX5QFa

LinkedIn https://bit.ly/2Xmozfy

Twitter https://bit.ly/2Mnv5MC

CONTACT Versatile Mobitech Pvt. Ltd., 3rd Floor, Uni Space Business Center, Modern Profound Tech Park, Survey No: 12, Kondapur, Hyderabad-500032 To Contact: +91 9701930011 E-Mail ID: [email protected]

#UIUX #UIservices #UXservices #UIdesigning #UXdesigning #mobileappsdesign #webdesign #webapplications #websitedesign #graphicdesign

0 notes

aarthi-m · 1 year ago

Text

#facebook #accessing Facebook from Instagram #passwordless Facebook login via Instagram #linking Facebook and Instagram accounts #seamless social media login

1 note · View note

t-baba · 6 years ago

Photo

Authenticating Firebase and Angular with Auth0: Part 1

This article was originally published on the Auth0.com blog, and is republished here with permission.

In this 2-part tutorial series, we'll learn how to build an application that secures a Node back end and an Angular front end with Auth0 authentication. Our server and app will also authenticate a Firebase Cloud Firestore database with custom tokens so that users can leave realtime comments in a secure manner after logging in with Auth0.

The Angular application code can be found at the angular-firebase GitHub repo and the Node API can be found in the firebase-auth0-nodeserver repo.

Authenticating Firebase and Angular with Auth0: Part 1

Part 1 of our tutorial will cover:

Firebase and Auth0

What We'll Build

Angular CLI

Auth0 Client and API

Firebase Project with Service Account

Node API

Set Up Angular App

Angular App Architecture

Implement Shared Modules

Implement Routing and Lazy Loaded Modules

Loading and Error Components

Authentication Logic

Core Logic

Next Steps

Firebase and Auth0

Firebase is a mobile and web application development platform. Firebase was acquired by Google in 2014, and continues to be developed under the Google umbrella. Firebase provides NoSQL databases (RTDB, or Realtime Database and Cloud Firestore, in beta at the time of writing) hosted in the cloud and connected using web sockets to provide realtime capabilities to apps.

Auth0 is a cloud-based platform that provides authentication and authorization as a service. As an authentication provider, Auth0 enables developers to easily implement and customize login and authorization security for their apps.

Choosing Auth0 + Firebase Authentication

If you're already familiar with Firebase's offerings, you might be asking: why would we implement Auth0 with custom tokens in Firebase instead of sticking with Firebase's built-in authentication by itself?

Firstly, there is an important distinction to make here. Using Auth0 to secure Firebase does not mean you are not using Firebase auth. Firebase has a custom authentication approach that allows developers to integrate their preferred identity solution with Firebase auth. This approach enables developers to implement Firebase auth so that it functions seamlessly with proprietary systems or other authentication providers.

There are many potential reasons we might want to integrate Auth0 with Firebase authentication. Alternatively, there are scenarios where using basic Firebase auth by itself could suffice. Let's explore.

You can use Firebase's built-in authentication by itself if you:

Only want to authenticate Firebase RTDB or Firestore and have no need to authenticate additional back ends

Only need a small handful of login options and do not need enterprise identity providers, integration with your own user storage databases, etc.

Do not need extensive user management, profile enrichment, etc. and are comfortable managing users strictly through an API

Have no need to customize authentication flows

Do not need to adhere to compliance regulations regarding the storage of user data.

You should consider Auth0 with a custom Firebase token if you:

Already have Auth0 implemented and want to add realtime capabilities to your app

Need to easily use issued tokens to secure a back end that is not provided by Firebase

Need to integrate social identity providers beyond just Google, Facebook, Twitter, and GitHub

Need to integrate enterprise identity providers, such as Active Directory, LDAP, ADFS, SAMLP, etc.

Need a customized authentication flow

Need robust user management with APIs and an admin-friendly dashboard

Want to be able to dynamically enrich user profiles

Want features like customizable passwordless login, multifactor authentication, breached password security, anomaly detection, etc.

Must adhere to compliance regulations such as HIPAA, GDPR, SOC2, etc.

Essentially, Firebase's basic authentication providers should suffice if you have a very simple app with bare-bones authentication needs and are only using Firebase databases. However, should you need more than that, Firebase offers a great way to use their services with other authentication solutions. This is a much more realistic scenario that many developers will be faced with, so we'll explore it in detail here.

What We'll Build

We're going to build a Node.js API secured with Auth0 that mints custom Firebase tokens and also returns data on ten different dog breeds.

We'll also build an Angular front end app called “Popular Dogs” that displays information about the ten most popular dogs in 2016, ranked by public popularity by the American Kennel Club (AKC). Our app will be secured by Auth0, call the Node API to fetch dog data, and call the API to acquire Firebase tokens to authorize users to add and delete comments in realtime with Cloud Firestore. The app will use shared modules as well as implement lazy loading.

To implement the app, you will need the following:

Angular CLI

A free Auth0 account with a Client and an API configured

A free Firebase project with a service account

Let's get started!

Angular CLI

Make sure you have Node.js with NPM installed on your local machine. Run the following command to install the Angular CLI globally:

$ npm install -g @angular/cli@latest

We will generate our Angular app and nearly all of its architecture using the CLI.

Auth0 Client and API

You'll need an Auth0 account to manage authentication. You can sign up for a free account here.

Next, set up an Auth0 client app and API so Auth0 can interface with the Angular app and Node API.

Set Up an Auth0 Client

Go to your Auth0 Dashboard and click the Create a New Client button.

Name your new app (something like Angular Firebase) and select Single Page Web Applications.

In the Settings for your new Auth0 client app, add http://localhost:4200/callback to the Allowed Callback URLs.

Enable the toggle for Use Auth0 instead of the IdP to do Single Sign On.

At the bottom of the Settings section, click "Show Advanced Settings". Choose the OAuth tab and verify that the JsonWebToken Signature Algorithm is set to “RS256”.

If you'd like, you can set up some social connections. You can then enable them for your app in the Client options under the Connections tab. The example shown in the screenshot above uses username/password database, Facebook, Google, and Twitter.

Note: For production, make sure you set up your own social keys and do not leave social connections set to use Auth0 dev keys.

Set Up an Auth0 API

Go to APIs in your Auth0 dashboard and click on the “Create API” button. Enter a name for the API, such as Firebase Dogs API. Set the Identifier to your API endpoint URL. In this tutorial, our API identifier is http://localhost:1337/. The Signing Algorithm should be “RS256”.

You can consult the Node.js example under the Quick Start tab in your new API's settings. In the next steps, we'll implement our Node API in this fashion using Express, express-jwt, and jwks-rsa.

We're now ready to implement Auth0 authentication on both our Angular client and Node back-end API.

Firebase Project with Service Account

Next you will need a free Firebase project.

Create a Firebase Project

Go to the Firebase Console and sign in with your Google account.

Click on Add Project.

In the dialog that pops up, give your project a name (such as Angular Firebase Auth0). A project ID will be generated based on the name you chose. You can then select your country/region.

Click the Create Project button.

Generate an Admin SDK Key

In order to mint custom Firebase tokens, you'll need access to the Firebase Admin SDK. To obtain access, you must create a service account in your new Firebase project.

Click on the gear wheel icon next to your Project Overview in the Firebase console sidebar and select Project Settings from the menu that appears:

In the settings view, click the Service Accounts tab. The Firebase Admin SDK UI will appear, showing a configuration code snippet. Node.js is selected by default. This is the technology we want, and we will implement it in our Node API. Click on the Generate New Private Key button.

A dialog will appear warning you to store your private key confidentially. We will take care never to check this key into a public repository. Click on the Generate Key button to download the key as a .json file. We will add this file to our Node API shortly.

Node API

The completed Node.js API for this tutorial can be found at the firebase-auth0-nodeserver GitHub repo. Let's learn how to build this API.

Node API File Structure

We'll want to set up the following file structure:

You can generate the necessary folders and files with the command line like so:

$ mkdir firebase-auth0-nodeserver $ cd firebase-auth0-nodeserver $ mkdir firebase $ touch firebase/.gitignore $ touch .gitignore $ touch config.js $ touch dogs.json $ touch package.json $ touch routes.js $ touch server.js

Firebase Admin SDK Key and Git Ignore

Now move the Firebase Admin SDK .json key file you downloaded earlier into the firebase folder. We will take care to make sure the folder is checked in, but its contents are never pushed to a repo using the firebase/.gitignore like so:

# firebase/.gitignore * */ !.gitignore

This .gitignore configuration ensures that Git will ignore any files and folders inside the firebase directory except for the .gitignore file itself. This allows us to commit an (essentially) empty folder. Our .json Firebase Admin SDK key can live in this folder and we won't have to worry about gitignoring it by filename.

Note: This is particularly useful if we have the project pulled down on multiple machines and have different keys (with different filenames) generated.

Next let's add the code for the root directory's .gitignore:

# .gitignore config.js node_modules

Dogs JSON Data

Next we'll add the data for ten dog breeds. For brevity, you can simply copy and paste this data into your dogs.json file.

Dependencies

Let's add our package.json file like so:

{ "name": "firebase-auth0-nodeserver", "version": "0.1.0", "description": "Node.js server that authenticates with an Auth0 access token and returns a Firebase auth token.", "repository": "https://github.com/auth0-blog/firebase-auth0-nodeserver", "main": "server.js", "scripts": { "start": "node server" }, "author": "Auth0", "license": "MIT", "dependencies": {}, "devDependencies": {} }

We'll install the dependencies with the command line and latest versions will be saved automatically to the package.json file:

$ npm install --save body-parser cors express express-jwt jwks-rsa firebase-admin

We'll need body-parser, cors, and express to serve our API endpoints. Authentication will rely on express-jwt and jwks-rsa, while Firebase token minting is implemented with the firebase-admin SDK (which we'll have access to using the key we generated).

Configuration

In the config.js file, add the following code and replace the placeholder values with your own settings:

// config.js module.exports = { AUTH0_DOMAIN: '<Auth0 Domain>', // e.g., you.auth0.com AUTH0_API_AUDIENCE: '<Auth0 API Audience>', // e.g., http://localhost:1337/ FIREBASE_KEY: './firebase/<Firebase JSON>', // e.g., your-project-firebase-adminsdk-xxxxx-xxxxxxxxxx.json FIREBASE_DB: '<Firebase Database URL>' // e.g., https://your-project.firebaseio.com };

Server

With our data, configuration, and dependencies in place, we can now implement our Node server. Open the server.js file and add:

// server.js // Modules const express = require('express'); const bodyParser = require('body-parser'); const cors = require('cors'); // App const app = express(); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: false })); app.use(cors()); // Set port const port = process.env.PORT || '1337'; app.set('port', port); // Routes require('./routes')(app); // Server app.listen(port, () => console.log(`Server running on localhost:${port}`));

This will launch our Node server with Express at http://localhost:1337/.

Note: Notice that this is the API identifier we set up in Auth0.

API Routes

Next open the routes.js file. This is where we'll define our API endpoints, secure them, and mint custom Firebase tokens. Add the following code:

// routes.js // Dependencies const jwt = require('express-jwt'); const jwks = require('jwks-rsa'); const firebaseAdmin = require('firebase-admin'); // Config const config = require('./config'); module.exports = function(app) { // Auth0 athentication middleware const jwtCheck = jwt({ secret: jwks.expressJwtSecret({ cache: true, rateLimit: true, jwksRequestsPerMinute: 5, jwksUri: `https://${config.AUTH0_DOMAIN}/.well-known/jwks.json` }), audience: config.AUTH0_API_AUDIENCE, issuer: `https://${config.AUTH0_DOMAIN}/`, algorithm: 'RS256' }); // Initialize Firebase Admin with service account const serviceAccount = require(config.FIREBASE_KEY); firebaseAdmin.initializeApp({ credential: firebaseAdmin.credential.cert(serviceAccount), databaseURL: config.FIREBASE_DB }); // GET object containing Firebase custom token app.get('/auth/firebase', jwtCheck, (req, res) => { // Create UID from authenticated Auth0 user const uid = req.user.sub; // Mint token using Firebase Admin SDK firebaseAdmin.auth().createCustomToken(uid) .then(customToken => // Response must be an object or Firebase errors res.json({firebaseToken: customToken}) ) .catch(err => res.status(500).send({ message: 'Something went wrong acquiring a Firebase token.', error: err }) ); }); // Set up dogs JSON data for API const dogs = require('./dogs.json'); const getDogsBasic = () => { const dogsBasicArr = dogs.map(dog => { return { rank: dog.rank, breed: dog.breed, image: dog.image } }); return dogsBasicArr; } // GET dogs (public) app.get('/api/dogs', (req, res) => { res.send(getDogsBasic()); }); // GET dog details by rank (private) app.get('/api/dog/:rank', jwtCheck, (req, res) => { const rank = req.params.rank * 1; const thisDog = dogs.find(dog => dog.rank === rank); res.send(thisDog); }); };

At a high level, our routes file does the following:

Sets up authentication checking to ensure that only logged in users can access routes with jwtCheck middleware

Initializes the Firebase Admin SDK with the private key generated from the Firebase project service account

Provides a secure GET endpoint that returns a custom Firebase token

Provides a public GET* endpoint that returns a short version of the dogs data

Provides a secure GET* endpoint that returns a specific dog's detailed data, requested by rank.

*Endpoints use variations of the same base dataset to simulate a more complex API.

You can read the code comments for more detail.

Serve the API

You can serve the Node API by running:

$ node server

The API will then be available at http://localhost:1337.

Note: If you try to access secure routes in the browser, you should receive a 401 Unauthorized error.

That's it for our server! Keep the API running so that it will be accessible to the Angular app, which we'll set up next.

Continue reading %Authenticating Firebase and Angular with Auth0: Part 1%

by Kim Maida via SitePoint https://ift.tt/2khDRxX

#CSS3 #HTML5 Branding #HTML5 Weekly #HTMLl5 demos #Javascript Branding #Javascript Weekly #Mobile #Mo

0 notes

tech-latest-blog · 4 years ago

Link

The 11 Weeks of Android just kicked off recently and we have a lot of good stuff coming up. There’ some new conversation features and along with it Google also unveiled some details about simplifying the password processes for Android apps with one tap.

One Tap Password Process on Android

So the video starts with recapping how “sign-in can be a challenge” from not knowing whether Google/Facebook was used to forgetting passwords for email-based accounts. The company’s existing solutions are centered around:

Google Sign-in: Using your Google Account to log-in to third-party services.

Smart Lock for Passwords: Automatic sign-in after opening app/visiting website.

Android Autofill: Users select the credentials.

So to convince users to use either of these solutions is a bit complex and for that Google is trying to address the problem with One Tap Password process.

When you will open an app for the first time, you will be promoted to sign-up with your Google account where a “secure, token based, passwordless account” will be created. This was announced for the web in 2017.

The UI will explain everything and the information a user is sharing, lists their Google account, and has a big “Continue as” button. However, users can still type their own password with One Tap able to save it.

For future logins, you will be asked to “Choose an account”. This will display both the Google-backed account login and also the credentials from Android Autofill, Smart Lock, and Chrome in the bottom sheet.

The second area in which Google wants to improve is “device upgrade experience”. For this, the credentials from various apps will be stored. Block Store is a “secure end-to-end encrypted credential storage solution” for developers where tokens are saved instead of plain text usernames/passwords.

The tokens are encrypted and stored in the local storage and can be transferred to the cloud if the user permits. So one can easily upload the tokens into the cloud and set up the new phone pretty easily and would not have to go through the hassle of logins in the new device again.

One Tap will support Block Store by the end of this year and One Tap and Block Store will be the part of the unified Google Identity Services(GIS) library for Android and this will replace the Google Sign-in and Smart Lock for passwords.

(VIA)