react-native-maplibre-lite 0.2.0 → 0.2.1

package/src/components/navigatorVoiceCatalog.ts

@@ -0,0 +1,275 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import { isKnownPhraseKey, type VoicePhraseKey } from './navigatorVoiceKeys';
+
+/**
+ * Каталог/манифест голосов навигатора и персист настроек. Порт
+ * `webProject/src/map/navigationVoiceCatalog.ts` на нативную часть:
+ * localStorage → AsyncStorage, плюс маппинг ключей фраз в URL клипов.
+ */
+
+export type VoiceCatalogEntry = {
+    dir: string;
+    name: string;
+    locale: string;
+};
+
+/** Per-voice manifest from S3: phrase key → variant ids. */
+export type VoiceManifest = Record<string, string[]>;
+
+export type VoicePref = { dir: string } | { disabled: true };
+
+export type VoiceRuntime = {
+    catalogUrl: string;
+    catalog: VoiceCatalogEntry[];
+    selectedDir: string;
+    clipBaseUrl: string;
+    manifest: VoiceManifest | null;
+    enabled: boolean;
+};
+
+const LS_VOICE_PREF = 'maplite-navigator-voice-pref';
+const LS_VOICE_VOLUME = 'maplite-navigator-voice-volume';
+
+export type VoiceVolumeLevel = 1 | 2 | 3 | 4 | 5;
+
+const DEFAULT_VOICE_VOLUME_LEVEL: VoiceVolumeLevel = 5;
+
+export function volumeLevelToGain(level: VoiceVolumeLevel): number {
+    return level * 0.2;
+}
+
+export async function readVoiceVolumeLevel(): Promise<VoiceVolumeLevel> {
+    try {
+        const raw = await AsyncStorage.getItem(LS_VOICE_VOLUME);
+        if (!raw) return DEFAULT_VOICE_VOLUME_LEVEL;
+        const n = Number.parseInt(raw, 10);
+        if (n >= 1 && n <= 5) return n as VoiceVolumeLevel;
+    } catch {
+        /* ignore */
+    }
+    return DEFAULT_VOICE_VOLUME_LEVEL;
+}
+
+export async function writeVoiceVolumeLevel(level: VoiceVolumeLevel): Promise<void> {
+    try {
+        await AsyncStorage.setItem(LS_VOICE_VOLUME, String(level));
+    } catch {
+        /* ignore */
+    }
+}
+
+export async function readVoicePref(): Promise<VoicePref | null> {
+    try {
+        const raw = await AsyncStorage.getItem(LS_VOICE_PREF);
+        if (!raw) return null;
+        const parsed = JSON.parse(raw) as unknown;
+        if (
+            parsed &&
+            typeof parsed === 'object' &&
+            'disabled' in parsed &&
+            (parsed as { disabled: unknown }).disabled === true
+        ) {
+            return { disabled: true };
+        }
+        if (
+            parsed &&
+            typeof parsed === 'object' &&
+            'dir' in parsed &&
+            typeof (parsed as { dir: unknown }).dir === 'string'
+        ) {
+            const dir = (parsed as { dir: string }).dir.trim();
+            if (dir) return { dir };
+        }
+    } catch {
+        /* ignore */
+    }
+    return null;
+}
+
+export async function writeVoicePref(pref: VoicePref): Promise<void> {
+    try {
+        await AsyncStorage.setItem(LS_VOICE_PREF, JSON.stringify(pref));
+    } catch {
+        /* ignore */
+    }
+}
+
+export function resolveVoiceCatalogUrl(url: string): string | null {
+    const t = url.trim();
+    if (!t) return null;
+    try {
+        // eslint-disable-next-line no-new
+        new URL(t);
+        return t;
+    } catch {
+        return null;
+    }
+}
+
+/** Base URL for a voice directory: `.../voices/{dir}`. */
+export function voiceDirBaseUrl(catalogUrl: string, dir: string): string {
+    const u = new URL(catalogUrl);
+    const parts = u.pathname.split('/').filter(Boolean);
+    if (parts.length > 0 && parts[parts.length - 1]!.toLowerCase().endsWith('.json')) {
+        parts.pop();
+    }
+    parts.push(dir);
+    u.pathname = `/${parts.join('/')}`;
+    return u.toString().replace(/\/+$/, '');
+}
+
+function voiceManifestUrl(baseUrl: string): string {
+    return `${baseUrl.replace(/\/+$/, '')}/data.json`;
+}
+
+export async function fetchVoiceCatalog(catalogUrl: string): Promise<VoiceCatalogEntry[]> {
+    const res = await fetch(catalogUrl);
+    if (!res.ok) {
+        throw new Error(`voice catalog fetch failed: ${res.status}`);
+    }
+    const data = (await res.json()) as unknown;
+    if (!Array.isArray(data)) {
+        throw new Error('voice catalog: expected JSON array');
+    }
+    const entries: VoiceCatalogEntry[] = [];
+    for (const item of data) {
+        if (
+            item &&
+            typeof item === 'object' &&
+            typeof (item as VoiceCatalogEntry).dir === 'string' &&
+            typeof (item as VoiceCatalogEntry).name === 'string'
+        ) {
+            const e = item as VoiceCatalogEntry;
+            entries.push({
+                dir: e.dir.trim(),
+                name: e.name,
+                locale: typeof e.locale === 'string' ? e.locale : 'RU',
+            });
+        }
+    }
+    if (entries.length === 0) {
+        throw new Error('voice catalog: empty');
+    }
+    return entries;
+}
+
+export async function fetchVoiceManifest(clipBaseUrl: string): Promise<VoiceManifest> {
+    const res = await fetch(voiceManifestUrl(clipBaseUrl));
+    if (!res.ok) {
+        throw new Error(`voice manifest fetch failed: ${res.status}`);
+    }
+    const data = (await res.json()) as unknown;
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw new Error('voice manifest: expected JSON object');
+    }
+    const manifest: VoiceManifest = {};
+    for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
+        if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+            manifest[key] = value as string[];
+        }
+    }
+    return manifest;
+}
+
+function resolveSelectedDir(catalog: VoiceCatalogEntry[], pref: VoicePref | null): string {
+    if (pref && 'dir' in pref) {
+        const found = catalog.find((e) => e.dir === pref.dir);
+        if (found) return found.dir;
+    }
+    return catalog[0]!.dir;
+}
+
+/**
+ * Loads catalog + user preference + optional per-voice manifest.
+ * When pref is `{ disabled: true }`, returns `enabled: false` and `manifest: null`.
+ */
+export async function loadVoiceRuntime(catalogUrl: string): Promise<VoiceRuntime | null> {
+    const resolved = resolveVoiceCatalogUrl(catalogUrl);
+    if (!resolved) return null;
+
+    const catalog = await fetchVoiceCatalog(resolved);
+    const pref = await readVoicePref();
+    const selectedDir = resolveSelectedDir(catalog, pref);
+    const clipBaseUrl = voiceDirBaseUrl(resolved, selectedDir);
+
+    if (pref != null && 'disabled' in pref && pref.disabled === true) {
+        return {
+            catalogUrl: resolved,
+            catalog,
+            selectedDir,
+            clipBaseUrl,
+            manifest: null,
+            enabled: false,
+        };
+    }
+
+    const manifest = await fetchVoiceManifest(clipBaseUrl);
+    return {
+        catalogUrl: resolved,
+        catalog,
+        selectedDir,
+        clipBaseUrl,
+        manifest,
+        enabled: true,
+    };
+}
+
+/** Reload manifest after user picks another voice (same catalog URL). */
+export async function reloadVoiceForDir(
+    catalogUrl: string,
+    catalog: VoiceCatalogEntry[],
+    dir: string
+): Promise<Pick<VoiceRuntime, 'selectedDir' | 'clipBaseUrl' | 'manifest' | 'enabled'>> {
+    const entry = catalog.find((e) => e.dir === dir);
+    if (!entry) {
+        throw new Error(`voice dir not in catalog: ${dir}`);
+    }
+    const clipBaseUrl = voiceDirBaseUrl(catalogUrl, entry.dir);
+    const manifest = await fetchVoiceManifest(clipBaseUrl);
+    await writeVoicePref({ dir: entry.dir });
+    return {
+        selectedDir: entry.dir,
+        clipBaseUrl,
+        manifest,
+        enabled: true,
+    };
+}
+
+function pickVariant(manifest: VoiceManifest, key: VoicePhraseKey): string {
+    const vars = manifest[key];
+    if (!vars?.length) return 'var1';
+    return vars[Math.floor(Math.random() * vars.length)] ?? 'var1';
+}
+
+/** clipId для S3: `{key}_{variant}`. */
+function phraseKeyToClipId(manifest: VoiceManifest, key: VoicePhraseKey, variant: string): string {
+    return `${key}_${variant}`;
+}
+
+/**
+ * Преобразует список ключей фраз (из веб-части) в список URL клипов
+ * `{clipBaseUrl}/{key}_{variant}.mp3`. Неизвестные / отсутствующие в
+ * манифесте ключи пропускаются.
+ */
+export function keysToClipUrls(
+    manifest: VoiceManifest,
+    clipBaseUrl: string,
+    keys: string[]
+): string[] {
+    const base = clipBaseUrl.replace(/\/+$/, '');
+    const variants = new Map<VoicePhraseKey, string>();
+    const urls: string[] = [];
+    for (const raw of keys) {
+        if (!isKnownPhraseKey(raw)) continue;
+        const key = raw;
+        if (!(key in manifest)) continue;
+        let variant = variants.get(key);
+        if (!variant) {
+            variant = pickVariant(manifest, key);
+            variants.set(key, variant);
+        }
+        urls.push(`${base}/${phraseKeyToClipId(manifest, key, variant)}.mp3`);
+    }
+    return urls;
+}

