Practical

Let’s dive into some practical scenarios. But before it, you’ll need an API key which can be grabbed by registering yourselves at https://viromedia.com/signup and it is to be added in manifest file as shown below:

We have to add two libraries: ARCore and ViroCore SDK. As it is based on ARCore, it will only run on AR supported devices.

We’ll use the assets provided by ViroCore – sample code. In this, we will have a window of a ship and through that window, we can pass into a beach world, for that we’ll need a 360 degree image of a beach world and a model of ship window and its textures. Place them in assets folder.

Here, .VRX format for model is ViroCore’s own extension. Here, it is basically a .FBX model.

Final output will be something similar to the below image:

In Activity’s onCreate( ) method, we need to set ViroView as content view. ViroView is basically a FrameLayout which initializes the camera for AR.

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);

   mViroView = new ViroViewARCore(this, new ViroViewARCore.StartupListener() {
       @Override
       public void onSuccess() {
           displayScene();
       }

       @Override
       public void onFailure(ViroViewARCore.StartupError error, String errorMessage) {
           Log.e(TAG, "Error initializing AR [" + errorMessage + "]");
       }
   });

   setContentView(mViroView);
}

As seen, we have a function-call in onSuccess( ) of ViroView’s initialization.

private void displayScene() {
   mScene = new ARScene();
   mScene.setListener(new ARSceneListener(this, mViroView));

   //add light
   OmniLight light = new OmniLight();
   light.setColor(Color.WHITE);
   light.setPosition(new Vector(0, 1, -4));
   mScene.getRootNode().addLight(light);

   //load ship window model
   Object3D shipDoorModel = new Object3D();
   shipDoorModel.loadModel(Uri.parse("file:///android_asset/portal_ship.vrx"), Object3D.Type.FBX, null);

   //create a portal
   Portal portal = new Portal();
   portal.addChildNode(shipDoorModel);
   portal.setScale(new Vector(0.5, 0.5, 0.5));

   //add a beach world
   PortalScene portalScene = new PortalScene();
   portalScene.setPosition(new Vector(0, 0, -5));
   portalScene.setPassable(true);
   portalScene.setPortalEntrance(portal);
   Bitmap beachBackground = getBitmapFromAssets("beach.jpg");          //load from assets
   Texture beachTexture = new Texture(beachBackground, Texture.Format.RGBA8, true, false);
   portalScene.setBackgroundTexture(beachTexture);

   mScene.getRootNode().addChildNode(portalScene);

   //set scene in ViroView
   mViroView.setScene(mScene);

   View.inflate(this, R.layout.viro_initializing_ar, ((ViewGroup) mViroView));
}

private Bitmap getBitmapFromAssets(String filePath) {
   AssetManager assetManager = getAssets();

   InputStream istr;
   Bitmap bitmap = null;
   try {
       istr = assetManager.open(filePath);
       bitmap = BitmapFactory.decodeStream(istr);
   } catch (IOException e) {
       // handle exception
   }

   return bitmap;
}

This will add an ARScene in VieroView.
Initially, we have set light position and color.

OmniLight light = new OmniLight();
light.setColor(Color.WHITE);
light.setPosition(new Vector(0, 1, -4));
mScene.getRootNode().addLight(light);

Then, we have created and loaded ship window model.

Object3D shipDoorModel = new Object3D();
shipDoorModel.loadModel(Uri.parse("file:///android_asset/portal_ship.vrx"), Object3D.Type.FBX, null);

Now, comes the main part. We have created a portal and have added a background to it.

Portal portal = new Portal();
portal.addChildNode(shipDoorModel);
portal.setScale(new Vector(0.5, 0.5, 0.5));

PortalScene portalScene = new PortalScene();
portalScene.setPosition(new Vector(0, 0, -5));
portalScene.setPassable(true);
portalScene.setPortalEntrance(portal);
Bitmap beachBackground = getBitmapFromAssets("beach.jpg");          //load from assets
Texture beachTexture = new Texture(beachBackground, Texture.Format.RGBA8, true, false);
portalScene.setBackgroundTexture(beachTexture);

setPassable(true) will allow us to create a portal in which we can enter. We have to set ship model as the entrance of PortalScene.

That’s it. Now, it’s beach time !!

Video

Future

We, here at Yudiz, are targeting to achieve nested portal scenarios (Portal inside another Portal).

Conclusion:

We are just a ‘portal’ away from AR-dominating world. Adapting to such amazing technologies as soon as possible will serve us and our businesses with a great benefits.

What is Architecture Components?

With the popular demand, The Android Team has written an opinionated guide to architecture android applications and developed a set of architecture components.

Architecture Components are a growing set of libraries there will be more of them coming out and they are meant for creating an Android Application in a better way.

The whole point of these libraries is to simplify things that might have been a small challenge with android mobile application development.

List of Architecture Components:

Room:

The room is a robust SQL object mapping library.

Lifecycle Components:

Lifecycle components like Live Data, Lifecycle Observers, View Model and Lifecycle owners helps you to handle your app’s life cycle.

Paging Library:

Paging library is a small library to help you to load data from server gradually.

Here, We’ll focus on Room Database.

What is Room Database?

• The room is persistence library that provides an abstraction layer over SQLite.
• So basically by using Room database, your SQLite code becomes much easier by implementing annotations. So now you don’t need to write a lot of code to save or store your data locally.
• Room database library reached 1.0 stable, so you can use this in an android application without any fear.

Why Room Database?

• Working directly with SQLite database in Android has several drawbacks like,
• You have to write a lot of boilerplate code.
• You have to implement object mapping for every single query you wrote.
• A database migration is too difficult in SQLite.
• Hard to access database.
• If you are not careful, you can easily do the long-running operation or task on the main thread.

Advantages of Room Database

• We just have to write a Little boilerplate code.
• All Entity and Query will be checked at compile time so no worries to check tables and queries that might crash the application.
• Room not only provides query error It also takes care of missing table error.
• You can fully integrate Room Database with other Architecture Components like Live Data.

Let’s get started with Room Database

Update the dependencies

Room Database libraries are available via Google’s maven repositories, So you need to add it to the list of repositories in a project level build.gradle file.

allprojects {
   repositories {
       google()
       jcenter()
   }
}

In your app/build.gradle file, you need to add dependencies for room database.

implementation       
"android.arch.persistence.room:runtime:1.0.0"

annotationProcessor
"android.arch.persistence.room:compiler:1.0.0"

Create Table with Room

@Entity(tableName = "tbl_employee")
public class Employee {
   @PrimaryKey(autoGenerate = true)
   private int id;

   @ColumnInfo(name = "name")
   private String name;

   @ColumnInfo(name = "mobile")
   private String mobile;
}

@Entity will define a table, write table name in ‘tableName’
(Ignore if your class name is same as your table name)

@PrimaryKey will define your column as a primary key. Add ‘autoGenerate’ as a true to auto-generate value in that particular column.

@ColumnInfo is used to define that field as a table column. Write the name of your table filed in ‘name’ (Ignore if the variable name and table field name are same)

Create DAO (Database Access Object)to handle all queries

Read query

@Dao
public interface EmployeeDao {
   @Query("SELECT * FROM tbl_employee")
   List getAllEmployees();
}

@Dao Contains all the methods which are used to access the database

@Query Here you can write all the Custom SQL Queries

Insert Query

@Insert
void insertEmployee(Employee employee);

@Insert annotation will automatically insert data in the table

Insert Query for list of data

@Insert
void insertEmployees(List employees);

@Insert If you want to add more than one employee than you can also do it by this annotation.(If you pass single record it will insert single If you pass the list of record it will insert all the records)

Update Query

@Update
void updateEmployee(Employee employee);

@Update annotation used to update any of the data stored in the table

Delete Query

@Delete 
void deleteEmployee(Employee employee);

@Delete annotation will delete the employee data

Generate Database class to handle tables and queries

@Database(entities = {Employee.class}, version = 1)
public abstract class EmployeeDB extends RoomDatabase {
   public abstract EmployeeDao employeeDao();
}

@Database annotation will create your database. In Entities, you have to specify all the entities(Tables) you have created.

Build database in your activity

database = 
Room.databaseBuilder(getApplicationContext(), 
EmployeeDB.class, 
DATABASE_NAME).allowMainThreadQueries().build();

Here you have to specify the name of Database and build the database after that you can access all Database query by object.

Retrieve all data employee

List employeeList = 
database.employeeDao().getAllEmployees();

By this, you can get all the employee detail as a list.

Insert Employee Data

database.employeeDao().insertEmployee(employee);

Here you have to specify employee details to insert into a table.

Update Employee Data

database.employeeDao().updateEmployee(employee);

You can update the employee details based on unique ID.

Delete Employee Data

database.employeeDao().deleteEmployee(employee);

Delete employee data from table based on unique ID.

Installing CocoaPods

Install CocoaPods on System.CocoaPods Guides.

OR

If you have already added CocoaPods to your project then you’ll just need to add the following line to your Podfile:

pod 'pop'

Basic Animation

Basic animations make linear, ease-in, ease-out, and ease-in-ease-out animations simple to leverage.

In given example, I’m simply rotating the view. POPBasicAnimation class is used for Basic Animation. POPBasicAnimation has several different properties, but I have used toValue, fromValue, duration to define the behavior of the view.

Steps:

1. Import framework in your UIViewController class: import pop
2. Create the outlet variables for UIView.
   

   @IBOutlet weak var animView: UIView!

   
   
3. Create POPBasicAnimation object with using Layer Properties.
   

   let anim = POPBasicAnimation(propertyNamed: kPOPLayerRotation)

4. Set the toValue, fromValue, duration of the animation.
   

   anim?.fromValue = 0
   anim?.toValue = Double.pi
   anim?.duration = 0.5

