Control a Chip Card Reader with Your Browser!

// ==========  usb-provider ===========
var HID = require( "node-hid" );
const EventEmitter = require('events');

class USBProvider extends EventEmitter  {

    constructor( ) {
        super();
        var self = this;
        this.onerror = function(e){ console.log('error: ' +e); };
        this.getDeviceHandle = function() { return deviceHandle; }

	 var SCAN_INTERVAL = 2000;
	 var VENDOR_ID = 0xACD; // default ID TECH vid
	 var deviceHandle = null; // stores our handle
	 var deviceRecord = null; // stores device record
	 var stopKey = null; // to stop polling (if needed)

        // This will be called repeatedly by poll(), below
        function cycle() {

           var deviceFound = false;
           HID.devices().forEach( function (device, index, records ) {

    	      deviceFound = ( device.vendorId == VENDOR_ID );

             if ( device.vendorId == VENDOR_ID && deviceRecord == null ) {
        	  deviceRecord = device;
        	  try {	
        		// Try to connect.
                   deviceHandle = 
                      new HID.HID( device.vendorId, device.productId );
                
                   deviceHandle.on( 'error', self.onerror );
                
		     //self.onconnect( deviceHandle ); // HANDLE CONNECTION EVENT
	           self.emit( 'usbconnect', deviceHandle );

                   console.log( "usbprovider: connect" );
               }
               catch(e) {
                  self.onerror("Exception caught:n" + e);
                  self.emit('usbexception',device);
               }
            } // if

            if ( index == records.length - 1 && !deviceFound ) {

             // HANDLE DISCONNECT EVENT
             if ( deviceRecord != null ) {
                    deviceRecord = deviceHandle = null; // nullify record	
                		 // self.ondisconnect();
		    self.emit( 'usbdisconnect' );
 
                    console.log( "usbprovider: disconnect");
                } // if 

	      }  // if 
    	   }); // forEach
  	 } // cycle
       
        this.poll = function() {
             this.stopKey = setInterval( cycle, SCAN_INTERVAL );
        }      
    }
}


//  ===========  socket-provider  ============
// Dependency: This module uses the socket.io module.
// There is a call to require("socket.io") further below, in the code.
  
/* Usage:
  
   SocketProvider = require('socket-provider');
   var sp = new SocketProvider();
   sp.setPort( 9001 );
   var server = sp.createServer();
   // to send a message from server:
   server.emit( 'message', something );
  
   (clients can now connect on port 9001)
  
   In BROWSER, do:
  
   <script src="/./browserscripts/socket.io.slim.js"></script>
   (Note: Get the socket.io.slim.js script from the socket.io module distro.
   It contains fallback code to make older browsers socket-aware.)
   <script>
   var port = 9001;
   var socket = io.connect('http://localhost:'+port);
   if ( socket )
       socket.on('message',
          (msg)=>{ ...do something with msg... });
   // Or send messages:
   socket.emit( 'echo', something );
  
   </script>
  
   TO CREATE A NODE CLIENT (running headless in Node!):
   socket = require( 'socket.io-client' );
   client = socket( "ws://localhost:9001" );
   client.on <-- handle events
   client.emit( 'message', someObject );
  
*/
  
class SocketProvider {
   
        constructor() {
                 
                var PORT = null;
                 
                this.setPort = function( p ) { PORT = p; };
   
                this.createServer = function( port ) {
   
                        // Create do-nothing http server
                        var server = require('http').createServer();
   
                        // require the socket.io module and attach to server:
                        var io = require('socket.io').listen(server);
                        
                        // on client connection we don't do much
                        io.sockets.on('connection', function (connection) {
                          
                                console.log('A client connected...');
                                connection.emit('message', 'Connected!');                             
                                
                                // Set up disconnect handler
                                connection.on('disconnect',  ()=> { 
					console.log('Client disconnected'); 
					} );
 
                                // broadcast 'echo' messages
                                connection.on('echo', (m)=>{
                                     io.sockets.emit('message',  m);                              
                                });
                        }); // on connection
                   
                        //      OK, now let's listen for socket requests
                        server.listen( port || PORT );
                        return io.sockets; // return instance of socket server
   
                };  // createServer
        } // constructor
}; // class




// ===========  usb-webshim  ============
/* by Kas Thomas. 
   Copyright 2017 by ID TECH.
	
   BY YOUR USE OF THIS CODE, YOU AGREE TO USE IT USE AT YOUR OWN RISK. 

   This shim establishes a USB-to-Websocket bridge.

   The strategy is
	1. Create a Websocket server instance.
	2. Make ourselves a client of the WS server.
	3. Detect USB events.
	4. Re-emit USB events onto our socket.

   In this way, anyone (e.g., a web browser) that chooses to be a
   client of the socket server can receive our USB events.

   NOTE: The server listens for 'echo' events and will
   re-broadcast them as 'message' events. So to broadcast
   something (to everyone), emit an 'echo' event.

*/



var PORT  = 9901;
var wsURL = "ws://localhost:"; 

// Include the required modules (if using modules! which right now, we're not)
// var USBProvider = require('usb-provider');
// var SocketProvider = require('socket-provider');
var connect = require( 'socket.io-client' );

// Get instances of the providers
var usb = new USBProvider();
var sockets = new SocketProvider();

// Set up a socket server
sockets.setPort( PORT );
var ss = sockets.createServer();

