Introduction

Libra, a global currency and financial infrastructure designed to empower billions, was just announced by Facebook. Users will soon be able to use Libra to transact on Messenger, WhatsApp, and Facebook.com.
Libra is fully backed by the “Libra Reverse”, a collection of low-volatility assets denominated in USD, GBP, EUR and JPY.
The not-for-profit “Libra Association” was created to manage assets and oversee future developments.
Funding participants of the association includes; Uber, eBay, Visa, Mastercard, Paypal, and Spotify.

Why Libra?

But whyyyyyyyy?

31% of the global population is completely unbanked, with no access to a bank account or mobile money.
$3.7 trillion could be added to the economies of developing countries by 2025 through increased access to digital financial services.
$16 billion a year could be saved by slashing remittance fees by just 5%!
A typical bank-to-bank transfer across borders takes three to five business days to complete.
With cryptocurrencies, this can be INSTANT.
Libra seek to make it simple for everybody to send and get cash simple enough by utilizing our applications to in a flash offer messages and photographs.
To empower this, Facebook is likewise propelling a free auxiliary called Calibra that will construct benefits that lets you send, spend and spare Libra – beginning with an advanced wallet that will be accessible in WhatsApp and Messenger and as an independent application one year from now.

How It Differs From Other Blockchains

Right now, we have bitcoin, ethereum, eos, hyperledger and other blockchain technology with different consensus algorithms. But some of these platforms has transactions scalability problem or some have fully anonymous behaviour as per their consensus algorithms. Lets see,

How it differs?

1. Like bitcoin, there’s no genuine personality on the Blockchain.
2. Like Hyperledger, it’s permissioned (at any rate to begin).
3. Like ethereum, it makes money programmable.
4. Likewise like ethereum, it considers proof of stake is the future, yet it is additionally not prepared at this point.
5. Like Binance’s coin, it completes a great deal of consuming.
6. Like coda, clients don’t have to clutch the entire exchange history.
7. Like EOS, it hasn’t worked everything out yet.

Stay tuned with us for creating first transaction on Libra by next blog.Thanks.

Step:1 Clone the Libra Core Repository

Git clone: https://github.com/libra/libra.git

Step:2 Setup Libra Core

cd libra
./scripts/dev_setup.sh

To setup Libra Core, run the setup script to install the dependencies.

The setup script performs these actions:

1. Installs rustup
2. Installs rust-toolchain
3. Installs CMake
4. Installs protoc
5. Installs Go

Step:3 Build Libra CLI Client and Connect to the Testnet

./scripts/cli/start_cli_testnet.sh

To connect to a validator node running on the Libra testnet.

Step:4 Check If the CLI Client Is Running on Your System

libra% account

Step:5 Create My Account

libra% account create

#0 is the index of My account.

Step:6 Create My’s Account

libra% account create

#1 is the index for My Friend’s account.

Step:7 (optional) List Accounts

libra% account list

Add Libra Coins to My and My Friend’s Accounts

Step:8 Add Libra to My Account

libra% account mint 0 100

• 0 is the index of My account.
• 100 is the amount of Libra to be added to My account.

Step: 9 Add Libra to My Friend’s Account

libra% account mint 1 200

• 1 is the index of My Friend’s account.
• 200 is the amount of Libra to be added to My Friend’s account.

Step: 10 Check the Balance

libra% query balance 0

libra% query balance 1

Step: 11 Query the Accounts’ Sequence Numbers

libra% query sequence 0

libra% query sequence 1

A sequence number of 0 for both My and My Friend’s accounts indicates that no transactions from either My or My Friend’s account has been executed so far.

Step: 12 Transfer Money

libra% transfer 0 1 10

• 0 is the index of My account.
• 1 is the index of My Friend’s account.
• 10 is the number of Libra to transfer.

Step: 13 Retrieve the information about the transaction

libra% query txn_acc_seq 0 0 true

Step: 14 Query Sequence Number After Transfer

libra% query sequence 0

libra% query sequence 1

Each time a transaction is sent from an account, the sequence number is increased by 1.

Step: 15 Check the Balance in Both Accounts After Transfer

libra% query balance 0

libra% query balance 1

Congratulations!

You have effectively executed your transaction on the Libra testnet and transferred 10 Libra from My account to My Friend’s account!

Demo Video:

States & Transaction

At any point of time Blockchain has a state. It is also known as ledger state. Ledger state represent current snapshot of the data on the Blockchain. This state is structured as key-values store, which maps account address to account values.
Users of the Libra Blockchain can update the ledger state by submitting the transactions. Transaction consists of transaction script and transaction arguments like recipient address and amount of Libra to send.
Ledger state is not updated until the transaction is committed by the consensus.

Ledger History

Most of the Blockchain maintains a linked list of each block of transactions with the hash of the block. The Libra Protocol uses single merkle tree to provide authenticated data structure.
The Ledger History stores previously executed transaction as well as associated events that is emitted by transaction. The purpose of ledger history is to keep a record of how the latest ledger state was computed. In ledger history, There is no concept of blocks of transactions like Bitcoin and Ethereum.
Any user can query against the ledger history and use the ledger history for the auditing the transaction execution.