package/src/components/navigatorVoiceKeys.ts

@@ -0,0 +1,132 @@
+/**
+ * Фиксированные ключи клипов навигатора (схема проекта). Зеркало
+ * `webProject/src/map/navigationVoiceKeys.ts` — веб-часть присылает эти
+ * ключи в событии `navigatorVoice`, нативная часть мапит их в аудио.
+ * Варианты (`var1`, …) и наличие записей — только из S3 voice manifest.
+ */
+export const VOICE_PHRASE_KEYS = [
+    'maneuver_sharp_left',
+    'maneuver_turn_left',
+    'maneuver_slight_left',
+    'maneuver_straight',
+    'maneuver_slight_right',
+    'maneuver_turn_right',
+    'maneuver_sharp_right',
+    'maneuver_arrival',
+    'maneuver_waypoint',
+    'maneuver_enter_roundabout',
+    'maneuver_leave_roundabout',
+    'maneuver_keep_left',
+    'maneuver_keep_right',
+    'maneuver_uturn',
+    'maneuver_uturn_left',
+    'maneuver_uturn_right',
+    'maneuver_default',
+    'exit_1',
+    'exit_2',
+    'exit_3',
+    'exit_4',
+    'exit_5',
+    'exit_6',
+    'exit_7',
+    'exit_8',
+    'exit_9',
+    'exit_10',
+    'exit_11',
+    'exit_12',
+    'roundabout_take_exit',
+    'prefix_via',
+    'connector_and',
+    'unit_meter',
+    'unit_meters_2_4',
+    'unit_meters_5_plus',
+    'unit_kilometer',
+    'unit_kilometers_2_4',
+    'unit_kilometers_5_plus',
+    'route_started',
+    'route_recalculated',
+    'arrived_title',
+    'arrival_at_destination',
+    'waypoint_reached',
+    'off_route',
+    'num_1',
+    'num_2',
+    'num_3',
+    'num_4',
+    'num_5',
+    'num_6',
+    'num_7',
+    'num_8',
+    'num_9',
+    'num_10',
+    'num_11',
+    'num_12',
+    'num_13',
+    'num_14',
+    'num_15',
+    'num_16',
+    'num_17',
+    'num_18',
+    'num_19',
+    'num_20',
+    'num_30',
+    'num_40',
+    'num_50',
+    'num_60',
+    'num_70',
+    'num_80',
+    'num_90',
+    'num_100',
+    'num_200',
+    'num_300',
+    'num_400',
+    'num_500',
+    'num_600',
+    'num_700',
+    'num_800',
+    'num_900',
+    'num_km_1',
+    'num_km_2',
+    'num_km_3',
+    'num_km_4',
+    'num_km_5',
+    'num_km_6',
+    'num_km_7',
+    'num_km_8',
+    'num_km_9',
+    'num_km_10',
+    'num_km_11',
+    'num_km_12',
+    'num_km_13',
+    'num_km_14',
+    'num_km_15',
+    'num_km_16',
+    'num_km_17',
+    'num_km_18',
+    'num_km_19',
+    'num_km_20',
+    'num_km_30',
+    'num_km_40',
+    'num_km_50',
+    'num_km_60',
+    'num_km_70',
+    'num_km_80',
+    'num_km_90',
+    'num_km_100',
+    'num_km_200',
+    'num_km_300',
+    'num_km_400',
+    'num_km_500',
+    'num_km_600',
+    'num_km_700',
+    'num_km_800',
+    'num_km_900',
+] as const;
+
+export type VoicePhraseKey = (typeof VOICE_PHRASE_KEYS)[number];
+
+const VOICE_PHRASE_KEY_SET = new Set<string>(VOICE_PHRASE_KEYS);
+
+export function isKnownPhraseKey(key: string): key is VoicePhraseKey {
+    return VOICE_PHRASE_KEY_SET.has(key);
+}