5. Add animation to View or Layer.
   

   animView.layer.pop_add(anim, forKey: "basicAnimation")

   
   NOTE: You can set any string as key
6. Implement button action method.
   

   func prepareForBasicAnimation() {
        		let anim = POPBasicAnimation(propertyNamed: kPOPLayerRotation)
         	    anim?.fromValue = 0
           	anim?.toValue = Double.pi
           	anim?.duration = 0.5
           	animView.layer.pop_add(anim, forKey: "basicAnimation")
       }

   
   

   @IBAction func btnAnimationTap(_ sender: UIButton) {
           	prepareForBasicAnimation()
       	}

Spring Animation

Here in the demo app, I have given the Bouncing effect to Rounded View when it moves up and down. There is one UISlider to set springBounciness of UIView. POPSpringAnimation class is used for Spring Animation. POPSpringAnimation has properties like springBounciness, springSpeed to define the behavior of spring. We can apply constraints to the object we wish to move. We can modify the value of kPOPLayoutConstraintConstant to animate our interface object.

Steps:

1. Import framework in your UIViewController class: import pop
2. Create the outlet for ballView, slider and vertical center constraint constant of UIView. Your code should look like this:
   

   @IBOutlet weak var ballView: UIView!
   @IBOutlet weak var slider: UISlider!
   @IBOutlet weak var ballCenterYConstraint: NSLayoutConstraint!

   
   
3. Here is Bool for to know Up/Down status
   

   var atTop: Bool = false

4. In the viewDidLoad method, add the following line of code to set UISlider minimum and maximum value.
   

   slider.minimumValue = 8.0
   slider.maximumValue = 20.0

5. Create POPSpringAnimation object by using NSLayoutConstraint Property.
   

   let spring = POPSpringAnimation(propertyNamed: kPOPLayoutConstraintConstant)

6. Set the toValue, springBounciness, springSpeed of animation.
   

   spring?.toValue = 100
   spring?.springBounciness = 8.0
   spring?.springSpeed = 8

7. Add animation to UIView vertical center constraint
   

   ballCenterYConstraint.pop_add(spring, forKey: "moveUp")

8. Same code for MoveDown, just change value to -100.
   

   func animateBottom() {
   let spring = POPSpringAnimation(propertyNamed: kPOPLayoutConstraintConstant)
           	spring?.toValue = -100
           	spring?.springBounciness = bounciness
           	spring?.springSpeed = 8
           	ballCenterYConstraint.pop_add(spring, forKey: "moveDown")
       	}

9. Implement button action method.
   

   func animateTop() {
           let spring = POPSpringAnimation(propertyNamed: kPOPLayoutConstraintConstant)
           spring?.toValue = 100
           spring?.springBounciness = bounciness
           spring?.springSpeed = 8
           ballCenterYConstraint.pop_add(spring, forKey: "moveUp")
       }

   
   

   func animateBottom() {
           let spring = POPSpringAnimation(propertyNamed: kPOPLayoutConstraintConstant)
           spring?.toValue = -100
           spring?.springBounciness = bounciness
           spring?.springSpeed = 8
           ballCenterYConstraint.pop_add(spring, forKey: "moveDown")
       }

   
   

   @IBAction func btnAnimationTap(_ sender: UIButton) {
           if atTop {
               animateBottom()
           } else {
               animateTop()
           }
           atTop = !atTop
       }

Decay Animation

Decay makes a movement to an eventual slow end. Decay use velocity as an input. In the demo app, I have given slow end effect to Rounded View. POPDecayAnimation class is used for Decay Animation. POPDecayAnimation has a property called velocity.

Steps:

1. Import framework in your UIViewController class: import pop.
2. Create the outlet variables for UIView and UISlider, as well as, Vertical Center Constraint Constant of UIView. Your outlet variable should look like this:
   

   @IBOutlet weak var ballView: UIView!
   @IBOutlet weak var ballCenterYConstraint: NSLayoutConstraint!

   
   
3. Create POPDecayAnimation object with using NSLayoutConstraint Property.
   

   let spring = POPDecayAnimation(propertyNamed: kPOPLayoutConstraintConstant)

4. Set the velocity of animation.
   

   spring?.velocity = NSValue(cgPoint: CGPoint(x: -642.0, y: 0))

5. Add animation to UIView vertical center constraint.
   

   ballCenterYConstraint.pop_add(spring, forKey: "move")

6. Implement button action method.
   

   func prepareForDecayAnimation() {
           let spring = POPDecayAnimation(propertyNamed: kPOPLayoutConstraintConstant)
           spring?.velocity = NSValue(cgPoint: CGPoint(x: -642.0, y: 0))
           rightBallCenterY.pop_add(spring, forKey: "move")
   }

   
   

   @IBAction func btnAnimationTap(_ sender: UIButton) {
           rightBallCenterY.constant = 160 //Reset your View Position Y 
           prepareForDecayAnimation()
   }

Delegation Handling

POP comes with a couple of delegate methods that alert you to particular events. We can take advantage of these when we are stacking animations in order to get the feeling you are looking for.

When one of these methods are called you can check the animation name to verify the animation in the one you need. For example:

let sprintAnimation = POPSpringAnimation(propertyNamed: kPOPViewScaleXY)
sprintAnimation?.velocity = NSValue(cgPoint: CGPoint(x: 8.0, y: 8.0))
sprintAnimation?.springBounciness = 20.0
sprintAnimation?.name = "send"
sprintAnimation?.delegate = self
btnSend.pop_add(sprintAnimation, forKey: "sendAnimation")

Some POPAnimationDelegate are:

// Called on animation start.
    func pop_animationDidStart(_ anim: POPAnimation!) {
        if anim.name == "send" {
            // perform a new animation or action
        }
    }

    // Called when value meets or exceeds to value.
    func pop_animationDidReach(toValue anim: POPAnimation!) {
        if anim.name == "send" {
            // perform a new animation or action
        }
    }

    // Called on animation stop.
    func pop_animationDidStop(_ anim: POPAnimation!, finished: Bool) {
        if anim.name == "send" {
            // perform a new animation or action
        }
    }

    // Called each frame animation is applied
    func pop_animationDidApply(_ anim: POPAnimation!) {
        if anim.name == "send" {
            // perform a new animation or action
        }
    }

#Example Highlighted UITableViewCell

Go to your UITableViewCell class and override the setHighlighted method using the given code snippet:

override func setHighlighted(_ highlighted: Bool, animated: Bool) {
        super.setHighlighted(highlighted, animated: animated)
        if highlighted {
            let scaleAnimation = POPBasicAnimation(propertyNamed: kPOPViewScaleXY)
            scaleAnimation?.duration = 0.1// defaults to 0.4
            scaleAnimation?.toValue = NSValue(cgPoint: CGPoint(x: 1.0, y: 1.0))
            self.lblTitle.pop_add(scaleAnimation, forKey: "scaleAnimation")
        } else {
            let springAnimation = POPSpringAnimation(propertyNamed: kPOPViewScaleXY)
            springAnimation?.toValue = NSValue(cgPoint: CGPoint(x: 0.9, y: 0.9))
            springAnimation?.velocity = NSValue(cgPoint: CGPoint(x: 2.0, y: 2.0))
            springAnimation?.springBounciness = 20.0//from 1 to 20
            self.lblTitle.pop_add(springAnimation, forKey: "springAnimation")
        }
    }

Properties To Know

• toValue: id // value type should match the property
• fromValue: id // value type should match the property
• velocity: id
• springBounciness: CGFloat // from 1 to 20
• springSpeed: CGFloat // from 1 to 20
• repeatForever: Bool // a convenient way to loop an animation
• duration: CFTimeInterval // defaults to 0.4
• beginTime: CFTimeInterval // if you want to delay the beginning of an animation
• name: NSString // identify the animation when delegate methods are called
• autoreverses: Bool // this will complete one full animation cycle; use repeateForever to loop the effect

Note: There are a number of predefined animation properties in the POPAnimatableProperty.h file that will help you make your animation.

Laravel Initial SetUp

Let’s start with a new fresh project.
*For Understanding Purpose we make it simple by using only two tables “users and posts”

• Create new project
  

  laravel new custom

• Set up SQL connection in .env file
• Make new migration table : posts
  

  php artisan make:migration create_post_table create=posts

• Add few columns like title, description, user_id(foreign constraint)
• Migrate database
  

  php artisan migrate

• Make Eloquent Model For User(if not exists) and Posts

Set Up Relationship (*optional)

1) Define relationships and add accessor in Post Eloquent Mode. (*optional)

public function user()
{
    return $this->belongsTo('App\User');
}

public function getCreatedAtAttribute($value)
{
    return \Carbon\Carbon::parse($value)->diffForHumans();
}

Same as Post Eloquent, add relationship and accessor in User Eloquent Model

public function posts()
{
    return $this->hasMany('App\Post');
}

public function getNameAttribute($value)
{
    return title_case($value);
}

2) Add few records in a database. (manually from phpMyAdmin)
3) As of now, the Basic app is to understand the custom commands.

Simple Commands

Generate Command File

php artisan make:command {command_name}
php artisan make:command allUsers

Structure Of Command

• After generating your command, you should fill in the signature and description properties of the class, which will be used when displaying your command on the list screen.
• The handle method will be called when your command is executed.
• You may place your command logic in this method.

Here one new command file is created : App\Console\Commands\allUsers.php

Now Modify our new command file:

protected $signature = 'command:name';

Signature Means : The command used after php artisan

So change signature variable to :

protected $signature = 'user:all';

Change the description :

protected $description = 'Get All Users.';

This message is displayed in the help section of our command.

