Get Raspberry Pi with Ubuntu

• Get Raspberry Pi 4 with 4 GB version.
• Go to https://ubuntu.com/download/raspberry-pi and install Ubuntu 18.04.4 LTS 32 bit version.

Install Ubuntu desktop:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install ubuntu-desktop

Edit /boot/firmware/usercfg.txt

nano /boot/firmware/usercfg.txt

Insert the following content to force the Rpi to use HDMI output.

Reboot the server.

Enable screen sharing for VNC

• Go to Settings and click Sharing.

• Click on Screen Sharing and enable it.

• Enable Remote Login.

• Run the following command to disable the encryption. This feature creates problems for Windows machine while connecting.

sudo gsettings set org.gnome.Vino require-encryption false

• Download the VNC Viewer from RealVNC: https://www.realvnc.com/en/connect/download/viewer/
• Create a new connection.

• Enter the Rpi IP address on VNC Server and unchecked the options for the Security Encryption. Click OK to save.

OpenCV 4

Install OpenCV 4 from this guide: https://www.pyimagesearch.com/2018/08/15/how-to-install-opencv-4-on-ubuntu/

Noted that OpenCV installed on the virtual environment cv.

Install the OCR Pytesseract and other required libraries

Install the OCR Pytesseract and other libraries on the virtual environment cv. Make sure you are installing from the virtual environment cv since we are installing the OpenCV in this environment.

workon cv

pip install vext

pip install vext.gi

pip install PyUserInput

pip install pillow

pip install pytesseract

sudo apt-get install tesseract-ocr

Install Chromium Web Browser

Run the following command to install the Chromium Web Browser:

sudo apt install chromium-browser

Open the browser and go to Google Duo site: https://duo.google.com. Sign in and install the app on the browser.

Run the Chromium browser in kiosk mode:

chromium-browser — kiosk — noerrors — disable-session-crashed-bubble — disable-infobars — disable-restore-session-state https://duo.google.com/

Map the Mouse Position

We need to perform the OCR on the are highlighted in yellow and also to get the mouse cursor location on the “Accept” button.

Update the Python code with the coordinate values.

Make it Auto Run

Create shell script googleduoauto.sh with the following content:

#!/bin/bash
cd /home/ubuntu
source ~/.bashrc
workon cv
python /home/ubuntu/googleduo.py

Create the entries for Chromium auto-start in kiosk mode and GoogleDuo shell script in Startup Applications Preferences.

Source code:

https://github.com/ferrygun/GoogleDuoBot

This is a simple hack with Google Duo to automatically pick up the calls from the recognized contacts.

Background

The reason is because I need to call my mom without need for her to find the phone, pick up the call and answer it. And also her phone is not always with her and sometimes she has forgotten to charge the battery. I need to build something easy for her to handle.

How it works ?

Whenever the Google Duo receives the calls from the recognized contacts, it will answer the call, otherwise it will just ignore it.

What you need to have

We need to prepare the following stuff to make it work flawlessly:

• Ubuntu desktop Linux (I might port it to Raspberry Pi in the future).
• Chromium Web Browser
• Python 3 with OCR library Tesseract
• Google Duo account

I presume you have the Ubuntu desktop Linux installed on your virtual machine so let’s get started!!

Install Chromium Web Browser and Auto Start After Boot

Open the terminal window and run the following command:

wget -qO — http://bintray.com/user/downloadSubjectPublicKey?username=bintray | sudo apt-key add -

echo “deb http://dl.bintray.com/kusti8/chromium-rpi jessie main” | sudo tee -a /etc/apt/sources.list

sudo apt-get update

sudo apt-get install chromium-browser -y

Now we need to set the chromium web browser to auto run on the startup.

Search for Startup Applications and create new startup entry.

Under command line, enter the following line:

chromium-browser — kiosk — disable-session-crashed-bubble — disab-infobars — disable-restore-session-state https://duo.google.com/

Identify the Incoming Call (with the recognized contacts)

We need to solve the problem on how does the bot can identify the incoming calls with the valid contacts (otherwise it will be treat as a spam and ignore it).

To identify the incoming call, I am doing a simple hack by checking the pixel value on the predefined coordinate. The background color will turn darker if there is an incoming call.

The next step is to make sure the bot is only answering the predefined contacts. To answer this, I am using the OCR to scan the certain area and get the result.

Install Python 3 with Tesseract. You may refer to this write up. Also install other necessary libraries: cv2 and pymouse. All code is here.

That’s all that we need and hopefully you can make it as well. Don’t forget to turn off the screen saver or screen lock.

Let’s get started !!

Setup Twilio WhatsApp Sandbox

• Create Twilio account and write down the Twilio Account SID and Auth. Token.

• Register your mobile number in Twilio Sandbox for WhatsApp.

That’s all the required setup in Twilio.

Google Sheets Setup

• Create Google Sheets account and create a new spreadsheet “WAReminders”
• Add two sheets: Twilio
  Under Twilio sheet, enter the Twilio SID and Token information as shown in the below screenshot

• And Contact
  Under Contact sheet, populate the cell number with format <country code><cell number>, for example: +6597123456. The cell number is the registered number in Twilio WhatsApp Sandbox.

• Create Google Apps script Code.gs and replace the content with the source code in my Git
• Basically the macro will get the calendar event title and check if title suffix ends with “~!#”
• If yes, send the WhatsApp message to the registered number and update the title with “~!#”

