Sanskrit mode reads every letter with its own vowel, as Sanskrit is read (राम → Rama). Turn it off to read Hindi, Marathi, Bengali, Gujarati, Odia and Punjabi as they are spoken (राम → Ram).
Uncategorized

DSC Signer for Mac: Sign Documents Using Your Indian DSC USB Token Without a Windows Laptop (HyperPKI HYP2003 / ePass2003)

Posted on by Sreekumar Kj / 0 Comment

If you are a company director in India, you probably know this problem.

You are travelling. You have your MacBook with you. You are getting some work done, attending meetings, responding to emails, and generally enjoying the convenience of carrying just one laptop.

And then, out of nowhere, someone sends you a document that needs your Digital Signature Certificate (DSC).

You take out your DSC USB token, plug it into your Mac, open Adobe Acrobat, and realise that you are in trouble.

The token works perfectly fine on Windows. But getting it to work on macOS is an entirely different story.

You might have to find a Windows machine, borrow someone’s laptop, or postpone signing the document until you get back to your office.

For company directors, this is not an entirely hypothetical situation. Board documents, agreements, financial approvals and other business paperwork can come up for signing at rather unpredictable times.

I have run into this inconvenience myself, and decided to do something about it.

Introducing DSC Signer for Mac

I built DSC Signer for Mac, a small macOS application that allows you to sign PDF documents using your Indian DSC USB token, without needing a Windows laptop.

The idea is simple.

You already carry your MacBook. Why should you need another laptop just because your DSC token and its associated software are primarily designed for Windows?

DSC Signer bridges this gap.

It communicates with compatible DSC hardware tokens through their PKCS#11 interface, allowing the signing operation to happen directly on macOS.

No Windows machine. No need to transfer documents to another computer. No unnecessary detours.

Just plug in your DSC token, open the PDF, sign it and get on with your work.

How does it work?

Most hardware-based Digital Signature Certificates use cryptographic USB tokens to securely store the private key.

The signing operation is performed by the hardware token itself. The private key is not supposed to leave the device.

The challenge on macOS is usually the software layer that communicates with these tokens.

Many DSC token vendors provide Windows-oriented middleware and drivers. Even when a compatible macOS PKCS#11 library is available, applications such as Adobe Acrobat can run into compatibility and sandboxing restrictions.

This is where DSC Signer takes a different approach.

Instead of relying on Adobe Acrobat to communicate with the token, the application communicates with the token through its PKCS#11 library and handles the PDF signing workflow itself.

The result is a digitally signed PDF that can be validated using Adobe Acrobat Reader and other compatible PDF viewers.

Features

Here are some of the things I have implemented.

1. Hardware-based digital signing

The application communicates directly with your DSC USB token through its PKCS#11 library.

It has been tested with HyperPKI HYP2003, commonly associated with ePass2003 tokens, using an Indian CCA-chain Class 3 signing certificate.

Other PKCS#11-compatible tokens can also be configured by pointing the application to their vendor-provided macOS library.

2. Acrobat-style visible signatures

I wanted the resulting document to look familiar to anyone who regularly signs PDFs using Adobe Acrobat.

You can visually position the signature on the document by drawing a rectangle on the page.

The signature preview includes the signer’s name in a cursive font over a faint seal, with the signing details alongside it.

You can move and resize the signature box before signing.

You can also provide an optional signing reason and location.

3. Standard PDF digital signatures

The application generates standard PAdES/PKCS#7 digital signatures using SHA-256.

It also supports optional RFC 3161 trusted timestamps.

The resulting document can be opened and validated in Adobe Acrobat Reader and other compatible PDF viewers.

4. Multiple signatures

Need more than one person to sign the same document?

You can sign an already signed PDF again.

Each subsequent signature is added as an incremental PDF update, preserving the earlier signatures.

5. Security and privacy

This is particularly important when dealing with company documents.

I have designed the application around a few straightforward security principles:

  • Your DSC private key never leaves the hardware token.
  • Your token PIN is never stored or logged.
  • The PIN is held in memory only while the signing operation is in progress.
  • The application reads the certificate directly from the token.
  • The document itself is never uploaded to an external service.

If you enable trusted timestamping, the application sends a cryptographic hash of the signature to DigiCert’s timestamping service. It does not send the PDF document.

I believe these are important properties for any application dealing with digital signatures.

How to install DSC Signer on your Mac

Getting started is fairly straightforward.

Step 1: Download the application

Visit the GitHub repository:

DSC Signer for Mac

Download the latest macOS ARM64 DMG package from the Releases section.

Step 2: Install

Open the downloaded DMG file and drag DSC Signer into your Applications folder.

The application currently targets Apple Silicon Macs running macOS 12 or later.

Step 3: Allow the application to run

The current release is not notarised by Apple. On the first launch, macOS may block it.

Open System Settings, navigate to Privacy & Security and select Open Anyway for DSC Signer.

Step 4: Set Up Your DSC USB Token

This is probably the only step that might require a little patience, but don’t worry. DSC Signer makes it quite straightforward.

Unlike an ordinary USB pen drive, a DSC token is a cryptographic device. It needs a small piece of software, called a driver, to communicate with your Mac.

If you have previously used your DSC token on Windows, you might already be familiar with installing token drivers. The same concept applies here, except that we need the macOS version of the driver.

The good news is that you don’t have to hunt for drivers or configure anything manually. DSC Signer guides you through the entire process.

4.1 Plug in your DSC USB token

Connect your DSC token to your Mac.

If your MacBook doesn’t have a USB-A port, you might need a USB-C adapter.

Open DSC Signer. The application will attempt to identify your token and display its make and model.

For example, my Hypersecu HyperPKI HYP2003 token is recognised automatically.

4.2 Let DSC Signer find the driver

The first time you open the application, it presents a dedicated Set up your DSC token window.

It walks you through three steps, displaying a green indicator as each step is completed.

The first step is connecting your token. The second is installing the appropriate driver.

Click Download the driver.

DSC Signer will take you to the manufacturer’s official driver download page whenever it knows the correct location. For other tokens, it searches the web for the appropriate Mac driver.

For my Hypersecu HyperPKI token, it directs you to:

https://hypersecu.com/updates-india

Download the macOS-compatible driver.

An important note: Make sure you download a driver compatible with Apple Silicon Macs (M1, M2, M3, M4 and newer), rather than an older Intel-only version.

4.3 Install the downloaded driver

Once the download finishes, DSC Signer displays an Open the downloaded installer button.

Click it to launch the installer.

Follow the installation wizard. In most cases, this simply involves clicking Continue, accepting the installation and entering your Mac login password when requested.

This is the same password you use to unlock your Mac, not your DSC token PIN.

Once the installation completes, return to DSC Signer.

You don’t need to locate the driver file, copy its path or edit any configuration files. The application automatically detects the newly installed driver.

4.4 Verify that your token works

The final step is to verify that DSC Signer can actually communicate with your token.

The application checks whether it can access the token and read the digital certificate stored inside it.

Once successful, the setup indicator turns green.

That’s it! Your DSC token is ready to use.

What if the token isn’t detected?

Sometimes macOS’s built-in smart card service can get stuck, even when the USB device is physically connected.

DSC Signer includes a Reset token connection option for this situation. It will ask for your Mac password, restart the relevant macOS service and guide you to unplug and reconnect the token.

You don’t need to open Terminal or execute any commands.

A note about other DSC tokens

I have tested DSC Signer with the Hypersecu HyperPKI HYP2003 token.

The application is designed to work with other PKCS#11-compatible DSC tokens as well, provided their manufacturers supply drivers compatible with Apple Silicon Macs.

This includes tokens such as ePass2003, Watchdata ProxKey, mToken, SafeNet eToken and Trust Key. However, these additional models have not all been tested by me.

If your token manufacturer provides a compatible Mac driver, there’s a good chance you can get it working too.

Once the initial setup is complete, you won’t have to repeat these steps every time you sign a document. Just plug in your token and launch DSC Signer.

Step 5: Sign your first PDF

Plug in your DSC token.

Open DSC Signer and select your PDF document.

The application will detect the certificate on your token and display the certificate holder’s name and expiry date.

Draw the signature box where you want the signature to appear.

Click Sign, enter your DSC PIN and save the signed document.

That’s it!

Who would find this useful?

I particularly think this will be useful to:

  • Company directors who regularly need to sign business documents using their DSC.
  • Founders and entrepreneurs who travel frequently.
  • Chartered accountants and finance professionals who work with digitally signed documents.
  • Legal professionals who need to sign PDF agreements.
  • Professionals who prefer macOS but are required to use Indian DSC hardware tokens.

If you are someone who carries a MacBook everywhere but occasionally finds yourself needing a Windows machine just to digitally sign a PDF, this project might save you quite a bit of inconvenience.