Now, an actual part of the command is here:

We need to add our logic part at

public function handle()
{
    // Add Your Logic / Task 
}

In this example we need to select user details, so add :

$users = User::select('id','name','email','contact')
    ->orderBy('name')
    ->get()
    ->toArray();

$this->table(['id','name','email','contact'],$users);

NOTE :

• If You Want to display details in tabular format, “toArray()” is required.
• In the table() we need to pass the column name(s) and array for that columns.
• Artisan CLI can manage the output as a table for GUI purpose (if needed).

Output :
Now, our command is ready to execute.
Go to terminal and execute the command

php artisan user:all

Print Details On Command Line :

$this->info("message");	          // success message

$this->error("message")          // error message

Get Input In Through Command Line

As of now we know how to fire custom command, now understand how to get input from command line and process that input.

Let’s make new command which fetches particular user’s details.

php artisan make:command userDetails

Change signature of our command :

protected $signature = 'user:get { id : ID Of User}';

Note :

• Here, {variable : description} is used to get input from user.
• As per our signature command will look like
  

  php artisan user:get 1

• Here we can also pass optional values by adding {id?} so “?” is used for optional values.
• If you want to add some options then use {–option_name}, if you want to add shortcut then {– A | argument } and you can access that value by using switch case
• If you have not fixed a length of output then you can use an array for it by adding *.
  Example :
  • COMMAND FILE : $signature = ‘user:get {– id =*}’;
  • TERMINAL : php artisan user:get –id=1 –id=2

Now add our logic part / task at

public function handle()
{
	// Add Your Logic / Task 
}

To use input of CLI :

$this->argument("argument_name");

In this example we need to select user details, post details, so add :

$bar = $this->output->createProgressBar(100);
$user_details = User::select('id','name','email','contact')
          ->where('id', $this->argument('id'))->get()->toArray();

if(sizeof($user_details) == 0) {
    $this->error("User Not Found!");
        $bar->advance();
    }
    else {
        $this->info("User Details");
        $this->table(['id','name','email','contact'],$user_details);
        $post_details = Post::select('title','description','created_at')
	          ->where('user_id',$this->argument('id'))->get()->toArray();
        $bar->advance(50);

        if(sizeof($post_details) == 0) {
            $this->error("No Post Found!");
        } else {
            $this->info("\n\nUser's Posts Details");
            $this->table(['Title','Description','Created By'],$post_details);
            $this->info("\nTotal Post(s) : ".sizeof($post_details));
            $bar->advance(50);
        }
    }
$bar->finish();
$this->info(''); // this is for new line

In above example we add ProgressBar, ProgressBar is used to get tracking information and nothing else.

• First, we need to init ProgressBar with max.
• After that just use advance() with an argument, the number of increment default is 1.
• To complete the use of ProgressBar, use finish() to end that ProgressBar.
• ProgressBar Is Completely Optional. It is only for GUI Purpose Only!

Output :
Now, our command is ready to execute.
Go to terminal and execute the command

php artisan user:get 1

php artisan user:all

php artisan post:all

Conclusion : –

That’s It! I hope you found out my article useful. For any suggestions, please hit comment below.

Thank You!

Privacy

As with all Apple software updates, enhanced privacy and security remain a top priority in iOS 12. In Safari, enhanced Intelligent Tracking Prevention helps block social media “Like” or “Share” buttons and comment widgets from tracking users without permission. Safari now also presents simplified system information when users browse the web, preventing them from being tracked based on their system configuration. Safari now also automatically creates, autofills and stores strong passwords when users create new online accounts and flags reused passwords so users can change them.

Reliability

• Apple’s looking to put the problematic iOS 11 behind it
• Older iPhones will be 40% to 70% faster at certain tasks

iOS 12 will focus on reliability and performance with this update, and support all of the same iPhones and iPads that iOS 11 worked with.

Features

Memoji

Not only can Animoji (and Memoji) recognize when you’re sticking your tongue out in iOS 12, as mentioned in the keynote, Apple says they’re better at recognizing winks as well—so your cartoon interactions will soon be able to go to a whole new level of suggestiveness.

Recorded Animoji and Memoji messages can now stretch to 30 seconds too. This is all still limited to the iPhone X and the extra tech it has packed into the front-facing camera.

Screen Time

Not only will your iOS device begin telling you how much time you spend (or waste) on your phone or tablet, but it will give you tools to help you tame your desire to be always connected.

As a reminder, iOS 12 is currently available in beta. It’s likely that features will change and look different by the time it’s released this fall.

Group FaceTime

FaceTime changed the way we communicate and share important moments, and now with Group FaceTime, it’s easy to chat with multiple people at the same time.

Users can video chat with 32 people simultaneously. Also, the Facetime app will automatically detect and highlight the person who is talking in the group of 32 people.

Participants can be added at any time, join later if the conversation is still active and choose to join using video or audio from an iPhone, iPad or Mac or even participate using FaceTime audio from Apple Watch.

You can add Animoji to everyone in the call.

Do Not Disturb

Do Not Disturb will also get a timing option, so you can set it for when you want it.
It is getting a bigger job – so if you sleep with DND on, or if you check the time at night, you won’t see a million notifications.

Grouped Notification

The newest iOS version automatically organizes contents from the same app in separate groups.

iOS 12 offers a much better way to deal with alerts. Apart from grouping notifications, the operating system also lets you hide alerts during your bedtime. If you wish to have complete peace at night, the Bedtime Mode is the perfect solution for keeping distraction at bay.

When you set notification grouping by an app, all the alerts from a particular app will be stacked. Then, you can head into a stack to glance through all the latest notifications. Swim across to find how it’s done!

Updates

Augmented Reality

ARKit 2 enables developers to create the most innovative AR apps for the world’s largest AR platform, with new tools to integrate shared experiences, persistent AR experiences tied to a specific location, object detection and image tracking, making AR apps even more dynamic.

Core ML

Apple’s Core ML 2 is 30% faster, cuts AI model sizes by up to 75%.
Apple introduced Core ML in June 2017 with the launch of iOS 11.

Apple Senior Software Engineer Federighi explained that it used to take one developer, Memrise, 24 hours to train a model with 20,000 images, but that Create ML reduced the training time for same model to 48 minutes.

Core ML is expected to play a key role in Apple’s future hardware products. The company is reportedly developing a chip — the Apple Neural Engine, or ANE — to accelerate computer vision, speech recognition, facial recognition, and other forms of artificial intelligence.

Photos

A new sharing suggestions feature makes it easier to share photos with friends, and friends who receive photos are prompted to share back any photos and videos they have from the same trip or event. Search suggestions surface the most relevant Events, People, Places, Groups, Categories and recent searches, and new search functionality lets users combine multiple search terms to find just the right photos.

Smart Voice Assistant (Siri)

Apple has upgraded Siri to allow it to control third – Party apps without users actually opening them. Users can also assign their own voice commands to trigger different actions.

Siri Shortcuts deliver a new, much faster way to get things done with the ability for any app to work with Siri. Siri intelligence can suggest an action at just the right time.

Whether it’s to order a coffee in the morning or start an afternoon workout. Users can customize Shortcuts by creating a simple voice command to kick off the task or download the new Shortcuts app to create a series of actions from different apps that can be carried out with a simple tap or customized voice command.

Conclusion

iOS 12 is a major overhaul to the iOS operating system that introduces tantalizing new features like Group FaceTime, local multiplayer shared AR experiences, new Animoji, and a Memoji feature that’s designed to let you create a personalized Animoji that looks just like you.

Animoji, stickers, text, and more can be used in FaceTime and the Messages app, and there’s a new Screen Time feature to help customers understand and manage the amount of time they’re spending on their iOS devices.

Siri has been improved in iOS 12 with Siri Shortcuts, which is designed to allow Siri to work with any app.

Under-the-hood improvements to iOS 12 will make everyday tasks on the iPhone and iPad faster and more responsive, with the camera launching up to 70 percent faster and the keyboard showing up up to 50 percent faster.

Only registered developers are able to download the iOS 12 beta at this time. As Apple has done in the past, a public beta for public beta testers will be provided later this summer after the software has gone through a couple rounds of developer testing.

iOS 12 will be available as a beta for several months as Apple works out all of the kinks and bugs. The update will see a public launch in the fall alongside new iPhones. iOS 12 will be available on all devices able to run iOS 11.

Creating A React Project

First we should have one React JS Project ,if we don’t have then create new one:

Example-

npx create-react-app my-react-app
cd my-react-app
npm start

