Merge branch 'hotfix/2.0.1'

Daisuke Baba · Daisuke Baba · commit ba8473e5b864 · 2017-12-06T13:45:25.000+09:00
diff --git a/README.md b/README.md
@@ -131,6 +131,9 @@ Set `GENERIC_BLE_TRACE=true` on starting Node-RED and you can find the precise l
 
 # Revision History
 
+* 2.0.1
+  - Fix an issue where `Select from scan result` failed to list characteristics
+
 * 2.0.0
   - Add `Poll Notify Events` message support so that Generic BLE out node can start to subscribe the given characteristic events
   - Support characteristic query by one or more uuids
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-generic-ble",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Node-RED nodes for generic BLE devices",
   "license": "Apache-2.0",
   "repository": {
diff --git a/src/generic-ble.js b/src/generic-ble.js
@@ -80,10 +80,10 @@ function getAddressOrUUID(peripheral) {
   return peripheral.address;
 }
 
-function deleteBleDevice(addressOrUUID) {
+function deleteBleDevice(addressOrUUID, RED) {
   let value = bleDevices.del(addressOrUUID);
   if (value && TRACE) {
-    console.log(`[GenericBLE:TRACE] Delete => ${addressOrUUID}`);
+    RED.log.info(`[GenericBLE:TRACE] Delete => ${addressOrUUID}`);
   }
 }
 
@@ -350,11 +350,11 @@ function characteristicsTask(services, bleDevice) {
   });
 }
 