Accounts

Libra have something what Ethereum tries to achieve with account abstraction.

• Each account has an instance of the standard module called libraAccount.
• This module stores basic information like balance, sequence number(like nonce in Ethereum) and authentication key.

The Libra protocol does not link any accounts to a real-world identity. A user is free to create as many as accounts by generating multiple key-pairs. Accounts constrained by the same clients have no link to one another.

Transaction Structure

In Libra Blockchain transaction is a signed message that contains the following data:

• Sender Address: Address of the account who sends the transaction.
• Senders Publickey: The public key that corresponds to the private key used to sign the transaction.
• Program: Generally program consists Move bytecode of transaction script.
• Gas Price: The number of Libra coins that the sender is willing to pay per unit of gas to execute the transaction.
• Maximum Gas Amount: Maximum Number of gas units that the transaction is allowed to consume.
• Sequence Number: A number that is equal to the number stored under the sender’s account. Once this transaction executes, sequence number is incremented by one. So only one transaction can be executed for given sequence number.
• Signature: The digital signature of the sender.

Move Programming Language

Move is a programming language created during the design of the Libra Protocol. Move is used to implement custom transaction and smart contract on Libra Blockchain.
Moves has three important roles in the system,

1. Enable flexible transaction via transaction script.
2. Allow user defined smart contract via modules.
3. Support configuration and extensibility of the Libra Protocol.

I know it’s a little bit confusing but I’m assuming you got it. Let’s move forward, just a few more to go!!!!!

LibraBFT

The Libra Blockchain uses variant of the Hotstuff consensus protocol called LibraBFT. LibraBFT assumes that 3f+1 votes is distributed among a set of validators that may be honest or Byzantine. LibraBFT stays safe, preventing attacks such as fork and double spends when at most f votes are controlled by Byzantine validators.
LibraBFT maintains safety when validator node crash or restart. Even if all validator node restart at the same time.

Validators (Validator Node)

When users of Libra Blockchain submit transaction, transaction will reach to validator node. Then validator node run consensus protocol, execute transaction and store transaction and it’s execution result in Blockchain. Validator node will decide which transaction will be added to Blockchain and in which order.

What is DI (dependency injection)?

Dependency Injection is a design pattern used to implement inverse of control, meaning the flow of an application is inverted. We can create the dependent object outside of the class and provide those object to class from different ways. DI can help with, moving the creation and binding of the dependent objects outside of the class that depends on them.

There are main 4 roles in DI
If you want to use this technique, you need classes that fulfil four basic roles. These are:

1. The service you want to use.
2. The client uses the service.
3. An interface that’s used by the client and implemented by the service.
4. The injector which makes a service instance and injects it into the client.

I hope you have understood DI and a little bit about koin.

How Koin Works

The koin works on simple DSL model. Here we have to create module first. In this module all the dependent objects are there, then we have to load one or more modules in koin. Then, we are ready to use this object. Generally we are loading module in to koin in application class by calling startKoin method,then we can inject the object wherever we want,this how the Koin works.

Koin Vs Dagger

Setting up Koin

• Gradle Setup

repositories {
    jcenter()    
}dependencies {
   implementation 'org.koin:koin-android:2.0.1'
}

• Setup for MVVM extension

repositories {
    jcenter()
}
dependencies {
    // ViewModel for Android
    implementation 'org.koin:koin-android-viewmodel:2.0.1'
    // or ViewModel for AndroidX
    implementation 'org.koin:koin-androidx-viewmodel:2.0.1'
}

Yeee! we have successfully completed the setup

Why to Use Koin?

The very simple answer, to this question, other options are very hard to understand like dagger 2 and having bolipater code, and options like toothpick and many more cannot able to integrate, with ViewModel, Scope Model, Ktor, where as Koin can easily integratable. Koin have it own separate testing module that helps to performing testing.koin uses its own DSL, rather than annotations, Koin DSL Composed of this five things.

1. Application context
2. Bean
3. Factory
4. Bind
5. Get

Example

Simple example

1. We have to create module of dependency that we need to inject

val myModule = module {
single{  BusinessService()}
 }
//class object which is going to injected
class BusinessService() {
    init {
        Log.d("BusinessService", "Created")
    }
    var data = "hello"
}

2. Now we have successfully created a module now we need to pass it to koin for loading it.

class KoinDemo : Application() {
    override fun onCreate() {
        super.onCreate()
          startKoin {
            androidContext(this@KoinDemo)
            modules(myModule)
            //modules(mySecoundModule)
        }
    }
}

3. Here we are ready to Inject.

val businessService: BusinessService by inject()
override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        businessService.data
    }

All done successfully, this quite simple, isn’t it?

MVVM example

ViewModel Support

Simple integration is just the tip of the iceberg. There are a lot of features that Koin provides. Most importantly, it supports architecture component’s ViewModel. This feature binds Koin more strongly with the android community, no?
Let’s dive into an example to see its usefulness.

1. Creating ViewModel Class

