// Package mobile is lectio's engine facade for the dlectio Android app. It is // bound to a native Android library with gomobile: // // gomobile bind -target=android/arm64 -tags fullbible \ // -o dlectio-engine.aar github.com/lukaszkasprzak/lectio/mobile // // The app calls Day() with a plain date/form/version and receives one JSON // document with the day's identity and rendered Mass readings. All liturgical // computation and text resolution happens here, in the exact validated lectio // engine — the app does none of it. Keep every exported signature to types // gomobile can marshal (string in, string out): that is why the payload is JSON. package mobile import ( "encoding/json" "strings" "github.com/lukaszkasprzak/lectio/internal/config" "github.com/lukaszkasprzak/lectio/internal/readings" "github.com/lukaszkasprzak/lectio/internal/render" ) // reading is one Mass reading, rendered in the requested corpus. type reading struct { Ord int `json:"ord"` Part string `json:"part"` // machine key, e.g. "ewangelium" / "psalm" Heading string `json:"heading"` // human label in the interface language, e.g. "Gospel" Citation string `json:"citation"` Text string `json:"text"` } // dayDoc is the JSON returned by Day. type dayDoc struct { Date string `json:"date"` Form string `json:"form"` Lang string `json:"lang"` Version string `json:"version"` Name string `json:"name"` Season string `json:"season"` Colour string `json:"colour"` Readings []reading `json:"readings"` Error string `json:"error,omitempty"` } // lectByForm maps the app's form code to lectio's lectionary value. func lectByForm(form string) string { if form == "ef" { return "traditional" } return "new" } // Day computes one day's identity and Mass readings and returns them as JSON. // // date - "YYYY-MM-DD" // form - "of" (Ordinary) or "ef" (1962) // version - corpus: "drb" | "wuj" | "vul" | "grb" // lang - interface language for the celebration name: "en" | "pl" // // It never panics: any engine error is reported in the JSON "error" field so the // JNI boundary always returns a well-formed string. func Day(date, form, version, lang string) string { lect := lectByForm(form) out := dayDoc{Date: date, Form: form, Lang: lang, Version: version} // Day identity (name/season/colour) in the interface language. cfgID := config.Config{UILanguage: lang, Lectionary: lect, All: true} if _, info, err := readings.Load(cfgID, readings.Options{Date: date, All: true}); err == nil { out.Name = info.Name out.Season = info.Season out.Colour = info.Colour } else { out.Error = err.Error() } // Readings, resolved and rendered in the requested corpus. The interface // language localizes the structural labels (Heading) and citation dialect; // the corpus (version) alone decides the scripture text. cfgR := config.Config{UILanguage: lang, Lectionary: lect, ReadingVersion: version, All: true} secs, _, err := readings.Load(cfgR, readings.Options{Date: date, All: true}) if err != nil { if out.Error == "" { out.Error = err.Error() } } else { for i, sec := range secs { // GatherVersion's lang localizes only the label/error wording, never // the verse text (which the corpus alone decides), so the interface // language is correct here. HeadingWithRef gives the same localized // "label (citation)" heading lectio shows in its cli/tui/web. _, blocks := render.GatherVersion(version, sec, lect, lang) out.Readings = append(out.Readings, reading{ Ord: i, Part: sec.PartID, Heading: render.HeadingWithRef(sec, lang), Citation: sec.Citation, Text: strings.Join(blocks, "\n"), }) } } b, err := json.Marshal(out) if err != nil { // Should be impossible with these types; degrade gracefully. return `{"error":"marshal failed"}` } return string(b) } // Ping is a trivial JNI smoke test: it returns "pong" so the app can confirm the // native engine loaded before issuing a real query. func Ping() string { return "pong" }