Module direct method (#159)

* Module direct method * Resolve comment
2018-09-11 19:23:13 +08:00 · 2018-09-11 19:23:13 +08:00 · 5057219a4b
--- a/package.json
+++ b/package.json
@ -41,6 +41,7 @@
    "onCommand:azure-iot-toolkit.createDevice",
    "onCommand:azure-iot-toolkit.deleteDevice",
    "onCommand:azure-iot-toolkit.invokeDeviceMethod",
+    "onCommand:azure-iot-toolkit.invokeModuleDirectMethod",
    "onCommand:azure-iot-toolkit.getDevice",
    "onCommand:azure-iot-toolkit.getDeviceTwin",
    "onCommand:azure-iot-toolkit.updateDeviceTwin",
@ -120,7 +121,12 @@
      },
      {
        "command": "azure-iot-toolkit.invokeDeviceMethod",
-        "title": "Invoke Direct Method",
+        "title": "Invoke Device Direct Method",
+        "category": "Azure IoT Hub"
+      },
+      {
+        "command": "azure-iot-toolkit.invokeModuleDirectMethod",
+        "title": "Invoke Module Direct Method",
        "category": "Azure IoT Hub"
      },
      {
@ -419,12 +425,23 @@
        },
        {
          "command": "azure-iot-toolkit.getModuleTwin",
-          "when": "view == iotHubDevices && viewItem == edge-module"
+          "when": "view == iotHubDevices && viewItem == edge-module",
+          "group": "azure-iot-toolkit@0"
+        },
+        {
+          "command": "azure-iot-toolkit.invokeModuleDirectMethod",
+          "when": "view == iotHubDevices && viewItem == module",
+          "group": "azure-iot-toolkit@1"
+        },
+        {
+          "command": "azure-iot-toolkit.invokeModuleDirectMethod",
+          "when": "view == iotHubDevices && viewItem == edge-module",
+          "group": "azure-iot-toolkit@1"
        },
        {
          "command": "azure-iot-toolkit.deleteModule",
          "when": "view == iotHubDevices && viewItem == module",
-          "group": "azure-iot-toolkit@1"
+          "group": "azure-iot-toolkit@2"
        }
      ],
      "editor/context": [
@ -469,6 +486,10 @@
        {
          "command": "azure-iot-toolkit.deleteModule",
          "when": "never"
+        },
+        {
+          "command": "azure-iot-toolkit.invokeModuleDirectMethod",
+          "when": "never"
        }
      ]
    },
--- a/src/azureIoTExplorer.ts
+++ b/src/azureIoTExplorer.ts
@ -85,8 +85,12 @@ export class AzureIoTExplorer {
        return this._deviceExplorer.deleteDevice(deviceItem);
    }