class MainActivityVM(var view: MainActivityView) : ViewModel() {
    var userName = ObservableField<String>()
    var password = ObservableField<String>()
    fun onSubmitClick() {
        if (userName.get().equals("yudiz") && password.get().equals("yudiz123")) {
            view.showToast("welcome")
        } else {
            view.showToast("incorrect data")
        }
    }
}

2. Creating koin module

val mvvmModuleDI = module {
    viewModel { (view: MainActivityView) ->
        MainActivityVM(view)
    }
}

3. Adding module to Koin

startKoin {
            // Android context
            androidContext(this@KoinDemo)
            modules(mvvmModuleDI)

 }

4. Injecting viewModel to Activity

class MvvmWithKoin : AppCompatActivity(), MainActivityView {
    override fun showToast(msg: String) {
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show()
    }
    //injecting viewModel
    val viewModel: MainActivityVM by viewModel { parametersOf(this) }
    lateinit var binding: ActivityMvvmWithKoinBinding
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_mvvm_with_koin)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_mvvm_with_koin)
        binding.viewModelKoin = viewModel
    }
}

What is Microservices?

Microservices also called Microservice Architecture is a collection of small modules and services. Each service and module are deployed individually and this modules communicate with each other.

Features of Microservices

• Decoupling
• Componentization
• Business Capabilities
• Autonomy
• Continuous Delivery
• Responsibility
• Decentralized Governance
• Agility
• Independent Development
• Independent Deployment
• Fault Isolation
• Mixed Technology Stack
• Granular Scaling

Microservices with .NET Core

Why Microservices with .NET Core?

• Cross-platform
• Consistent across architectures
• Command-line tools
• Flexible deployment
• Compatible
• Open source

Prerequisite for build Microservices with .Net Core

• Visual studio 2017
• .NET Core SDK
• Windows 10 pro for Docker Installation with 64 bit windows
• Docker for Windows
• Docker Tools

Creating Application of Microservices with .NET Core

Check the checkbox right hand side panel “Enable Docker Support”
And select from dropdown linux after that click Create

Now you want to right click on project name then select “Container Orchestrator Support” option

It will create the Docker-Compose.This docker compose use for running your application.

Be careful before running your application, you must start your docker.
In this application you can create the small modules or services and you can run this service individually using docker. Before starting your application you want to check your port is same or not in “Dockerfile” or “docker-compose.yml”

After that you can run your Application you get the following output

We are very grateful for our client feedback. These reviews help us enhance our Clutch profile in order to help us attract new clients.

“We appreciate all our clients who have taken time from their busy schedule to review us on Clutch. These reviews mean a lot to us because it strengthens our online presence and also makes us feel proud that our clients are happy with our services and we have successfully delivered them solutions that surpassed their expectations. These reviews act as an online word-of-mouth and makes our prospects feel comfortable in starting a new business relationship with us.” – Kalyan Acharya, Business Development Head.

Why NopCommerce?

• Open source
• Secure
• Cost Effective
• Easy to develop and design

Features of NopCommerce

• Mobile Commerce (Responsive)
• Multi Store
• Multi vendor
• Product features
  • Product attribute
  • Product comparison
  • Stock management
  • Price management
  • Downloadable product
  • Return management
  • Multiple images per product
• SEO
  • Search engine friendly
  • Sitemap
  • Microdata
  • Localizable URLs
  • Breadcrumbs
  • Google Analytics integration
• Checkout
• Marketing
  • Reward Point Features
  • Related Product
  • Discount
  • Coupons
  • Product review and rating
• Payment method
• Shipping features
• Tax features

Can we implement the API integration with NopCommerce?

Yes, We can integrate the API with NopCommerce, we can also change the theme of front and also change the code of NopCommerce.

And NopCommerce also provide admin panel and frontend side. In Admin panel NopCommerce provides a lot of menu.

Overview

If you are someone who loves cameras & have shot a lot projects both in games & real life, Cinemachine is specifically designed for you.

Adam Myhill – Head of Cinematics, Unity came up with the idea, to make storytelling fun, fast & iterative, so the users can create shot sequences with the power of procedural cameras. He wanted to establish a relationship between the cameras & their subject so they would act as an army of little robots, ready to follow their instruction and that’s how Cinemachine was born.

That being said, today I hope to share my learnings on how one can make their own Unity Cinemachine Video.

Today, we would be covering the following topics:

Introduction To Unity Cinemachine:

Cinemachine is a complete unity package that consists of steps to make cutscenes, film video, virtual cinematography and more. Cinemachine is also used in-game camera handling without scripting camera behaviors. There are in total 2 different versions available.

1. Cinemachine for Games:

For using the cinemachine, speed of game development is high. It is easy to use for gaming, for example, FPS(first-person shooter) to follow a camera, any story game to make a scene and play a video for that game also supports 2D and 3D platform.

2. Cinemachine for Film And Video:

It’s also easy to use cinemachine to make a film or video. It supports many features of camera motions for example, tracking, dollies, shake, etc. you can change your animation after set up the layout in unity. you can create dynamically adjusts your shots.

How to get started?

1. Download and install Unity. (2017.1) or higher version (Recommended)
2. Open or Create a new 3d project.

3. Go to the Window in package manager.
4. Search or find the name cinemachine, and install package.

