feat: improve ui logic and support more email operations

9 files changed, 293 insertions, 16 deletions

diff --git a/src/sdk/GFSDKBasic.cpp b/src/sdk/GFSDKBasic.cpp
index ed734bbe..1c7816d2 100644
--- a/src/sdk/GFSDKBasic.cpp
+++ b/src/sdk/GFSDKBasic.cpp
@@ -32,7 +32,7 @@
 #include "core/function/SecureMemoryAllocator.h"
 #include "core/function/gpg/GpgCommandExecutor.h"
 #include "core/utils/BuildInfoUtils.h"
-#include "sdk/private/CommonUtils.h"
+#include "private/GFSDKPrivat.h"
 #include "ui/UIModuleManager.h"
 
 auto GFAllocateMemory(uint32_t size) -> void* {
diff --git a/src/sdk/GFSDKExtra.cpp b/src/sdk/GFSDKExtra.cpp
index 6a95a8f9..1c755389 100644
--- a/src/sdk/GFSDKExtra.cpp
+++ b/src/sdk/GFSDKExtra.cpp
@@ -31,7 +31,7 @@
 #include <core/utils/BuildInfoUtils.h>
 #include <core/utils/CommonUtils.h>
 
-#include "sdk/private/CommonUtils.h"
+#include "private/GFSDKPrivat.h"
 
 auto GFCompareSoftwareVersion(const char *current_version,
                               const char *latest_version) -> int {
diff --git a/src/sdk/GFSDKGpg.cpp b/src/sdk/GFSDKGpg.cpp
index 88162ffa..ae467b7b 100644
--- a/src/sdk/GFSDKGpg.cpp
+++ b/src/sdk/GFSDKGpg.cpp
@@ -24,4 +24,92 @@
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  *
- */
\ No newline at end of file
+ */
+
+#include "GFSDKGpg.h"
+
+#include "GFSDKBasic.h"
+#include "core/function/gpg/GpgBasicOperator.h"
+#include "core/function/gpg/GpgKeyGetter.h"
+#include "core/function/gpg/GpgKeyImportExporter.h"
+#include "core/model/DataObject.h"
+#include "core/model/GpgSignResult.h"
+#include "core/typedef/GpgTypedef.h"
+
+//
+#include "core/utils/GpgUtils.h"
+#include "private/GFSDKPrivat.h"
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgSignData(int channel, char** key_ids,
+                                                 int key_ids_size, char* data,
+                                                 int sign_mode, int ascii,
+                                                 GFGpgSignResult** ps) -> int {
+  auto singer_ids = CharArrayToQList(key_ids, key_ids_size);
+
+  GpgFrontend::KeyArgsList signer_keys;
+  for (const auto& signer_id : singer_ids) {
+    auto key =
+        GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(signer_id);
+    if (key.IsGood()) signer_keys.push_back(key);
+  }
+
+  if (signer_keys.empty()) return -1;
+
+  auto in_buffer = GpgFrontend::GFBuffer(GFUnStrDup(data).toUtf8());
+
+  auto gpg_sign_mode =
+      sign_mode == 0 ? GPGME_SIG_MODE_NORMAL : GPGME_SIG_MODE_DETACH;
+
+  auto [err, data_object] =
+      GpgFrontend::GpgBasicOperator::GetInstance(channel).SignSync(
+          signer_keys, in_buffer, gpg_sign_mode, ascii != 0);
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) return -1;
+
+  auto result =
+      GpgFrontend::ExtractParams<GpgFrontend::GpgSignResult>(data_object, 0);
+  auto out_buffer =
+      GpgFrontend::ExtractParams<GpgFrontend::GFBuffer>(data_object, 1);
+
+  *ps =
+      static_cast<GFGpgSignResult*>(GFAllocateMemory(sizeof(GFGpgSignResult)));
+  auto* s = *ps;
+  s->signature = GFStrDup(out_buffer.ConvertToQByteArray());
+  s->hash_algo = GFStrDup(result.HashAlgo());
+  return 0;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgPublicKey(int channel, char* key_id,
+                                                  int ascii) -> char* {
+  auto key = GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(
+      GFUnStrDup(key_id));
+
+  if (!key.IsGood()) return nullptr;
+
+  auto [err, buffer] =
+      GpgFrontend::GpgKeyImportExporter::GetInstance(channel).ExportKey(
+          key, false, ascii != 0, true);
+
+  if (GpgFrontend::CheckGpgError(err) != GPG_ERR_NO_ERROR) return nullptr;
+
+  return GFStrDup(buffer.ConvertToQByteArray());
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgKeyPrimaryUID(int channel, char* key_id,
+                                                      GFGpgKeyUID** ps) -> int {
+  auto key = GpgFrontend::GpgKeyGetter::GetInstance(channel).GetKey(
+      GFUnStrDup(key_id));
+
+  if (!key.IsGood()) return -1;
+
+  auto uids = key.GetUIDs();
+  auto& primary_uid = uids->front();
+
+  *ps = static_cast<GFGpgKeyUID*>(GFAllocateMemory(sizeof(GFGpgKeyUID)));
+
+  auto* s = *ps;
+  s->name = GFStrDup(primary_uid.GetName());
+  s->email = GFStrDup(primary_uid.GetEmail());
+  s->comment = GFStrDup(primary_uid.GetComment());
+  return 0;
+}
diff --git a/src/sdk/GFSDKGpg.h b/src/sdk/GFSDKGpg.h
index 1bbf5914..b7b40324 100644
--- a/src/sdk/GFSDKGpg.h
+++ b/src/sdk/GFSDKGpg.h
@@ -28,4 +28,52 @@
 
 #pragma once
 
-extern "C" {}
\ No newline at end of file
+#include "GFSDKExport.h"
+
+extern "C" {
+
+struct GFGpgSignResult {
+  char* signature;
+  char* hash_algo;
+};
+
+struct GFGpgKeyUID {
+  char* name;
+  char* email;
+  char* comment;
+};
+
+/**
+ * @brief
+ *
+ * @param key_id
+ * @param data
+ * @param mode
+ * @return const char*
+ */
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgSignData(int channel, char** key_ids,
+                                                 int key_ids_size, char* data,
+                                                 int sign_mode, int ascii,
+                                                 GFGpgSignResult**) -> int;
+
+/**
+ * @brief
+ *
+ * @param key_id
+ * @param data
+ * @param mode
+ * @return const char*
+ */
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgPublicKey(int channel, char* key_id,
+                                                  int ascii) -> char*;
+
+/**
+ * @brief
+ *
+ * @param channel
+ * @param key_id
+ * @return GpgKeyUID
+ */
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFGpgKeyPrimaryUID(int channel, char* key_id,
+                                                      GFGpgKeyUID**) -> int;
+}
\ No newline at end of file
diff --git a/src/sdk/GFSDKModule.cpp b/src/sdk/GFSDKModule.cpp
index 5435b0a1..e76847d2 100644
--- a/src/sdk/GFSDKModule.cpp
+++ b/src/sdk/GFSDKModule.cpp
@@ -29,9 +29,9 @@
 #include "GFSDKModule.h"
 
 #include <core/module/ModuleManager.h>
-#include <sdk/private/CommonUtils.h>
 
 #include "GFSDKBasic.h"
+#include "private/GFSDKPrivat.h"
 
 void GFModuleListenEvent(const char *module_id, const char *event_id) {
   return GpgFrontend::Module::ModuleManager::GetInstance().ListenEvent(
diff --git a/src/sdk/GFSDKUI.cpp b/src/sdk/GFSDKUI.cpp
index 54716209..cc08705c 100644
--- a/src/sdk/GFSDKUI.cpp
+++ b/src/sdk/GFSDKUI.cpp
@@ -31,9 +31,10 @@
 #include <core/utils/CommonUtils.h>
 
 #include <QMap>
+#include <QObject>
 #include <QString>
 
-#include "sdk/private/CommonUtils.h"
+#include "private/GFSDKPrivat.h"
 #include "ui/UIModuleManager.h"
 
 auto MetaDataArrayToQMap(MetaData** meta_data_array,
@@ -53,7 +54,7 @@ auto MetaDataArrayToQMap(MetaData** meta_data_array,
 }
 
 auto GFUIMountEntry(const char* id, MetaData** meta_data_array,
-                    int meta_data_array_size, EntryFactory factory) -> int {
+                    int meta_data_array_size, QObjectFactory factory) -> int {
   if (id == nullptr || factory == nullptr) return -1;
 
   auto meta_data = MetaDataArrayToQMap(meta_data_array, meta_data_array_size);
@@ -69,3 +70,76 @@ auto GFUIMountEntry(const char* id, MetaData** meta_data_array,
 
   return 0;
 }
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUIMainWindowPtr() -> void* {
+  return GpgFrontend::UI::UIModuleManager::GetInstance().GetQObject(
+      "main_window");
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT
+GFUIShowDialog(void* dialog_raw_ptr, void* parent_raw_ptr) -> bool {
+  if (dialog_raw_ptr == nullptr) {
+    LOG_E() << "dialog raw ptr is nullptr";
+    return false;
+  }
+
+  auto* q_obj = static_cast<QObject*>(dialog_raw_ptr);
+  QPointer<QDialog> dialog = qobject_cast<QDialog*>(q_obj);
+
+  if (dialog == nullptr) {
+    LOG_E() << "convert dialog raw ptr to qdialog failed";
+    return false;
+  }
+
+  QPointer<QWidget> parent = nullptr;
+  if (parent_raw_ptr != nullptr) {
+    auto* qp_obj = static_cast<QObject*>(parent_raw_ptr);
+    parent = qobject_cast<QWidget*>(qp_obj);
+
+    if (parent == nullptr) {
+      LOG_E() << "convert parent raw ptr to qwidget failed";
+      return false;
+    }
+  }
+
+  auto* main_thread = QApplication::instance()->thread();
+
+  LOG_D() << "before entering into main thread, current thread id:"
+          << QThread::currentThreadId()
+          << ", dialog thread: " << dialog->thread()
+          << "main thread: " << main_thread;
+
+  if (dialog->thread() != main_thread) {
+    LOG_E() << "dialog must be created on main thread";
+    return false;
+  }
+
+  QMetaObject::invokeMethod(
+      parent == nullptr ? QPointer<QObject>(QApplication::instance()) : parent,
+      [dialog, parent]() -> int {
+        LOG_D() << "show qdialog, current thread id:"
+                << QThread::currentThreadId();
+        dialog->setParent(parent);
+        dialog->show();
+        return 0;
+      });
+
+  return true;
+}
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUICreateGUIObject(QObjectFactory factory,
+                                                       void* data) -> void* {
+  QEventLoop loop;
+  void* object = nullptr;
+
+  QMetaObject::invokeMethod(QApplication::instance(), [&]() -> int {
+    LOG_D() << "create gui object, current thread id:"
+            << QThread::currentThreadId();
+    object = factory(data);
+    loop.quit();
+    return 0;
+  });
+
+  loop.exec();
+  return object;
+}
diff --git a/src/sdk/GFSDKUI.h b/src/sdk/GFSDKUI.h
index bf4c3721..f9307cee 100644
--- a/src/sdk/GFSDKUI.h
+++ b/src/sdk/GFSDKUI.h
@@ -32,15 +32,24 @@
 
 extern "C" {
 
-using EntryFactory = void* (*)(const char*);
+using QObjectFactory = void* (*)(void*);
 
 struct MetaData {
   const char* key;
   const char* value;
 };
 
-auto GPGFRONTEND_MODULE_SDK_EXPORT GFUIMountEntry(const char* id,
-                                                  MetaData** meta_data_array,
-                                                  int meta_data_array_size,
-                                                  EntryFactory factory) -> int;
+auto GPGFRONTEND_MODULE_SDK_EXPORT
+GFUIMountEntry(const char* id, MetaData** meta_data_array,
+               int meta_data_array_size, QObjectFactory factory) -> int;
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUICreateGUIObject(QObjectFactory factory,
+                                                       void* data) -> void*;
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUIMainWindowPtr() -> void*;
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUIActiveWindowPtr() -> void*;
+
+auto GPGFRONTEND_MODULE_SDK_EXPORT GFUIShowDialog(void* dialog,
+                                                  void* parent) -> bool;
 }
\ No newline at end of file
diff --git a/src/sdk/private/CommonUtils.cpp b/src/sdk/private/GFSDKPrivat.cpp
index 68afcb5f..71136535 100644
--- a/src/sdk/private/CommonUtils.cpp
+++ b/src/sdk/private/GFSDKPrivat.cpp
@@ -26,7 +26,7 @@
  *
  */
 
-#include "CommonUtils.h"
+#include "GFSDKPrivat.h"
 
 #include <core/utils/MemoryUtils.h>
 
@@ -34,6 +34,8 @@
 
 #include "GFSDKModule.h"
 
+Q_LOGGING_CATEGORY(sdk, "sdk")
+
 auto GFStrDup(const QString& str) -> char* {
   auto utf8_str = str.toUtf8();
   auto* c_str = static_cast<char*>(
@@ -58,9 +60,10 @@ auto CharArrayToQMap(char** char_array, int size) -> QMap<QString, QString> {
   QMap<QString, QString> map;
   for (int i = 0; i < size; i += 2) {
     QString const key = GFUnStrDup(char_array[i]);
-    QString const value = QString::fromUtf8(char_array[i + 1]);
+    QString const value = GFUnStrDup(char_array[i + 1]);
     map.insert(key, value);
   }
+
   return map;
 }
 
@@ -100,4 +103,32 @@ auto ConvertEventParamsToMap(GFModuleEventParam* params)
   }
 
   return param_map;
-}
\ No newline at end of file
+}
+
+auto CharArrayToQList(char** char_array, int size) -> QStringList {
+  QStringList list;
+  for (int i = 0; i < size; ++i) {
+    if (char_array[i] != nullptr) {
+      QString value = GFUnStrDup(char_array[i]);
+      list.append(value);
+    }
+  }
+  GpgFrontend::SecureFree(char_array);
+  return list;
+}
+
+auto QListToCharArray(const QStringList& list) -> char** {
+  char** char_array = static_cast<char**>(
+      GpgFrontend::SecureMalloc(list.size() * sizeof(char*)));
+
+  int index = 0;
+  for (const QString& item : list) {
+    QByteArray value = item.toUtf8();
+    char_array[index] =
+        static_cast<char*>(GpgFrontend::SecureMalloc(value.size() + 1));
+    std::strcpy(char_array[index], value.constData());
+    index++;
+  }
+
+  return char_array;
+}
diff --git a/src/sdk/private/CommonUtils.h b/src/sdk/private/GFSDKPrivat.h
index 9539befe..7cfa2c76 100644
--- a/src/sdk/private/CommonUtils.h
+++ b/src/sdk/private/GFSDKPrivat.h
@@ -28,6 +28,15 @@
 
 #pragma once
 
+// declare logging category
+Q_DECLARE_LOGGING_CATEGORY(sdk)
+
+#define LOG_D() qCDebug(sdk)
+#define LOG_I() qCInfo(sdk)
+#define LOG_W() qCWarning(sdk)
+#define LOG_E() qCCritical(sdk)
+#define LOG_F() qCFatal(sdk)
+
 struct GFModuleEventParam;
 
 /**
@@ -77,4 +86,22 @@ auto QMapToCharArray(const QMap<QString, QString> &map, int &size) -> char **;
  * @return QMap<QString, QString>
  */
 auto ConvertEventParamsToMap(GFModuleEventParam *params)
-    -> QMap<QString, QString>;
\ No newline at end of file
+    -> QMap<QString, QString>;
+
+/**
+ * @brief
+ *
+ * @param char_array
+ * @param size
+ * @return QStringList
+ */
+auto CharArrayToQList(char **char_array, int size) -> QStringList;
+
+/**
+ * @brief
+ *
+ * @param list
+ * @param size
+ * @return char**
+ */
+auto QListToCharArray(const QStringList &list) -> char **;
\ No newline at end of file