note-(npx comes with npm 5.2+ and higher.so in this app we used NPM 5.6.0.
It will generate a react app, name will be my-react-app.And here is the folder structure as follows:

my-react-app
├── README.md
├── node_modules
├── package.json
├── .gitignore
├── public
│   └── favicon.ico
│   └── index.html
│   └── manifest.json
└── src
    └── App.css
    └── App.js
    └── App.test.js
    └── index.css
    └── index.js
    └── logo.svg
    └── registerServiceWorker.js

Analyse the changes to be

Now we can see that Public folder,so here we are going to add all our new files related to that new fonts with different extensions or type. And we should have all those files in one common folder (like fonts folder we can create and put all the fonts file inside this fonts folder)

Example-

my-app
├── README.md
├── node_modules
├── package.json
├── .gitignore
├── public
│   └── fonts(folder which contains all about new fonts)

Now we need to add a style.css file inside our app(Folder)>style.css, which will contain following lines of code and here we are taking example code like how we can add New font (Miriam) in our app .

my-app
├── README.md
├── node_modules
├── package.json
├── .gitignore
├── public
│   └── favicon.ico
│   └── index.html
│   └── manifest.json
└── src
    └── App.css
    └── style.css(file adding font)
    └── App.js
    └── App.test.js
    └── index.css
    └── index.js

Inside style.css we can add our new fonts as :

@font-face {
   font-family: 'Miriam';
   font-style: normal;
   font-weight: 400;
   src: url('../../../public/fonts/miriam-libre-v2-latin-regular.eot');
   src: url('../../../public/fonts/Miriam.eot?#iefix') format('embedded-opentype'),
       url('../../../public/fonts/miriam-libre-v2-latin-regular.eot') format('woff2'),
       url('../../../public/fonts/miriam-libre-v2-latin-regular.woff') format('woff'),
       url('../../../public/fonts/miriam-libre-v2-latin-regular.ttf') format('truetype'),
       url('../../../public/fonts/miriam-libre-v2-latin-regular.svg') format('svg');
}

Here,we can see how we are going to add ‘Miriam’ font to our project and inside this file we can change font-style and font-weight also. So for that we need to have basic idea about the files we have in fonts folder(all fonts files). So in fonts folder we have different types of files with their different types of extensions which will support to apply our font on every types of environment and for adding those files for our app we need to give relative path for them also in our style.css file.

Note– Here we can see we have some different types of files with different types of extensions too. So all of these things we will explain once we will define the loader of these files.

Process to add new Font

There are following steps to add new fonts:

Step-1=>

run npm install –save-dev url-loader inside our app to load files related to new font. The url-loader works like the file-loader, but can return a DataURL if the file is smaller than a byte limit.

Step-2=>

Now inside our Webpack.dev.js we need to add following lines of codes:

Inside module.exports>loaders(Array) we need to add our loader to load files for that new font:

Loaders:[
     {
       test: /\.(gif|eot|woff|woff2|ttf|svg)$/,
       loaders: [
         'url-loader'
       ]
     }
]

Description of Loaded Files

This url-loader will load different types of files to add new font about which we are as follows:

Embedded Open Type (EOT) files-
EOT fonts are designed by Microsoft.it is a compact form of Open Type of Fonts. It is designed to use Embedded fonts on Web.

Web Open Font Format (WOFF) files-
WOFF fonts basically support all types of browsers.
Web Open Font Format (WOFF2) files-
WOFF2 is the next generation of WOFF.

TrueType Font (TTF) files-
TrueType Fonts format was developed by Apple and Microsoft as a response to the PostScript font format.

Scalable Vector Graphics font (SVG) files-
SVG fonts are defined using the SVG’s ‘font’ element. In iPhone and iPad we should use SVG fonts.

Conclusion : –

So we have done all about adding new font in our application now we can use our new font(new added) as :
fontFamily:”Miriam”.

NOTE:–
So it was for our entire app but if we want to add new font for a single component then we have to do all the things we have done except that style.css file . Now in this case we will add that style.css file for that component only not for entire app. And rest of steps will be same and we can use that CSS as:
fontFamily:”Miriam”.

Design

Shimmer is a very easy way to add shimmering effect. I’ved used UITableViewCell.

Placeholder Cell

Coding

Before writing code, I thought it would be better to have my own property (in UIView using @IBInspectable) to easily enable animation from storyboard

@IBInspectable var shimmerAnimation: Bool {
        get {
            return isAnimate
        }
        set {
            self.isAnimate = newValue
        }
    }

We can not access IBInspectable value at runtime, but with the help of associatedObject its possible, it will return boolean value using compute variable isAnimate.

fileprivate var isAnimate: Bool {
        get {
            return objc_getAssociatedObject(self, &associateObjectValue) as? Bool ?? false
        }
        set {
            return objc_setAssociatedObject(self, &associateObjectValue, 
newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN)
        }
    }

Now its very simple, open the storyboard and select the targeted UIView which need to be animated. Go to attributes inspector you will find our property ‘Shimmer Animation’. By default it is off, we need to turn it on.

So far so good. Now, we require a recursive function which will return all views including its subviews.

func subviewsRecursive() -> [UIView] {
        return subviews + subviews.flatMap { $0.subviewsRecursive() }
    }

Here we don’t want all views but only the view with ‘shimmer animation’ true.

func getSubViewsForAnimate() -> [UIView] {
        var obj: [UIView] = []
        for objView in view.subviewsRecursive() {
            obj.append(objView)
        }
        return obj.filter({ (obj) -> Bool in
            obj.shimmerAnimation
        })
    }

That’s it. We can start animation using the startAnimation function. In below method, we are going to mask the UIView using the CAGradientLayer also animate with CABasicAnimation.

We need to set start and end point of gradient effect to object of gradientLayer with colors and frame according to animateView. At last, mask the animateView layer with gradientLayer.

For the CABasicAnimation it requires keyPath string so be specific with the key. It plays an important role for the animation. Thus, pass the duration of animation alone with from and to value. At last, using gradientLayer add animation object.

func startAnimation() {
        for animateView in getSubViewsForAnimate() {
            animateView.clipsToBounds = true
            let gradientLayer = CAGradientLayer()
            gradientLayer.colors = [UIColor.clear.cgColor, UIColor.white.withAlphaComponent(0.8).cgColor, UIColor.clear.cgColor]
            gradientLayer.startPoint = CGPoint(x: 0.7, y: 1.0)
            gradientLayer.endPoint = CGPoint(x: 0.0, y: 0.8)
            gradientLayer.frame = animateView.bounds
            animateView.layer.mask = gradientLayer

            let animation = CABasicAnimation(keyPath: "transform.translation.x")
            animation.duration = 1.5
            animation.fromValue = -animateView.frame.size.width
            animation.toValue = animateView.frame.size.width
            animation.repeatCount = .infinity

            gradientLayer.add(animation, forKey: "")
        }
    }

To stop the animation just remove all the animation from layer and nil mask layer.

func stopAnimation() {
        for animateView in getSubViewsForAnimate() {
            animateView.layer.removeAllAnimations()
            animateView.layer.mask = nil
        }
    }

Please take a look at code. Feel free to ask any query/doubts in below commenting section.

Video Description

Google’s Sceneform SDk brings the marker detection feature called Augmented Images. Scanning a unique image to load 3D models in the virtual environments can be used in various ways for business and personal purposes. Here is one such demo.

Application ideas

An application for I-card can be developed using this feature. A card, which has human unreadable content like QR code, can be scanned and actual information can be fetched to show it in 3D using ARCore.

Conclusion

Sceneform SDK is not less than a boon for Android developers who are eager to learn AR. Being so powerful in beta version, I’m eager to see what its future features will comprise of.

Prerequisites

• Xcode 9.3
• iOS 11.3
• Device with A9 processor

Project Setup

Open Xcode and create a new project. Choose “Augmented Reality App” and fill the required details.

Apple provide options for Content Technology like SceneKit, SpriteKit, and Metal. Here we will choose SceneKit. If you want to place any 3D object model then Xcode needs to read that 3D object file in SceneKit supported format(.scn) or .dae.

ARKit is a session-based framework. The session contains a scene that renders virtual objects in the real world. For that, ARKit needs to use an iOS device’s camera. So you have to add this to your info.plist file.

Privacy – Camera Usage Description.

Now in here, we need to set couple of IBOutlet as below with ARSCNView and UILabel, infoLabel for acknowledging user about AR session states and any updates of the node.

@IBOutlet var sceneView: ARSCNView!
    @IBOutlet var infoLabel: UILabel!

For debugging purpose you can set sceneView.debugOptions = [ARSCNDebugOptions.showFeaturePoints] and can see how ARKit detects surface. When you run the app, you should see a lot of yellow dots on the scene. These are feature points and it is helpful to estimate properties like the orientation and position of physical objects in the current base environment. The more feature points in the area, the better chance ARKit can determine and track the environment.

override func viewDidLoad() {
        ….      
        // Show statistics such as fps and timing information
        sceneView.showsStatistics = true

        sceneView.debugOptions = [ARSCNDebugOptions.showFeaturePoints]

       let scene = SCNScene()
       sceneView.scene = scene
       ....
       }

Now it’s time to set a world-tracking session with a horizontal plane. As you can see in your viewWillAppear method session has been already created and set to run.

configuration.planeDetection = .horizontal

So now your method will look like this.

override func viewWillAppear(_ animated: Bool) {
        ...
        // Create a session configuration
        let configuration = ARWorldTrackingConfiguration()
        configuration.planeDetection = .horizontal
        sceneView.session.run(configuration)
        ...
    }

Detect plane and place object

When we detect any surface in ARKit, it will provide ARPlaneAnchor an object. An ARPlaneAnchor object is basically containing information about position & orientation of a real world detected surface.

To know when surface will detect, update or remove , use ARSCNViewDelegate methods which looks like a magic in ARKit. Implement following ARSCNViewDelegate methods so you will be notified when an update is available in sceneview.

override func viewDidLoad() {
        ...      
        sceneView.delegate = self
        ...
 }

 // MARK: - ARSCNView delegate

func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        // Called when any node has been added to the anchor
    }

 func renderer(_ renderer: SCNSceneRenderer, didRemove node: SCNNode, for anchor: ARAnchor) {
        // This method will help when any node has been removed from sceneview
    }

func renderer(_ renderer: SCNSceneRenderer, didUpdate node: SCNNode, for anchor: ARAnchor) {
        // Called when any node has been updated with data from anchor
    }

 func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
        // help us inform the user when the app is ready
    }

ARSessionDelegate protocol provides current tracking state of the camera so you are able to know that your app is ready to detect or not. When you are getting a normal state, you are ready to detect plane. For that implement these delegates.