5. Create an empty Gameobject and name it Timeline.

6. Open Timeline Window

7. Select TimelineObject And Click On to Create in Timeline window and save.

8. Delete timeline animator because we do not need it.

9. Drag and Drop Object or Character in Timeline for Animation.

10. Right-click and select animation for your object.

11. Record Animation If you want.

12. Now add a Cinemachine brain to your Main Camera

13. Create Virtual Camera from Cinemachine Window

14. Select virtual camera and take any shot in the scene window and click to Move to view and align with view of virtual camera.

15. Drag and drop a focus point in lookat and follow in virtual camera.

16. Create a second virtual camera from cinemachin window
17. Create another shot and drag and drop a focuspoint to look at in second virtual camera.

18. Drag and drop a main camera in timeline window to create a Cinemachin track.

19. Drag all the virtual camera to an cinemachine track and play.

Overview

Today, we are going to design 3D looking 2D Design. From Infographics to Modelling to Magazine Illustrations, the 3D style seems to be everywhere lately. It’s only safe to assume that as per the trend, it’s going to be more popular. Isometric Illustration is a modern & polished way of creating 3D Looking objects look similar to a 2D vector art. Let’s draw an Isometric design in an Adobe llustrator CC to understand in detail.

I have covered these topics in my blog:

Why Isometric designs have been trending

The reason why they have been trending nowadays is because they are easy to understand, less cluttered & more detailed. In an Isometric design, we are able to see 3 different sides at a time which produce a fake 3D effect.

Let me know what do you think about my following work.

Here you can find the Reference Link.

Let’s have a look at the steps now..

Here are some steps through which you can create Isometric design on your own in Adobe Illustrator CC 2019. Over here, we will see how to draw the isometric design from a Front View of Design.

How to design Isometric grid in illustrator cc

(1) Create Artboard & Open Rulers

First, Open the Adobe illustrator CC and create an artboard of w1080 x h1920. To open the rulers click on View > Rulers > Show Rulers.

(2) Adding Guides to the Rulers

You will see the rulers on the top and on your left side. Just double click on the top ruler and you can see the guide as above.

(3) Setting Keyboard Increment

Now press cmd+K (For mac) or Ctrl+k (For Windows). You will see a popup as above. Set keyboard increment to 30px.

(4) Verifying the Incremented Guide

Select Guide and then press option + right arrow key (For Mac) or Alt + right arrow key (For windows). The guide will be copied and paste to the next 30px of increment. Do it until you see guides like this.

(5) Rotate the Guides

In this step select the all guides & press cmd + G (For mac )or ctrl + G (For Windows). You can do a right-click to group them. Now press “ R ” And press “ enter ”. You will see a popup of Rotate. Set angle to 120º & click ok.

(6) Copy and Reflect the Rotated Guide

Select the guide – press “ O ” and press “ enter ”. It will show you the above popup. Select vertical and press copy.

(7) Base of Isometric Design

You will be able to see the above screen. This is a base of Isometric design. In isometric design whatever you draw your design should be aligned with these guides.

Overview

It has been over a few decades since the use of green screens has taken a pace. Initially, this technology was said to be primarily reserved for Hollywood blockbusters and local news stations only but is now utilized by almost all the major YouTubers.

Back in the day, the process used to be quite complex. Things like the optical printers, film strips and more were required for adding a green screen effect. But thanks to the modern-day invention, all it takes now to add a green screen effect is roughly $30, a smartphone & a high graphic video editor.

Wondering why I have only been talking about the green screens? What’s so special about it?

It actually is a visual effect used prominently by the Industry these days known as “Chroma key effect”. If you haven’t encountered with Chroma Key effect before, go through my blog to get more insights.

What is the Chroma Key effect?

“A chroma key is an effect that allows you to remove all of one selected.”

The Chroma key effect has many names associated with it. It is known as colour keying OR colour separation overlay OR Green-screen OR the Blue-screen effect. This effect allows the user to easily remove the background. Chroma Effect is majorly used in the film industry, news channels, Television programs, studios and advertisement. Mostly Green and Blue colour is used in chroma effect according to film or video background. It can be either done in post-production or during the real-time recording.

(Green Footage)

(Output)

Why only Green/Blue Colour?

The principle behind using the Chroma keying is because of the reason the colour Green/blue holds an opposite colour shade to our skin tone. Black and White colours too are used in chroma effect but only in the rarest of cases. If we used other colours like Red, Orange or any colour tone of them then it will be affected in human skin or clothes or other object which is important in video. That’s why we can not use other colour in chroma effect.

What is System Music Player?

The system music player uses the built-in Music app on your behalf. On instantiation, it takes on the current Music app state, such as the identification of the now-playing item. If a user happens to switch away from your app while the music is still playing, that music will continue playing. The Music app then has your music player’s almost every detail such as most recently-set repeat mode, shuffle mode, playback state, and now-playing item.

Design

Code explained

Code Topics

• Creating Outlets
• Import Framework
• Permission added in infoPlist file
• Actions for Play, Pause, Next, Previous button

Creating Outlets