package/src/components/navigatorVoicePlayer.tsx

@@ -0,0 +1,126 @@
+import { forwardRef, useImperativeHandle, useRef, useState } from 'react';
+
+import Video from 'react-native-video';
+
+/**
+ * Последовательный проигрыватель клипов озвучки навигатора. Порт логики
+ * очереди из `webProject/src/map/navigationVoicePlayer.ts` на `react-native-video`:
+ * веб присылает список ключей фраз, нативная часть собирает из них URL и
+ * проигрывает их по очереди с короткой паузой между клипами.
+ */
+
+/** Пауза между клипами (как в веб-плеере). */
+const CLIP_PAUSE_MS = 300;
+
+export type NavigatorVoicePlayerRef = {
+    /** Проиграть очередь URL подряд (прерывает текущую очередь). */
+    playUrls: (urls: string[]) => void;
+    /** Остановить воспроизведение и очистить очередь. */
+    stop: () => void;
+    /** Установить громкость (0..1). */
+    setVolume: (gain: number) => void;
+};
+
+type NavigatorVoicePlayerProps = {
+    /** Начальная громкость (0..1); далее управляется через ref. */
+    initialVolume?: number;
+};
+
+export const NavigatorVoicePlayer = forwardRef<
+    NavigatorVoicePlayerRef,
+    NavigatorVoicePlayerProps
+>((props, ref) => {
+    const [current, setCurrent] = useState<{ uri: string; token: number } | null>(null);
+    const [volume, setVolume] = useState(
+        typeof props.initialVolume === 'number'
+            ? Math.min(1, Math.max(0, props.initialVolume))
+            : 1
+    );
+
+    const queueRef = useRef<string[]>([]);
+    const indexRef = useRef(0);
+    /** Поколение очереди: рост инвалидирует «хвосты» предыдущих очередей. */
+    const genRef = useRef(0);
+    /** Меняем токен, чтобы перерисовать `<Video>` даже при том же URL подряд. */
+    const tokenRef = useRef(0);
+    const pauseTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+    const clearPause = () => {
+        if (pauseTimerRef.current != null) {
+            clearTimeout(pauseTimerRef.current);
+            pauseTimerRef.current = null;
+        }
+    };
+
+    const playIndex = () => {
+        const uri = queueRef.current[indexRef.current];
+        if (uri == null) {
+            setCurrent(null);
+            return;
+        }
+        tokenRef.current += 1;
+        setCurrent({ uri, token: tokenRef.current });
+    };
+
+    const advance = (gen: number) => {
+        if (gen !== genRef.current) return;
+        indexRef.current += 1;
+        if (indexRef.current >= queueRef.current.length) {
+            setCurrent(null);
+            return;
+        }
+        clearPause();
+        pauseTimerRef.current = setTimeout(() => {
+            pauseTimerRef.current = null;
+            if (gen === genRef.current) playIndex();
+        }, CLIP_PAUSE_MS);
+    };
+
+    useImperativeHandle(
+        ref,
+        () => ({
+            playUrls: (urls: string[]) => {
+                clearPause();
+                genRef.current += 1;
+                queueRef.current = urls;
+                indexRef.current = 0;
+                if (urls.length === 0) {
+                    setCurrent(null);
+                    return;
+                }
+                playIndex();
+            },
+            stop: () => {
+                clearPause();
+                genRef.current += 1;
+                queueRef.current = [];
+                indexRef.current = 0;
+                setCurrent(null);
+            },
+            setVolume: (gain: number) => {
+                setVolume(Math.min(1, Math.max(0, gain)));
+            },
+        }),
+        []
+    );
+
+    if (!current) return null;
+
+    const gen = genRef.current;
+    return (
+        <Video
+            key={current.token}
+            source={{ uri: current.uri }}
+            paused={false}
+            volume={volume}
+            repeat={false}
+            ignoreSilentSwitch="ignore"
+            playInBackground
+            onEnd={() => advance(gen)}
+            onError={() => advance(gen)}
+            style={{ width: 0, height: 0 }}
+        />
+    );
+});
+
+NavigatorVoicePlayer.displayName = 'NavigatorVoicePlayer';

