Audio adding to AnkiDroid works

aecsocket · aecsocket · commit 3d2bde2bb48d · 2025-06-16T07:31:02.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -107,6 +107,8 @@ xz2                  = { version = "0.1" }
 zbus                 = { version = "5.5", default-features = false }
 zip                  = { version = "4.0" }
 android_logger = { version = "0.15.0"}
+sha2 = { version = "0.10"}
+hex = { version = "0.4" }
 
 [workspace.metadata.cargo-shear]
 ignored = ["bzip2"]
diff --git a/crates/wordbase/Cargo.toml b/crates/wordbase/Cargo.toml
@@ -61,7 +61,8 @@ tokio-util           = { workspace = true, features = ["rt"] }
 tracing              = { workspace = true }
 unicode-segmentation = { workspace = true }
 uniffi               = { workspace = true, optional = true, features = ["tokio"] }
-# tracing-log          = { workspace = true, optional = true }
+sha2 = { workspace = true }
+hex = { workspace = true }
 
 derive_more = { workspace = true, features = [
   "debug",
diff --git a/crates/wordbase/src/anki.rs b/crates/wordbase/src/anki.rs
@@ -4,7 +4,7 @@ use {
     itertools::Itertools,
     maud::html,
     serde::Serialize,
-    std::{collections::HashMap, fmt::Write as _, ops::Range},
+    std::{collections::HashMap, ops::Range},
     wordbase_api::{
         DictionaryId, FrequencyValue, NormString, ProfileId, Record, RecordEntry, Term, dict,
     },
@@ -24,12 +24,12 @@ impl Engine {
 
         let span_min = entries
             .iter()
-            .map(|record| record.span_bytes.start)
+            .map(|entry| entry.span_bytes.start)
             .min()
             .context("no records")?;
         let span_max = entries
             .iter()
-            .map(|record| record.span_bytes.end)
+            .map(|entry| entry.span_bytes.end)
             .max()
             .context("no records")?;
         let term_span = (usize::try_from(span_min).unwrap_or(usize::MAX))
@@ -42,32 +42,38 @@ impl Engine {
                 .map_or("?", |dict| dict.meta.name.as_str())
         };
         let glossaries = glossaries(&entries);
-        let fields = [
-            ("Expression", term_part(term.headword())),
-            ("ExpressionReading", term_part(term.reading())),
-            ("ExpressionFurigana", term_ruby_plain(term)),
-            (
-                "Sentence",
-                sentence_cloze(sentence, term_span).unwrap_or_default(),
-            ),
-            (
-                "MainDefinition",
-                glossaries.first().cloned().unwrap_or_default(),
-            ),
-            ("Glossary", all_glossaries(&glossaries)),
-            ("IsWordAndSentenceCard", String::new()),
-            ("IsClickCard", String::new()),
-            ("IsSentenceCard", "x".into()),
-            ("PitchPosition", pitch_positions(&entries)),
-            ("Frequency", frequency_list(&entries, dict_name)),
-            ("FreqSort", frequency_harmonic_mean(&entries)),
-        ];
 
         Ok(TermNote {
-            fields: fields
-                .into_iter()
-                .map(|(k, v)| (k.to_string(), v))
-                .collect(),
+            fields: [
+                ("Expression", term_part(term.headword())),
+                ("ExpressionReading", term_part(term.reading())),
+                ("ExpressionFurigana", term_ruby_plain(term)),
+                (
+                    "Sentence",
+                    sentence_cloze(sentence, term_span).unwrap_or_default(),
+                ),
+                // TODO: generate sentence furigana, like AJT does
+                // this is kinda complicated though
+                // I can't use AJT's code for this since it uses an incredibly copyleft license
+                (
+                    "MainDefinition",
+                    glossaries.first().cloned().unwrap_or_default(),
+                ),
+                ("Glossary", all_glossaries(&glossaries)),
+                ("IsWordAndSentenceCard", String::new()),
+                ("IsClickCard", String::new()),
+                ("IsSentenceCard", "x".into()),
+                ("PitchPosition", pitch_positions(&entries)),
+                ("Frequency", frequency_list(&entries, dict_name)),
+                ("FreqSort", frequency_harmonic_mean(&entries)),
+            ]
+            .into_iter()
+            .map(|(k, v)| (k.to_string(), NoteField::String(v)))
+            .chain(
+                term_audio(&entries)
+                    .map(|audio| ("ExpressionAudio".to_string(), NoteField::Audio(audio))),
+            )
+            .collect::<HashMap<_, _>>(),
         })
     }
 
@@ -102,10 +108,16 @@ impl Engine {
     }
 }
 
-#[derive(Debug, Serialize)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
 pub struct TermNote {
-    pub fields: HashMap<String, String>,
+    pub fields: HashMap<String, NoteField>,
+}
+
+#[derive(Debug, Serialize)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
+pub enum NoteField {
+    String(String),
+    Audio(Vec<u8>),
 }
 
 fn term_part(part: Option<&NormString>) -> String {
@@ -115,23 +127,39 @@ fn term_part(part: Option<&NormString>) -> String {
 fn term_ruby_plain(term: &Term) -> String {
     match term {
         Term::Full(headword, reading) => {
-            let mut result = String::new();
-            for (headword_part, reading_part) in lang::jpn::furigana_parts(headword, reading) {
-                _ = write!(&mut result, "{headword_part}");
-                if !reading_part.is_empty() {
-                    _ = write!(&mut result, "[{reading_part}]");
-                }
-                // Lapis uses a space to separate headword/reading part pairs
-                // todo do this properly use this as ref: 落とし穴
-                _ = write!(&mut result, " ");
-            }
-            result
+            // Lapis does something a bit screwy with furigana.
+            // "押し込む" -> "押[お]し 込[こ]む"
+            // Notice:
+            // - after kanji segments, there is "[{reading}]", and no space afterwards
+            // - after kana segments, there is a space
+            lang::jpn::furigana_parts(headword, reading)
+                .map(|(headword_part, reading_part)| {
+                    if reading_part.is_empty() {
+                        format!("{headword_part} ")
+                    } else {
+                        format!("{headword_part}[{reading_part}]")
+                    }
+                })
+                .join("")
         }
         Term::Headword(headword) => headword.to_string(),
         Term::Reading(reading) => reading.to_string(),
     }
 }
 
+fn term_audio(entries: &[&RecordEntry]) -> Option<Vec<u8>> {
+    entries
+        .iter()
+        .find_map(|entry| match &entry.record {
+            Record::YomichanAudioForvo(audio) => Some(&audio.audio),
+            Record::YomichanAudioJpod(audio) => Some(&audio.audio),
+            Record::YomichanAudioNhk16(audio) => Some(&audio.audio),
+            Record::YomichanAudioShinmeikai8(audio) => Some(&audio.audio),
+            _ => None,
+        })
+        .map(|audio| audio.data.to_vec())
+}
+
 fn sentence_cloze(sentence: &str, term_span: Range<usize>) -> Option<String> {
     let cloze_prefix = sentence.get(..term_span.start)?;
     let cloze_body = sentence.get(term_span.clone())?;
@@ -176,7 +204,7 @@ fn all_glossaries(glossaries: &[String]) -> String {
 fn pitch_positions(entries: &[&RecordEntry]) -> String {
     entries
         .iter()
-        .filter_map(|record| match &record.record {
+        .filter_map(|entry| match &entry.record {
             Record::YomitanPitch(dict::yomitan::Pitch { position, .. }) => Some(*position),
             _ => None,
         })
@@ -194,11 +222,11 @@ fn frequency_list<'a>(
 ) -> String {
     entries
         .iter()
-        .filter_map(|record| match &record.record {
+        .filter_map(|entry| match &entry.record {
             Record::YomitanFrequency(dict::yomitan::Frequency { value, display }) => {
                 match (value, display) {
-                    (_, Some(display)) => Some((record, display.clone())),
-                    (Some(FrequencyValue::Rank(rank)), None) => Some((record, format!("{rank}"))),
+                    (_, Some(display)) => Some((entry, display.clone())),
+                    (Some(FrequencyValue::Rank(rank)), None) => Some((entry, format!("{rank}"))),
                     _ => None,
                 }
             }
@@ -217,7 +245,7 @@ fn frequency_harmonic_mean(entries: &[&RecordEntry]) -> String {
     harmonic_mean(
         entries
             .iter()
-            .filter_map(|record| match &record.record {
+            .filter_map(|entry| match &entry.record {
                 Record::YomitanFrequency(dict::yomitan::Frequency {
                     // TODO: how do we handle occurrences?
                     value: Some(FrequencyValue::Rank(rank)),
diff --git a/crates/wordbase/src/deinflect/lindera.rs b/crates/wordbase/src/deinflect/lindera.rs
@@ -1,8 +1,16 @@
+// TODO: cases to handle:
+// - ㌀ -> アパート
+// - ２０日 -> 20日
+
 use {
     super::{Deinflection, Deinflector},
     anyhow::{Context as _, Result},
     itertools::Itertools,
     lindera::{
+        character_filter::{
+            BoxCharacterFilter,
+            unicode_normalize::{UnicodeNormalizeCharacterFilter, UnicodeNormalizeKind},
+        },
         dictionary::{DictionaryKind, load_dictionary_from_kind},
         mode::Mode,
         segmenter::Segmenter,
@@ -30,7 +38,12 @@ impl Lindera {
         let dictionary = load_dictionary_from_kind(DictionaryKind::UniDic)
             .context("failed to load dictionary")?;
         let segmenter = Segmenter::new(Mode::Normal, dictionary, None);
-        let tokenizer = Tokenizer::new(segmenter);
+
+        let mut tokenizer = Tokenizer::new(segmenter);
+        tokenizer.append_character_filter(BoxCharacterFilter::from(
+            UnicodeNormalizeCharacterFilter::new(UnicodeNormalizeKind::NFKC),
+        ));
+
         Ok(Self {
             tokenizer,
             lookahead,
@@ -462,6 +475,32 @@ mod tests {
             (text, start),
             [Deinflection::new(start, text, "有り難う")],
         );
+
+        assert_deinflects(
+            &deinflector,
+            ("２０日", 0),
+            [
+                Deinflection::new(0, "２０日", "２０日"),
+                Deinflection::new(0, "２０日", "二零日"),
+                Deinflection::new(0, "２０", "２０"),
+                Deinflection::new(0, "２０", "二零"),
+                Deinflection::new(0, "２", "２"),
+                Deinflection::new(0, "２", "二"),
+            ],
+        );
+
+        assert_deinflects(
+            &deinflector,
+            ("20日", 0),
+            [
+                Deinflection::new(0, "２０日", "２０日"),
+                Deinflection::new(0, "２０日", "二零日"),
+                Deinflection::new(0, "２０", "２０"),
+                Deinflection::new(0, "２０", "二零"),
+                Deinflection::new(0, "２", "２"),
+                Deinflection::new(0, "２", "二"),
+            ],
+        );
     }
 
     static TOKENIZER: LazyLock<Tokenizer> = LazyLock::new(|| {
diff --git a/wordbase-android/app/src/main/AndroidManifest.xml b/wordbase-android/app/src/main/AndroidManifest.xml
@@ -48,6 +48,12 @@
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
+
+        <provider
+            android:name=".NoteProvider"
+            android:authorities="io.github.aecsocket.wordbase.note"
+            android:exported="true"
+            android:grantUriPermissions="true" />
     </application>
 
 </manifest>
diff --git a/wordbase-android/app/src/main/java/io/github/aecsocket/wordbase/NoteProvider.kt b/wordbase-android/app/src/main/java/io/github/aecsocket/wordbase/NoteProvider.kt
@@ -0,0 +1,66 @@
+package io.github.aecsocket.wordbase
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import android.util.Log
+import androidx.core.net.toUri
+import java.io.FileOutputStream
+
+private const val TAG = "NoteProvider"
+
+class NoteProvider : ContentProvider() {
+    override fun onCreate() = true
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String?>?,
+        selection: String?,
+        selectionArgs: Array<out String?>?,
+        sortOrder: String?
+    ) = null
+
+    override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? {
+        Log.i(TAG, "Request to open note content $uri")
+        val data = data ?: return null
+        Log.i(TAG, "We have data, reading...")
+
+        val (read, write) = ParcelFileDescriptor.createPipe()
+        Thread {
+            write.use { write ->
+                FileOutputStream(write.fileDescriptor).use { stream ->
+                    stream.write(data)
+                }
+            }
+            Log.i(TAG, "All data written")
+        }.start()
+        Log.i(TAG, "Sent")
+        return read
+    }
+
+    override fun getType(uri: Uri) = null
+
+    override fun insert(
+        uri: Uri,
+        values: ContentValues?
+    ) = null
+
+    override fun delete(
+        uri: Uri,
+        selection: String?,
+        selectionArgs: Array<out String?>?
+    ) = 0
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String?>?
+    ) = 0
+
+    companion object {
+        val uri = "content://io.github.aecsocket.wordbase.note".toUri()
+        var data: ByteArray? = null
+    }
+}
diff --git a/wordbase-android/app/src/main/java/io/github/aecsocket/wordbase/RecordsView.kt b/wordbase-android/app/src/main/java/io/github/aecsocket/wordbase/RecordsView.kt