// MARK: - ARSessionObserver

    func sessionWasInterrupted(_ session: ARSession) {
        infoLabel.text = "Session was interrupted"
    }

    func sessionInterruptionEnded(_ session: ARSession) {
        infoLabel.text = "Session interruption ended"
        resetTracking()
    }

    func session(_ session: ARSession, didFailWithError error: Error) {
        infoLabel.text = "Session failed: \(error.localizedDescription)"
        resetTracking()
    }

     func resetTracking() {
        let configuration = ARWorldTrackingConfiguration()
        configuration.planeDetection = .horizontal
        sceneView.session.run(configuration, options: [.resetTracking, .removeExistingAnchors])
    }

func session(_ session: ARSession, cameraDidChangeTrackingState camera: ARCamera) {
        // help us inform the user when the app is ready
        switch camera.trackingState {
        case .normal :
            infoLabel.text = "Move the device to detect horizontal surfaces."

        case .notAvailable:
            infoLabel.text = "Tracking not available."

        case .limited(.excessiveMotion):
            infoLabel.text = "Tracking limited - Move the device more slowly."

        case .limited(.insufficientFeatures):
            infoLabel.text = "Tracking limited - Point the device at an area with visible surface detail."

        case .limited(.initializing):
            infoLabel.text = "Initializing AR session."

        default:
            infoLabel.text = ""
        }
    }

When plane has been detected, add object onto it. Here we are going to add 3D model named “Shoes_V4.dae”.

class ViewController: UIViewController, ARSessionDelegate {
  ...
  var object: SCNNode!
  ...

func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        // Called when any node has been added to the anchor
        ...
        guard let planeAnchor = anchor as? ARPlaneAnchor else { return }
        DispatchQueue.main.async {
            self.infoLabel.text = "Surface Detected."
        }

        let shoesScene = SCNScene(named: "Shoes_V4.dae", inDirectory: "Model.scnassets")
        object = shoesScene?.rootNode.childNode(withName: "group1", recursively: true)
        object.simdPosition = float3(planeAnchor.center.x, planeAnchor.center.y, planeAnchor.center.z)
        sceneView.scene.rootNode.addChildNode(object)
        node.addChildNode(object)
        ...
    }
}

You can get a childNodes name from here. Here it is “group1“.

Now build and run your app. You can see that some surfaces show more feature points and in some area, you can not get much better result compared to others. Surfaces which are shiny or one colored make it difficult for the ARKit to obtain a strong reference point for plane detection and to be able to determine unique points in the environment. If you are unable to see more feature points then move your device around the area and try to detect it with different objects or surfaces. Once ARKit is ready with the detected plane then your object will be added on it.

Change position of object to tap location with UITapGestureRecognizer

For placing an object on tap first add UITapGestureRecognizer in scene view.

