docs: function addCachedScanResults(bundle) {
          debugLFDS('In Add Cached Scan Results');
          
          var defered = q.defer();
          var scannedData = bundle.scannedData;
          var cScannedData;
          if(self.cachedScanBundle) {
              if(self.cachedScanBundle.scannedData) {
                  cScannedData = self.cachedScanBundle.scannedData;
              } else {
                  cScannedData = {};
              }
          } else {
              cScannedData = {};
          }
  
          debugLFDS('Cached Connection Types:');
          printScannedDataConnectionTypes(cScannedData);
          debugPrintFlatScannedData(cScannedData, debugLFDS);
          debugMACT('!!! In addCachedScanResults');
          debugPrintFlatScannedData(cScannedData, debugMACT);
          // console.log('Current Devices', self.cachedCurrentDevices);
          // console.log('Current bundle', bundle.scannedData);
          
  
          var cKeys = Object.keys(cScannedData);
          cKeys.forEach(function(cKey) {
              if(scannedData[cKey]) {
                  debugLFDS('We already have the key', cKey);
                  // If the key exists we need to transfer data about the device
                  // connection types.  The only reason why the key would exist
                  // already is if the device is open due to no scans having been
                  // performed.  
  
                  // The situation that this branch needs to cover is if a currently
                  // connected device is found to have valid Ethernet/WiFi connections.
                  // Due to no scan having been performed, the types WILL show up
                  // as "added by attribute".  If the cached scan had them showing
                  // up as 'scan' then that information should be indicated as such.
                  /* 
                   * Need to update the following keys:
                   * numConnectionTypes (int) ex: 1
                   * connectionTypeNames (String Array) ex: ['Ethernet']
                   * unverifiedConnectionTypes (Object array) [object]
                   * unverifiedConnectionTypeNames (String Array) ex: ['Ethernet']
                   * verifiedConnectionTypeNames: [],
                   * connectionTypes (object array) [object]
                   */
  
                   // On second thought, due to this case being run into due to
                   // the device's handle being open.  Lets ignore it.  The previous
                   // scan data may be invalid and we should only use the latest
                   // scan data.  If a user wants re-freshed data, then they should
                   // perform a new scan.
              } else {
                  debugLFDS('We dont have the key', cKey);
                  // If the key doesn't exist then copy over the data.
                  scannedData[cKey] = cScannedData[cKey];
              }
          });
  
          bundle.scannedData = scannedData;
          // console.log('New bundle', bundle);
          // console.log('Scanned Data', scannedData);
          if(DEBUG_MARKING_ACTIVE_CONNECTION_TYPES) {
              var sDKeys = Object.keys(scannedData);
              var foundActiveConnection = false;
              var activeConnection = {
                  'sn': 0,
                  'ct': {},
              };
  
              sDKeys.forEach(function(key) {
                  var dev = scannedData[key];
                  dev.connectionTypes.forEach(function(ctInfo) {
                      if(ctInfo.isActive) {
                          foundActiveConnection = true;
                          activeConnection.sn = dev.serialNumber;
                          activeConnection.ct = ctInfo;
                      }
                  });
                  // console.log('Device:',dev.serialNumber,'CTs',dev.connectionTypes);
              });
              if(foundActiveConnection) {
                  debugMACT('!!! We found an active CT', activeConnection);
              } else {
                  debugMACT('!!! We did not find an active CT');
              }
          }
          defered.resolve(bundle);
          return defered.promise;
      }