Open Source

I have released DSC Signer for Mac under the MIT License.

The source code is available on GitHub, and I welcome contributions, feedback and suggestions.

GitHub repository: https://github.com/technologistkj/dsc-pdf-signer-for-mac

If you use a different DSC token, I would particularly appreciate feedback on compatibility. The application is designed to support other PKCS#11-compatible tokens, but I would like to test it with more hardware and vendor drivers.

Carry your Mac. Keep your DSC token. Sign your documents wherever you are.

Happy signing.

Poetry

Aindram Volume 01, My First Stint at AI Music Production

Posted on by Sreekumar Kj / 0 Comment
Aindram Volume 01 Cover

So, my first stint with AI music production has finally borne fruit, Aindram Volume 01.

Aindram is a collection of five poems I wrote on Indra, the Numero Uno God of the Vedas. I’ve published them in this portal for reference.

For me, this project began as an experiment. What happens when poetry, Vedic thought, music, and modern AI music production come together? I wanted to take verses that originated in my own mind and give them a musical life, not merely as spoken poetry, but as songs with energy, rhythm, emotion, and a distinctly Indic character.

Indra has always fascinated me. In the Vedic vision, he is the mighty wielder of the Vajra, the destroyer of obstacles, the conqueror of forces that stand against the seeker, and a powerful embodiment of strength, courage, vitality, and victory.

That is the Indra I wanted to express through these poems.

Aindram Volume 01 is not an attempt to recreate ancient Vedic hymns. These are new poems, written in our time, inspired by the imagery, spirit, and grandeur of the Vedic Indra.

An interesting part of this process was using AI not only for the music, but also to help polish the lyrics. The poems were refined for poetic meter, rhythm, and their ability to fit naturally within the chosen raagas. This was an iterative process, where the original verses were retained while their structure and phrasing were refined to work as musical compositions.

The music was then created with the help of AI, turning those poems into something I could actually hear and, eventually, share with the world.

This has been a fascinating journey. There is something almost magical about writing a verse, shaping its mood and intent, and then watching AI transform it into a musical composition. At the same time, it has made me think more deeply about what the role of a human creator should be in an age where machines can participate in almost every stage of artistic production.

For me, the answer is becoming clearer. The human provides the thought, the intent, the vision and the soul. AI becomes another instrument in the creative process.

And this is only Volume 01. Find it on Spotify here:

I hope you enjoy listening to Aindram Volume 01 as much as I enjoyed creating it.

Indram vardhantu no giraḥ, may our songs grow Indra’s affluence.

notes/technology

Getting 401 unauthorized on Asterisk Login in spite of correct creds in PJSIP.Conf

Posted on by Sreekumar Kj / 0 Comment

Rest all being good, the issue was the credentials from chan_sip module (sip.conf) were being picked up.

Do these:

asterisk -rx "module show like chan_sip"
asterisk -rx "module unload chan_sip.so"
# persistently disable:
sudo sed -i 's/^load=chan_sip\.so$/noload=chan_sip.so/' /etc/asterisk/modules.conf || echo 'noload=chan_sip.so' | sudo tee -a /etc/asterisk/modules.conf
Code Philosophies

The Universe May Be Running at 10⁴³ FPS — And Planck Already Knew It

Posted on by Sreekumar Kj / 0 Comment

In 1899, Max Planck uncovered something timeless: the smallest unit of time that still has physical meaning.

We now call it Planck time: 

tP​≈5.39×10−44 seconds

It’s unimaginably short — far beyond direct measurement — but incredibly profound.

Because if we treat that as the duration of a single frame of reality, then we’re forced to ask:

Is the universe updating frame by frame?

Reality as a Causal Engine

Let’s follow that thought. If each Planck time is one “tick” of the universal clock, then the frame rate of the universe is: 

FPS=tP​1​≈1.855×1043 frames per second

Yes. Roughly 185 trillion trillion trillion trillion frames per second.

That’s not science fiction. That’s the math baked into physical constants.

And you heard that frame rate here first.

From Time to Space: The Planck Grid

It gets more intriguing when we realize that:

ℓP​=c⋅tP​

That is, Planck time multiplied by the speed of light gives us Planck length, the smallest measurable unit of space.

So we now have:

  • A pixel size: 1.616×10⁻³⁵ meters
  • A frame duration: 5.39×10⁻⁴⁴ seconds
  • A universal constraint: No signal or event can propagate faster than one pixel per frame.

Which is exactly what we mean by the speed of light.