override func viewDidLoad() {
        ...        
        let tapGesture = UITapGestureRecognizer(target: self, action: #selector(didTap(_:)))
        sceneView.addGestureRecognizer(tapGesture)
        ...       
}

Then in the handling of tap gesture add a node at tap position. A node represents the position and the coordinates of an object in a 3D space. Here we set a position of the node to tap position.

@objc
    func didTap(_ gesture: UIPanGestureRecognizer) {
       guard let _ = object else { return }

        let tapLocation = gesture.location(in: sceneView)
        let results = sceneView.hitTest(tapLocation, types: .featurePoint)

        if let result = results.first {
            let translation = result.worldTransform.translation
            object.position = SCNVector3Make(translation.x, translation.y, translation.z)
            sceneView.scene.rootNode.addChildNode(object)
        }
    }

For getting the translation of worldTransform add this extension.

extension float4x4 {
    var translation: float3 {
        let translation = self.columns.3
        return float3(translation.x, translation.y, translation.z)
    }
}

Scaling object with UIPinchGestureRecognizer

For zoom-in and zoom-out 3D object we have to change a scale of object while user pinch. For recognize when user pinch on sceneview, add UIPinchGestureRecognizer.

override func viewDidLoad() {
        ...        
        let pinchGesture = UIPinchGestureRecognizer(target: self, action: #selector(didPinch(_:)))
        sceneView.addGestureRecognizer(pinchGesture)
        ...       
}

Here we set a maximum zoom scale as 2(200% zoom-out then original object) and minimum scale as 0.5(50% zoom-in then original object). You can set it according to your necessities.

@objc
    func didPinch(_ gesture: UIPinchGestureRecognizer) {
        guard let _ = object else { return }
        var originalScale = object?.scale

        switch gesture.state {
        case .began:
            originalScale = object?.scale
            gesture.scale = CGFloat((object?.scale.x)!)
        case .changed:
            guard var newScale = originalScale else { return }
            if gesture.scale < 0.5{ newScale = SCNVector3(x: 0.5, y: 0.5, z: 0.5) }else if gesture.scale > 2{
                newScale = SCNVector3(2, 2, 2)
            }else{
                newScale = SCNVector3(gesture.scale, gesture.scale, gesture.scale)
            }
            object?.scale = newScale
        case .ended:
            guard var newScale = originalScale else { return }
            if gesture.scale < 0.5{ newScale = SCNVector3(x: 0.5, y: 0.5, z: 0.5) }else if gesture.scale > 2{
                newScale = SCNVector3(2, 2, 2)
            }else{
                newScale = SCNVector3(gesture.scale, gesture.scale, gesture.scale)
            }
            object?.scale = newScale
            gesture.scale = CGFloat((object?.scale.x)!)
        default:
            gesture.scale = 1.0
            originalScale = nil
        }
    }

Rotate object using UIPanGestureRecognizer

For rotation of any object using pan gesture add UIPanGestureRecognizer in sceneview.

override func viewDidLoad() {
        ...        
        let panGesture = UIPanGestureRecognizer(target: self, action: #selector(didPan(_:)))
        panGesture.delegate = self
        sceneView.addGestureRecognizer(panGesture)
        ...       
}

class ViewController: UIViewController, ARSessionDelegate {
    ...
    var currentAngleY: Float = 0.0
    ...

    @objc
    func didPan(_ gesture: UIPanGestureRecognizer) {
        guard let _ = object else { return }
        let translation = gesture.translation(in: gesture.view)
        var newAngleY = (Float)(translation.x)*(Float)(Double.pi)/180.0

        newAngleY += currentAngleY
        object?.eulerAngles.y = newAngleY

        if gesture.state == .ended{
            currentAngleY = newAngleY
        }
    }
}

You can also rotate object using UIRotationGestureRecognizer. But this will recognize a rotation using two fingers. Here we used only one finger to rotate object in sceneview.

Thanks for coming.
If you have enjoyed and learned something valuable from this tutorial, please let me know by sharing this tutorial with your friends.

What is ChatBot and why do you need it.

Chatbot is an artificial intelligence (AI) program that simulates interactive human conversation by using key pre-calculated user phrases and auditory or text-based signals. According to techopedia, Chatbots are frequently used for basic customer service and marketing systems like social networking hubs and instant messaging (IM) clients. They are also often included in operating systems as intelligent virtual assistants. As indicated by a current report by Grand View Research, the worldwide chatbot advertise is relied upon to reach $1.23 billion by 2025, an exacerbated yearly development rate (CAGR) of 24.3%. Inside the worldwide chatbot advertise, around 45% of end clients incline toward chatbots as the essential method of correspondence for client benefit asks.

Oracle surveys says that, 80% of businesses want chatbots by 2020.

What kind of chatbot can be?

To give idea on creating chatbot may not be my relative argument (It depends on your business domain and how it helps your business) but still let’s see what kind of chatbots are available in market and what kind of chatbots are possible to build.

• E- Commerce
• Online Marketing
• Customer Service
• Travel, Movies
• Hospitality
• Banking
• Financial Services
• HR & Recruiting
• Assistant For appointment
• IOT & Voice Based

What’s good and bad about chatbots?

• Fast and Accurate
• Works 24*7 without taking break
• Customer satisfaction
• Automation of repetitive work
• Bots are not equal to google…
  Without knowing bot’s type you can’t ask anything or non-relevant questions to it. It may be possible some smart bot would insult you with sarcasm.

How to Build Chatbot ?

• Analyze the problem and why did you choose the chatbot as a solution?
• Choose the Platform on which platform you want to integrate your bot?
  • Facebook Messenger
  • Whatsapp
  • Slack
  • Skype
  • Alexa
  • Cortana
  • Google Assistant
  • Twilio
  • Telegram
• Choosing NLP engine is most essential part of building bot. Your bot should be able to understand natural languages that human speaks. Popular NLP engines are,
  • Facebook’s wit.ai
  • Google’s dialogflow
  • Microsoft’s luis.ai
  • Amazon’s lex
• That’s It. Now Create, Customize, Test and Launch.

Conclusion : –

In conclusion, there are plenty of advantages identified in having a chatbot. Some of which have been portrayed in this post. Organizations who have the capacity to spend a considerable measure of money by which they can acquire more income with the assistance of these bots that work 24*7 without having a break. Furthermore, with new head ways coming each year like AI, NLP and Machine Learning which makes the bot more clever to a point where it doesn’t need to be guided by a representative, this isn’t too far away. Thus, it is sheltered to state that the eventual fate of chatbots is brilliant and shining.

Provide your reference images

To provide images reference, we need to add them to our project asset catalog in Xcode.

• Open asset catalog in project, click left corner (+) or you can use right click to add new AR Resource folder group and rename as per your requirement.
• Drag the images from finder to newly created folder
• For all individual images we need to set dimensions using inspector.

Configuration image tracking

We need to create ARImageTrackingConfiguration, this will allow to track our reference images in the user’s environment. After that, create an instance of ARReferenceImage containing the reference of images from the AR Resource folder as per mine I have named it “iOSDept”. The property maximumNumberOfTrackedImages will set the maximum number of tracked images in given frame, default value is one.

func configureARImageTracking() {
        // Create a session configuration
        let configuration = ARImageTrackingConfiguration()
        if let imageTrackingReference = ARReferenceImage.referenceImages(inGroupNamed: "iOSDept", bundle: Bundle.main) {
            configuration.trackingImages = imageTrackingReference
            configuration.maximumNumberOfTrackedImages = 1
        } else {
            print("Error: Failed to get image tracking referencing image from bundle")
        }
        // Run the view's session
        sceneView.session.run(configuration, options: [.resetTracking, .removeExistingAnchors])
    }

Image Detection

Now we are going to update the method renderer(_:didAdd:for:) because anchor in this method is type of ARImageAnchor.

Casting down ARAnchor to ARImageAnchor using if statement. The object imageAnchor contain the property of reference images which we have placed in an asset catalog under “iOSDept” folder. SCNPlane is set of action, animating fadeIn and fadeOut

func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
        /// Casting down ARAnchor to `ARImageAnchor`.
        if let imageAnchor =  anchor as? ARImageAnchor {
            let imageSize = imageAnchor.referenceImage.physicalSize

            let plane = SCNPlane(width: CGFloat(imageSize.width), height: CGFloat(imageSize.height))
            plane.firstMaterial?.diffuse.contentsTransform = SCNMatrix4Translate(SCNMatrix4MakeScale(1, -1, 1), 0, 1, 0)

            let imageHightingAnimationNode = SCNNode(geometry: plane)
            imageHightingAnimationNode.eulerAngles.x = -.pi / 2
            imageHightingAnimationNode.opacity = 0.25
            node.addChildNode(imageHightingAnimationNode)
       } else {
            print("Error: Failed to get ARImageAnchor")
       }
}

Load and animate Spritekit scene

Here I’ve used SpriteKitScene named “About” and initializing the object of it. Make sure the property isPaused should be false for the animating containing node in it. To load SKScene in user environment, we need to create an object of SCNPlane which contains firstMaterial property and its sub properties. Thus pass the object aboutSpriteKitScene to aboutUsPlane.firstMaterial?.diffuse.contents to load the SpriteKitScene in real world.

Animating the SKNode are pretty simple just use SKAction and their methods.

// About
                let aboutSpriteKitScene = SKScene(fileNamed: "About")
                aboutSpriteKitScene?.isPaused = false
                
                let aboutUsPlane = SCNPlane(width: CGFloat(imageSize.width * 1.5), height: CGFloat(imageSize.height * 1.2))
                aboutUsPlane.firstMaterial?.diffuse.contents = aboutSpriteKitScene
                aboutUsPlane.firstMaterial?.diffuse.contentsTransform = SCNMatrix4Translate(SCNMatrix4MakeScale(1, -1, 1), 0, 1, 0)
                
                let aboutUsNode = SCNNode(geometry: aboutUsPlane)
                aboutUsNode.geometry?.firstMaterial?.isDoubleSided = true
                aboutUsNode.eulerAngles.x = -.pi / 2
                aboutUsNode.position = SCNVector3Zero
                node.addChildNode(aboutUsNode)
                
                let moveAction = SCNAction.move(by: SCNVector3(0.25, 0, 0), duration: 0.8)
                aboutUsNode.runAction(moveAction, completionHandler: {
                    let titleNode = aboutSpriteKitScene?.childNode(withName: "TitleNode")
                    titleNode?.run(SKAction.moveTo(y: 90, duration: 1.0))
                    
                    let name = aboutSpriteKitScene?.childNode(withName: "DescriptionNode")
                    name?.run(SKAction.moveTo(y: -30, duration: 1.0))
})

Load and animate 3D Model on reference image

Loading and animating 3D Model on reference image is simple. Place your 3D model arts.scnassets folder containing texture images. Create an object of SCNScene using the 3D model name and use the firstNode property to set angles, scale and their other respective properties as per requirement. Last add the object of firstNode to the did add node method.

// Logo Related
let logoScene = SCNScene(named: "art.scnassets/Yudiz_3D_Logo.dae")!
let logoNode = logoScene.rootNode.childNodes.first!
logoNode.scale = SCNVector3(0.022, 0.022, 0.022)
logoNode.eulerAngles.x = -.pi / 2
logoNode.position = SCNVector3Zero
logoNode.position.z = 0.05
let rotationAction = SCNAction.rotateBy(x: 0, y: 0, z: 0.5, duration: 1)
let inifiniteAction = SCNAction.repeatForever(rotationAction)
logoNode.runAction(inifiniteAction)
node.addChildNode(logoNode)

Conclusion : –

I hope you like this article and also learned some valuable things from it. Feel free to share with your social network. For the more reference, you can download this project on Github. Also, I welcome your contribution in this project.

Prerequisite

• Facebook Page
• Facebook Developer Account
• Understanding of Dialogflow
• Knowledge of Node.js

Getting Started

Let’s start by creating Facebook App from Facebook Developer Account.

You will be redirected to the Dashboard, Add a Messenger Product from there

After setting up, select your Facebook page in Token Generation and Generate Token from there.

Setting Up Server

Creating a simple server in node.js is easy.

Navigate to your desired folder where you are going to setup this project. Open that folder in your Terminal and run npm init this will generate the package.json file.

Now, we have to install our dependencies,
Run npm i apiai axios body-parser express uuid –save

After installing dependencies create index.js file and import that dependencies that we just installed and create simple express server. Also, make one config.js file so we can store our credentials in that file for better code management and security purpose or instead of config.js you can also create env file.

Index.js

const apiai = require("apiai");
const express = require("express");
const bodyParser = require("body-parser");
const uuid = require("uuid");
const axios = require('axios');

//Import Config file
const config = require("./config");

//setting Port
app.set("port", process.env.PORT || 5000);

//serve static files in the public directory
app.use(express.static("public"));

// Process application/x-www-form-urlencoded
app.use(
  bodyParser.urlencoded({
    extended: false
  })
);

// Process application/json
app.use(bodyParser.json());

// Index route
app.get("/", function (req, res) {
  res.send("Hello world, I am a chat bot");
});

// for Facebook verification
app.get("/webhook/", function (req, res) {
  console.log("request");
  if (
    req.query["hub.mode"] === "subscribe" &&
    req.query["hub.verify_token"] === config.FB_VERIFY_TOKEN
  ) {
    res.status(200).send(req.query["hub.challenge"]);
  } else {
    console.error("Failed validation. Make sure the validation tokens match.");
    res.sendStatus(403);
  }
});

// Spin up the server
app.listen(app.get("port"), function () {
  console.log("Magic Started on port", app.get("port"));
});

Spin up the server. We need to make communication live so here we are using ngrok to make our localhost live but you can always use any other platform like heroku, localtunnel or any other third party services.

To make our server live type ./ngrok http 5000 in your terminal which will give you live URL. But make sure while running above command you have ngrok downloaded for Your Suitable OS. Ngrok file should be in your current working directory to successfully execute above command.

Config.js

module.exports = {
  FB_PAGE_TOKEN: "Page Access Token",
  FB_VERIFY_TOKEN: "Facebook Verification code for Webhook",
  API_AI_CLIENT_ACCESS_TOKEN: "DialogFlow token",
  FB_APP_SECRET: "Facebook Secret Code",
};

FB_PAGE_TOKEN : Copy the Page Access token that we generated and paste in config.js.
FB_APP_SECRET : You will find App Secret on Settings<

Now click on set up webhook you will find that just below token generation window.
Paste your server URL with endpoint /webhook and Verify Token can be anything and check messages and messaging_postbacks.

When You click on Verify and Save You will receive verification GET request from Facebook. (make sure you copy https:// URL)

FB_VERIFY_TOKEN : Paste the verify token in your config.js file.
SERVER_URL : Copy your ngrok live URL and paste.

Dialogflow integration

Now let’s configure dialogflow with our webhook code. Add New agent and Select v1 API and copy client access token and paste in API_AI_CLIENT_ACCESS_TOKEN.

Let’s create intent in dialogflow.

1. Add intent from the left sidebar.
2. Give an Intent Name: Send-text
3. Add Training Phrases “Hey, send me an example of a text message” or relevant to it.
4. Add Action Name “send-text”
5. Save it.
6. Now do the same thing for send-image, send-media, send-list, send-receipt, send-Quick Reply, send-graph, send-carouselMake sure you give the unique action to all intent. We need to identify the intent of a user to send the appropriate response from our webhook server.Click on the Fulfillment tab and add your webhook endpoint here and save it.
7. That’s it nothing more in Dialogflow for this example.

If you are not familiar with dialogflow please read the documentation.

Let’s come back to the index.js add this code snippet to connect with Dialogflow.

const apiAiService = apiai(config.API_AI_CLIENT_ACCESS_TOKEN, {
  language: "en",
  requestSource: "fb"
});
const sessionIds = new Map();

Setup Webhook Endpoint

Now when user will send some message on facebook we will receive the post request on the our node server. So we need to handle that /webhook endpoint.

/*
 * All callbacks for Messenger are POST-ed. They will be sent to the same
 * webhook. Be sure to subscribe your app to your page to receive callbacks
 * for your page. 
 * https://developers.facebook.com/docs/messenger-platform/product-overview/setup#subscribe_app
 *
 */
app.post("/webhook/", function (req, res) {
  var data = req.body;
  // Make sure this is a page subscription
  if (data.object == "page") {
    // Iterate over each entry
    // There may be multiple if batched
    data.entry.forEach(function (pageEntry) {
      var pageID = pageEntry.id;
      var timeOfEvent = pageEntry.time;

      // Iterate over each messaging event
      pageEntry.messaging.forEach(function (messagingEvent) {
        if (messagingEvent.message) {
          receivedMessage(messagingEvent);
        } else {
          console.log("Webhook received unknown messagingEvent: ",messagingEvent);
        }
      });
    });
    // Assume all went well.
    // You must send back a 200, within 20 seconds
    res.sendStatus(200);
  }
});

Messages, Messaging_postbacks these two events that we checked while setting up webhook. (we are not using postback event here)
receivedMessage(messagingEvent) let’s make this function now,

function receivedMessage(event) {
  var senderID = event.sender.id;
  var recipientID = event.recipient.id;
  var timeOfMessage = event.timestamp;
  var message = event.message;

  if (!sessionIds.has(senderID)) {
    sessionIds.set(senderID, uuid.v1());
  }

  var messageId = message.mid;
  var appId = message.app_id;
  var metadata = message.metadata;

  // You may get a text or attachment but not both
  var messageText = message.text;
  var messageAttachments = message.attachments;

  if (messageText) {
    //send message to api.ai
    sendToApiAi(senderID, messageText);
  } else if (messageAttachments) {
    handleMessageAttachments(messageAttachments, senderID);
  }
}

If you console the event you will get JSON like,

For now, Just Focus on sender.id and What message.text.
If there is messageText in receivedMessage() function then we will call sendToApiAi().

In this function, we will first call sendTypingOn() to show that bot is typing in Messenger.

function sendToApiAi(sender, text) {
  sendTypingOn(sender);
  let apiaiRequest = apiAiService.textRequest(text, {
    sessionId: sessionIds.get(sender)
  });

  apiaiRequest.on("response", response => {
    if (isDefined(response.result)) {
      handleApiAiResponse(sender, response);
    }
  });

  apiaiRequest.on("error", error => console.error(error));
  apiaiRequest.end();
}

Send Typing On

SendTyping will call the Facebook send API to send the Typing Action.

/*
 * Turn typing indicator on
 *
 */
const sendTypingOn = (recipientId) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    sender_action: "typing_on"
  };
  callSendAPI(messageData);
}

callSendAPI() function will send the message data that we are generating. (here we are sending the typing on action)

/*
 * Call the Send API. The message data goes in the body. If successful, we'll 
 * get the message id in a response 
 *
 */
const callSendAPI = async (messageData) => {

const url = "https://graph.facebook.com/v3.0/me/messages?access_token=" + config.FB_PAGE_TOKEN;
  await axios.post(url, messageData)
    .then(function (response) {
      if (response.status == 200) {
        var recipientId = response.data.recipient_id;
        var messageId = response.data.message_id;
        if (messageId) {
          console.log(
            "Successfully sent message with id %s to recipient %s",
            messageId,
            recipientId
          );
        } else {
          console.log(
            "Successfully called Send API for recipient %s",
            recipientId
          );
        }
      }
    })
    .catch(function (error) {
      console.log(error.response.headers);
    });
}

Let’s come back to sendToApiAi() function next is we are calling isDefined() function to just make sure we are receiving the proper response.

const isDefined = (obj) => {
  if (typeof obj == "undefined") {
    return false;
  }
  if (!obj) {
    return false;
  }
  return obj != null;
}

In the same function sendToApiAi() we will get the response from the Dialogflow in form of JSON.

Send that data to the handleApiAiResponse().

function handleApiAiResponse(sender, response) {
  let responseText = response.result.fulfillment.speech;
  let responseData = response.result.fulfillment.data;
  let messages = response.result.fulfillment.messages;
  let action = response.result.action;
  let contexts = response.result.contexts;
  let parameters = response.result.parameters;

  sendTypingOff(sender);

 if (responseText == "" && !isDefined(action)) {
    //api ai could not evaluate input.
    console.log("Unknown query" + response.result.resolvedQuery);
    sendTextMessage(
      sender,
      "I'm not sure what you want. Can you be more specific?"
    );
  } else if (isDefined(action)) {
    handleApiAiAction(sender, action, responseText, contexts, parameters);
  } else if (isDefined(responseData) && isDefined(responseData.facebook)) {
    try {
      console.log("Response as formatted message" + responseData.facebook);
      sendTextMessage(sender, responseData.facebook);
    } catch (err) {
      sendTextMessage(sender, err.message);
    }
  } else if (isDefined(responseText)) {
    sendTextMessage(sender, responseText);
  }
}

Send Typing Off

Remember? we started Typing on Action on Messenger now we have response to turn it off call the sendTypingOff() function.

/*
 * Turn typing indicator off
 *
 */
const sendTypingOff = (recipientId) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    sender_action: "typing_off"
  };

  callSendAPI(messageData);
}

