Provider Interfaces

Interfaces for implementing custom data providers.

Namespace: Lexis

ILocalizationProvider

Main interface for all localization data providers.

public interface ILocalizationProvider
{
    string ProviderId { get; }
    string DisplayName { get; }
    ProviderCapabilities Capabilities { get; }

    UniTask InitializeAsync(ProviderConfig config);
    UniTask<LocaleData> LoadLocaleAsync(string localeCode);
    UniTask<string> GetTranslationAsync(string key, string localeCode);
    UniTask SaveLocaleAsync(string localeCode, LocaleData data);
    UniTask<string[]> GetAvailableLocalesAsync();
}

Properties

Property	Type	Description
ProviderId	string	Unique identifier (e.g., "json", "csv")
DisplayName	string	Human-readable name
Capabilities	ProviderCapabilities	Flags indicating supported operations

Methods

Method	Description
InitializeAsync	Initialize with configuration
LoadLocaleAsync	Load all translations for a locale
GetTranslationAsync	Get single translation (lazy load)
SaveLocaleAsync	Save translations for a locale
GetAvailableLocalesAsync	List available locale codes

ProviderCapabilities

Flags enum indicating what operations a provider supports.

[Flags]
public enum ProviderCapabilities
{
    None = 0,
    Read = 1,           // Can load translations
    Write = 2,          // Can save translations
    LazyLoad = 4,       // Load individual keys on demand
    Watch = 8,          // Detect external file changes
    Offline = 16,       // Works without network
    Sync = 32,          // Supports synchronous operations
    BatchWrite = 64     // Efficient bulk saves
}

ProviderConfig

Configuration data for providers.

public class ProviderConfig
{
    public string ProviderId { get; set; }
    public string ConfigJson { get; set; }
}

LocaleData

Container for loaded translation data.

public class LocaleData
{
    public string LocaleCode { get; set; }
    public Dictionary<string, string> Entries { get; set; }
    public Dictionary<string, LocaleEntryMetadata> Metadata { get; set; }
}

public class LocaleEntryMetadata
{
    public string Comment { get; set; }
    public int MaxLength { get; set; }
    public List<string> Tags { get; set; }
}

IWatchableProvider

Extension interface for providers that can watch for external changes.

public interface IWatchableProvider : ILocalizationProvider
{
    event Action<string> OnLocaleDataChanged;
    void StartWatching();
    void StopWatching();
}

Implementing a Custom Provider

public class MyCustomProvider : ILocalizationProvider
{
    public string ProviderId => "mycustom";
    public string DisplayName => "My Custom Provider";
    public ProviderCapabilities Capabilities =>
        ProviderCapabilities.Read | ProviderCapabilities.Write;

    private string _basePath;

    public async UniTask InitializeAsync(ProviderConfig config)
    {
        var settings = JsonUtility.FromJson<MySettings>(config.ConfigJson);
        _basePath = settings.basePath;
    }

    public async UniTask<LocaleData> LoadLocaleAsync(string localeCode)
    {
        var path = Path.Combine(_basePath, $"{localeCode}.dat");
        var content = await File.ReadAllTextAsync(path);
        return ParseContent(content, localeCode);
    }

    public async UniTask<string> GetTranslationAsync(string key, string localeCode)
    {
        var data = await LoadLocaleAsync(localeCode);
        return data.Entries.GetValueOrDefault(key);
    }

    public async UniTask SaveLocaleAsync(string localeCode, LocaleData data)
    {
        var path = Path.Combine(_basePath, $"{localeCode}.dat");
        var content = SerializeContent(data);
        await File.WriteAllTextAsync(path, content);
    }

    public async UniTask<string[]> GetAvailableLocalesAsync()
    {
        var files = Directory.GetFiles(_basePath, "*.dat");
        return files.Select(f => Path.GetFileNameWithoutExtension(f)).ToArray();
    }

    private LocaleData ParseContent(string content, string localeCode)
    {
        // Parse your custom format
        return new LocaleData { LocaleCode = localeCode, Entries = new() };
    }

    private string SerializeContent(LocaleData data)
    {
        // Serialize to your custom format
        return "";
    }
}

Registering Custom Providers

Custom providers can be registered at runtime:

// Create and configure provider
var customProvider = new MyCustomProvider();
await customProvider.InitializeAsync(new ProviderConfig
{
    ProviderId = "mycustom",
    ConfigJson = "{\"basePath\": \"Assets/Localization\"}"
});

// Use with LocalizationService
var service = new LocalizationService();
service.RegisterProvider(customProvider);

Built-in Providers

Provider	ID	Capabilities
JsonProvider	json	Read, Write, Offline, Sync
CsvProvider	csv	Read, Write, Offline, Sync
POProvider	po	Read, Write, Offline, Sync
GoogleSheetsProvider	googlesheets	Read, Write, Watch, BatchWrite