// Make ourselves a client of that server
var shim = connect( wsURL + PORT ); 

// A 'message' event with source == 'POS' and
// type of 'start contactless transaction'
// needs to trigger the appropriate VP3300 command.
shim.on( 'message', ( msg )=> {

   if ( msg.source == 'POS' && msg.type == 'start contactless transaction' ) {

       if ( deviceHandle.getDeviceInfo().product.match(/pisces/i) )
          sendDataCommand(START_CONTACTLESS_TX_PISCES , deviceHandle );

       if ( deviceHandle.getDeviceInfo().product.match(/unipay/i) )
          sendDataCommand(START_CONTACTLESS_TX_UNIPAYIII , deviceHandle );

       else if ( deviceHandle.getDeviceInfo().product.match(/BTPay mini/i) )
          sendDataCommand( START_CONTACTLESS_TX_BTPAY_MINI , deviceHandle ); 

       else if (deviceHandle.getDeviceInfo().product.match(/goose/i) )
          sendDataCommand( START_CONTACTLESS_TX_VP4880 , deviceHandle ); 
   }

   // Any 'client' can send a 'raw command' with this message scheme
   if ( msg.source == 'client' && msg.type == 'raw command' )
	sendDataCommand( msg.data, deviceHandle );
});




// ========== USB/Websockets Shim ==========

// Store the USB device handle here:
var deviceHandle = null;

// Function to create a data object out of source, data, type
dataObject = ( source, data, type ) => ({ source:source, data:data, type:type });

var dataCache = [];

var START_CONTACTLESS_TX_UNIPAYIII = "5669564f746563683200024000211e9a031704129c01009f02060000000001009f03060000000000009f21031536314c6c";

var START_CONTACTLESS_TX_PISCES = '5669564f74656368320002200026001e010000009a031704109c01009f02060000000001009f03060000000000009f2103075020e354';

var START_CONTACTLESS_TX_VP4880 = "5669564f746563683200024000211e9a031704079c01009f02060000000001009f03060000000000009f2103095336b001";

var START_CONTACTLESS_TX_BTPAY_MINI = 
"5669564f746563683200024000211e9a031704079c01009f02060000000001009f03060000000000009f2103155324c105";


function formatViVOcommand( cmdString ) {

   // We will handle single-packet commands only, for now
   var cmd = "01" + cmdString;  // Report Type 1
   var array = [];
   cmd.match(/../g).forEach( (b)=> {
      var num = 1 * ('0x' + b );
      array.push( num );
   } );
   return array;
}

function ViVOdevice( dh ) {
   if ( dh.getDeviceInfo().product.match(/goose/i) ||
        dh.getDeviceInfo().product.match(/pisces/i) ||
        dh.getDeviceInfo().product.match(/unipay/i) ||
        dh.getDeviceInfo().product.match(/btpay/i) )
       return true;
   return false;
}

function sendDataCommand( cmdString, deviceHandle ) {

   // Right now, we only handle ViVOtech2 devices
   if ( deviceHandle != null ) {
      var cmdArray = ViVOdevice( deviceHandle ) ? 
		formatViVOcommand( cmdString ) : null;
      deviceHandle.write( cmdArray );
   }
}

function isViVOtech2( data ) {
   return data.indexOf('5669564f746563683200') == 2;
}

function trimViVOdata( data ) {
   var lengthBytes = data.slice(24,28);
   var length = (1*('0x'+lengthBytes));
   return data.slice(0, 28 + 2*length + 4);
}

// On USB connect, cache the device handle
// and set a data handler  
usb.on( 'usbconnect', function( h ) {

    deviceHandle = h; // cache the handle
    deviceHandle.on( 'data', (data)=> {

       var hex = data.toString('hex')
       var dataIN = null;

       // single-packet payload
       if ( isViVOtech2(hex)  && hex.slice(0,2) == '01' )
           dataIN = trimViVOdata( hex.slice(2) );

       // beginning of a multi-packet payload
       else if ( isViVOtech2(hex)  && hex.slice(0,2) == '02' ) {
           dataCache.push( hex.slice(2) );
           return;
       }

       // continuation packet
       else if (  hex.slice(0,2) == '03' )  {
           dataCache.push( hex.slice(2) );
           return;
       }

       // final packet of multi-piece payload
       else if ( hex.slice(0,2) == '04' ) {
           dataCache.push( hex.slice(2) ); // push last packet onto array
           dataIN = dataCache.join('');  // get all the data
           dataIN = trimViVOdata( dataIN ); // trim zeros
           dataCache = [];  // clear the cache
       }

       var msg = dataObject( 'usb',
                             dataIN,
                             'data' );
       shim.emit( 'echo', msg );

    }); // on data
    
    // Re-emit the 'usbconnect' event as a semantically rich
    // 'echo' + dataObject, via the socket server
    var message = dataObject( 'usb', 
				h.getDeviceInfo().product, 
				'connected' );

    shim.emit( 'echo', message ); // send the meaningful message

}); // on usbconnect

// On USB disconnect, nullify the deviceHandle
// and broadcast the event
usb.on( 'usbdisconnect', ()=>{ 
    deviceHandle = null; 
    var message = dataObject( 'usb', 
				null, 
				'disconnected' );
    shim.emit( 'echo', message );
} );

usb.on( 'usbexception', (e)=>{ 

    console.log('n usb exception in shim: ' + e); 
    }
});

usb.poll(); // start polling!