• Add the trigger and let the script runs every 5 minutes

Testing!

• Add an event in your Google Calendar

• Check your WhatsApp if you are getting any message from Twilio

Whats Next ?

Adding a WhatsApp reminder is just one of the option. We can add a display reminder for example turning on and off the LED light.

That’s all about it and I hope it is beneficial for you with this simple trick!

Here are the screenshots of the final app that we are going to build.

Configuration & Installation

We need to configure & install the following software.

• SAP Mobile Platform SDK
• SAP Web IDE Full Stack with HAT enabled
• SAP HAT Local Installation
• Anyline Cordova SDK

SAP Mobile Platform SDK

Download and install SAP Mobile Platform SDK from https://www.sap.com/sea/developer/trials-downloads/additional-downloads/mobile-platform-sdk-free-download-13098.html

Install the following components. The version in the bracket is the version that I am currently using and is working perfectly.

• Oracle Java (1.8.0)
• Android SDK
• Android Studio (3.0.1)
• Cordova (6.5.0)
• Kapsel SDK (3.16.0)
• Ant (1.10.5)

Set the following environment variables: ANT_HOME, JAVA_HOME and KAPSEL_HOME.

SAP Web IDE Full Stack with HAT enabled

Logon to SAP Cloud Platform Cockpit and enable the SAP Web IDE Full Stack

Then go to service.

Click Preferences > Features (Extensions) and search for Hybrid App Toolkit.

Enable and save it.

You will see the Hybrid App Toolkit.

Even though this feature has reached the end of maintenance, I can still use this feature to build the awesome apps and I find it easier.

Next step is to install the HAT locally on your computer.

SAP HAT Local Installation

Download the HAT from this link: https://www.sap.com/india/developer/trials-downloads/additional-downloads/hybrid-app-toolkit-add-on-13586.html

I downloaded version 1.29.7

Download the required components for HAT.

• NodeJS (8.9.4)
• Npm (5.6.0)
• Git (2.13.2)
• Bower (1.8.4)

Extract the HAT Add-on to your C:\ drive. For my case is C:\SAP_HAT_local-1.29.7

We need to modify the HAT Add-on setup script, otherwise you will get an error message (I think is the setup script is too old and not maintained anymore by SAP).

Open check_env.cmd at folder .\SAP_HAT_local-1.29.7\setup\scripts\win and change the NodeJS version major, minor and build at line 62–64.

Change it according to your NodeJS version (for my case is 8.9.4):

Run the setup.cmd.

If no error, the browser will be opened. Click Check All to start the installation.

Make sure there is no error on each step and status is passed.

When you at step 2.Install Hybrid App Toolkit > 3. Configure HAT Connector for SAP Web IDE, enter the SAP Web IDE Full Stack URL

At step 5 Configure path for custom plugins, specify the folder where you want to put the Anyline SDK Cordova plugin (for my case is C:\SAP\Plugins). Later we will download this plugin.

Continue the installation.

Check again to ensure there is no error and all steps are passed then close the browser.

Go to HAT Add-on folder installation and run the HAT server.

Check if SAP Web IDE can communicate to the server. Go to Web IDE > Hybrid Application Toolkit and test the connection. If no error, you will see the similar result as per the below screenshot.

Anyline Cordova SDK

Download Anyline Cordova SDK from https://github.com/Anyline/anyline-ocr-cordova-module and put it under C:\SAP\Plugins\Anyline. That’s it!.

Create SAPUI5 App

On SAP Web IDE, create the SAPUI5 app Scanner.

Click Finish to complete.

Go to Project Settings.

Select Hybrid App Toolkit > App Configuration > Application

Enter the App Name and App Id.

Select Hybrid App Toolkit > App Configuration > Plugins > Custom.

Select Local > AnylineSDK

Click Save

Click Deploy > Prepare Hybrid Project

You will see the progress on the console. One of the activity is to install the Anyline Cordova plugin locally.

Wait until the app has been successfully deployed.

It will be saved at C:\Users\<user>\SAPHybrid\Scanner

Open Android Studio and import the project at C:\Users\<user>\SAPHybrid\Scanner\hybrid\platforms\android

If you see this error message:

Open gradle-wrapper.properties, change distributionUrl to:

distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-all.zip

Update buildscript and allprojects on build.gradle (Project level):

buildscript {
    repositories {
        mavenCentral()
        google()
        jcenter()
    }

    // Switch the Android Gradle plugin version requirement depending on the
    // installed version of Gradle. This dependency is documented at
    // http://tools.android.com/tech-docs/new-build-system/version-compatibility
    // and https://issues.apache.org/jira/browse/CB-8143
    dependencies {
        classpath 'com.android.tools.build:gradle:3.2.1'
    }
}

// Allow plugins to declare Maven dependencies via build-extras.gradle.
allprojects {
    repositories {
        mavenCentral();
        google()
        jcenter()
    }
}

Update dependencies:

dependencies {
    compile fileTree(dir: 'libs', include: '*.jar')
    // SUB-PROJECT DEPENDENCIES START
    //debugCompile(project(path: "CordovaLib", configuration: "debug"))
    //releaseCompile(project(path: "CordovaLib", configuration: "release"))
    compile project(':CordovaLib')
    // SUB-PROJECT DEPENDENCIES END
}

