network/http_server_stream/example_client/javascript/src/js/index.js Silicon Labs

/**
 * 
 */
var HttpStreamClient = function() {
   var client = {}
   
   if(!GosWsDataApi) {
      throw new Error('Must include gos_ws_data_api library')
   }
   
   /** -----------------------------
    * Private variables
    */
   
   var ws_api = GosWsDataApi()
   
   client.onConnected = null 
   client.onDisconnected = null
   client.readLedPeriod = 5000
   client.writeLedPeriod = 5000
   client.writeLedTimeout = 5000
   client.readAdcPeriod = 5000
   client.readTimePeriod = 5000
   
   var readLedTimer = null
   var writeLedTimer = null
   var readAdcTimer = null
   var readTimeTimer = null
   var logger = Logger('[CLIENT] ')
   
   
   /** -----------------------------
    * Public methods
    */
   client.start = function(host) {
      ws_api.open(host)
   }
   
   client.stop = function() {
      ws_api.close()
   }
   
   client.isConnected = function() {
      return ws_api.isConnected()
   }
   client.setLogger = function(l) {
      logger.setLogger(l)
      ws_api.setLogger(l)
      ws_api.setMsgpackLogger(l)
   }
   
   
   
   /** -----------------------------
    * Private methods
    */
   
   
   /** -----------------------------
    * Handler called when client connects to device
    */
   ws_api.onConnected = function() {
      logger.info('Connected')
      
      var deviceStreamListingHandler = function(result, data) {
         if(!result) {
            logger.error('Failed to list device streams, err: ' + data)
         } else {
            logger.info('Device has the following streams registered: ' + data)
         }
      }
      ws_api.list(deviceStreamListingHandler)
      if(client.readLedPeriod) {
         logger.info('Starting LED stream reader loop')
         readLedTimer = setTimeout(readLedDeviceStreamHandler, client.readLedPeriod)
      }
      if(client.writeLedPeriod) {
         logger.info('Starting LED stream writer loop')
         writeLedTimer = setTimeout(writeLedDeviceStreamHandler, client.writeLedPeriod)
      }
      if(client.readAdcPeriod) {
         logger.info('Starting ADC stream reader loop')
         readAdcTimer = setTimeout(readAdcDeviceStreamHandler, client.readAdcPeriod)
      }
      if(client.readTimePeriod) {
         logger.info('Starting Time stream reader loop')
         readTimeTimer = setTimeout(readTimeDeviceStreamHandler, client.readTimePeriod)
      }
      if(client.onConnected) {
         client.onConnected()
      }
   }
   
   
   /** -----------------------------
    * Handler called when client disconnect from device
    */
   ws_api.onDisconnected = function() {
      logger.info('Disconnected')
      
      if(readLedTimer) {
         clearTimeout(readLedTimer)
         readLedTimer = null
      }
      if(writeLedTimer) {
         clearTimeout(writeLedTimer)
         writeLedTimer = null
      }
      if(readAdcTimer) {
         clearTimeout(readAdcTimer)
         readAdcTimer = null
      }
      if(readTimeTimer) {
         clearTimeout(readTimeTimer)
         readTimeTimer = null
      }
      
      if(client.onDisconnected) {
         client.onDisconnected()
      }
   }
   
   
   var getTimestamp = function() {
      var dt = new Date()
      return dt.toUTCString()
   }
   
   /*******************************************************************************************
    * The following are stream handlers the device reads/writes  from/to the client
    *  e.g.:  
    *  device -> client
    */
   
   
   /** -----------------------------
    * This is called when the device read the 'sysinfo' client stream.
    * See: websocket_periodic_read_sysinfo_stream_handler() in the example app.
    */
   var sysInfoClientStreamHandler = function(stream, action, data) {
      logger.info('[Device->Client] Reading stream: sysinfo')
      
     
      var response = {
         timestamp: getTimestamp(),
         platform: navigator.appName,
         os: navigator.platform
      }
      
      return response
   }
   /** -----------------------------
    * This is called when the device writes the 'version' client stream.
    *  See: websocket_periodic_write_version_stream_handler() in the example app.
    */
   var versionClientStreamHandler = function(stream, action, data) {
      logger.info('[Device->Client] Writing stream: ' + stream + ', data: ' + JSON.stringify(data))
   }
   
   
   
   /*******************************************************************************************
    * The following are periodically invoked by this client to read/write device streams.
    * e.g.:  
    * client -> device
    */
   
   
   
   /** -----------------------------
    * This is call periodically when the client reads the device's 'led' stream.
    *  See: led_stream_handler() in the example app
    */
   var readLedDeviceStreamHandler = function() {
      logger.debug('[Client->Device] Reading stream: led')
      
      var responseHandler = function(result, data) {
         if(!result) {
            logger.error('[Client->Device] Failed to read led stream, err:' + data.message)
         } else {
            logger.info('[Client->Device] Read stream: led, data:' + JSON.stringify(data))
         }
         
         if(ws_api.isConnected() && client.readLedPeriod) {
            readLedTimer = setTimeout(readLedDeviceStreamHandler, client.readLedPeriod)
         }
      }
      
      ws_api.read('led', responseHandler)
      
   }
   
   /** -----------------------------
    * This is call periodically when the client writes the device's 'led' stream.
    *  See: led_stream_handler() in the example app
    */
   var writeLedDeviceStreamHandler = function() {
      logger.debug('[Client->Device] Writing stream: led')
      
      var request = {
         timestamp: getTimestamp(),
         value: 'toggle'
      }
      
      var responseHandler = function(result, data) {
         if(!result) {
            logger.error('[Client->Device] Failed to write led stream, err:' + data.message)
         } else {
            logger.info('[Client->Device] Successfully wrote led stream')
         }
         
         if(ws_api.isConnected() && client.writeLedPeriod) {
            writeLedTimer = setTimeout(writeLedDeviceStreamHandler, client.writeLedPeriod)
         }
      }
      
      ws_api.write('led', request, responseHandler, client.writeLedTimeout)
      
   }
   
   
   /** -----------------------------
    * This is call periodically when the client reads the device's 'adc' stream.
    * See: adc_stream_handler() in the example app
    */
   var readAdcDeviceStreamHandler = function() {
      logger.debug('[Client->Device] Reading stream: adc')
      
      var responseHandler = function(result, data) {
         if(!result) {
            logger.error('[Client->Device] Failed to read adc stream, err:' + data.messsage)
         } else {
            logger.info('[Client->Device] Read stream: adc, data:' + JSON.stringify(data))
         }
         
         if(ws_api.isConnected() && client.readAdcPeriod) {
            readAdcTimer = setTimeout(readAdcDeviceStreamHandler, client.readAdcPeriod)
         }
      }
      
      ws_api.read('adc', responseHandler)
   }
   
   
   /** -----------------------------
    * This is call periodically when the client reads the device's 'time' stream.
    *See: time_stream_handler() in the example app
    */
   var readTimeDeviceStreamHandler = function() {
      logger.debug('[Client->Device] Reading stream: time')
      
      var responseHandler = function(result, data) {
         if(!result) {
            logger.error('[Client->Device] Failed to read time stream, err:' + data.messsage)
         } else {
            logger.info('[Client->Device] Read stream: time, data:' + JSON.stringify(data))
         }
         
         if(ws_api.isConnected() && client.readTimePeriod) {
            readTimeTimer = setTimeout(readTimeDeviceStreamHandler, client.readTimePeriod)
         }
      }
      
      ws_api.read('time', responseHandler)
   }
   
   ws_api.setLogger(console)
   ws_api.setMsgpackLogger(console)
   
   logger.info('Registering stream handlers ...')
   ws_api.register('sysinfo', sysInfoClientStreamHandler)
   ws_api.register('version', versionClientStreamHandler)
   return client
};