added on project save callback for web

Author: igorkorsukov

src/app/webapi_export.cpp

@@ -27,6 +27,6 @@
 using namespace mu::webbridge;
 
 extern "C" {
-void onclickTest1(int num) { WebApi::onclickTest1(num); }
-void load(const void* source, unsigned int len) { WebApi::load(source, len); }
+void onclickTest1(int num) { WebApi::instance()->onclickTest1(num); }
+void load(const void* source, unsigned int len) { WebApi::instance()->load(source, len); }
 }

src/appshell_web/view/appmenumodel.cpp

@@ -54,6 +54,7 @@ void AppMenuModel::load()
     AbstractMenuModel::load();
 
     MenuItemList items {
+        makeFileMenu(),
         makeEditMenu(),
         makeViewMenu(),
         makeAddMenu(),
@@ -110,6 +111,15 @@ MenuItem* AppMenuModel::makeMenuItem(const ActionCode& actionCode, MenuItemRole
     return item;
 }
 
+muse::uicomponents::MenuItem* AppMenuModel::makeFileMenu()
+{
+    MenuItemList fileItems {
+        makeMenuItem("file-save")
+    };
+
+    return makeMenu(TranslatableString("appshell/menu/file", "&File"), fileItems, "menu-file");
+}
+
 MenuItem* AppMenuModel::makeEditMenu()
 {
     MenuItemList editItems {

src/appshell_web/view/appmenumodel.h

@@ -67,6 +67,7 @@ class AppMenuModel : public muse::uicomponents::AbstractMenuModel
     using muse::uicomponents::AbstractMenuModel::makeMenuItem;
     muse::uicomponents::MenuItem* makeMenuItem(const muse::actions::ActionCode& actionCode, muse::uicomponents::MenuItemRole role);
 
+    muse::uicomponents::MenuItem* makeFileMenu();
     muse::uicomponents::MenuItem* makeEditMenu();
     muse::uicomponents::MenuItem* makeViewMenu();
     muse::uicomponents::MenuItem* makeAddMenu();

src/framework/stubs/extensions/extensionsproviderstub.cpp

@@ -88,7 +88,7 @@ std::vector<ExecPoint> ExtensionsProviderStub::execPoints(const Uri&) const
 
 Ret ExtensionsProviderStub::performPoint(const ExecPointName&)
 {
-    return muse::make_ret(Ret::Code::NotSupported);
+    return muse::make_ret(Ret::Code::Ok);
 }
 
 void ExtensionsProviderStub::performPointAsync(const ExecPointName&)

src/project/inotationproject.h

@@ -24,8 +24,9 @@
 
 #include <memory>
 
-#include "io/path.h"
-#include "types/ret.h"
+#include "global/io/path.h"
+#include "global/types/ret.h"
+#include "global/async/channel.h"
 
 #include "iprojectaudiosettings.h"
 #include "notation/imasternotation.h"
@@ -69,8 +70,10 @@ class INotationProject
     virtual bool needAutoSave() const = 0;
     virtual void setNeedAutoSave(bool val) = 0;
 
-    virtual muse::Ret save(
-        const muse::io::path_t& path = muse::io::path_t(), SaveMode saveMode = SaveMode::Save, bool createBackup = true) = 0;
+    virtual muse::Ret save(const muse::io::path_t& path = muse::io::path_t(), SaveMode saveMode = SaveMode::Save,
+                           bool createBackup = true) = 0;
+    virtual muse::async::Channel<muse::io::path_t, SaveMode> saveComplited() const = 0;
+
     virtual muse::Ret writeToDevice(QIODevice* device) = 0;
 
     virtual ProjectMeta metaInfo() const = 0;

src/project/internal/notationproject.cpp

@@ -466,13 +466,16 @@ Ret NotationProject::save(const muse::io::path_t& path, SaveMode saveMode, bool
 {
     TRACEFUNC;
 
+    Ret ret;
+    muse::io::path_t savePath = path;
+
     switch (saveMode) {
-    case SaveMode::SaveSelection:
-        return saveSelectionOnScore(path);
+    case SaveMode::SaveSelection: {
+        ret = saveSelectionOnScore(savePath);
+    } break;
     case SaveMode::Save:
     case SaveMode::SaveAs:
     case SaveMode::SaveCopy: {
-        muse::io::path_t savePath = path;
         if (savePath.empty()) {
             IF_ASSERT_FAILED(!m_path.empty()) {
                 return false;
@@ -486,30 +489,40 @@ Ret NotationProject::save(const muse::io::path_t& path, SaveMode saveMode, bool
         // Whether a backup file will be created depends on both the caller's and user's will
         bool shouldCreateBackup = createBackup && configuration()->createBackupBeforeSaving();
 
-        Ret ret = saveScore(savePath, suffix, shouldCreateBackup);
+        ret = saveScore(savePath, suffix, shouldCreateBackup);
         if (ret) {
             if (saveMode != SaveMode::SaveCopy) {
                 markAsSaved(savePath);
             }
         }
-
-        return ret;
-    }
-    case SaveMode::AutoSave:
-        std::string suffix = io::suffix(path);
+    } break;
+    case SaveMode::AutoSave: {
+        std::string suffix = io::suffix(savePath);
         if (suffix == IProjectAutoSaver::AUTOSAVE_SUFFIX) {
-            suffix = io::suffix(io::completeBasename(path));
+            suffix = io::suffix(io::completeBasename(savePath));
         }
 
         if (suffix.empty()) {
             // Then it must be a MSCX folder
             suffix = engraving::MSCX;
         }
 
-        return saveScore(path, suffix, false /*generateBackup*/, false /*createThumbnail*/, true /*isAutosave*/);
+        ret = saveScore(savePath, suffix, false /*generateBackup*/, false /*createThumbnail*/, true /*isAutosave*/);
+    } break;
+    default:
+        ret = muse::make_ret(Ret::Code::UnknownError);
+    }
+
+    if (ret) {
+        m_saved.send(savePath, saveMode);
     }
 
-    return make_ret(notation::Err::UnknownError);
+    return ret;
+}
+
+muse::async::Channel<path_t, SaveMode> NotationProject::saveComplited() const
+{
+    return m_saved;
 }
 
 Ret NotationProject::writeToDevice(QIODevice* device)

src/project/internal/notationproject.h

@@ -96,6 +96,8 @@ class NotationProject : public INotationProject, public muse::Injectable, public
 
     muse::Ret save(
         const muse::io::path_t& path = muse::io::path_t(), SaveMode saveMode = SaveMode::Save, bool createBackup = true) override;
+    muse::async::Channel<muse::io::path_t, SaveMode> saveComplited() const override;
+
     muse::Ret writeToDevice(QIODevice* device) override;
 
     ProjectMeta metaInfo() const override;
@@ -138,6 +140,8 @@ class NotationProject : public INotationProject, public muse::Injectable, public
 
     muse::async::Notification m_needSaveNotification;
 
+    muse::async::Channel<muse::io::path_t, SaveMode> m_saved;
+
     bool m_isNewlyCreated = false; /// true if the file has never been saved yet
     bool m_isImported = false;
     bool m_needAutoSave = false;

src/webbridge/distr/muapi.js

@@ -10,13 +10,20 @@ const MuApi = {
         this.Module.HEAPU8.set(data, ptr);
         this.Module._load(ptr, data.length);
         this.Module._free(ptr);
-    }
-
+    },
 }
 
 let createMuApi = (function(config, onInited) {
 
     MuApi.Module = config.muwasm
+
+    MuApi.Module.onProjectSaved = function(data) {
+        console.log("[js muapi internal] onProjectSaved len: ", data.length)
+        if (config.onProjectSaved) {
+            config.onProjectSaved(data)
+        }
+    }
+
     return MuApi
 })
 

src/webbridge/internal/memfilesystem.cpp

@@ -224,6 +224,5 @@ muse::DateTime MemFileSystem::lastModified(const muse::io::path_t& /*path*/) con
 
 muse::Ret MemFileSystem::isWritable(const muse::io::path_t& /*path*/) const
 {
-    NOT_IMPLEMENTED;
-    return muse::Ret();
+    return muse::make_ok();
 }

src/webbridge/viewer/viewer.html

@@ -155,7 +155,12 @@
         function onInit() {
           console.log("on init mu api")
           window.muapi = createMuApi({
-            muwasm: window.muwasm   
+            muwasm: window.muwasm,
+
+            // callbacks
+            onProjectSaved: function(data) {
+              console.log("[html] onProjectSaved len: ", data.length)
+            }   
           })
         }
 

src/webbridge/webapi.cpp

@@ -21,13 +21,70 @@
  */
 #include "webapi.h"
 
+#ifdef Q_OS_WASM
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+#endif
+
 #include "global/io/file.h"
 
 #include "log.h"
 
 using namespace muse;
 using namespace mu::webbridge;
 
+#ifdef Q_OS_WASM
+static void callJsWithBytes(const char* fnname, const uint8_t* data, size_t size)
+{
+    emscripten::val jsArray = emscripten::val::global("Uint8Array").new_(
+        emscripten::typed_memory_view(size, data)
+        );
+
+    emscripten::val::module_property(fnname)(jsArray);
+}
+
+#else
+static void callJsWithBytes(const char*, const uint8_t*, size_t)
+{
+    NOT_SUPPORTED;
+}
+
+#endif
+
+WebApi* WebApi::instance()
+{
+    static WebApi a;
+    return &a;
+}
+
+void WebApi::init()
+{
+    auto onProjectChanged = [this]() {
+        if (m_currentProject) {
+            m_currentProject->saveComplited().resetOnReceive(this);
+        }
+
+        m_currentProject = globalContext()->currentProject();
+
+        if (m_currentProject) {
+            m_currentProject->saveComplited().onReceive(this, [this](const muse::io::path_t& path, project::SaveMode mode) {
+                onProjectSaved(path, mode);
+            });
+        }
+    };
+
+    globalContext()->currentProjectChanged().onNotify(this, onProjectChanged);
+
+    onProjectChanged();
+}
+
+void WebApi::deinit()
+{
+    if (m_currentProject) {
+        m_currentProject->saveComplited().resetOnReceive(this);
+    }
+}
+
 void WebApi::onclickTest1(int num)
 {
     LOGI() << "num: " << num;
@@ -39,9 +96,29 @@ void WebApi::load(const void* source, unsigned int len)
     LOGI() << source << ", len: " << len;
     ByteArray data = ByteArray::fromRawData(reinterpret_cast<const char*>(source), len);
     io::path_t tempFilePath = "/mu/temp/current.mscz";
+
+    //! NOTE Remove last previous
+    io::File::remove(tempFilePath);
+
+    //! NOTE Write new project
     io::File::writeFile(tempFilePath, data);
 
     dispatcher()->dispatch("file-open", actions::ActionData::make_arg1(QUrl::fromLocalFile(tempFilePath.toQString())));
+}
 
-    io::File::remove(tempFilePath);
+void WebApi::onProjectSaved(const muse::io::path_t& path, mu::project::SaveMode)
+{
+    IF_ASSERT_FAILED(io::File::exists(path)) {
+        LOGE() << "file does not exist, path: " << path;
+        return;
+    }
+
+    ByteArray data;
+    Ret ret  = io::File::readFile(path, data);
+    if (!ret) {
+        LOGE() << "failed read file, path: " << path;
+        return;
+    }
+
+    callJsWithBytes("onProjectSaved", data.constData(), data.size());
 }

src/webbridge/webapi.h

@@ -21,20 +21,36 @@
  */
 #pragma once
 
+#include "global/async/asyncable.h"
+
 #include "global/modularity/ioc.h"
 #include "global/iinteractive.h"
 #include "actions/iactionsdispatcher.h"
+#include "context/iglobalcontext.h"
 
 namespace mu::webbridge {
-class WebApi
+class WebApi : public muse::async::Asyncable
 {
     inline static muse::GlobalInject<muse::IInteractive> interactive;
     inline static muse::GlobalInject<muse::actions::IActionsDispatcher> dispatcher;
+    inline static muse::GlobalInject<mu::context::IGlobalContext> globalContext;
 
 public:
     WebApi() = default;
 
-    static void onclickTest1(int num);
-    static void load(const void* source, unsigned int len);
+    static WebApi* instance();
+
+    void init();
+    void deinit();
+
+    void onclickTest1(int num);
+
+    void load(const void* source, unsigned int len);
+
+private:
+
+    void onProjectSaved(const muse::io::path_t& path, mu::project::SaveMode mode);
+
+    project::INotationProjectPtr m_currentProject;
 };
 }

src/webbridge/webbridgemodule.cpp

@@ -27,6 +27,8 @@
 
 #include "internal/webinteractive.h"
 
+#include "webapi.h"
+
 #include "log.h"
 
 using namespace mu::webbridge;
@@ -52,6 +54,12 @@ void WebBridgeModule::registerExports()
     ioc()->registerExport<muse::IInteractive>(moduleName(), new WebInteractive(originInteractive));
 }
 
-void WebBridgeModule::onStartApp()
+void WebBridgeModule::onInit(const muse::IApplication::RunMode&)
+{
+    WebApi::instance()->init();
+}
+
+void WebBridgeModule::onDeinit()
 {
+    WebApi::instance()->deinit();
 }

src/webbridge/webbridgemodule.h

@@ -30,6 +30,7 @@ class WebBridgeModule : public muse::modularity::IModuleSetup
 
     std::string moduleName() const override;
     void registerExports() override;
-    void onStartApp() override;
+    void onInit(const muse::IApplication::RunMode& mode) override;
+    void onDeinit() override;
 };
 }