-function disconnectPeripheral(peripheral, done) {
+function disconnectPeripheral(peripheral, done, RED) {
   if (peripheral.state === 'disconnected' || peripheral.state === 'disconnecting') {
     delete peripheral._lock;
     if (TRACE) {
-      console.log(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect`);
+      RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect`);
     }
     if (done) {
       return done();
@@ -364,7 +364,7 @@ function disconnectPeripheral(peripheral, done) {
   if (peripheral._skipDisconnect) {
     delete peripheral._skipDisconnect;
     if (TRACE) {
-      console.log(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect <LOCKED>`);
+      RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect <LOCKED>`);
     }
     if (done) {
       return done();
@@ -375,7 +375,7 @@ function disconnectPeripheral(peripheral, done) {
   let timeout;
   let onDisconnected = () => {
     if (TRACE) {
-      console.log(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECTED`);
+      RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECTED`);
     }
     if (timeout) {
       deleteTimeout(timeout);
@@ -390,7 +390,7 @@ function disconnectPeripheral(peripheral, done) {
   };
   timeout = addTimeout(() => {
     if (TRACE) {
-      console.log(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECT TIMEOUT`);
+      RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECT TIMEOUT`);
     }
     deleteTimeout(timeout);
     timeout = null;
@@ -407,20 +407,22 @@ function disconnectPeripheral(peripheral, done) {
   delete peripheral._lock;
 }
 
-function connectToPeripheral(peripheral) {
+function connectToPeripheral(peripheral, RED, forceConnect=false) {
   if (peripheral._lock) {
     if (TRACE) {
-      console.log(`<connectToPeripheral> <${peripheral.uuid}> Gave up to connect`);
+      RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Gave up to connect`);
     }
     peripheral._skipDisconnect = true;
     return Promise.reject(`<${peripheral.uuid}> Try again`);
   }
   let bleDevice = configBleDevices[getAddressOrUUID(peripheral)];
-  if (!hasPendingOperations(bleDevice)) {
-    if (TRACE) {
-      console.log(`<connectToPeripheral> <${peripheral.uuid}> Skip to connect as there's nothing to do`);
+  if (!forceConnect) {
+    if (!hasPendingOperations(bleDevice)) {
+      if (TRACE) {
+        RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Skip to connect as there's nothing to do`);
+      }
+      return Promise.resolve();
     }
-    return Promise.resolve();
   }
   return new Promise((resolve, reject) => {
     let timeout;
@@ -439,14 +441,14 @@ function connectToPeripheral(peripheral) {
       deleteTimeout(timeout);
       timeout = null;
       if (TRACE) {
-        console.log(`<connectToPeripheral> <${peripheral.uuid}> discovering all services and characteristics...`);
+        RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovering all services and characteristics...`);
       }
       if (onDiscover) {
         onDiscover(peripheral);
       }
       if (peripheral.services) {
         if (TRACE) {
-          console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
+          RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
         }
         return resolve([peripheral.services, bleDevice]);
       }
@@ -455,7 +457,7 @@ function connectToPeripheral(peripheral) {
           deleteTimeout(discoveryTimeout);
           if (peripheral.services) {
             if (TRACE) {
-              console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
+              RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
             }
             return resolve([peripheral.services, bleDevice]);
           }
@@ -464,11 +466,11 @@ function connectToPeripheral(peripheral) {
         return;
       }
       if (TRACE) {
-        console.log(`<connectToPeripheral> <${peripheral.uuid}> Setting up discoveryTimeout`);
+        RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Setting up discoveryTimeout`);
       }
       let discoveryTimeout = addTimeout(() => {
         if (TRACE) {
-          console.log(`<connectToPeripheral> <${peripheral.uuid}> discoveryTimeout fired`);
+          RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discoveryTimeout fired`);
         }
         if (bleDevice) {
           bleDevice.emit('timeout');
@@ -485,18 +487,18 @@ function connectToPeripheral(peripheral) {
           (err, services) => {
         peripheral._discovering = false;
         if (TRACE) {
-          console.log(`<connectToPeripheral> <${peripheral.uuid}> discoverAllServicesAndCharacteristics OK`);
+          RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discoverAllServicesAndCharacteristics OK`);
         }
         deleteTimeout(discoveryTimeout);
         discoveryTimeout = null;
         if (err) {
           if (TRACE) {
-            console.log(`<connectToPeripheral> <${peripheral.uuid}> err`, err);
+            RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> err`, err);
           }
           return reject(`<${peripheral.uuid}> ${err}\n=>${err.stack}`);
         }
         if (TRACE) {
-          console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 01`);
+          RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 01`);
         }
         return resolve([services, bleDevice]);
       });
@@ -511,11 +513,11 @@ function connectToPeripheral(peripheral) {
       onConnected = null;
       reject(`<${peripheral.uuid}> Connection Timeout`);
       if (TRACE) {
-        console.log(`<connectToPeripheral> <${peripheral.uuid}> Connection Timeout`);
+        RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Connection Timeout`);
       }
     }, BLE_CONNECTION_TIMEOUT_MS);
     if (TRACE) {
-      console.log(`<connectToPeripheral> <${peripheral.uuid}> peripheral.state=>${peripheral.state}`);
+      RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> peripheral.state=>${peripheral.state}`);
     }
     if (peripheral.state === 'connected') {
       return onConnected();
@@ -526,7 +528,7 @@ function connectToPeripheral(peripheral) {
   });
 }
 
-function peripheralTask(uuid, task, done, RED) {
+function peripheralTask(uuid, task, done, RED, forceConnect=false) {
   return (next) => {
     if (TRACE) {
       RED.log.info(`<peripheralTask> <${uuid}> START`);
@@ -560,10 +562,10 @@ function peripheralTask(uuid, task, done, RED) {
           done(err);
         }
         next(err);
-      });
+      }, RED);
     }
 
-    connectToPeripheral(peripheral).then((result) => {
+    connectToPeripheral(peripheral, RED, forceConnect).then((result) => {
       if (!result) {
         return new Promise((resolve) => {
           setTimeout(() => {
@@ -580,11 +582,11 @@ function peripheralTask(uuid, task, done, RED) {
   };
 }
 
-function schedulePeripheralTask(uuid, task, done, RED) {
+function schedulePeripheralTask(uuid, task, done, RED, forceConnect=false) {
   if (!task) {
     return;
   }
-  q.push(peripheralTask(uuid, task, done, RED));
+  q.push(peripheralTask(uuid, task, done, RED, forceConnect));
 }
 
 function addErrorListenerToQueue(RED) {
@@ -627,7 +629,7 @@ function onDiscoverFunc(RED) {
         schedulePeripheralTask(peripheral.uuid, characteristicsTask, null, RED);
       }
     } else {
-      deleteBleDevice(addressOrUUID);
+      deleteBleDevice(addressOrUUID, RED);
     }
   };
 }
@@ -1051,6 +1053,6 @@ export default function(RED) {
           return res.status(500).send({ status: 500, message: (err.message || err) }).end();
         }
       }
-    }, RED);
+    }, RED, true);
   });
 }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "node-red-contrib-generic-ble",`
`3`		`- "version": "2.0.0",`
	`3`	`+ "version": "2.0.1",`
`4`	`4`	`"description": "Node-RED nodes for generic BLE devices",`
`5`	`5`	`"license": "Apache-2.0",`
`6`	`6`	`"repository": {`
Original file line number	Diff line number	Diff line change
`@@ -80,10 +80,10 @@ function getAddressOrUUID(peripheral) {`
`80`	`80`	`return peripheral.address;`
`81`	`81`	`}`
`82`	`82`
`83`		`-function deleteBleDevice(addressOrUUID) {`
	`83`	`+function deleteBleDevice(addressOrUUID, RED) {`
`84`	`84`	`let value = bleDevices.del(addressOrUUID);`
`85`	`85`	`if (value && TRACE) {`
`86`		- console.log(`[GenericBLE:TRACE] Delete => ${addressOrUUID}`);
	`86`	+ RED.log.info(`[GenericBLE:TRACE] Delete => ${addressOrUUID}`);
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`@@ -350,11 +350,11 @@ function characteristicsTask(services, bleDevice) {`
`350`	`350`	`});`
`351`	`351`	`}`
`352`	`352`
`353`		`-function disconnectPeripheral(peripheral, done) {`
	`353`	`+function disconnectPeripheral(peripheral, done, RED) {`
`354`	`354`	`if (peripheral.state === 'disconnected' \|\| peripheral.state === 'disconnecting') {`
`355`	`355`	`delete peripheral._lock;`
`356`	`356`	`if (TRACE) {`
`357`		- console.log(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect`);
	`357`	+ RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect`);
`358`	`358`	`}`
`359`	`359`	`if (done) {`
`360`	`360`	`return done();`
`@@ -364,7 +364,7 @@ function disconnectPeripheral(peripheral, done) {`
`364`	`364`	`if (peripheral._skipDisconnect) {`
`365`	`365`	`delete peripheral._skipDisconnect;`
`366`	`366`	`if (TRACE) {`
`367`		- console.log(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect <LOCKED>`);
	`367`	+ RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> Skipped to disconnect <LOCKED>`);
`368`	`368`	`}`
`369`	`369`	`if (done) {`
`370`	`370`	`return done();`
`@@ -375,7 +375,7 @@ function disconnectPeripheral(peripheral, done) {`
`375`	`375`	`let timeout;`
`376`	`376`	`let onDisconnected = () => {`
`377`	`377`	`if (TRACE) {`
`378`		- console.log(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECTED`);
	`378`	+ RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECTED`);
`379`	`379`	`}`
`380`	`380`	`if (timeout) {`
`381`	`381`	`deleteTimeout(timeout);`
`@@ -390,7 +390,7 @@ function disconnectPeripheral(peripheral, done) {`
`390`	`390`	`};`
`391`	`391`	`timeout = addTimeout(() => {`
`392`	`392`	`if (TRACE) {`
`393`		- console.log(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECT TIMEOUT`);
	`393`	+ RED.log.info(`<disconnectPeripheral> <${peripheral.uuid}> DISCONNECT TIMEOUT`);
`394`	`394`	`}`
`395`	`395`	`deleteTimeout(timeout);`
`396`	`396`	`timeout = null;`
`@@ -407,20 +407,22 @@ function disconnectPeripheral(peripheral, done) {`
`407`	`407`	`delete peripheral._lock;`
`408`	`408`	`}`
`409`	`409`
`410`		`-function connectToPeripheral(peripheral) {`
	`410`	`+function connectToPeripheral(peripheral, RED, forceConnect=false) {`
`411`	`411`	`if (peripheral._lock) {`
`412`	`412`	`if (TRACE) {`
`413`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> Gave up to connect`);
	`413`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Gave up to connect`);
`414`	`414`	`}`
`415`	`415`	`peripheral._skipDisconnect = true;`
`416`	`416`	return Promise.reject(`<${peripheral.uuid}> Try again`);
`417`	`417`	`}`
`418`	`418`	`let bleDevice = configBleDevices[getAddressOrUUID(peripheral)];`
`419`		`- if (!hasPendingOperations(bleDevice)) {`
`420`		`- if (TRACE) {`
`421`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> Skip to connect as there's nothing to do`);
	`419`	`+ if (!forceConnect) {`
	`420`	`+ if (!hasPendingOperations(bleDevice)) {`
	`421`	`+ if (TRACE) {`
	`422`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Skip to connect as there's nothing to do`);
	`423`	`+ }`
	`424`	`+ return Promise.resolve();`
`422`	`425`	`}`
`423`		`- return Promise.resolve();`
`424`	`426`	`}`
`425`	`427`	`return new Promise((resolve, reject) => {`
`426`	`428`	`let timeout;`
`@@ -439,14 +441,14 @@ function connectToPeripheral(peripheral) {`
`439`	`441`	`deleteTimeout(timeout);`
`440`	`442`	`timeout = null;`
`441`	`443`	`if (TRACE) {`
`442`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discovering all services and characteristics...`);
	`444`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovering all services and characteristics...`);
`443`	`445`	`}`
`444`	`446`	`if (onDiscover) {`
`445`	`447`	`onDiscover(peripheral);`
`446`	`448`	`}`
`447`	`449`	`if (peripheral.services) {`
`448`	`450`	`if (TRACE) {`
`449`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
	`451`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
`450`	`452`	`}`
`451`	`453`	`return resolve([peripheral.services, bleDevice]);`
`452`	`454`	`}`
`@@ -455,7 +457,7 @@ function connectToPeripheral(peripheral) {`
`455`	`457`	`deleteTimeout(discoveryTimeout);`
`456`	`458`	`if (peripheral.services) {`
`457`	`459`	`if (TRACE) {`
`458`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
	`460`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 00`);
`459`	`461`	`}`
`460`	`462`	`return resolve([peripheral.services, bleDevice]);`
`461`	`463`	`}`
`@@ -464,11 +466,11 @@ function connectToPeripheral(peripheral) {`
`464`	`466`	`return;`
`465`	`467`	`}`
`466`	`468`	`if (TRACE) {`
`467`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> Setting up discoveryTimeout`);
	`469`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Setting up discoveryTimeout`);
`468`	`470`	`}`
`469`	`471`	`let discoveryTimeout = addTimeout(() => {`
`470`	`472`	`if (TRACE) {`
`471`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discoveryTimeout fired`);
	`473`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discoveryTimeout fired`);
`472`	`474`	`}`
`473`	`475`	`if (bleDevice) {`
`474`	`476`	`bleDevice.emit('timeout');`
`@@ -485,18 +487,18 @@ function connectToPeripheral(peripheral) {`
`485`	`487`	`(err, services) => {`
`486`	`488`	`peripheral._discovering = false;`
`487`	`489`	`if (TRACE) {`
`488`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discoverAllServicesAndCharacteristics OK`);
	`490`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discoverAllServicesAndCharacteristics OK`);
`489`	`491`	`}`
`490`	`492`	`deleteTimeout(discoveryTimeout);`
`491`	`493`	`discoveryTimeout = null;`
`492`	`494`	`if (err) {`
`493`	`495`	`if (TRACE) {`
`494`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> err`, err);
	`496`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> err`, err);
`495`	`497`	`}`
`496`	`498`	return reject(`<${peripheral.uuid}> ${err}\n=>${err.stack}`);
`497`	`499`	`}`
`498`	`500`	`if (TRACE) {`
`499`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> discovered 01`);
	`501`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> discovered 01`);
`500`	`502`	`}`
`501`	`503`	`return resolve([services, bleDevice]);`
`502`	`504`	`});`
`@@ -511,11 +513,11 @@ function connectToPeripheral(peripheral) {`
`511`	`513`	`onConnected = null;`
`512`	`514`	reject(`<${peripheral.uuid}> Connection Timeout`);
`513`	`515`	`if (TRACE) {`
`514`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> Connection Timeout`);
	`516`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> Connection Timeout`);
`515`	`517`	`}`
`516`	`518`	`}, BLE_CONNECTION_TIMEOUT_MS);`
`517`	`519`	`if (TRACE) {`
`518`		- console.log(`<connectToPeripheral> <${peripheral.uuid}> peripheral.state=>${peripheral.state}`);
	`520`	+ RED.log.info(`<connectToPeripheral> <${peripheral.uuid}> peripheral.state=>${peripheral.state}`);
`519`	`521`	`}`
`520`	`522`	`if (peripheral.state === 'connected') {`
`521`	`523`	`return onConnected();`
`@@ -526,7 +528,7 @@ function connectToPeripheral(peripheral) {`
`526`	`528`	`});`
`527`	`529`	`}`
`528`	`530`
`529`		`-function peripheralTask(uuid, task, done, RED) {`
	`531`	`+function peripheralTask(uuid, task, done, RED, forceConnect=false) {`
`530`	`532`	`return (next) => {`
`531`	`533`	`if (TRACE) {`
`532`	`534`	RED.log.info(`<peripheralTask> <${uuid}> START`);
`@@ -560,10 +562,10 @@ function peripheralTask(uuid, task, done, RED) {`
`560`	`562`	`done(err);`
`561`	`563`	`}`
`562`	`564`	`next(err);`
`563`		`- });`
	`565`	`+ }, RED);`
`564`	`566`	`}`
`565`	`567`
`566`		`- connectToPeripheral(peripheral).then((result) => {`
	`568`	`+ connectToPeripheral(peripheral, RED, forceConnect).then((result) => {`
`567`	`569`	`if (!result) {`
`568`	`570`	`return new Promise((resolve) => {`
`569`	`571`	`setTimeout(() => {`
`@@ -580,11 +582,11 @@ function peripheralTask(uuid, task, done, RED) {`
`580`	`582`	`};`
`581`	`583`	`}`
`582`	`584`
`583`		`-function schedulePeripheralTask(uuid, task, done, RED) {`
	`585`	`+function schedulePeripheralTask(uuid, task, done, RED, forceConnect=false) {`
`584`	`586`	`if (!task) {`
`585`	`587`	`return;`
`586`	`588`	`}`
`587`		`- q.push(peripheralTask(uuid, task, done, RED));`
	`589`	`+ q.push(peripheralTask(uuid, task, done, RED, forceConnect));`
`588`	`590`	`}`
`589`	`591`
`590`	`592`	`function addErrorListenerToQueue(RED) {`
`@@ -627,7 +629,7 @@ function onDiscoverFunc(RED) {`
`627`	`629`	`schedulePeripheralTask(peripheral.uuid, characteristicsTask, null, RED);`
`628`	`630`	`}`
`629`	`631`	`} else {`
`630`		`- deleteBleDevice(addressOrUUID);`
	`632`	`+ deleteBleDevice(addressOrUUID, RED);`
`631`	`633`	`}`
`632`	`634`	`};`
`633`	`635`	`}`
`@@ -1051,6 +1053,6 @@ export default function(RED) {`
`1051`	`1053`	`return res.status(500).send({ status: 500, message: (err.message \|\| err) }).end();`
`1052`	`1054`	`}`
`1053`	`1055`	`}`
`1054`		`- }, RED);`
	`1056`	`+ }, RED, true);`
`1055`	`1057`	`});`
`1056`	`1058`	`}`