package services
|
|
import (
|
"fmt"
|
"sync"
|
"voicesnap/internal/config"
|
"voicesnap/internal/engine"
|
"voicesnap/internal/language"
|
"voicesnap/internal/model"
|
"voicesnap/internal/modelselection"
|
"voicesnap/internal/paths"
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
)
|
|
// EngineService provides engine status and model management to the frontend.
|
type EngineService struct {
|
app *application.App
|
initCallback func()
|
mu sync.RWMutex
|
status string
|
hardwareInfo string
|
lastError string
|
}
|
|
func NewEngineService() *EngineService {
|
return &EngineService{status: "loading"}
|
}
|
|
// ModelExists returns true if the ASR model files are present.
|
func (s *EngineService) ModelExists() bool {
|
return engine.ModelExists()
|
}
|
|
func (s *EngineService) GetStatus() map[string]interface{} {
|
s.mu.RLock()
|
defer s.mu.RUnlock()
|
return map[string]interface{}{
|
"status": s.status,
|
"hardwareInfo": s.hardwareInfo,
|
"error": s.lastError,
|
}
|
}
|
|
func (s *EngineService) GetCurrentModelStatus() map[string]interface{} {
|
current := s.currentModel()
|
resolved, err := model.ResolveModel(current.ModelID)
|
installed := err == nil && resolved.IsUsable()
|
status := model.ModelNotInstalled
|
var missing []string
|
var problems []string
|
if err == nil {
|
status = resolved.Status
|
missing = resolved.Missing
|
problems = resolved.Problems
|
}
|
|
return map[string]interface{}{
|
"modelID": current.ModelID,
|
"displayName": current.Profile.DisplayName,
|
"backendKind": current.Profile.BackendKind,
|
"languageID": current.LanguageSettings.EffectiveLanguageID,
|
"selectionMode": current.SelectionMode,
|
"installed": installed,
|
"installStatus": status,
|
"missing": missing,
|
"problems": problems,
|
"fallbackReason": current.FallbackReason,
|
"downloadSize": current.Profile.ApproxSize,
|
"supportedLanguages": current.Profile.SupportedLanguageIDs,
|
"recommendedLanguage": current.Profile.RecommendedFor,
|
}
|
}
|
|
func (s *EngineService) SetStatus(status, hardwareInfo, lastError string) {
|
s.mu.Lock()
|
defer s.mu.Unlock()
|
s.status = status
|
s.hardwareInfo = hardwareInfo
|
s.lastError = lastError
|
}
|
|
// DownloadModel downloads the ASR model with progress events.
|
func (s *EngineService) DownloadModel(primaryURL, fallbackURL string) error {
|
err := model.Download(primaryURL, fallbackURL, paths.ModelsRoot(), func(percent float64, downloaded, total int64) {
|
if s.app != nil {
|
s.app.Event.Emit("model:download-progress", map[string]interface{}{
|
"percent": percent,
|
"downloaded": downloaded,
|
"total": total,
|
})
|
}
|
})
|
if err != nil {
|
return err
|
}
|
|
if s.initCallback != nil {
|
go s.initCallback()
|
}
|
return nil
|
}
|
|
func (s *EngineService) DownloadCurrentModel() error {
|
current := s.currentModel()
|
if len(current.Profile.DownloadURLs) == 0 {
|
return fmt.Errorf("no download URL configured for model %s", current.ModelID)
|
}
|
|
err := model.DownloadProfile(current.Profile, current.Profile.DownloadURLs, paths.ModelsRoot(), func(percent float64, downloaded, total int64) {
|
if s.app != nil {
|
s.app.Event.Emit("model:download-progress", map[string]interface{}{
|
"percent": percent,
|
"downloaded": downloaded,
|
"total": total,
|
"modelID": current.ModelID,
|
"modelName": current.Profile.DisplayName,
|
})
|
}
|
})
|
if err != nil {
|
return err
|
}
|
|
if s.initCallback != nil {
|
go s.initCallback()
|
}
|
return nil
|
}
|
|
func (s *EngineService) ReloadCurrentModel() {
|
if s.initCallback != nil {
|
go s.initCallback()
|
}
|
}
|
|
// SetInitCallback sets the callback to re-initialize the engine after model download.
|
func (s *EngineService) SetInitCallback(cb func()) {
|
s.initCallback = cb
|
}
|
|
// SetApp sets the Wails app reference for event emission.
|
func (s *EngineService) SetApp(app *application.App) {
|
s.app = app
|
}
|
|
func (s *EngineService) currentModel() modelselection.CurrentModel {
|
cfg, err := config.Load()
|
if err != nil {
|
cfg = config.Default()
|
}
|
return modelselection.Resolve(cfg, language.NewSystemDetector())
|
}
|