Send Text Message

Whenever we get unknown query from user we have to send Default message to that user.

const sendTextMessage = async (recipientId, text) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      text: text
    }
  };
  await callSendAPI(messageData);
}

Above function will call facebook send API and send the text message that we defined as default.

Now, if the Intent of user is matched with dialogflow we will get the action(action we are getting from dialogflow response) of that intent, based on the action we will send the response to each user.

When user asks : “Send me an example of text message” -> our intent “send-text” will get called and based on intent we will get the unique action of it. In my case I gave same action name as intent name.

If we get Action from dialogflow response, we are calling the handleApiAiAction().

function handleApiAiAction(sender, action, responseText, contexts, parameters) {
   switch (action) {
    case "send-text":
      var responseText = "This is example of Text message."
      sendTextMessage(sender, responseText);
      break;
    default:
      //unhandled action, just send back the text
    sendTextMessage(sender, responseText);
  }
}

Conclusion : –

This is how you can interact with users by sending simple text message from the webhook server. Next time we will look at the rich messages like images, videos, quick-reply and receipt templates.
Comment your ideas about chatbots, we will try to build together.

Prerequisite

• Facebook Page
• Facebook Developer Account
• Understanding of Dialogflow
• Knowledge of Node.js

Getting Started

We have seen how to send simple text message from the webhook server using Facebook Send API.
Now, we will look at Rich responses like card, receipts, videos, image, Buttons. But before getting started make sure you have everything working from previous blog and all intent set up with unique action in dialogflow.

Send Image

When user asks ‘send me image’ out intent from dialogflow ‘send-photo’ will get triggered and based on the intent we will get the action of that specific intent.

Make a new case in switch statement in index.js file

Index.js

case "fb-send-image":
     var imgUrl = "https://mir-s3-cdn-cf.behance.net/project_modules/max_1200/881e6651881085.58fd911b65d88.png";
      sendImageMessage(sender, imgUrl);
break;

Now make new function that can send Image.

const sendImageMessage = async (recipientId, imageUrl) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "image",
        payload: {
          url: imageUrl
        }
      }
    }
  };
    await callSendAPI(messageData);
}

callSendAPI() function we made last time it will send messageData to send API and user will get Image as response.

Send Video or Media template

When user asks ‘send me video’ out intent from dialogflow ‘send-video’ will get triggered and based on the intent we will get the action of that specific intent.

case "send-video":
    const messageData = [
        {
            "media_type": "video",
            "url": "https://www.facebook.com/FacebookIndia/videos/1772075119516020/",
            "buttons": [
                {
                    "type": "web_url",
                    "url": "https://f1948e04.ngrok.io",
                    "title": "View Website",
                }
            ]
        }
    ]
    sendVideoMessage(sender, messageData);
break;

You can also specify button to the video or image you are sending, for more information look at media template.

Note: In this media template you only can send images and videos that are posted on facebook. You can not send images or video from other sources. If you are sending image then you have to give media_type as “image” and for video message media_type will be “video”

Let’s create function to send the video to user.

const sendVideoMessage = async (recipientId, elements) => {
  const messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: {
          template_type: "media",
          elements: elements
        }
      }
    }
  };
await callSendAPI(messageData)
}

callSendAPI() function will send messageData to send API and user will get Video or images as response.

Send Quick Replies

Sending Quick replies comes in handy it’s easy. We use quick replies to request a person’s location, email address, and phone number. When you tap on quick reply button it will get disappeared and the title of that button will posted to the conversation as a message.

Add a new case in Switch statement,

case "send-quick-reply":
    var responseText = "Choose the options"
    var replies = [{
        "content_type": "text",
        "title": "Example 1",
        "payload": "Example 1",
    },
    {
        "content_type": "text",
        "title": "Example 2",
        "payload": "Example 2",
    },
    {
        "content_type": "text",
        "title": "Example 3",
        "payload": "Example 3",
    }];
    sendQuickReply(sender, responseText, replies)
break;

Now let’s create the function to send those replies,

const sendQuickReply = async (recipientId, text, replies, metadata) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      text: text,
      metadata: isDefined(metadata) ? metadata : "",
      quick_replies: replies
    }
  };
  await callSendAPI(messageData);
}

callSendAPI() function will send messageData to send API and user will get Quick replies as response.

Send Generic template & Carousel of Generic Templates

Generic template is kind of card that contains Maximum 3 buttons, image, title and subtitle. Carousel is like slider that includes more than two generic templates. Think as developer’s point of view while making some product level chatbot we should not make two functions for sending those responses, so we will try to make some optimization.

Create new case in switch statement,