@IBOutlet var imageAlbum: UIImageView! // display dong profile image 
@IBOutlet var lblTitle: UILabel! // display artist name and song name
@IBOutlet var lblDuration: UILabel! // display total song duration
@IBOutlet var lblElapsed: UILabel! // display elapsed time
@IBOutlet var lblRemaining: UILabel! // display remaining time

Import Framework

First, you’ll need to import media framework

import MediaPlayer

Create a variable for the media player and timer

let audioPlayer = MPMusicPlayerController.systemMusicPlayer
var timer = Timer()

Permission added in infoPlist file

Now set the permission to access the Apple Music. And set in info.plist

<key>NSAppleEventsUsageDescription</key>

Next we’ll need to add some code to the viewDidLoad function to get things going at startup, starting with getting the media player ready to go:

audioPlayer.prepareToPlay()

Next, you’ll need to set up the timer, this will come in the handle when a song is playing.

self.timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(self.timerFired(_:)), userInfo: nil, repeats: true)

Actions for Play, Pause, Next, Previous button

We create some actions for play, pause, next and previous music.

@IBAction func btnNextTapped(_ sender: UIButton) {
     audioPlayer.skipToNextItem()
 }

@IBAction func btnPreviousTapped(_ sender: UIButton) {
     audioPlayer.skipToPreviousItem()
 }

@IBAction func btnPlayPauseTapped(_ sender:  UIButton) {
        btnPlayPauseUpdate()
 }

func btnPlayPauseUpdate() {
        btnPlayPause.isSelected = !btnPlayPause.isSelected
        btnPlayPauseType = btnPlayPause.isSelected ? .play : .pause
        btnPlayPauseType == .play ? startTimer() : stopTimer()
        btnPlayPauseType == .play ? audioPlayer.play() : audioPlayer.pause()
 }

Inside that function is where we are going to update all of the labels as well as get the slider to progress along with the song. Enter the following in the function:

if let currentTrack = MPMusicPlayerController.systemMusicPlayer.nowPlayingItem { 
}

This creates a constant for

MPMusicPlayerController.systemMusicPlayer().nowPlayingItem

so it’s easier to call while also ensuring that it exists before trying to pull the information. We’re going to need to pull a few key things before we can do anything, and the code should be pretty self-explanatory.

let trackArtist = currentTrack.artist ?? ""

let albumImage = currentTrack.artwork?.image(at: imageAlbum.bounds.size)

let trackDuration = currentTrack.playbackDuration

let trackElapsed = audioPlayer.currentPlaybackTime

Now we set the timer’s interval to 1, the information will be updated every 1 second, so the currentPlaybackTime will constantly update as the song plays.

So what do we do with that information? First, let’s go ahead and set the image to the current track’s album artwork, which we’ve already gotten above.

imageAlbum.image = albumImage

We can also set the label above the slider to display the song’s artist and title.

lblTitle.text = "\(trackArtist) - \(trackName)"

Now calculate the total duration of song.

let trackDuration = currentTrack.playbackDuration
//Convert total seconds into minutes
let trackDurationMinutes = Int(trackDuration / 60)
//get last remaining seconds
let trackDurationSeconds = trackDuration.truncatingRemainder(dividingBy: 60)
//convert second into integer
let trackDurationInt = Int(trackDurationSeconds)
//display total duration of song
lblDuration.text = "Length:\(trackDurationMinutes):\(trackDurationInt)"

In Next step calculate the remaining and elapsed time.

// get current playback time
let trackElapsed = audioPlayer.currentPlaybackTime

// convert into minutes and get remaining seconds
let trackElapsedMinutes = Int(trackElapsed / 60)
//get last remaining seconds
let trackElapsedSeconds = trackElapsed.truncatingRemainder(dividingBy: 60)
// Convert into integer track elapsed time
let trackElapsedInt = Int(trackElapsedSeconds)
// Display elapsed time
lblElapsed.text = "Elapsed: \(trackElapsedMinutes):\(trackElapsedInt)"

// calculate last remaining minutes and seconds
let trackRemaining = Int(trackDuration) - Int(trackElapsed)
let trackRemainingMinutes = trackRemaining / 60
let trackRemainingSeconds = trackRemaining % 60
// Display remaining time
lblRemaining.text = "Remaining: \(trackRemainingMinutes):\(trackRemainingSeconds)"

Now run the application and test how it works.

Introduction

The SMS User Consent API allows your app to prompt the consent dialog asking to allow or deny the permission to read specific incoming SMS. After granting the permission, the app can access the whole message body to perform the further SMS verification process. The SMS User Consent API is more user interactive than SMS Retriever API.

When To Use?

The SMS User Consent API does not require any custom format or hashcode in its message body. So If you don’t have control over the SMS body you can use the SMS User Consent API.

As it is recommended by Google, if it is possible we should use SMS Retriever API for SMS verification process because it gives fully automated, more secure and best user experience.

How Does It work?

credits: Google

To implement the SMS verification we need to interact with both, app-side and server-side.
The SMS User Consent API Listener will listen next five minutes for the new messages after it’s triggering.

Install & add angular/pwa

