# 🧩 ShiroginSDK Service Architecture (v1.0.0)

**Modular • Service-Oriented • Event-Driven Core Framework**

ShiroginSDK’nin servis çekirdeği, tüm SDK modüllerinin (IAP, Popup, Theme, Analytics, RemoteConfig vb.) **tek merkezden yönetilmesini** sağlayan soyut bir sistemdir.  
Bu sistem, Unity projelerinde **bağımlılık enjeksiyonu**, **servis yaşam döngüsü** ve **event forwarding** gibi prensipleri uygular.

---

## 🧱 Temel Yapı

| Bileşen | Görev |
|----------|--------|
| **IShiroginService** | Her servisin uyması gereken temel sözleşme (interface) |
| **ServiceBase** | Ortak yaşam döngüsü (Initialize / Dispose) davranışını sağlar |
| **ServiceLocator** | Global erişim noktası, tüm servis örneklerini saklar |
| **ShiroginServiceRegistry** | Servislerin otomatik başlatılmasını ve kayıt edilmesini yönetir |
| **IDataService**, **IEventService** vb. | Özelleşmiş interface türleri (örnek: veri yönetimi, event yönetimi) |

---

## ⚙️ Mimarinin Amacı

- 🔁 Servislerin bağımlılıklarını merkezi olarak yönetmek
- 🧩 Servislerin birbiriyle loosely coupled (gevşek bağlı) çalışmasını sağlamak
- 🧠 Modül bazlı mimariyle SDK’nın kolay genişletilmesini mümkün kılmak
- 🧰 Editor araçları, runtime servisler ve sistem olaylarını tek lifecycle üzerinden yürütmek

---

## 🔄 Servis Yaşam Döngüsü

Tüm servisler aşağıdaki sırayla çalışır:

```

SDKInitializer
↓
ShiroginServiceRegistry.InitializeAll()
↓
ServiceLocator.Register<T>()
↓
OnInitialize() çağrısı
↓
EventService aracılığıyla sistem olayları
↓
OnDispose() (Oyun kapanışı veya reset)

````

---

## 🧠 1. IShiroginService

Tüm servislerin temel interface’i.

```csharp
public interface IShiroginService
{
    void Initialize();
    void Dispose();
    bool IsInitialized { get; }
}
````

Amaç: Her servisin başlatma ve temizleme rutinini standartlaştırmak.

---

## 🧩 2. ServiceBase

`MonoBehaviour`’e ihtiyaç duymadan servislerin yaşam döngüsünü yönetir.
Tüm custom servisler bu sınıftan türetilir.

```csharp
public abstract class ServiceBase : IShiroginService
{
    public bool IsInitialized { get; private set; }

    public void Initialize()
    {
        if (IsInitialized) return;
        OnInitialize();
        IsInitialized = true;
    }

    public void Dispose()
    {
        OnDispose();
        IsInitialized = false;
    }

    protected abstract void OnInitialize();
    protected virtual void OnDispose() { }
}
```

> 🔹 Her servis `OnInitialize()` ve `OnDispose()` metodlarını override ederek kendi kurulum/temizlik işlemlerini yapar.
> 🔹 `DontDestroyOnLoad` kullanımı veya `MonoBehaviour` bağımlılığı olmadan çalışır.

---

## 🧭 3. ServiceLocator

Servislerin global erişim noktasını oluşturur.
İçerisinde **tip güvenli bir dictionary** tutar ve `Get<T>()` ile erişim sağlar.

```csharp
var dataService = ServiceLocator.Get<IDataService>();
var eventService = ServiceLocator.Get<IEventService>();
```

Yeni servis kaydı:

```csharp
ServiceLocator.Register<IDataService>(new DataService());
```

> 📌 ServiceLocator, **Singleton yerine Dependency Injection** felsefesine yakındır.
> Servislerin instance yönetimi `ShiroginServiceRegistry` tarafından yapılır.

---

## 🏗️ 4. ShiroginServiceRegistry

Tüm servislerin oluşturulmasından, sırayla başlatılmasından ve kapatılmasından sorumludur.

```csharp
 public static class ShiroginServiceRegistry
    {
        public static void InitializeAll()
        {
            // ------------------------------------------------------------------
            // 🧩 CORE LAYER
            // ------------------------------------------------------------------
            RegisterAndInit<IEventService>(new EventService());           // Events backbone
            RegisterAndInit<IDataService>(new DataService());             // Save/Load system
            RegisterAndInit<ICoroutineRunnerService>(new CoroutineRunnerService()); // Global coroutine executor

            // ------------------------------------------------------------------
            // 🔥 BACKEND LAYER
            // ------------------------------------------------------------------
            RegisterAndInit<IFirebaseService>(new FirebaseService());     // Firebase Analytics + Remote Config
            RegisterAndInit<IRemoteConfigService>(new RemoteConfigService()); // Uses FirebaseService
            RegisterAndInit<IAppsFlyerService>(new AppsFlyerService());   // AppsFlyer analytics SDK
            RegisterAndInit<IFacebookService>(new FacebookService());     // Facebook SDK
            RegisterAndInit<IAnalyticsService>(new AnalyticsService());   // Unified analytics forwarding

            // ------------------------------------------------------------------
            // 💰 ECONOMY & ADS
            // ------------------------------------------------------------------
            RegisterAndInit<IIAPService>(new IAPService());               // In-app purchases
            RegisterAndInit<IAdsService>(new AdsService());               // Rewarded & Interstitial ads

            // ------------------------------------------------------------------
            // 🎨 UI / PRESENTATION LAYER
            // ------------------------------------------------------------------
            RegisterAndInit<IThemeService>(new ThemeService());           // UI themes / skins
            RegisterAndInit<IPopupService>(new PopupService());           // Global popup queue system

            UnityEngine.Debug.Log("[ShiroginSDK] ✅ All services initialized successfully.");
        }

        /// <summary>
        /// Registers and initializes a service with its interface type.
        /// </summary>
        private static void RegisterAndInit<TInterface>(ServiceBase service) where TInterface : class
        {
            // Register by interface type
            ServiceLocator.Register<TInterface>((TInterface)(object)service);
            service.Initialize();
        }

        public static void DisposeAll()
        {
            ServiceLocator.Clear();
            UnityEngine.Debug.Log("[ShiroginSDK] 🧹 All services disposed.");
        }
    }
```