Remove uses-sdk tag on AndroidManifest.xml.

<uses-sdk android:minSdkVersion="16" android:targetSdkVersion="25" />

Also remove uses-sdk on AndroidManifest.xml at CordovaLib level:

<uses-sdk android:minSdkVersion="14" />

Try to rebuild again.

Now the build is success!

Now we need to update the Scanner.controller.js and Scanner.view.xml.

Get the code from Git below and update these two files:

https://github.com/ferrygun/Scanner/blob/master/webapp/controller/Scanner.controller.js

https://github.com/ferrygun/Scanner/blob/master/webapp/view/Scanner.view.xml

Copy the asset folder as well. This is the list of available trained fonts that will be used to recognize the character in the scanning process. We are going to use only the Calibri.traineddata for this purpose. Feel free to experiment with other asset files if the scan result is poor.

https://github.com/ferrygun/Scanner/tree/master/webapp/assets

Let’s take a look at the main function in Scanner.controller.js before we build the app. We need to define the Anyline OCR & Barcode configuration.

Anyline OCR config:

Anyline Barcode config:

Create getBarcode() and getOCR() to initiate barcode label and OCR scan.

Now everything is setup and we will build and run the app !

The complete codes can be found here:

ferrygun/Scanner

Thanks for reading and let me know if you have any questions!

The same post has been published in SAP blog: https://blogs.sap.com/2019/01/08/create-text-recognition-ocr-app-with-google-ml-kit-and-sap-web-ide/

Here is the sample screenshot of the app. On the left hand-side, the app will recognize the barcode and expiry date at the same. Once it recognizes, it will throw the result automatically.

Let’s grab and modify the multi-detector tutorial from https://developers.google.com/vision/android/multi-tracker-tutorial. We will remove the Face detector and add the text detector.

Creating a Text Detector

Create a text detector to track texts.

TextRecognizer textRecognizer = new TextRecognizer.Builder(context).build();

Creating a MultiProcessor for Managing Detected Texts

Create a text tracker factory, ocrTrackerFactory for each text.

OcrTrackerFactory ocrTrackerFactory = new OcrTrackerFactory(mGraphicOverlay, this);
textRecognizer.setProcessor(
        new MultiProcessor.Builder<>(ocrTrackerFactory).build());

Conceptually, this creates a portion of the detector processing pipeline which looks like this:

This portion of the pipeline works as follows:

1. The text detector detects texts and creates a collection of text instances.
2. A multi-processor instance keeps track of each text that is currently active. It uses a factory to create a new graphic tracker instance per text.
3. As texts are tracked across video frames, the multi-processor sends updates to the corresponding text tracker instances. In this case, text updates are simply the position and size of the text within the video frame.

Using a MultiDetector to Combine the Barcode and Text Detectors

Modify the multi detector on MultiTrackerActivity.java to include text detector and remove the face detector.

MultiDetector multiDetector = new MultiDetector.Builder()
        .add(barcodeDetector)
        .add(textRecognizer)
        .build();

OCRTrackerFactory.java

Create OCRTrackerFactory.java with two OcrTrackerFactory and OcrGraphic classes.

GraphicTracker.java

On onUpdate() method we need to create a logic to differentiate if the detection result is barcode or text.

If detection result is text (OCR), set the flag to true otherwise is false (barcode)

On onBarcodeDetected() method in MultiTrackerActivity.java, get the detection result. If you notice on the barcode result, I only need to get the first barcode that has found:

Barcode barcode = items.valueAt(0)

Create a Thread to Get the Detected Barcode and Text

Create a thread Task() on MultiTrackerActivity.java that will loop every one second to get the barcode and text result. Once we got the barcode and text values, start a new activity, SendScannedBarcode().

Here is the full source code: https://github.com/ferrygun/multi-tracker

Enjoy !!

We need to have two machines running on Ubuntu. We will install NodeJS client and Hyperledger Fabric component on each machine.

The high-level architecture would be like this:

Hyperledger Fabric Server

Follow my below post to setting up the server. Install and configure Hyperledger Fabric on the first machine.

Getting Started with Hyperledger Composer

You don’t need to install and configure the REST server. Take note the IP address of this machine.

NodeJS Client App

On the second machine, install the composer-client and composer-cli:

npm install --save composer-client@0.20

npm install --save composer-admin@0.20

We need to copy the admin@tutorial-network that we created on the Fabric side to the client side. Logon to the first machine and copy the admin@tutorial-network folder located $HOME/.composer/cards and $HOME/.composer/client-data.

Logon to the client machine and paste those files to the client machine.

Open the connection.json from $HOME\.composer\cards\admin@tutorial-network and update the connection string from localhost to the server IP address (for my case is 192.168.0.109):

Execute the Script

We will execute the NodeJS app on the client side:

• To create the participant and asset, execute:

node cli serverregistry bootstrap

The script will populate the participant and asset with the predefined value:

• To get the list of the asset, execute:

node cli serverregistry list

As you can see in the above screenshot, the value of Active_Memory, HW_Model, etc is still empty because we haven’t submitted the transaction.

• To submit the transaction, execute:

node cli serverregistry submit 64 "Model A" 8 4 "Server A" ADM

with parameters:

· Active_Memory: 64