In angular 7, we have a feature to generate PWA files automatically and all its dependency.
PWA version is 0.7.4.

ng add @angular/pwa

Installed packages for tooling via npm.

CREATE ngsw-config.json (392 bytes)
CREATE src/assets/icons/icon-128x128.png (1253 bytes)
CREATE src/assets/icons/icon-144x144.png (1394 bytes)
CREATE src/assets/icons/icon-152x152.png (1427 bytes)
CREATE src/assets/icons/icon-192x192.png (1790 bytes)
CREATE src/assets/icons/icon-384x384.png (3557 bytes)
CREATE src/assets/icons/icon-512x512.png (5008 bytes)
CREATE src/assets/icons/icon-72x72.png (792 bytes)
CREATE src/assets/icons/icon-96x96.png (958 bytes)
CREATE src/manifest.json (1083 bytes)
UPDATE angular.json (3563 bytes)
UPDATE package.json (1388 bytes)
UPDATE src/app/app.module.ts (526 bytes)
UPDATE src/index.html (390 bytes)

The command generates all of the dependencies installed for PWA support, also create default service-worker config file, and default manifest.json file and even default icons for your splash screen and mobile home screen. You can edit these files as per your need.

Now you app is ready to be build.

ng build --prod

Your app with service worker & manifest file is ready to deploy. Service worker cache CSS/SCSS, JS, assets and index.html file. It is only working for production builds because caching Javascript is not working in development mode, where live debugging might be needed.

iOS Support

For Android, it will take a support of manifest file but ios will not support manifest file. We have to add the following meta tag in index.html manually.

<meta name="apple-mobile-web-app-capable" content="yes">
// by default it will take app title
 <meta name="apple-mobile-web-app-title" content="My Contact App">
//by default it will take a screenshoot of app as a logo 
 <meta name="apple-touch-icon" href="assets/icons/icon-192x192.png" sizes="180x180">
 <meta name="apple-touch-icon" href="assets/icons/icon-128x128.png" sizes="120x120">
//by default ios have square logo so in blank space it will take black color
 <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">

Inviting User To Install App

Invite the user to add our application to the home screen, we need the following code in app.component.ts.

ngOnInit(){
if ((navigator as any).standalone === false) {
     this.snackbar.open("You can add this to the Home Screen", '', {
       duration: 3000
     });
   }
if ((navigator as any).standalone == undefined) {
     if (window.matchMedia("(display-mode:browser").matches) {
       // in browser
       window.addEventListener('beforeinstallprompt', event => {
         event.preventDefault();
         const snackbar = this.snackbar.open("Do you want to install this App?", "Install ", {
           duration: 5000
         });
         sb.onAction().subscribe(() => {
           (event as any).prompt();
           (event as any).userChoice.then(result => {
             if (result.outcome == 'dismissed') {
               console.log("Dismissed");
             } else {
               console.log("Installed");
             }
           })
         })
         return false;
       })
     }
   }
}

Introduction

Everyone knows that Camera development is not an easy task. When I say camera development is, it means you have to provide a consistent experience across a range of devices. CameraX provide backward compatibility. It works on Lollipop and higher version of Android devices. it is a use-case based approach which is app-lifecycle aware. It comes with three use cases that cover all functionality which is required for Camera App development.

What’s New In CameraX

Backward compatible:

CameraX is backward compatible with Android 5.0 / Lollipop (API 21) and it works on 90% of devices in the market today.

Consistent behaviour:

CameraX provide the same consistency as camera1 via the camera2 API Legacy layer. Uptil now, we had to do a lot of manually code to provide consistency across a variety of devices.

Fixed a lot of issues across the device:
Some of the issue fix in cameraX.

• Front/Back camera switch crashes
• Optimised camera closures
• Orientation incorrect
• Flash not firing

Here is the typical walkthrough of the camera app architecture.
Uptil now, Camera app used to communicate with the public Camera2 API and the camera2 API handled communication with device HAL (Hardware abstraction layer).

Now we only have to deal with cameraX as it hides all the lower level complex from the developers.

Let’s Do Some Practical

Requirements:

• Android API level 21
• Android Architecture Components 1.1.1

Add below Dependencies:

def camerax_version = "1.0.0-alpha03"
implementation "androidx.camera:camera-core:${camerax_version}"
implementation "androidx.camera:camera-camera2:${camerax_version}"

Add Camera permission in AndroidManifest:

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

CameraX launch with three use-case.

1. Preview
2. Image analysis
3. Image capture

Here we are briefly talking about use-cases:

1. Preview:

Build a preview config using a builder.

val previewConfig = PreviewConfig.Builder().apply {
    	setTargetAspectRatio(Rational(1, 1))
    	setTargetResolution(Size(640, 640))
	}.build()

Configure the preview.

val preview = Preview(previewConfig)

Set PreviewOutListener. What’s going on now when the preview becomes active, It’s going to output a preview output.

preview.setOnPreviewOutputUpdateListener {
				previewOutput: Preview.PreviewOutput? ->
// To update the SurfaceTexture	
}

Next step is just to turn it on and turn off. So binding the preview use-case to activity lifecycle. It means when an activity starts, the preview is going to start and the camera is going to start to stream. And when activity stops, the preview is going to stop and the camera is going to shut down.