> ✅ Servisler initialize sırasına göre çalışır, dispose’da ters sırayla kapanır.
> 🧩 Yeni servis eklemek yalnızca ` RegisterAndInit<IPopupService>(new MyService());` satırı eklemek kadar kolaydır.

---

## 🧩 5. Yeni Servis Oluşturma

Aşağıda yeni bir servis (örnek: `AudioService`) nasıl ekleneceği gösterilmiştir.

```csharp
using ShiroginSDK.Runtime.Services.Base;
using ShiroginSDK.Runtime.Services.Interfaces;
using UnityEngine;

public class AudioService : ServiceBase, IAudioService
{
    protected override void OnInitialize()
    {
        Debug.Log("[AudioService] Initialized");
        // Audio mixer setup, volume cache, etc.
    }

    protected override void OnDispose()
    {
        Debug.Log("[AudioService] Disposed");
    }

    public void PlaySFX(string clipName)
    {
        // ...
    }
}
```

**Kayıt etmek için:**

```csharp
RegisterAndInit<IEventService>(new AudioService());  
```

Artık global erişim mümkündür:

```csharp
ServiceLocator.Get<IAudioService>().PlaySFX("coin_pickup");
```

---

## ⚙️ 6. Servis Arası Etkileşim

Her servis `ServiceLocator` aracılığıyla diğer servislere erişebilir:

```csharp
protected override void OnInitialize()
{
    var dataService = ServiceLocator.Get<IDataService>();
    var eventService = ServiceLocator.Get<IEventService>();
    eventService.Invoke(new GameStartedEvent());
}
```

> Bu sayede servisler birbirine doğrudan bağımlı değil, **aracılı** çalışır.
> Bu yapı **test edilebilirliği** ve **mock servis** kullanımını kolaylaştırır.

---

## 🧠 7. İleri Konular

### 🔹 CoroutineRunnerService

`MonoBehaviour` bağlamında coroutine çalıştırmak için soyut bir arayüz sunar.
`CoroutineRunner.Start(...)` ile tüm SDK servisleri coroutine başlatabilir.

### 🔹 IDataService

Oyun verilerinin (`BaseData`) yönetimini sağlar: `Get<T>()`, `SaveAll()`, `ToJson()` vb.

### 🔹 IEventService

SDK genelinde event forwarding sağlar.
Tüm servisler event’leri publish/subscribe ile paylaşır.
Örneğin:

```csharp
_eventService.Invoke(new ShiroginEvents.PurchaseCompletedEvent());
```

### 🔹 Extensibility (Genişletilebilirlik)

Yeni servisler yalnızca şu 3 adıma ihtiyaç duyar:

1. `ServiceBase`’ten türet
2. Gerekirse bir `IYourService` interface tanımla
3. `ShiroginServiceRegistry.Register(new YourService())` çağrısı ekle

---

## 🔍 8. Debugging & Logging

Tüm servisler initialization sırasında log üretir.
Hatalar `[ShiroginSDK]` etiketiyle konsola basılır.

Örnek:

```
[PopupService] ✅ Initialized and bound to SDKConfig.
[ThemeService] 🌈 Active theme set to 'Snow'
[IAPService] 💳 Unity Purchasing initialized.
```

---

## ⚡ 9. Performans Notları

* Servisler `DontDestroyOnLoad` veya `MonoBehaviour` objelerine bağlı değildir.
* Tüm bağımlılıklar `ServiceLocator` üzerinden çözülür, böylece yükleme sırası kontrol altındadır.
* Gereksiz singleton oluşturulmaz, yalnızca kullanılan servisler bellekte kalır.

---

## 🧾 10. Özet

| Özellik                    | Açıklama                                      |
| -------------------------- | --------------------------------------------- |
| 🔄 **Lifecycle Yönetimi**  | `ServiceBase` ve `ServiceRegistry` üzerinden  |
| 🧩 **Bağımlılık Yönetimi** | `ServiceLocator` ile type-safe çözüm          |
| 🚀 **Modüler Yapı**        | Her modül bağımsız servis olarak çalışır      |
| 🧱 **Event-Driven**        | `IEventService` ile sistem içi iletişim       |
| ⚙️ **Kolay Genişletme**    | 3 satırda yeni servis ekleme                  |
| 🧠 **Test Edilebilir**     | Mock servislerle bağımsız testler yapılabilir |

---

**Prepared by:** Emir Han MAMAK

**Version:** 1.1.0 (2025.12)

**Module:** ShiroginSDK.Runtime.Services

---

> 📘 İpucu:
> Servis sisteminin amacı “oyun sistemleri arasındaki sınırları netleştirmek”tir.
> Bu yapıyı doğru kullandığında, SDK’nın her yeni modülü — IAP, Popup, RemoteConfig, Theme — sadece **bir servis olarak** eklenir.
> Böylece ShiroginSDK, Unity’nin üstünde kendi mini operating system’ini oluşturur.