Speech Synthesis - Android

import androidx.annotation.NonNull;
import androidx.arch.core.util.Function;
import androidx.core.util.Consumer;
import androidx.core.util.Supplier;

import com.vivoka.vsdk.Exception;

import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;

public class TextMarker {
    private int _sampleRate;
    private int _channelCount;
    private int _previousWordIndex;
    private final List<Marker> _markers;
    private final Object _callbackMutex = new Object();
    private Consumer<Marker> _callback;

    public TextMarker(int sampleRate, int channelCount) throws Exception {
        setAudioFormat(sampleRate, channelCount);
        _previousWordIndex = -1;
        _markers = new ArrayList<>();
    }

    public void setAudioFormat(int sampleRate, int channelCount) throws Exception {
        Exception.bAssert(sampleRate > 0,
            "Sample rate cannot be zero or less than zero");

        Exception.bAssert(channelCount > 0,
            "Channel count cannot be zero or less than zero");

        this._sampleRate = sampleRate;
        this._channelCount = channelCount;
    }

    public void addMarker(String markerMessage) throws Exception {
        synchronized (_markers) {
            _markers.add(new Marker(markerMessage));
        }
    }

    public void setReachedMarkerCallback(Consumer<Marker> callback) {
        synchronized (_callbackMutex) {
            this._callback = callback;
        }
    }

    public void onPlayerProgress(Long position) throws Exception {
        try {
            Function<Integer, Marker> safeGet = (Integer idx) -> {
                synchronized (_markers) {
                    return 0 <= idx && idx < _markers.size() ? _markers.get(idx) : null;
                }
            };

            Supplier<Integer> size = () -> {
                synchronized (_markers) {
                    return _markers.size();
                }
            };

            for (int i = _previousWordIndex + 1; i < size.get(); ++i) {
                Marker marker = safeGet.apply(i);
                if (marker != null) {
                    if (marker.startPosInAudio() > position) {
                        break;
                    }
                    synchronized (_callbackMutex) {
                        if (_callback != null) {
                            _callback.accept(marker);
                        }
                    }
                    _previousWordIndex = i;
                }
            }
        } catch (RuntimeException e) {
            throw new Exception("Failed to update TextMarker progress", e);
        }
    }

    public void reset() {
        _previousWordIndex = -1;
        synchronized (_markers) {
            _markers.clear();
        }
    }

    // Marker class for demonstration purposes
    public static class Marker {
        private final double _startPosInAudio;
        private final double _endPosInAudio;
        private final double _startPosInText;
        private final double _endPosInText;
        private final String _word;
        private final String _text;

        public Marker(String jsonString) throws Exception {
            try {
                JSONObject obj   = new JSONObject(jsonString);
                _text            = obj.getString("text");
                _word            = obj.getString("word");
                _startPosInText  = obj.getLong("start_pos_in_text");
                _endPosInText    = obj.getLong("end_pos_in_text");
                _startPosInAudio = obj.getLong("start_pos_in_audio");
                _endPosInAudio   = obj.getLong("end_pos_in_audio");
            } catch (JSONException e) {
                throw new Exception("Failed to parse json word marker", e);
            }
        }

        public double startPosInAudio() {
            return _startPosInAudio;
        }

        public double endPosInAudio() {
            return _endPosInAudio;
        }

        public double startPosInText() {
            return _startPosInText;
        }

        public double endPosInText() {
            return _endPosInText;
        }

        public String word() {
            return _word;
        }

        public String text() {
            return _text;
        }

        @NonNull
        @Override
        public String toString() {
            JSONObject obj = new JSONObject();
            try {
                obj.put("word", _word);
                obj.put("text", _text);
                obj.put("start_pos_in_audio", _startPosInAudio);
                obj.put("end_pos_in_audio", _endPosInAudio);
                obj.put("start_pos_in_text", _startPosInText);
                obj.put("end_pos_in_text", _endPosInText);
            } catch (JSONException e) {
                (new Exception("Failed to convert marker to string", e)).printFormattedMessage();
            }
            return obj.toString();
        }
    }
}