CameraX.bindToLifecycle(this as LifecycleOwner, preview)

Note: If you face any issue after adding the line of code mentioned above, you’ll need to add the following dependency as well.

implementation 'androidx.appcompat:appcompat:1.1.0-rc01'

Here instead of activity lifecycle we can also use other lifecycle such as the fragment lifecycle.
There would need to be code for setting up permission, attaching to views, and managing the surface texture.

2. Image analysis:

CameraX provide easy access to the buffers from the camera, so you can perform your own analysis.

Step same as preview use-case to create an Image analysis config object.

val imageAnalysisConfig = ImageAnalysisConfig.Builder()
    	.setTargetResolution(Size(1280, 720))
	.build()

The above step is to request a resolution. Now let’s say your processing requires some minimum resolution for it to succeed. That you’ll specify here.

TheCameraX is going to balance the requests from your application with the device capability. So if you’re able to get the target resolution, you’ll get it Otherwise cameraX would try the next higher resolution, and if failing to get request resolution then cameraX will fall back to a 640 x 480 resolution, which is guaranteed across all devices.

val imageAnalysis = ImageAnalysis(imageAnalysisConfig)
imageAnalysis.setAnalyzer { 
	image: ImageProxy, rotationDegrees: Int ->
   	// write your code here.
}

Image analysers provide all information required for image processing.
We have to bind image analysis use case to lifecycle, so add imageAnalysis to CameraX.bindToLifecycle(…) method.

CameraX.bindToLifecycle(this as LifecycleOwner, preview, imageAnalysis)

3. Image capture:

Image capture allows you to take a high-quality picture with the camera.
Create an Image capture config object.

val imageCaptureConfig = ImageCaptureConfig.Builder()
				.setTargetRotation(windowManager.defaultDisplay.rotation)
   				.build()

		val imageCapture = ImageCapture(imageCaptureConfig)
		CameraX.bindToLifecycle(this as LifecycleOwner, preview, imageAnalysis, imageCapture)

We know getting rotation on devices can be hard, getting portrait mode and landscape mode just right on a variety of devices is harder. But in cameraX this problem is reduced.

Now it is ready to go. Preview will be displayed on screen, the analyzer will be running, and application-ready to take a picture.

But, What about attaching to output?
It simply requires to call tackPicture method on image-capture use case on button click.

fun captureImage(view: View) {
   val file = File(externalMediaDirs.first(), "${System.currentTimeMillis()}.jpg")

   imageCapture.takePicture(file,
       object : ImageCapture.OnImageSavedListener {
           override fun onError(
               error: ImageCapture.UseCaseError,
               message: String,
               exc: Throwable?
           ) {
               val msg = "Photo capture failed: $message"
               Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
               Log.e("CameraXApp", msg)
               exc?.printStackTrace()
           }

           override fun onImageSaved(file: File) {
               val msg = "Photo capture succeeded: ${file.absolutePath}"
               Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
               Log.d("CameraXApp", msg)
           }
       })
}

In this method we need to pass the destination of image where the image will be stored after capturing.

You can also attach a listener to listen success and failure events.

Prerequisite

PHP Version 7.2.0 or above

Installation

It’s not new in laravel, it is the same as it was in other versions, but it has a slight change on using default CSS and JS files.

To get a quick start with default laravel auth please follow the below steps.

Steps for default laravel auth

Step 1:

To get a fresh copy of laravel version 6, fire the following command in your terminal.

composer create-project –prefer-dist laravel/laravel project_name

> It’ll create a new project in your system.

NOTE: Remember this command will install laravel version 6 only if you have installed php version >= 7.2.0 in your system.

Step 2:

Before you move for the built-in login and registration process you have to install laravel UI as per the new Laravel version. For that fire the following command.

composer require laravel/ui

Step 3:

php artisan ui vue –auth

> Laravel 6 has removed “php artisan make:auth” command and instead, they design a new command “php artisan ui vue –auth” for a quick start on login and registration setup process.

REMEMBER: Here you’ll not find any “css” or “js” folder inside “public” folder of your project, it was created automatically in previous versions of laravel after firing “php artisan make:auth” command for the login and registration pages and other related pages design.

Now to get a scaffold of CSS and JS file you have to follow the below steps.

Step 4:

Fire the following command in terminal

npm install

> Which will install all the node dependencies in your project.

Step 5:

After installing npm, fire the next command

npm run dev

> As laravel built-in “webpack.min.js” file considers default scaffolding as SASS, you have to run this to make your own scaffolding.

NOTE: After running “npm run dev” command in terminal you’ll find 2 folders inside your public folder. Which will be “css” and “js” and you’ll find the files inside of it.

Now just refresh your login url and you’ll find the designed layout.

Apple Arcade

Apple introduced the new service in the game area. This is a huge step taken by apple specific for the game lovers. Apple added a new tab in the app store apps which listed games under the Arcade menu. Also, Apple tie-up or partnerships with many game vendors to add more & more games in the future.

Apple Arcade will charge $4.99 per month & enable the family sharing option up to 6 members. You can use as a free trial as well. Available on September 19th.