-    public invokeDeviceMethod(deviceItem: DeviceItem): void {
-        this._iotHubDirectMethodExplorer.invokeDeviceMethod(deviceItem);
+    public invokeDeviceDirectMethod(deviceItem: DeviceItem): void {
+        this._iotHubDirectMethodExplorer.invokeDeviceDirectMethod(deviceItem);
+    }
+
+    public invokeModuleDirectMethod(moduleItem: ModuleItem): void {
+        this._iotHubDirectMethodExplorer.invokeModuleDirectMethod(moduleItem);
    }

    public getDeviceTwin(deviceItem: DeviceItem): void {
--- a/src/constants.ts
+++ b/src/constants.ts
@ -53,6 +53,7 @@ export class Constants {
    public static IoTHubAIC2DMessageStartEvent = "AZ.C2D.Send.Start";
    public static IoTHubAIC2DMessageDoneEvent = "AZ.C2D.Send.Done";
    public static IoTHubAIInvokeDeviceMethodEvent = "AZ.DeviceMethod.Invoke";
+    public static IoTHubAIInvokeModuleMethodEvent = "AZ.ModuleMethod.Invoke";
    public static IoTHubAIGetDeviceTwinStartEvent = "AZ.DeviceTwin.Get.Start";
    public static IoTHubAIGetDeviceTwinDoneEvent = "AZ.DeviceTwin.Get.Done";
    public static IoTHubAIUpdateDeviceTwinEvent = "AZ.DeviceTwin.Update";
--- a/src/extension.ts
+++ b/src/extension.ts
@ -73,9 +73,13 @@ export function activate(context: vscode.ExtensionContext) {
    });

    let invokeDeviceMethod = vscode.commands.registerCommand("azure-iot-toolkit.invokeDeviceMethod", (DeviceItem) => {
-        azureIoTExplorer.invokeDeviceMethod(DeviceItem);
+        azureIoTExplorer.invokeDeviceDirectMethod(DeviceItem);
    });

+    context.subscriptions.push(vscode.commands.registerCommand("azure-iot-toolkit.invokeModuleDirectMethod", (moduleItem) => {
+        azureIoTExplorer.invokeModuleDirectMethod(moduleItem);
+    }));
+
    let getDeviceTwin = vscode.commands.registerCommand("azure-iot-toolkit.getDeviceTwin", (DeviceItem) => {
        azureIoTExplorer.getDeviceTwin(DeviceItem);
    });
--- a/src/iotHubDirectMethodExplorer.ts
+++ b/src/iotHubDirectMethodExplorer.ts
@ -3,11 +3,13 @@

 "use strict";
 import { Message } from "azure-iot-common";
-import { Client as ServiceClient } from "azure-iothub";
+import { Client as ServiceClient, DeviceMethodParams } from "azure-iothub";
+import { Callback } from "azure-iothub/lib/interfaces";
 import * as vscode from "vscode";
 import { BaseExplorer } from "./baseExplorer";
 import { Constants } from "./constants";
 import { DeviceItem } from "./Model/DeviceItem";
+import { ModuleItem } from "./Model/ModuleItem";
 import { TelemetryClient } from "./telemetryClient";
 import { Utility } from "./utility";

@ -16,7 +18,7 @@ export class IotHubDirectMethodExplorer extends BaseExplorer {
        super(outputChannel);
    }

-    public async invokeDeviceMethod(deviceItem: DeviceItem) {
+    public async invokeDeviceDirectMethod(deviceItem: DeviceItem) {
        let iotHubConnectionString = await Utility.getConnectionString(Constants.IotHubConnectionStringKey, Constants.IotHubConnectionStringTitle);
        if (!iotHubConnectionString) {
            return;
@ -27,34 +29,62 @@ export class IotHubDirectMethodExplorer extends BaseExplorer {
            return;
        }

-        vscode.window.showInputBox({ prompt: `Enter [Method Name] sent to [${deviceItem.deviceId}]` }).then((methodName: string) => {
-            if (methodName !== undefined) {
-                vscode.window.showInputBox({ prompt: `Enter [Payload] sent to [${deviceItem.deviceId}]` }).then((payload: string) => {
-                    let methodParams = {
-                        methodName,
-                        payload,
-                        timeoutInSeconds: 10,
-                        connectTimeoutInSeconds: 10,
-                    };
-                    let serviceClient = ServiceClient.fromConnectionString(iotHubConnectionString);
-                    this._outputChannel.show();
-                    this.outputLine(Constants.IoTHubDirectMethodLabel, `Invokeing Direct Method [${methodName}] to [${deviceItem.deviceId}] ...`);
-                    serviceClient.open((error) => {
-                        if (error) {
-                            this.outputLine(Constants.IoTHubDirectMethodLabel, error.message);
-                        } else {
-                            serviceClient.invokeDeviceMethod(deviceItem.deviceId, methodParams, (err, result) => {
-                                if (err) {
-                                    this.outputLine(Constants.IoTHubDirectMethodLabel, `Failed to invoke Direct Method: ${err.message}`);
-                                } else {
-                                    this.outputLine(Constants.IoTHubDirectMethodLabel, `Response from [${deviceItem.deviceId}]:`);
-                                    this.outputLine(Constants.IoTHubDirectMethodLabel, JSON.stringify(result, null, 2));
-                                }
-                            });
-                        }
-                    });
-                });
+        this.invokeDirectMethod(iotHubConnectionString, deviceItem.deviceId);
+    }
+
+    public async invokeModuleDirectMethod(moduleItem: ModuleItem) {
+        let iotHubConnectionString = await Utility.getConnectionString(Constants.IotHubConnectionStringKey, Constants.IotHubConnectionStringTitle);
+        if (!iotHubConnectionString) {
+            return;
+        }
+
+        TelemetryClient.sendEvent(Constants.IoTHubAIInvokeModuleMethodEvent);
+        this.invokeDirectMethod(iotHubConnectionString, moduleItem.deviceId, moduleItem.moduleId);
+    }
+
+    private invokeDirectMethod(iotHubConnectionString: string, deviceId: string, moduleId?: string) {
+        const target = moduleId ?  `[${deviceId}/${moduleId}]` : `[${deviceId}]`;
+
+        vscode.window.showInputBox({ prompt: `Enter [Method Name] sent to ${target}`, ignoreFocusOut: true }).then((methodName: string) => {
+            if (methodName === undefined) {
+                return;
            }
+            vscode.window.showInputBox({ prompt: `Enter [Payload] sent to ${target}`, ignoreFocusOut: true }).then((payload: string) => {
+                if (payload === undefined) {
+                    return;
+                }
+                const methodParams: DeviceMethodParams = {
+                    methodName,
+                    payload,
+                    responseTimeoutInSeconds: 10,
+                    connectTimeoutInSeconds: 10,
+                };
+                const serviceClient = ServiceClient.fromConnectionString(iotHubConnectionString);
+                this._outputChannel.show();
+                this.outputLine(Constants.IoTHubDirectMethodLabel, `Invoking Direct Method [${methodName}] to ${target} ...`);
+                serviceClient.open((error) => {
+                    if (error) {
+                        this.outputLine(Constants.IoTHubDirectMethodLabel, error.message);
+                    } else {
+                        this.invokeDirectMethodWithServiceClient(serviceClient, deviceId, methodParams, (err, result) => {
+                            if (err) {
+                                this.outputLine(Constants.IoTHubDirectMethodLabel, `Failed to invoke Direct Method: ${err.message}`);
+                            } else {
+                                this.outputLine(Constants.IoTHubDirectMethodLabel, `Response from ${target}:`);
+                                this._outputChannel.appendLine(JSON.stringify(result, null, 2));
+                            }
+                        }, moduleId);
+                    }
+                });
+            });
        });
    }
+
+    private invokeDirectMethodWithServiceClient(serviceClient: ServiceClient, deviceId: string, methodParams: DeviceMethodParams, done?: Callback<any>, moduleId?: string) {
+        if (moduleId) {
+            serviceClient.invokeDeviceMethod(deviceId, moduleId, methodParams, done);
+        } else {
+            serviceClient.invokeDeviceMethod(deviceId, methodParams, done);
+        }
+    }
 }