· HW_Model: Model A

· Installed_CPUs: 8

· Installed_RAM: 4

· Server_Model: Server A

· datacenterid: ADM

Try to execute the previous command: node cli serverregistry listand you will see the transaction has been populated:

• To listen to the event, execute:

node cli serverregistry listen

Event will be emitted once you submit the transaction. You will see the console log printed out.

All codes can be found on my Git repo: https://github.com/ferrygun/NodeJS-Blockchain

Get Best Software Deals Directly In Your Inbox

Blockchain NodeJS Server Monitoring was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Problem statement:

When you click “Connect now”, you can’t connect the network

Error message:

Error: Error trying to ping. Error: Failed to connect before the deadline

Resolution:

• I presume you already have the business network archive (.bna) file and business network card (.card) in your folder. If not, please follow this link to generate those files: https://hyperledger.github.io/composer/latest/tutorials/developer-tutorial.html
• Stop and tear down the fabric:

~/fabric-dev-servers/stopFabric.sh

~/fabric-dev-servers/teardownFabric.sh

• Remove the previous docker containers:

docker kill $(docker ps -q)
docker rm $(docker ps -aq)
docker rmi $(docker images dev-* -q)

• Start the Fabric and create the Peer Admin card:

~/fabric-dev-servers/startFabric.sh
~/fabric-dev-servers/createPeerAdminCard.sh

• If you trying to ping now, you will get this message:

• Navigate to the folder where you kept the .bna and .card files.

• Install the business network archive (.bna):

composer network install --card PeerAdmin@hlfv1 --archiveFile tutorial-network@0.0.1.bna

• Start the business network:

composer network start --networkName tutorial-network --networkVersion 0.0.1 --networkAdmin admin --networkAdminEnrollSecret adminpw --card PeerAdmin@hlfv1 --file networkadmin.card

• Ping the network:

composer network ping --card admin@tutorial-network

• Now click “Connect now”, you will get the message “refreshing the connection to …”. And you are connected to the network now.

Hope that helps!

Discover and review best Blockchain softwares

What is Hyperledger Composer?

According to their website: Hyperledger Composer is a set of collaboration tools for building blockchain business networks that make it simple and fast for business owners and developers to create smart contracts and blockchain applications to solve business problems. Built with JavaScript, leveraging modern tools including node.js, npm, CLI and popular editors, Composer offers business-centric abstractions as well as sample apps with easy to test devops processes to create robust blockchain solutions that drive alignment across business requirements with technical development.

https://www.hyperledger.org/projects/composer

Hyperledger Composer Installation

At your home directory, install the prerequisites by running the following script:

cd $HOME
curl -O -k https://hyperledger.github.io/composer/latest/prereqs-ubuntu.sh
chmod u+x prereqs-ubuntu.sh

run the command to install the:

sudo apt-get install -y software-properties-common

Once it’s completed without any error, you will get this message:

Install Required Components

npm install -g composer-cli@0.20
npm install -g composer-rest-server@0.20
npm install -g generator-hyperledger-composer@0.20
npm install -g yo

Install Playground

npm install -g composer-playground@0.20

Install Hyperledger Fabric

Create a directory fabric-dev-servers at your home directory.

mkdir ~/fabric-dev-servers && cd ~/fabric-dev-servers

And run curl command to download the tool and unzip it.

curl -O https://raw.githubusercontent.com/hyperledger/composer-tools/master/packages/fabric-dev-servers/fabric-dev-servers.tar.gz

tar -xvf fabric-dev-servers.tar.gz

Download the runtime:

export FABRIC_VERSION=hlfv12
./downloadFabric.sh

Running on the First Time

cd ~/fabric-dev-servers
 export FABRIC_VERSION=hlfv12
 ./startFabric.sh
 ./createPeerAdminCard.sh

To stop, run this command:

~/fabric-dev-servers/stopFabric.sh

Start the Playground

To start, run the following command:

composer-playground

It will open the browser automatically and redirect to http://localhost:8080/login

Create New Business Network with Command Line

Create a new folder at your home folder, name it (for example) blockchainDocker. Go to that folder and run this command:

yo hyperledger-composer:businessnetwork

Fill the Business network name: tutorial-network, Namespace: org.basic.server and the rest is up to you.

Upon successful, you will see the new folder tutorial-network was created.

Go to the folder tutorial-network/lib and update the logic.js with the following content:

Update org.basic.server.cto in tutorial-network/models with the following content:

We will leave permissions.acl file as it is.

Generate a Business Network Archive

After we defined the business network, it must be packaged into a deployable business network archive (.bna) file. Go to the tutorial-network folder and run this command.

composer archive create -t dir -n .

Deploying Business Network Archive

Run the following command to install the business network from tutorial-network directory:

composer network install --card PeerAdmin@hlfv1 --archiveFile tutorial-network@0.0.1.bna

To start the business network, run the following command:

composer network start --networkName tutorial-network --networkVersion 0.0.1 --networkAdmin admin --networkAdminEnrollSecret adminpw --card PeerAdmin@hlfv1 --file networkadmin.card

To import the network administrator identity as a usable business network card, run the following command:

composer card import --file networkadmin.card

Once you have imported, you will see the card in the Playground: http://localhost:8080/login

To check that the business network has been deployed successfully, run the following command to ping the network:

composer network ping --card admin@tutorial-network

Test the Network

We are going to test the network by populating the prerequisite information for the asset DataCenterId. The Participant Personnel in this example is not being used. Once we have the DataCenterID populated, we can submit the transaction against the particular DataCenterID with the server parameters like how many memory installed, how many CPU installed, etc.

• Go to http://localhost:8080/login
• Click Connect now to connect to the network

• Go to Test tab.
• Populate the prerequisite information. Under Participants, select Personnel and click New Participant.

• Once you created, you will see the registry entry under Participants.

• Create the Asset DataCenterId (for example DC1).

• Submit a transaction to a particular Data Center, for this example is the Data Center Id DC1 that we just created.

• If we submit the transaction to the Data Center Id which is not exist, it will throw an error message. In this example below, the Data Center Id DC2 has not been defined and we will get an error message.

• Once you have successfully submitted the transaction, you will see the server parameter information is populated under the Data Center Id you have submitted (in this case is DC1).

• To see the log of transactions, select All Transactions. Click view record to see all the detail log transactions.

REST Server

The last thing that we want to build is the REST server. With this, we can expose the Assets, Participants and Transactions that we have created so it can be consumed with the client app like web or mobile app.

We will create a docker container for this purpose with the following steps:

• Install the LoopBack connector for MongoDB:

npm install -g loopback-connector-mongodb

• Make sure you can ping the tutorial-network. Run this command:

composer network ping -c admin@tutorial-network

• Start an instance of docker called mongo. This instance will be used to persist all information regarding authenticated users and their wallets for the REST server.

docker run -d --name mongo --network composer_default -p 27017:27017 mongo

• Create a new file called Dockerfile under new folder with the following contents:

FROM hyperledger/composer-rest-server
RUN npm install --production loopback-connector-mongodb passport-github && \
    npm cache clean --force && \
    ln -s node_modules .node_modules

• Run this command:

docker build -t myorg/my-composer-rest-server .

• Create a new file envvars.txt on the same folder with this content:

COMPOSER_CARD=admin@tutorial-network
COMPOSER_NAMESPACES=never
COMPOSER_AUTHENTICATION=true
COMPOSER_MULTIUSER=false
COMPOSER_PROVIDERS='{
    "github": {
        "provider": "github",
        "module": "passport-github",
        "clientID": "REPLACE_WITH_CLIENT_ID",
        "clientSecret": "REPLACE_WITH_CLIENT_SECRET",
        "authPath": "/auth/github",
        "callbackURL": "/auth/github/callback",
        "successRedirect": "/",
        "failureRedirect": "/"
    }
}'
COMPOSER_DATASOURCES='{
    "db": {
        "name": "db",
        "connector": "mongodb",
        "host": "mongo"
    }
}'

• Run this command to load it to the environment variable:

source envvars.txt

• We need to update the localhost string on the ~/.composer/cards/admin@tutorial-network/connection.json.

sed -e ‘s/localhost:7051/peer0.org1.example.com:7051/’ -e ‘s/localhost:7053/peer0.org1.example.com:7053/’ -e ‘s/localhost:7054/ca.org1.example.com:7054/’ -e ‘s/localhost:7050/orderer.example.com:7050/’ < $HOME/.composer/cards/admin@tutorial-network/connection.json > /tmp/connection.json && cp -p /tmp/connection.json $HOME/.composer/cards/admin@tutorial-network/

• run the docker:

docker run \
    -d \
    -e COMPOSER_CARD=${COMPOSER_CARD} \
    -e COMPOSER_NAMESPACES=${COMPOSER_NAMESPACES} \
    -e COMPOSER_AUTHENTICATION=${COMPOSER_AUTHENTICATION} \
    -e COMPOSER_MULTIUSER=${COMPOSER_MULTIUSER} \
    -e COMPOSER_PROVIDERS="${COMPOSER_PROVIDERS}" \
    -e COMPOSER_DATASOURCES="${COMPOSER_DATASOURCES}" \
    -v ~/.composer:/home/composer/.composer \
    --name rest \
    --network composer_default \
    -p 3000:3000 \
    myorg/my-composer-rest-server

• Check if the server is running without error, you will see the message as per below screenshot.

docker logs -f rest

• Open the web browser and go to this URL: http://localhost:3000/auth/github
• Click Authorize.

• If no error, you will see the page below with the access token information.

• Select Server : A transaction named Server and click Post. Populate with the below data and click Try it out!.

{
 “$class”: “org.basic.server.Server”,
 “Active_Memory”: 4,
 “HW_Model”: “Dell”,
 “Installed_CPUs”: 2,
 “Installed_RAM”: 4,
 “Server_Model”: “Model A”,
 “datacenterid”: “DC1”
}

• Now select Get and click Try it out!. You will see the data that you have posted.

Stay tuned for part 2 where we will build a SAP mobile app (SAPUI5) that consumed the REST API. Thanks for reading my post.

Get Best Software Deals Directly In Your Inbox

Getting Started with Hyperledger Composer was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

I have made one 👌 and it is available for public (you can try it now) from your phone or Google Home.

If I can make it, I hope you also can do it, so let’s get started!!

https://www.facebook.com/TrainOnDemand/

Train On Demand

See What’s Inside

The train arrival times information is based on the SMRTConnect App.