case "send-carousel" :
  const elements = [{
    "title": "Welcome!",
    "subtitle": "We have the right hat for everyone.We have the right hat for everyone.We have the right hat for everyone.",
    "imageUrl": "https://www.stepforwardmichigan.org/wp-content/uploads/2017/03/step-foward-fb-1200x628-house.jpg",
    "buttons": [
      {
        "postback": "https://f1948e04.ngrok.io",
        "text": "View Website"
      }, {
        "text": "Start Chatting",
        "postback": "PAYLOAD EXAMPLE"
      }
    ]
  }, {
    "title": "Welcome!",
    "imageUrl": "https://www.stepforwardmichigan.org/wp-content/uploads/2017/03/step-foward-fb-1200x628-house.jpg",
    "subtitle": "We have the right hat for everyone.We have the right hat for everyone.We have the right hat for everyone.",
    "buttons": [
      {
        "postback": "https://f1948e04.ngrok.io",
        "text": "View Website"
      }, {
        "text": "Start Chatting",
        "postback": "PAYLOAD EXAMPLE"
      }
    ]
  },{
    "title": "Welcome!",
    "imageUrl": "https://www.stepforwardmichigan.org/wp-content/uploads/2017/03/step-foward-fb-1200x628-house.jpg",
    "subtitle": "We have the right hat for everyone.We have the right hat for everyone.We have the right hat for everyone.",
    "buttons": [
      {
        "postback": "https://f1948e04.ngrok.io",
        "text": "View Website"
      }, {
        "text": "Start Chatting",
        "postback": "PAYLOAD EXAMPLE"
      }
    ]
  }];
  handleCardMessages(elements, sender)
break;

We are sending 3 objects in Array so it will be a carousel if we send one it will be simple Generic template.

Create handleCardMessages() to handle above elements,
async function handleCardMessages(messages, sender) {
  let elements = [];
  for (var m = 0; m < messages.length; m++) {
    let message = messages[m];
    let buttons = [];
    for (var b = 0; b < message.buttons.length; b++) {
      let isLink = message.buttons[b].postback.substring(0, 4) === "http";
      let button;
      if (isLink) {
        button = {
          type: "web_url",
          title: message.buttons[b].text,
          url: message.buttons[b].postback
        };
      } else {
        button = {
          type: "postback",
          title: message.buttons[b].text,
          payload: message.buttons[b].postback
        };
      }
      buttons.push(button);
    }
    let element = {
      title: message.title,
      image_url: message.imageUrl,
      subtitle: message.subtitle,
      buttons: buttons
    };
    elements.push(element);
  }
  await sendGenericMessage(sender, elements);
}

The above function will make payload that facebook API Accepts. Let’s make sendGenericMessage() function to send elements,

const sendGenericMessage = async (recipientId, elements) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: {
          template_type: "generic",
          elements: elements
        }
      }
    }
  };
  await callSendAPI(messageData);
}

callSendAPI() function will send messageData to send API and user will get Generic template or carousel as response.

Conclusion : –

I have shown the way how to send each type of responses to facebook messenger now it’s your turn to think about creative ideas to build chatbot. Fill free to hit comments if you get stuck anywhere.

Prerequisite

• Facebook Page
• Facebook Developer Account
• Understanding of Dialogflow
• Knowledge of Node.js

Send List template

The list template is a list of 2-4 elements with an button where button can be optional. Each item may contain a thumbnail image, title, subtitle, and one button.

Create new case in Switch statement,

case "send-list":
    const list = {
        "template_type": "list",
        "top_element_style": "compact",
        "elements": [
            {
                "title": "Classic T-Shirt Collection",
                "subtitle": "See all our colors",
                "image_url": "http://pngimg.com/uploads/tshirt/tshirt_PNG5450.png",
                "buttons": [
                    {
                        "title": "View",
                        "type": "web_url",
                        "url": "https://yudiz-bot.herokuapp.com/collection",
                        "messenger_extensions": true,
                        "webview_height_ratio": "tall",
                        "fallback_url": "https://yudiz-bot.herokuapp.com"
                    }
                ]
            },
            {
                "title": "Classic White T-Shirt",
                "subtitle": "See all our colors",
                "default_action": {
                    "type": "web_url",
                    "url": "https://yudiz-bot.herokuapp.com/view?item=100",
                    "messenger_extensions": false,
                    "webview_height_ratio": "tall"
                }
            },
            {
                "title": "Classic Blue T-Shirt",
                "image_url": "http://pngimg.com/uploads/tshirt/tshirt_PNG5450.png",
                "subtitle": "100% Cotton, 200% Comfortable",
                "default_action": {
                    "type": "web_url",
                    "url": "https://yudiz-bot.herokuapp.com/view?item=101",
                    "messenger_extensions": true,
                    "webview_height_ratio": "tall",
                    "fallback_url": "https://yudiz-bot.herokuapp.com"
                },
                "buttons": [
                    {
                        "title": "Shop Now",
                        "type": "web_url",
                        "url": "https://yudiz-bot.herokuapp.com/shop?item=101",
                        "messenger_extensions": true,
                        "webview_height_ratio": "tall",
                        "fallback_url": "https://yudiz-bot.herokuapp.com"
                    }
                ]
            }
        ],
        "buttons": [
            {
                "title": "View More",
                "type": "postback",
                "payload": "payload"
            }
        ]
    }
    sendListMessege(sender, list)
break;

To send this list Create new function,

const sendListMessege = async (recipientId, elements) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: elements
      }
    }
  };
  await callSendAPI(messageData);
}

callSendAPI() function will send messageData to send API and user will get List as response.

Send Button template

Button template includes text message with up to three attached buttons. We can send three types of buttons that can handle postback, Phone call, and URL.

Create new case in switch statement,

case "send-button":
  const responseText = "exmple buttons";
  const elements = [{
    "type": "web_url",
    "url": "https://f1948e04.ngrok.io",
    "title": "URL",
  }, {
    "type": "postback",
    "title": "POSTBACK",
    "payload": "POSTBACK TEST"
  }, {
    "type": "phone_number",
    "title": "CALL",
    "payload": "+919510733999"
  }]
  sendButtonMessage(sender, responseText, elements)
break;
Create a sendButtonMessage() function to send those elements,
const sendButtonMessage = async (recipientId, text, buttons) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: {
          template_type: "button",
          text: text,
          buttons: buttons
        }
      }
    }
  };
  await callSendAPI(messageData);
}

callSendAPI() function will send messageData to send API and user will get Buttons as response.

Send Open Graph template

The open graph template allows to send open graph URL with optional button. Currently, only sharing songs is supported.

Create new case in Switch Statement,

case "send-graph" :
  var element = [{
    "url": "https://open.spotify.com/album/1XbZ2tMfcQTbVkr55JnoRg",
    "buttons": [
      {
        "type": "web_url",
        "url": "https://en.wikipedia.org/wiki/Rickrolling",
        "title": "View More"
      }
    ]     
  }]  
  sendGraphTemplate(sender,element);
break;

Now create sendGraphTemplate() function to send element,

const sendGraphTemplate = async (recipientId, elements) => {
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: {
          template_type: "open_graph",
          elements: elements
        }
      }
    }
  };
  await callSendAPI(messageData);
}

callSendAPI() function will send messageData to send API and the song will appear in a bubble that allows the user to see album art and preview the song.

Send Receipt template

When you are making chatbot for shopping related apps and when user buys something from your bot you must send receipt at the end of payment, that’s the receipt template facebook provides.

Create new case in switch statement,

case "send-receipt":
    const recipient_name = "Nikhil Savaliya";
    const currency = "INR";
    const payment_method = "Visa 2345";
    const timestamp = 1428444852;
    const elementRec = [{
        "title": "Classic Blue T-Shirt",
        "subtitle": "100% Soft and Luxurious Cotton",
        "quantity": 1,
        "price": 350,
        "currency": "INR",
        "image_url": "http://pngimg.com/uploads/tshirt/tshirt_PNG5450.png"
    }];
    const address = {
        "street_1": "A-6, First Floor",
        "street_2": "Safal Profitaire,",
        "city": "Ahmedabad",
        "postal_code": "380015",
        "state": "Gujarat",
        "country": "IN"
    };
    const summary = {
        "subtotal": 350.00,
        "shipping_cost": 4.95,
        "total_tax": 6.19,
        "total_cost": 361.14
    };
    const adjustments = [
        {
            "name": "New Customer Discount",
            "amount": 20
        },
        {
            "name": "$10 Off Coupon",
            "amount": 10
        }
    ];
    const order_url = "https://37cf1e51.ngrok.io"
    sendReceiptMessage(sender,
        recipient_name,
        currency,
        payment_method,
        timestamp,
        elementRec,
        address,
        summary,
        adjustments,
        order_url);
break;

Create sendReceiptMessage() function to send above elements,

const sendReceiptMessage = async (
  recipientId,
  recipient_name,
  currency,
  payment_method,
  timestamp,
  elements,
  address,
  summary,
  adjustments,
  order_url
 ) => {
  var receiptId = "order" + Math.floor(Math.random() * 1000);
  var messageData = {
    recipient: {
      id: recipientId
    },
    message: {
      attachment: {
        type: "template",
        payload: {
          template_type: "receipt",
          recipient_name: recipient_name,
          order_number: receiptId,
          currency: currency,
          payment_method: payment_method,
          order_url: order_url,
          timestamp: timestamp,
          address: address,
          summary: summary,
          adjustments: adjustments,
          elements: elements,
        }
      }
    }
  };
  await callSendAPI(messageData);
}

By this way you can generate and send receipt to users when they make payment.

Conclusion : –

I have shown the way how to send each type of responses to facebook messenger now it’s your turn to think about creative ideas to build chatbot. Fill free to hit comments if you get stuck anywhere.

Yudiz portfolio

Here, at Yudiz, we have developed apps wherein beacons are used at restaurants and when user’s device gets into the it range, he gets awarded with offers.

Conclusion

Beacon’s future is bright and one can imagine a wide range of possible applications targeting this technology.

Conclusion

So Devs!, These are few components of material design using that you can create attractive and beautiful digital experience. You must try your hands on updated Material Components.

To know more about Material design introduced in Google I/O 2018 refer this.

Conclusion

“A slice is designed to solve a problem: I’m a user and want to get something quickly done on my device,”