But maybe we’ve been calling it the wrong thing all along.

It’s the Speed of Events

What we call “c” isn’t about photons. It’s a fundamental limit on how fast any event can ripple through the fabric of spacetime.

Like updates in a distributed system, or signals in a finite-element simulation, every interaction can only spread to adjacent nodes — one at a time — per frame.

In this light (no pun intended), the universe appears less like a smooth continuum, and more like a vast, local-update-driven causal mesh.

Planck gave us the constants. The frame rate, pixel size, and speed limit all emerge from them.

All we’re doing now is connecting the dots.

Why This Matters

This framing — no longer poetic but grounded in physical constants — has implications across:

  • Quantum gravity
  • Simulation hypotheses
  • Discrete spacetime models
  • Relativistic causality
  • The intersection of computation and cosmology

It might help explain why spacetime resists division beyond certain limits, why causality holds, and how the “engine” of the cosmos keeps time.

And just maybe, it hints that reality is more digital than continuous.

Next time someone says “the speed of light is the fastest thing in the universe”, you can tell them:

It’s not the speed of light.
It’s the speed of reality itself.

And it’s running at ~10⁴³ frames per second.

Intriguing right?
And yes, you read the FPS here first.

technology

Heard of ScyllaDB? A Glitch Reveals My Data Stack’s Limits – And Our Response to it.

Posted on by Sreekumar Kj / 0 Comment

Deployed systems have a knack for humbling even experienced engineers. You trust your stack—until one morning it silently fails. Last week, during DheeGPT’s development, that exact scenario unfolded and forced us to rethink our infrastructure.

The Day Cassandra Let Us Down

We chose Apache Cassandra to power DheeGPT, our agentic AI engine for Indic languages. It had handled thousands of writes per second in our legacy and production systems — however in the development environment of our newest platform, a routine query returned zero rows:

  • The data was unquestionably in the table.
  • A secondary-index query returned no results.
  • A full table scan confirmed the rows existed—but the index was stale.

No errors. No alerts. Just missing data. Numerous minutes of debugging later, we traced the fault to Cassandra’s secondary index divergence. Invisible failures like this are unacceptable for real-time AI and and automations which are mission critical.

Where Cassandra’s Design Reveals Strain

Cassandra excels as a write-optimized ledger. Yet when you layer on dynamic queries and tight consistency, its limits appear:

  1. Secondary indexes can silently desynchronize.
  2. Rigid schemas force costly refactors if access patterns evolve.
  3. JVM GC pauses inject unpredictable P99 spikes.

As we built DheeGPT, these factors made us question whether Cassandra could sustain our reliability bar.

The Pivot to ScyllaDB During Development

Facing looming deadlines, we swapped in ScyllaDB mid-development. The transition was surprisingly smooth:

  • Zero code changes — Same CQL, same Spring Data drivers.
  • C++ Seastar lock-free, thread-per-core design.
  • Up to 10× throughput on identical hardware.
  • Sub-10 ms P99 latencies, even under traffic surges.

Though ScyllaDB launched in 2016, it still flies under the radar. License concerns and slower early evangelism held it back—yet today it’s a mature, high-performance alternative.

How DheeYantra Leverages Robust Infra

At DheeYantra, we build Dhee.AI Digital Employees that:

  • Power 24×7 customer support in Hindi, Tamil, Bengali, and more
  • Automate document processing and data extraction
  • Orchestrate workflows across enterprise systems in real time

For us, infrastructure reliability isn’t optional—it’s the core of our product promise. With ScyllaDB, we maintain sub-second response times at scale, reduce cluster size (and costs), and shift focus from firefighting infra to advancing AI logic.

Key Takeaways

  1. Revisit your defaults. Even proven tech can hide silent failure modes.
  2. Decouple API from engine. A compatible interface lets you switch back ends with minimal friction.
  3. Benchmark real workloads. Surface tail-latency and consistency issues before they reach prod.
  4. Invest in observability. Detect index divergence proactively, not after customers complain.

What’s Next: Digital Employees Powered by Indic Agentic LLMs

We’re excited to announce that next week we’re rolling out the new DheeGPT platform alongside our first Indic Agentic LLMs. These models will underpin Dhee.AI Digital Employees—reliable, multilingual agents tailored for Indian enterprises.

👉 Keep an eye on DheeYantra’s page for the official launch and demos.

👉 Reach out to explore how Dhee-powered Digital Employees can transform your workflows—whether in support, finance, HR, or field services.