SMRTConnect - Apps on Google Play

Download the latest apk (version 3.1.3) from https://apkpure.com/smrtconnect/sg.com.smrt.smrtconnect

We will analyze how it works and where to get the necessary information for our app. Download jadx and we will use this tool to analyze the code.

Let’s take a look at the asset folder and check if we can find anything useful.

I found this app.properties under asset folder.

The app is using Hawk authentication mechanism.

Citing from https://github.com/hueniverse/hawk:
Hawk is an HTTP authentication scheme providing mechanisms for making authenticated HTTP requests with partial cryptographic verification of the request and response, covering the HTTP method, request URI, host, and optionally the request payload.

From the properties file we can see the server URL, hawk id and key. We will be using the following information:

wshelper.server-prefix2=https://connectv3.smrt.wwprojects.com/smrt/
wshelper.hawk-id2=ww-connectv3-android
wshelper.hawk-key2=h42325aqx6krj5z2uzm5e8wwqr2wchk5xq704n1e

Get the hawk-key2 and let’s name it as key. The below code is NodeJS syntax. We will create the app in NodeJS.

let key = 'h42325aqx6krj5z2uzm5e8wwqr2wchk5xq704n1e';

From this point, we need to trace in the codes where this key is being used.

Top 3 Bot Tutorials

1. Write a serverless Slack chat bot using AWS

2. Chatbot using django rest framework + api.ai + slack

3. Building a ChatBot with Watson

Take a look at this piece of code in com.smrt.smrtconnect.Helpers.wsHelper.WSHelper.java under method getAuthorizationHeader.

I found another important key to calculate the MAC with the hash algorithm sha256
Let’s name this key as hashq:

let hashq = 'q/t+NNAkQZNlq/aAD6PlexImwQTxwgT2MahfTa9XRLA=';

This method getAuthorizationHeader is very important and as our reference to build the app.

Let’s go a little deeper. We need to find other methods that are calling getAuthorizationHeader.

And I found refreshTokens method under com.smrt.smrtconnect.Helpers.CDNHelper.java. We will be using this token to refresh the updated station information.

Output token from the above code:

