event callback

Author: UnixY2K

cpp/include/AppCenter.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include <utils.hpp>
+
+namespace Interop {
+namespace AppCenter {
+
+void setTrackEventCallback(void (*callback)(const char *str));
+void setTrackEventCallback(void (*callback)(const char *str, const char *data));
+
+void trackEvent(std::string event);
+void trackEvent(std::string event, Properties properties);
+
+} // namespace AppCenter
+} // namespace Interop

cpp/include/utils.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <string>
+#include <unordered_map>
+
+using Properties = std::unordered_map<std::string, std::string>;
+
+inline std::string toJson(Properties &properties) {
+	std::string json = "{";
+	for (auto &p : properties) {
+		json += "\"" + p.first + "\":\"" + p.second + "\",";
+	}
+	json.pop_back();
+	json += "}";
+	return json;
+}

cpp/meson.build

@@ -3,6 +3,7 @@ myApp_inc = include_directories('include')
 myApp_sources = [
     'src/main.cpp',
     'src/dialogBox.cpp',
+    'src/AppCenter.cpp',
 ]
 myApp_args = []
 myApp_link = []

cpp/src/AppCenter.cpp

@@ -0,0 +1,34 @@
+#include <AppCenter.hpp>
+#include <iostream>
+
+namespace Interop {
+namespace AppCenter {
+void (*trackEventCallback)(const char *str) = nullptr;
+void (*trackEventExtraCallback)(const char *str, const char *data) = nullptr;
+
+void setTrackEventCallback(void (*callback)(const char *str)) {
+	trackEventCallback = callback;
+}
+void setTrackEventCallback(void (*callback)(const char *str,
+                                            const char *data)) {
+	trackEventExtraCallback = callback;
+}
+
+void trackEvent(std::string event) {
+	if (trackEventCallback) {
+		trackEventCallback(event.c_str());
+	} else {
+		std::cerr << "Interop::AppCenter::trackEventCallback is nullptr\n";
+	}
+}
+
+void trackEvent(std::string event, Properties properties) {
+	if (trackEventExtraCallback) {
+		trackEventExtraCallback(event.c_str(), toJson(properties).c_str());
+	} else {
+		std::cerr << "Interop::AppCenter::trackEventExtraCallback is nullptr\n";
+	}
+}
+
+} // namespace AppCenter
+} // namespace Interop

cpp/src/main.cpp

@@ -1,3 +1,4 @@
+#include <AppCenter.hpp>
 #include <dialogBox.hpp>
 #include <iostream>
 
@@ -7,11 +8,26 @@
 // your main code
 int main() {
 	std::cout << "C++ Powered\n";
+	Interop::AppCenter::trackEvent("[Native][Init]", {{"Hello", "from C++"}});
 	showDialogBox("C++ Powered", "Hello from C++!");
 }
 // the entry point of your program
 // you need to export this function
 
 extern "C" {
 myAppAPI void dllEntry() { main(); }
+// this will setup the callbacks needed by the C++ code
+// in order to call the AppCenter.trackEvent() function
+myAppAPI void setupAppCenterCallbacks(
+    void (*trackEventCallback)(const char *str),
+    void (*trackEventExtraCallback)(const char *str, const char *data)) {
+	Interop::AppCenter::setTrackEventCallback(trackEventCallback);
+	Interop::AppCenter::setTrackEventCallback(trackEventExtraCallback);
+}
+
+// on this we call the funtion provided by the parameter
+myAppAPI void dllCallback(void (*callback)()) {
+	std::cout << "Callback from C++\n";
+	callback();
+}
 }

csharp/csharp-cross-platform.csproj

@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <Compile Remove="source\Program.cs" />
+    <Compile Remove="source\interop\AppCenter.cs" />
   </ItemGroup>
 
   <ItemGroup>

csharp/source/Program.cs

@@ -1,7 +1,6 @@
 namespace csharp;
 
-// DllImport
-using System.Runtime.InteropServices;
+using interop;
 
 // Microsoft AppCenter SDK
 using Microsoft.AppCenter;
@@ -22,10 +21,8 @@ static void Main()
         // this is only for demo purposes
         System.Console.WriteLine("App Center Powered.");
         AppCenter.Start("{Your App Secret}", typeof(Analytics), typeof(Crashes));
-        dllEntry();
+        AppCenterCpp.setup();
+        AppCenterCpp.initApp();
     }
-
-    // define the DLL entry point from c++ dll (void dllEntry() from myApp.dll)
-    [DllImport("myApp.dll", EntryPoint = "dllEntry")]
-    public static extern void dllEntry();
+    
 }

csharp/source/interop/AppCenter.cs

@@ -0,0 +1,54 @@
+namespace csharp.interop;
+
+// DllImport
+using System.Runtime.InteropServices;
+
+// Microsoft AppCenter SDK
+using Microsoft.AppCenter.Analytics;
+
+// JSON conversion
+using Newtonsoft.Json;
+
+static class AppCenterCpp
+{
+
+    // setup the required data and callbacks for C++
+    // it is require that the AppCenter SDK is initialized before calling this function
+    public static void setup()
+    {
+        setupAppCenterCallbacks(trackEvent, trackEventFunc);
+    }
+    // initialize the C++ dll entry point
+    // it is required that the setup is called before calling this function
+    public static void initApp()
+    {
+        dllEntry();
+    }
+
+    // the C++ dll entry point
+    [DllImport("myApp.dll", EntryPoint = "dllEntry")]
+    private static extern void dllEntry();
+    [DllImport("myApp.dll")]
+    private static extern void setupAppCenterCallbacks(TrackEventDelegate normal, TrackEventExtraDelegate extra);
+
+    private static void trackEventFunc(string eventName)
+    {
+        Console.WriteLine("trackEventFunc: " + eventName);
+        Analytics.TrackEvent(eventName);
+    }
+    private static void trackEventFunc(string eventName, string properties)
+    {
+        Console.WriteLine("trackEventFunc: " + eventName + " " + properties);
+        // convert the properties string(json) to a dictionary
+        var props = JsonConvert.DeserializeObject<Dictionary<string, string>>(properties);
+        Analytics.TrackEvent(eventName, props);
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void TrackEventDelegate(string eventName);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void TrackEventExtraDelegate(string eventName, string eventProperties);
+    private static TrackEventDelegate trackEvent = trackEventFunc;
+    private static TrackEventExtraDelegate trackEventExtra = trackEventFunc;
+}