Merge pull request #35 from REVrobotics/feature/list-dfu-image-elements

Add method to list DFU element info for an image

Author: LandryNorris

lib/binding.ts

@@ -1,6 +1,11 @@
 import {promisify} from "util";
 import * as path from "path";
 
+export interface DfuImageElement {
+    startAddress: number;
+    size: number;
+}
+
 export interface CanMessage {
     data: number[];
     messageID: number;
@@ -59,7 +64,8 @@ export class CanBridge {
     initializeNotifier: () => void;
     waitForNotifierAlarm: (time:number) => Promise<number>;
     stopNotifier: () => void;
-    writeDfuToBin: (dfuFileName:string, binFileName:string) => Promise<number>;
+    writeDfuToBin: (dfuFileName:string, binFileName:string, elementIndex?: number) => Promise<number>;
+    getImageElements: (dfuFileName: string, imageIndex: number) => DfuImageElement[];
     openHALStreamSession: (messageId: number, messageMask:number, numMessages:number) => number;
     readHALStreamSession: (streamHandle:number, numMessages:number) => CanMessage[];
     closeHALStreamSession: (streamHandle:number) => void;
@@ -87,7 +93,8 @@ export class CanBridge {
             this.initializeNotifier = addon.initializeNotifier;
             this.waitForNotifierAlarm = promisify(addon.waitForNotifierAlarm);
             this.stopNotifier = addon.stopNotifier;
-            this.writeDfuToBin = promisify(addon.writeDfuToBin);
+            this.writeDfuToBin = addon.writeDfuToBin;
+            this.getImageElements = addon.getImageElements;
             this.openHALStreamSession = addon.openHALStreamSession;
             this.readHALStreamSession = addon.readHALStreamSession;
             this.closeHALStreamSession = addon.closeHALStreamSession;

src/DfuSeFile.h

@@ -101,10 +101,15 @@ class DFUImage {
     const char* Name() { return m_prefix.Name; }
     int Size() { return m_prefix.Size; }
     const std::vector<DFUTarget>& Elements() const { return m_targets; }
-    void Write(const std::string filename, writer::detail::FileWriter& writer) const {
+    void Write(const std::string filename, const int elementIndex, writer::detail::FileWriter& writer) const {
         std::ofstream outputFile(filename, std::ofstream::binary);
         auto fw = writer.Clone();
-        fw->Write(outputFile, m_targets[0]);
+
+        if(elementIndex >= m_targets.size()) {
+            throw std::invalid_argument("Element index out of range");
+        }
+
+        fw->Write(outputFile, m_targets[elementIndex]);
         outputFile.close();
     }
 

src/addon.cc

@@ -31,7 +31,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set(Napi::String::New(env, "stopNotifier"),
                 Napi::Function::New(env, stopNotifier));
     exports.Set(Napi::String::New(env, "writeDfuToBin"),
-                Napi::Function::New(env, writeDfuToBin));
+    Napi::Function::New(env, writeDfuToBin));
+    exports.Set(Napi::String::New(env, "getImageElements"),
+                Napi::Function::New(env, getImageElements));
     exports.Set(Napi::String::New(env, "openHALStreamSession"),
                 Napi::Function::New(env, openHALStreamSession));
     exports.Set(Napi::String::New(env, "readHALStreamSession"),

src/canWrapper.cc

@@ -671,19 +671,57 @@ void stopNotifier(const Napi::CallbackInfo& info) {
     HAL_CleanNotifier(m_notifier, &status);
 }
 
-void writeDfuToBin(const Napi::CallbackInfo& info) {
+Napi::Promise writeDfuToBin(const Napi::CallbackInfo& info) {
     std::string dfuFileName = info[0].As<Napi::String>().Utf8Value();
     std::string binFileName = info[1].As<Napi::String>().Utf8Value();
-    Napi::Function cb = info[2].As<Napi::Function>();
+    int elementIndex;
+
+    if(info[2].IsUndefined() || info[2].IsNull()) {
+        elementIndex = 0;
+    } else {
+        elementIndex = info[2].As<Napi::Number>().Int32Value();
+    }
 
     dfuse::DFUFile dfuFile(dfuFileName.c_str());
     int status = 0;
     if (dfuFile && dfuFile.Images().size() > 0 && dfuFile.Images()[0]) {
-        dfuFile.Images()[0].Write(binFileName, dfuse::writer::Bin);
+        dfuFile.Images()[0].Write(binFileName, elementIndex, dfuse::writer::Bin);
     } else {
         status = 1;
     }
-    cb.Call(info.Env().Global(), {info.Env().Null(), Napi::Number::New(info.Env(), status)});
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(info.Env());
+
+    deferred.Resolve(Napi::Number::New(info.Env(), status));
+    return deferred.Promise();
+}
+
+Napi::Array getImageElements(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    std::string dfuFileName = info[0].As<Napi::String>().Utf8Value();
+    const int imageIndex = info[1].As<Napi::Number>().Int32Value();
+
+    Napi::Array elements = Napi::Array::New(env);
+
+    const dfuse::DFUFile dfuFile(dfuFileName.c_str());
+
+    if(imageIndex >= dfuFile.Images().size()) {
+        const std::string errorMessage = "Image index out of range";
+        Napi::Error::New(env, errorMessage).ThrowAsJavaScriptException();
+        return elements;
+    }
+
+    const dfuse::DFUImage image = dfuFile.Images()[imageIndex];
+
+    uint32_t elementsCount = 0;
+    for(auto element: image.Elements()) {
+        Napi::Object elementObject = Napi::Object::New(env);
+        elementObject.Set("startAddress", element.Address());
+        elementObject.Set("size", element.Size());
+
+        elements[elementsCount++] = elementObject;
+    }
+
+    return elements;
 }
 
 void cleanupHeartbeatsRunning() {

src/canWrapper.h

@@ -18,7 +18,8 @@ Napi::Number sendHALMessage(const Napi::CallbackInfo& info);
 void initializeNotifier(const Napi::CallbackInfo& info);
 void waitForNotifierAlarm(const Napi::CallbackInfo& info);
 void stopNotifier(const Napi::CallbackInfo& info);
-void writeDfuToBin(const Napi::CallbackInfo& info);
+Napi::Promise writeDfuToBin(const Napi::CallbackInfo& info);
+Napi::Array getImageElements(const Napi::CallbackInfo& info);
 Napi::Number openHALStreamSession(const Napi::CallbackInfo& info);
 Napi::Array readHALStreamSession(const Napi::CallbackInfo& info);
 void closeHALStreamSession(const Napi::CallbackInfo& info);