package/src/components/navigatorVoiceStrings.ts

@@ -0,0 +1,42 @@
+import type { NavigatorLang } from './types';
+
+/**
+ * Подписи нативного UI навигатора (FAB-кнопки, меню голоса, подсказка
+ * pick-режима). Текст HUD маршрута приходит готовым из веб-части, поэтому
+ * здесь только то, что рисуется нативно. Порт voice/recenter-строк из
+ * `webProject/src/map/local.ts`.
+ */
+export type NavigatorUiStrings = {
+    recenterAria: string;
+    voicePickerAria: string;
+    voiceDisable: string;
+    voiceOff: string;
+    voiceVolumeLabel: string;
+    voiceVolumeStepAria: (step: number) => string;
+    /** Подсказка в HUD, когда активен режim выбора позиции кликом (dev). */
+    pickHint: string;
+};
+
+const ru: NavigatorUiStrings = {
+    recenterAria: 'Вернуть фокус на положение',
+    voicePickerAria: 'Голос навигатора',
+    voiceDisable: 'Отключить озвучку',
+    voiceOff: 'Озвучка выкл.',
+    voiceVolumeLabel: 'Громкость',
+    voiceVolumeStepAria: (step: number) => `Громкость ${step} из 5`,
+    pickHint: 'Кликните по карте, чтобы установить текущее положение',
+};
+
+const en: NavigatorUiStrings = {
+    recenterAria: 'Recenter on your position',
+    voicePickerAria: 'Navigator voice',
+    voiceDisable: 'Turn off voice guidance',
+    voiceOff: 'Voice off',
+    voiceVolumeLabel: 'Volume',
+    voiceVolumeStepAria: (step: number) => `Volume ${step} of 5`,
+    pickHint: 'Tap the map to set the current position',
+};
+
+export function navigatorUiStrings(lang: NavigatorLang | undefined): NavigatorUiStrings {
+    return lang === 'en' ? en : ru;
+}