Reliable AI starts with dependable infrastructure—and when it comes to reliability – we don’t “play”.

Mail me your digital employee requirements at Sales at DheeYantra dot Com. Let’s build the future, together.

notes/technology

Activate back lighting of LIVE TECH gaming keyboard on Ubuntu

Posted on by Sreekumar Kj

To enable the back light LEDs of the Live Tech keyboard in Ubuntu follow these steps

sudo apt install brightnessctl
sudo brightnessctl -ls #note the scrolllock input with a suffix greater than 5
sudo brightnessctl --device input16::scrolllock s 1 #Assuming the suffix is 16

This should light up the LEDs in the Keyboard.

Link Keyboard Lighting Script to a Function Key

Want to control your keyboard backlight with a simple function key? Follow ahead.

Step 1: Create the Keyboard Lighting Script

  1. Open Terminal
  2. Create the script: vi ~/lightupKeyboard.sh
  3. Add the following content: pkexec brightnessctl --device input16::scrolllock s 1 >> /tmp/lightupKB.log 2>&1
  4. Save and exit
  5. Make the script executable: chmod +x ~/lightupKeyboard.sh

Step 2: Link to a Function Key

  1. Open Keyboard Shortcuts Settings:
    • On GNOME: Settings > Keyboard > View and Customize Shortcuts
    • On KDE: System Settings > Shortcuts
  2. Create a New Shortcut:
    • Name: Light Up Keyboard
    • Command: bash ~/lightupKeyboard.sh
  3. Assign a Key: Press the desired Function Key (e.g., F6) when prompted.
  4. Save and Close Settings.

Press the assigned function key to turn on your keyboard lighting. You will also see a log entry in /tmp/lightupKB.log for each press.

technology

Network devices not found after Ubuntu upgrade from 20.04 LTS to 22.04 LTS

Posted on by Sreekumar Kj / 0 Comment

I had recently upgraded my laptop from Ubuntu 20.04 from 22.04. Once restarted after the upgrade, my laptop just wouldn’t connect to any network (LAN/Wifi/USB tethering)

I ran this command to see the network devices:

sudo lshw -c network

Which gave a very similar result as this:

*-network UNCLAIMED       
   description: Ethernet controller
   product: RTL8111/8168/8411 PCI Express Gigabit Ethernet Controller
   vendor: Realtek Semiconductor Co., Ltd.
   physical id: 0
   bus info: pci@0000:03:00.0
   version: 03
   width: 64 bits
   clock: 33MHz
   capabilities: pm msi pciexpress msix vpd bus_master cap_list
   configuration: latency=0
   resources: ioport:d800(size=256) memory:f8fff000-f8ffffff memory:f8ff8000-f8ffbfff memory:f9ee0000-f9efffff


 *-network UNCLAIMED
   description: Network controller
   product: RTL8812AE 802.11ac PCIe Wireless Network Adapter
   vendor: Realtek Semiconductor Co., Ltd.
   physical id: 0
   bus info: pci@0000:02:00.0
   version: 01
   width: 64 bits
   clock: 33MHz
   capabilities: pm msi pciexpress bus_master cap_list
   configuration: latency=0
   resources: ioport:c800(size=256) memory:f9dfc000-f9dfffff

Solution

After some research these were the steps which I followed to get the network devices and the network connectivity back

In terminal, run

uname -r
6.5.0-25-generic

Note the output, for me it was “6.5.0-25-generic”

From another computer, download linux-modules-extra-6.5.0-25-generic.deb from here.

Please note that depending on the kernel version you are running (as indicated by the uname output,) your exact .deb file will be different.

Copy the downloaded .deb file into the network-broken laptop using a pen-drive.

Now in the network-broken laptop, cd to the location of the .deb file.

Run

sudo dpkg -i linux-modules-extra-6.5.0-25-generic_6.5.0-25.25~22.04.1_amd64.deb

Restart the laptop.

The network devices and network connectivity was restored.

technology

Fix ChromaDB startup error: Your system has an unsupported version of sqlite3.

Posted on by Sreekumar Kj / 0 Comment

Problem:

After installing chromadb, when we try to start it using the command

 chroma run --host localhost --port 8000 --path /home/user/chromadata

Its give this error:

Traceback (most recent call last):
  File "/home/dheeyantra/.local/bin/chroma", line 5, in <module>
    from chromadb.cli.cli import app
  File "/home/dheeyantra/.local/lib/python3.8/site-packages/chromadb/__init__.py", line 79, in <module>
    raise RuntimeError(
RuntimeError: Your system has an unsupported version of sqlite3. Chroma                     requires sqlite3 >= 3.35.0.
Please visit                     https://docs.trychroma.com/troubleshooting#sqlite to learn how                     to upgrade.

Fix:

pip install pysqlite3-binary
vi ~/.local/lib/python3.8/site-packages/chromadb/__init__.py

#add these lines to the TOP OF THE FILE and save it.
__import__('pysqlite3')
import sys
sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')

Start the chromadb. Should work now.

technology

A QR Code Scanner Component for Cordova in ReactJS that works on Android.

Posted on by Sreekumar Kj / 0 Comment

Yes, a component that does the job well. Code below, customise for your use case.

Note: It does not use the “cordova-plugin-qrscanner” which is broken at the time of writing.

import React, { Component } from "react";
import jsQR from "jsqr";
import $ from "jquery";

class QrCodeScanner extends Component {
  constructor(props) {
    super(props);
    this.videoRef = React.createRef();
    this.state = {
      qrcode: "",
      videoError: false
    }
  }

  componentDidMount() {
    this.checkCameraPermissions();
  }

  componentWillUnmount() {
    this.stopScanner();
  }

  checkCameraPermissions = async () => {
    var thisController = this;

    cordova.plugins.permissions.requestPermission(
      cordova.plugins.permissions.CAMERA,
      function (status) {
        if (status.hasPermission) {
          console.log("Camera permission granted");
          thisController.startScanner();
        } else {
          console.log("Camera permission denied");
          thisController.state.videoError = true;
          thisController.setState(thisController.state);
        }
      },
      function () {
        console.log("Error requesting camera permission");
        thisController.state.videoError = true;
        thisController.setState(thisController.state);
      }
    );
  };

  startScanner = () => {
    navigator.mediaDevices.getUserMedia({ video: { facingMode: "environment" } })
      .then((stream) => {
        this.videoRef.current.srcObject = stream;
        this.videoRef.current.play();
        this.videoRef.current.addEventListener("loadedmetadata", this.scanFrame);
      })
      .catch((error) => {
        console.error("Error starting scanner: ", error);
        this.state.videoError = true;
      });
  };

  stopScanner = () => {
    const stream = this.videoRef.current.srcObject;
    if (stream) {
      const tracks = stream.getTracks();
      tracks.forEach((track) => {
        track.stop();
      });
    }
    document.getElementById("qrScannerPreview").pause();
  };

  scanFrame = () => {
    var thisController = this;
    const canvas = document.createElement("canvas");
    const context = canvas.getContext("2d");
    const video = this.videoRef.current;

    canvas.width = video.videoWidth;
    canvas.height = video.videoHeight;
    context.drawImage(video, 0, 0, canvas.width, canvas.height);
    const imageData = context.getImageData(0, 0, canvas.width, canvas.height);

    const code = jsQR(imageData.data, imageData.width, imageData.height);
    if (code) {
      console.log("QR code detected: ", code.data);
      //Do something with the extracted code.

        return;
      }

    }

    requestAnimationFrame(this.scanFrame);
  };


  render() {

    return (
      <div style={{ height: "90vh", marginTop: "7vh" }} >

        <div id="view-qrscanner" >
          <div>
            <div className="container-qr">
              <div style={{ paddingTop: "1vh" }} >
                <div align="center">
                  <h3 style={{ fontWeight: 'bold', fontSize: "1.28rem", color: 'white' }}>Scan your onboarding QR code</h3>
                  <label style={{ padding: "10vw", fontSize: "0.92rem", color: 'white' }}>Postion the QR Code a few inches away</label>
                </div>
                <div id="camera" className="pre_capture_frame" style={{ width: '95vw' }} />
                {!this.state.videoError && <video style={{ width: "85vw", height: "85vw", margin: '4.5vw', borderRadius: '12px' }}
                  ref={this.videoRef} id="qrScannerPreview" />}
                {this.state.videoError && <div>Could not start the video source.
                  Please ensure that you have granted camera permissions and that 
                  the camera is not being used by another app.</div>}
                <br />
                <div id="tick" align="center" style={{ display: 'none', color: '#94bde9',
                                                     fontSize: '108px', width: '95vw' }}>
                  &#10004;
                </div>
              </div>

            </div>
          </div>
        </div>

      </div>
    );
  }
}

export default QrCodeScanner;