Refactor services into classes (#183)

TactilityHeadless/Source/service/ServiceRegistry.cpp

@@ -3,7 +3,6 @@
 #include "Mutex.h"
 #include "service/ServiceInstance.h"
 #include "service/ServiceManifest.h"
-#include "TactilityCore.h"
 #include <string>
 #include <unordered_map>
 
@@ -11,8 +10,8 @@ namespace tt::service {
 
 #define TAG "service_registry"
 
-typedef std::unordered_map<std::string, const ServiceManifest*> ManifestMap;
-typedef std::unordered_map<std::string, ServiceInstance*> ServiceInstanceMap;
+typedef std::unordered_map<std::string, std::shared_ptr<const ServiceManifest>> ManifestMap;
+typedef std::unordered_map<std::string, std::shared_ptr<ServiceInstance>> ServiceInstanceMap;
 
 static ManifestMap service_manifest_map;
 static ServiceInstanceMap service_instance_map;
@@ -20,30 +19,41 @@ static ServiceInstanceMap service_instance_map;
 static Mutex manifest_mutex(Mutex::Type::Normal);
 static Mutex instance_mutex(Mutex::Type::Normal);
 
-void addService(const ServiceManifest* manifest) {
-    TT_LOG_I(TAG, "Adding %s", manifest->id.c_str());
+void addService(std::shared_ptr<const ServiceManifest> manifest, bool autoStart) {
+    // We'll move the manifest pointer, but we'll need to id later
+    std::string id = manifest->id;
 
-    manifest_mutex.acquire(TtWaitForever);
-    if (service_manifest_map[manifest->id] == nullptr) {
-        service_manifest_map[manifest->id] = manifest;
+    TT_LOG_I(TAG, "Adding %s", id.c_str());
+
+    manifest_mutex.lock(TtWaitForever);
+    if (service_manifest_map[id] == nullptr) {
+        service_manifest_map[id] = std::move(manifest);
     } else {
-        TT_LOG_E(TAG, "Service id in use: %s", manifest->id.c_str());
+        TT_LOG_E(TAG, "Service id in use: %s", id.c_str());
+    }
+    manifest_mutex.unlock();
+
+    if (autoStart) {
+        startService(id);
     }
-    manifest_mutex.release();
 }
 
-const ServiceManifest* _Nullable findManifestId(const std::string& id) {
+void addService(const ServiceManifest& manifest, bool autoStart) {
+    addService(std::make_shared<const ServiceManifest>(manifest), autoStart);
+}
+
+std::shared_ptr<const ServiceManifest> _Nullable findManifestId(const std::string& id) {
     manifest_mutex.acquire(TtWaitForever);
     auto iterator = service_manifest_map.find(id);
-    _Nullable const ServiceManifest * manifest = iterator != service_manifest_map.end() ? iterator->second : nullptr;
+    auto manifest = iterator != service_manifest_map.end() ? iterator->second : nullptr;
     manifest_mutex.release();
     return manifest;
 }
 
-static ServiceInstance* _Nullable service_registry_find_instance_by_id(const std::string& id) {
+static std::shared_ptr<ServiceInstance> _Nullable findServiceInstanceById(const std::string& id) {
     manifest_mutex.acquire(TtWaitForever);
     auto iterator = service_instance_map.find(id);
-    _Nullable ServiceInstance* service = iterator != service_instance_map.end() ? iterator->second : nullptr;
+    auto service = iterator != service_instance_map.end() ? iterator->second : nullptr;
     manifest_mutex.release();
     return service;
 }
@@ -51,42 +61,53 @@ static ServiceInstance* _Nullable service_registry_find_instance_by_id(const std
 // TODO: Return proper error/status instead of BOOL?
 bool startService(const std::string& id) {
     TT_LOG_I(TAG, "Starting %s", id.c_str());
-    const ServiceManifest* manifest = findManifestId(id);
+    auto manifest = findManifestId(id);
     if (manifest == nullptr) {
         TT_LOG_E(TAG, "manifest not found for service %s", id.c_str());
         return false;
     }
 
-    auto* service = new ServiceInstance(*manifest);
-    manifest->onStart(*service);
+    auto service_instance = std::make_shared<ServiceInstance>(manifest);
 
+    // Register first, so that a service can retrieve itself during onStart()
     instance_mutex.acquire(TtWaitForever);
-    service_instance_map[manifest->id] = service;
+    service_instance_map[manifest->id] = service_instance;
     instance_mutex.release();
+
+    service_instance->getService()->onStart(*service_instance);
+
     TT_LOG_I(TAG, "Started %s", id.c_str());
 
     return true;
 }
 
-_Nullable ServiceContext* findServiceById(const std::string& service_id) {
-    return static_cast<ServiceInstance*>(service_registry_find_instance_by_id(service_id));
+std::shared_ptr<ServiceContext> _Nullable findServiceContextById(const std::string& id) {
+    return findServiceInstanceById(id);
+}
+
+std::shared_ptr<Service> _Nullable findServiceById(const std::string& id) {
+    auto instance = findServiceInstanceById(id);
+    return instance != nullptr ? instance->getService() : nullptr;
 }
 
 bool stopService(const std::string& id) {
     TT_LOG_I(TAG, "Stopping %s", id.c_str());
-    ServiceInstance* service = service_registry_find_instance_by_id(id);
-    if (service == nullptr) {
+    auto service_instance = findServiceInstanceById(id);
+    if (service_instance == nullptr) {
         TT_LOG_W(TAG, "service not running: %s", id.c_str());
         return false;
     }
 
-    service->getManifest().onStop(*service);
-    delete service;
+    service_instance->getService()->onStop(*service_instance);
 
     instance_mutex.acquire(TtWaitForever);
     service_instance_map.erase(id);
     instance_mutex.release();
 
+    if (service_instance.use_count() > 1) {
+        TT_LOG_W(TAG, "Possible memory leak: service %s still has %ld references", service_instance->getManifest().id.c_str(), service_instance.use_count() - 1);
+    }
+
     TT_LOG_I(TAG, "Stopped %s", id.c_str());
 
     return true;