Apple TV+

Another big service announced is Apple TV+. We already had a little bit of an idea before the event. The most lovely thing is 1 year included if we’ll buy any apple device like Mac, Apple watch etc.. Apple TV+ will launch on November 1st for $4.99 per month. We can use it for a 1 week trial period. Initially, Apple TV+ launch with 5 Original TV shows. Just amazing!!

iPad

As we all know the new iPad just launch in the event has many features. Let’s drive deep to know more about it.

First, The size of the iPad is 10.2 inch with Retina Display as it’s common. The more exciting is iPadOS 13 which has mind-blowing features. It helps people in all areas like gaming, business, entertainment etc.. The New iPad has apple pencil support & floating one hand keyboard.

According to me, iPad have A10 Fusion process. I expected it should have at least A12 Bionic. By doing it might affect the price of an iPad.
The new iPad Price starting with $329 & for education $299.

Concept of Morph

Morphing is a special effect in Motion Graphics and animations that morph one image or shape into another through a transition. Morphing is one of the cross-fading techniques which apply to the Motion scene.

Another word for Morphing is twining. It is the process of generating intermediate frames between two images or two frames, which makes it look like a second image is slowly take part in the first image.

It is a George W.Bush(43rd president of the United States) and Arnold Schwarzenegger(American actor, Politician) morph image

We create motion between Text, Logo, Shape through Morphing. After Effect is a platform or tool that can create morph between footage keyframes. Morphing techniques are classified into two parts. They are Mesh-based methods and Feature-based methods. In mesh-based methods, the images are declared by a solid vertex shape. In Feature-based methods, the images are as lines or a set of points. Now-a-days Feature-based methods are popular.

Here is an example of morphing in circle, square and triangle with bounce motion. So it is a simple type of shape morphing in after effect. This is a mesh-based method in morphing. In Mesh-based morphing, first the edge point of all shape path you used are decided. Then make keyframe of all these shape edge path and all key paste in one of our shapes in path keyframe. Set all keyframes to the different time with the same gap, make all keyframes to easy ease. See the same shine on it so apply the Glow Effect on the shape.

How to create Morphing

Here we have created the Morph Effect between two texts. So let’s do this…

Step 1:

Make new after effect project of 1080×1080 px composition.

Step 2:

Write two letters or text that you want to morph.

Step 3:

Then right-click on the text layer and “create shape from text” layer for both.

Step 4:

Now it generates outlines layer in the timeline. Find both outlines path and create a keyframe of it for all letters.

Step 5:

Copy all keyframes one by one in another outline letter path.

Step 6:

Set all keyframes to a different time with the same Time gap.

Step 7:

For a better view of animation movement retouch letters first vertex point. So animation starts at that point of the edge.

Step 8:

Make all keyframes easy ease.

So this is our text morphing…

I have some additional touch on font shadow, reflection, color tone for a better view and smoothness of morphing.

Where we use Morphing

Morphing is used in titles, advertisements, logo animation, story animation. Here I have created animation between google’s logo and google assistant’s logo. Like this, we can implement Morphing on Motion Graphics.

What is the U1 chip?

The U1 chip uses Ultra-Wideband(UWB) technology that allows the new iPhone to locate and communicate with other U1 equipped devices. “U” in U1 means “ultra-wideband”. Ultra-wideband is low energy, short-range radio technology used for wireless transmission.

What could iPhone 11’s U1 chip do?

Apple is the first company to use Ultra-Wideband(UWB) technology in smartphones. The U1 chip mainly used in Airdrop as Apple said “the latest directional version of Airdrop”. That shows another U1 equipped device’s direction and distance using radio waves. Apple is also merging Find My Friend and Find My iPhone into a single app “Find My” in iOS 13.

Difference between Bluetooth and U1(UWB) chip

Bluetooth also does the same thing as UWB in the existing Tile tracker. This tracker works by measuring signal strength. Bluetooth is inexplicit and insecure as compared to UWB. UWB uses time-of-flight calculation for measure distance. UWB can also give the direction to another device, for example, the device is 2 feet away to the left. In the future, the new trackers will be using this latest U1 chip.

Devices with U1 chip

iPhone 11, iPhone 11 Pro and iPhone 11 Pro max are all new devices that have U1(Ultra Wideband) chip.

It’s an interesting time in the gaming industry. According to Capcom, an estimated 25 billion dollars’ worth of gaming products will be purchased in 2019. That’s a lot of people picking Luigi in Mario Kart and even more fitting shapes together on Tetris.

Stay in the know about current industry guidelines in the gaming sphere on The Manifest, a business resource for companies looking for quality information that’s useful to their business success. And to see the work that we’re so proud of making, check out our digital portfolio on Visual Objects. Visual Objects is a Clutch site that is a resource for businesses looking for partners.

We’re excited to see where the industry takes us and even lead the way for a few companies just starting out. We’re thankful to our clients for the reviews.

We’re also awarded as a development leader by Clutch, know more about it on our blog.

Be sure to stay updated on the Yudiz Solutions blog.

You can also book time with our team to discuss a potential development project.