{“results”:{“http://connect-v3-cdn.smrt.wwprojects.com/":"?Policy=eyJTdGF0ZW1lbnQiOlt7IlJlc291cmNlIjoiaHR0cDovL2Nvbm5lY3QtdjMtY2RuLnNtcnQud3dwcm9qZWN0cy5jb20vKiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTUzMDAwOTQ3NX19fV19&Signature=hvfLverTCMgEDGW6zzFaVKm0PIVid0~jW9P1JH-S4BFivkHJEeyCxo9VGUFWuxu3hj1fXF~IbphdM~bgF3X6LwiJ~u3eNY7cEuxPrgItti6OXlszjotgk8aJL7pqD7BCi6Y2PTcfXT26RAbVYn9uAGh6XL9uU2Y4I6sHGPJfvO6BB07UD4xj3D8JB6IuuyzjRV-ZI--~eeFzYRWf8k02bXEmwf7ZDDvUJS5uPfzvKBHJX~qDIoPjWu~Q4wVP8Gsj0dHQpGtNExy87QhSHC29bjxKW1hvXBPlpvvIPkp6Mf3i~nDcFo~lwYqIJ6LNiuRroSXi3zR8CrMKteqszhsSEQ__&Key-Pair-Id=APKAIZHURKILCXZIMLUA"}}

From the given token, we will get the most updated station information from stations.json.

let path = '/autoupdate_data/stations.json?Key-Pair-Id=' + keypairid + '&Signature=' + signature + '&Policy=' + policy;

Apart from the above method, I am also using the Charles Proxy to analyze the network traffic. With that combination, it will be easier to trace the flow of the app and validate the responses.

Fun Part

With the above reference, we will build a simple NodeJS app to validate the response. Once it is successful, we will continue to build the app on Google Assistant.

Generate the Authentication Header

The Node app will generate the authentication header by calculating a timestamp, generating a nonce and constructing the normalized request string (each value followed by a newline character):

hawk.1.header
1529992949
261EDD5E9A7C
GET
/smrt/api/cdn_token/
connectv3.smrt.wwprojects.com
443
q/t+NNAkQZNlq/aAD6PlexImwQTxwgT2MahfTa9XRLA=

Generate the MAC (Message Authentication Code)

The request MAC is calculated using HMAC with the specified hash algorithm sha256 and the key over the normalized request string. The result is base64-encoded to produce the request MAC:

UJu120qHBk8LOdJP2BXOIQr9jy8MrCOSpHxV3cEqmag=

Getting Together

We will compose HTTP GET request with the generated MAC.

This is a sample HTTP GET request generated from the above code:

{ url: 'https://connectv3.smrt.wwprojects.com/smrt/api/train_arrival_time_by_id/?station=Commonwealth',
 method: 'GET',
 headers:
 { Connection: 'Keep-Alive',
 'User-Agent': 'SMRT Connect/3.0 Android/7.0',
 'Accept-Encoding': 'gzip',
 'Content-Type': 'text/plain',
 Referer: 'https://connectv3.smrt.wwprojects.com/smrt/',
 Authorization: 'Hawk id=”ww-connectv3-android”,mac=”UJu120qHBk8LOdJP2BXOIQr9jy8MrCOSpHxV3cEqmag=”,hash=”q/t+NNAkQZNlq/aAD6PlexImwQTxwgT2MahfTa9XRLA=”,ts=”1529993914",nonce=”ADBC4BFE5F0B”’ } }

If there is no error, we will get he response feedback in JSON format:

{ results:
 [ { status: 1,
 platform_ID: 'COM_A',
 code: 'EW20',
 next_train_arr: '1',
 mrt: 'Commonwealth',
 subseq_train_arr: '6',
 next_train_destination: 'Pasir Ris',
 subseq_train_destination: 'Pasir Ris' },
 { status: 1,
 platform_ID: 'COM_B',
 code: 'EW20',
 next_train_arr: 'Arr',
 mrt: 'Commonwealth',
 subseq_train_arr: '5',
 next_train_destination: 'Tuas Link',
 subseq_train_destination: 'Joo Koon' } ] }

It is very simple and clean !!. With this you can run the Node app on Raspberry Pi and display the arrival times on mini LCD display 😆

Deploy to Google Cloud

Clone the app on my Git repo and download it to a folder. We will be using Google Cloud service to host and run the app.

Run the following command to deploy to Google Cloud:

gcloud app deploy

Once it success, take note the URL https://XXXXXXXX.appspot.com. We will use this information to setup the webhook in Dialogflow shortly.

More Fun with Dialogflow

Create an free account on Dialogflow (https://dialogflow.com/) and create a new agent. I have created mine: TrainOnDemand.

Intents

We will create and modify the following intents:
About, Default Exit Intent, Default Fallback Intent, Default Welcome Intent, Refresh and SayMRTStation.

About Intent

If user asking “who are you?”, the bot will reply “I am Train On Demand, I can let you know the train arrival timing status. Just let me know the station name for East West Line, North South Line and Circle Line of SMRT stations.”

Default Exit Intent

If user says “good bye”, “bye” or “no”, the bot will reply “Good bye and have a safe journey!” or “Be well and have a pleasant journey!” and will end the conversation.

Default Fallback Intent

If the bot can’t recognize the response from user, for example user is saying unknown MRT station, the bot will reply “I could not find that MRT station. What is the correct MRT station name ?”.

Default Welcome Intent

When user starts the conversation with bot, it will reply “Hi! I am Train On Demand. I can provide you the train arrival status. Which MRT station that you would like to know ?”

Refresh

User says “Refresh” to update the train arrival information.
If there is no response from the backend, the bot will reply “Searching took a little longer than expected, please say it again now.”. This is to avoid the Dialogflow ends the conversation due to timeout (no response from the backend).

SayMRTStation

To check the train arrival time information on the specific MRT station name.

Under Action and parameters, there is a link to the entity: @MRTStation. We will cover it shortly.

Entities

We will create one entity MRTStation that comprises of the list of available MRT stations in Singapore. Just ignore the Platform entity in the screenshot.

MRTStation Entity

You can add and update the MRT station list in this section. Also include the station code, like EW21 for Buona Vista station.

We are done with Intents and Entities.

Test & Deploy

Select Fulfillment and enter the URL in this format and set it to enable.

https://xxxxxxxxxx.appspot.com/hook

Select Integrations and click Integration Settings.

Click Test to test the app and make sure everything is work as expected.

Once you have tested, now you can click Manage Assistant App to deploy to production.

That’s it! Now you can create a new app for Google Assistant. Let me know if you have any questions and until next time!! 👌

Make Google Assistant App to Check Train Arrival Times with Dialogflow was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

The benefit of using the smart glass for warehouse picking operations:

• Hands Free display is everything you need to boost the accuracy and productivity.
• Augmented reality to capture the working environment and provide the relevant information.
• Cheap and flexible compare with the high-end handheld/RF scanner.
• Simple Output Process without impacting (low impact) on the current business process. A business process that does not require an intensive interaction between the user and the application are ideal candidates for a Smart Glass solution.
• No dedicated infrastructure. We just can tap to the existing infrastructure as long as there is WiFi connectivity.
• Easily integrated with ERP (SAP) and WMS (Oracle) back-end.

I would like to walk through how to build a wearable glass android app based on the Vuforia template and we will be using M300 Vuzix SDK and some opensource libraries. I don’t have Vuzix M300 yet, but we will be using Android phone for demo purpose.

Let’s get started!!

Download Vuforia SDK and Sample App

Create a Vuforia account and go to https://developer.vuforia.com/downloads/sdk to download the required SDK. On this post, we will be creating an Android app. Let’s download the SDK for Android.

Extract the SDK on your local folder. For my case is:

Download the sample app, we will be using Video Playback as a base. Go to Download > Samples > Advanced Topics section and download it.

Once you have downloaded, extract the VideoPlayback-7–1–34.zip to your sample folder.

We also need to create a license. Go to https://developer.vuforia.com/targetmanager/licenseManager/summaryForFreePlan to create a license.

Enter the app name: Quickware and click Confirm.

Note down the license key.

Import to Android Studio

Open your Android Studio and select Open an existing Android Studio project.

Now go to app > res > values > strings.xml and update the app_name and app_description. Let’s name it Quickware.

<string name="app_name">Quickware</string>
<string name="app_description">Quickware Wearable Glass</string>

We will remove the Splash and About Screen activity. Open AndroidManifest.xml file and replace with the below content.

We will add Vuforia license key. Open app > src > main > java > com > vuforia > samples > SampleApplication > SampleApplicationSession.

Under setInitParameters, add your Vuforia license key.

Vuforia.setInitParameters(mActivity, mVuforiaFlags, "YOUR_VUFORIA_LICENSE_KEY");

Add this point you can run the demo app and you will see the app running without splash and about screen.

Install the Vuzix M300 SDK

Create an account for Vuzix at https://www.vuzix.com/Developer/Dashboard.

Follow the instruction to install the M300 SDK in Android Studio:

Vuzix | View The Future

Now we need to update the project to use M300 SDK. Follow the below guideline:

Vuzix | View The Future

Even though now we are not using the Vuzix speech recognition SDK (as I don’t have the device yet), we will still add the library and use in the future.

Download Other Libraries

We also need to download the required libraries:

1. ZXing 1D/2D barcode image processing library (https://github.com/zxing/zxing)
   Download core-3.3.3.jar from https://repo1.maven.org/maven2/com/google/zxing/core/3.3.3/
2. Google gson(https://github.com/google/gson)
   Download gson-2.8.1.jar from https://repo1.maven.org/maven2/com/google/code/gson/gson/2.8.1/
3. Ksoap2-android (http://simpligility.github.io/ksoap2-android/index.html)
   Download ksoap2-android-assembly-3.6.2-jar-with-dependencies.jar from https://oss.sonatype.org/content/repositories/ksoap2-android-releases/com/google/code/ksoap2-android/ksoap2-android-assembly/3.6.2/ksoap2-android-assembly-3.6.2-jar-with-dependencies.jar

Copy all jar files to libs folder.

Open the build.gradle on the module app and replace the content with the following.

You can verify the setting under Project Structure > Modules > app as well.

Create the App

Let’s start coding now !!

Open VideoPlayback.java and modify it.

On the OnCreate method, we add the addOverlayView to execute the workflow and create the transparent HTML menu.

Calling the workflow is initiated at:

commandInvocation = new CommandInvocation(getApplicationContext(), webView, this);

Let’s take look at CommandInvocation.java. The workflow is defined in the WorkFlow.json. We will take a look at this file shortly.

Also we define the method to execute the task based on the workflow, for example method displayInputShipmentId().

Workflow

Workflow is the process flow in the program to validate and execute the objects or methods defined in the process flow based on the input command. Workflow is defined in WorkFlow.json under Asset folder.

The workflow consist of list of available Commands and Tasks.

We only can execute the commands that are listed there, for example: scan, next, done, auto, etc.

The entry point of the workflow is the task id start which will execute the targetRef: inputShipmentId. We will talk about this targetRef, commandRef shortly.

Under Task Id: forward, we define the following fields:

• name (mandatory field)
• commandRef (optional field)
  To refer and execute the objects defined in functionRef, validfatorRef or targetRef .
• functionRef (optional field)
  To refer and execute the method defined in this field, for example: method scanShipmentId. We need to create the corresponding method in CommandInvocation.java.

• validatorRef (optional field)
  To validate the input before the targetRef is executed, for example isInputCorrect. This method will always return true or false. We need to create the corresponding method in CommandInvocation.java.

• targetRef (optional field)
  To refer and execute the objects defined in targetRef. We need to create the corresponding method in CommandInvocation.java. The method should be in this format: “display” + targetRef with the first letter is a capital letter. For example: displayInputShipmentId.

The core workflow methods can be found in WorkFlow.java

Calling the Workflow

On the initial menu, the app will execute the workflow to display the menu to enter the Shipment Number.

The above method is calling the JavaScript function LoadInputScreen defined in the app.js. which will generate the HTML5 menu.

There are three commands in this HTML5 menu: Scan to launch the scanner, Next to proceed to the next screen once the scan is done. Cancel to clear the input value and Reset to refresh the box.

Let’s take a look at Scan command.

When the user click the Scan link, the JavaScript runScanFunction() in app.js will be executed and it will call the receiveCommandStringFromJS method in WebViewJavaScriptInterface.java with the input command “scan”. And then it will call the updateView method in CommandInvocation.java which will then trigger the workflow.

//in app.js
function runScanFunction() {
  var command = "scan";
  myJSscriptToNativeCodeHandler.receiveCommandStringFromJS(command);
}

//in WebViewJavaScriptInterface.java
@JavascriptInterface
public void receiveCommandStringFromJS(String commandKeyWord) {
    final String generatedSelectCommand = commandKeyWord;
    new Handler(this.context.getMainLooper()).post(new Runnable() {
        public void run() {
            WebViewJavaScriptInterface.commandInvocation.updateView(generatedSelectCommand);
        }
    });
}

And the workflow is executed in method triggerNextStep in Workflow.java.

If you notice, under this method there is validateScreen method that will execute against the validatorRef value: isInputCorrect.

isInputCorrect method is defined in CommandInvocation.java.

The same flow is apply for all other commands: Next, Cancel and Reset.

All the source codes can be found on my Git repo.

Future Works

I list down the open items for the future works:

• To implement Vuzix Speech Recognition.
• To connect with ERP SAP backend using OData services.
• To enhance the workflow process.

That’s all that we need and I hope it gives you a good glance to start developing the wearable smart glass app.