Fixed bug which was causing AnkiDroid API to not list media on cards.

Author: ujjol1234

AnkiDroid/src/androidTest/java/com/ichi2/anki/tests/ContentProviderTest.kt

@@ -50,6 +50,7 @@ import com.ichi2.libanki.utils.set
 import com.ichi2.testutils.common.assertThrows
 import com.ichi2.utils.KotlinCleanup
 import com.ichi2.utils.emptyStringArray
+import kotlinx.serialization.json.Json
 import net.ankiweb.rsdroid.exceptions.BackendNotFoundException
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers.containsString
@@ -1344,6 +1345,57 @@ class ContentProviderTest : InstrumentedTest() {
             } ?: fail("query returned null")
     }
 
+    @Test
+    fun testMediaFilesAddedCorrectlyInReviewInfo() {
+        val frontContent = """<img src="img.jpg"> [sound:test.mp3]"""
+        val imageFileName = "img.jpg"
+        val audioFileName = "test.mp3"
+        val note = addNoteUsingBasicModel("Hello $frontContent", "backContent")
+        val ord = 0
+        val card = note.cards(col)[ord]
+
+        card.queue = QueueType.New
+        card.due = col.sched.today
+        col.updateCard(card)
+
+        contentResolver
+            .query(
+                FlashCardsContract.ReviewInfo.CONTENT_URI,
+                null,
+                null,
+                null,
+                null,
+            )?. let { cursor ->
+                if (!cursor.moveToFirst()) {
+                    fail("failed")
+                }
+
+                assertNotNull("Cursor should not be null", cursor)
+
+                val mediaFilesArray = cursor.getString(cursor.getColumnIndex(FlashCardsContract.ReviewInfo.MEDIA_FILES))
+
+                var imageFilePresent = false
+                var audioFilePresent = false
+                var allMediaFilesPresent = false
+
+                val media: List<String> = Json.decodeFromString(mediaFilesArray)
+
+                for (ele in media) {
+                    if (ele == imageFileName) {
+                        imageFilePresent = true
+                    }
+                    if (ele == audioFileName) {
+                        audioFilePresent = true
+                    }
+                }
+                if (imageFilePresent and audioFilePresent) {
+                    allMediaFilesPresent = true
+                }
+
+                assertTrue("All media files should be present in the media_files array", allMediaFilesPresent)
+            }
+    }
+
     private fun reopenCol(): com.ichi2.libanki.Collection {
         Timber.i("closeCollection: %s", "ContentProviderTest: reopenCol")
         CollectionManager.closeCollectionBlocking()

AnkiDroid/src/main/java/com/ichi2/anki/provider/CardContentProvider.kt

@@ -1140,7 +1140,7 @@ class CardContentProvider : ContentProvider() {
                 FlashCardsContract.ReviewInfo.NEXT_REVIEW_TIMES -> rb.add(nextReviewTimesJson.toString())
                 FlashCardsContract.ReviewInfo.MEDIA_FILES ->
                     rb.add(
-                        JSONArray(col.media.filesInStr(currentCard.question(col) + currentCard.answer(col))),
+                        JSONArray(col.media.filesInStr(currentCard)),
                     )
                 else -> throw UnsupportedOperationException("Queue \"$column\" is unknown")
             }

AnkiDroid/src/main/java/com/ichi2/libanki/Media.kt

@@ -20,8 +20,13 @@ package com.ichi2.libanki
 import androidx.annotation.WorkerThread
 import com.google.protobuf.kotlin.toByteString
 import com.ichi2.libanki.exception.EmptyMediaException
+import com.ichi2.libanki.template.TemplateFilters
 import timber.log.Timber
 import java.io.File
+import java.util.Locale
+import java.util.TreeSet
+import java.util.regex.Matcher
+import java.util.regex.Pattern
 
 /**
  * Media manager - handles the addition and removal of media files from the media directory (collection.media) and
@@ -65,15 +70,135 @@ open class Media(
      * @param string The string to scan for media filenames ([sound:...] or <img...>).
      * @return A list containing all the sound and image filenames found in the input string.
      */
-    fun filesInStr(string: String): List<String> =
-        col.backend
-            .extractAvTags(string, true)
-            .avTagsList
-            .filter {
-                it.hasSoundOrVideo()
-            }.map {
-                it.soundOrVideo
+    fun filesInStr(
+        currentCard: Card,
+        includeRemote: Boolean = false,
+    ): List<String> {
+        val l: MutableList<String> = ArrayList()
+        val model = currentCard.noteType(col)
+        val renderOutput = currentCard.renderOutput(col)
+        val string = renderOutput.questionText + renderOutput.answerText
+
+        val strings: MutableList<String?> =
+            if (model!!.isCloze && string.contains("{{c")) {
+                // Expand clozes if necessary
+                expandClozes(string)
+            } else {
+                mutableListOf(string)
+            }
+
+        for (s in strings) {
+            var s = s
+            // Handle LaTeX
+            val svg = model.optBoolean("latexsvg", false)
+            s = LaTeX.mungeQA(s!!, col, svg)
+
+            // Extract filenames from the strings using regex patterns
+            var m: Matcher
+            for (p in REGEXPS) {
+                val fnameIdx =
+                    when (p) {
+                        fSoundRegexps -> 2
+                        fImgAudioRegExpU -> 2
+                        else -> 3
+                    }
+                m = p.matcher(s)
+                while (m.find()) {
+                    val fname = m.group(fnameIdx)!!
+                    val isLocal = !fRemotePattern.matcher(fname.lowercase(Locale.getDefault())).find()
+                    if (isLocal || includeRemote) {
+                        l.add(fname)
+                    }
+                }
+            }
+
+            val ankiPlayPattern = Pattern.compile("\\[anki:play:(q|a):(\\d+)]")
+            m = ankiPlayPattern.matcher(s)
+            while (m.find()) {
+                val side = m.group(1) // 'q' or 'a'
+                val index = m.group(2)!!.toInt()
+
+                val avTag =
+                    if (side == "q") {
+                        if (index < renderOutput.questionAvTags.size) {
+                            renderOutput.questionAvTags[index]
+                        } else {
+                            null
+                        }
+                    } else {
+                        if (index < renderOutput.answerAvTags.size) {
+                            renderOutput.answerAvTags[index]
+                        } else {
+                            null
+                        }
+                    }
+
+                if (avTag != null) {
+                    val fname = extractFilenameFromAvTag(avTag)
+                    if (fname != null) {
+                        val isLocal = !fRemotePattern.matcher(fname.lowercase(Locale.getDefault())).find()
+                        if (isLocal || includeRemote) {
+                            l.add(fname)
+                        }
+                    }
+                }
             }
+        }
+
+        return l
+    }
+
+    private fun expandClozes(string: String): MutableList<String?> {
+        val ords: MutableSet<String> = TreeSet()
+        var m = Pattern.compile("\\{\\{c(\\d+)::.+?\\}\\}").matcher(string)
+
+        while (m.find()) {
+            ords.add(m.group(1)!!)
+        }
+
+        val strings = ArrayList<String?>(ords.size + 1)
+        val clozeReg = "(?si)\\{\\{(c)%s::(.*?)(::(.*?))?\\}\\}"
+
+        for (ord in ords) {
+            val buf = StringBuffer()
+            m = Pattern.compile(String.format(Locale.US, clozeReg, ord)).matcher(string)
+
+            while (m.find()) {
+                if (!m.group(4).isNullOrEmpty()) {
+                    m.appendReplacement(buf, "[${m.group(4)}]")
+                } else {
+                    m.appendReplacement(buf, TemplateFilters.CLOZE_DELETION_REPLACEMENT)
+                }
+            }
+
+            m.appendTail(buf)
+            val s =
+                buf.toString().replace(
+                    String.format(Locale.US, clozeReg, ".+?").toRegex(),
+                    "$2",
+                )
+            strings.add(s)
+        }
+
+        strings.add(
+            string.replace(
+                String.format(Locale.US, clozeReg, ".+?").toRegex(),
+                "$2",
+            ),
+        )
+
+        return strings
+    }
+
+    private fun extractFilenameFromAvTag(avTag: AvTag): String? {
+        val tagString = avTag.toString()
+        val fname = tagString.substringAfter("filename=").substringBefore(')')
+        if (fname.isNotEmpty()) {
+            return fname
+        }
+
+        return null // Could not extract filename
+    }
 
     fun findUnusedMediaFiles(): List<File> = check().unusedFileNames.map { File(dir, it) }
 
@@ -136,6 +261,52 @@ open class Media(
     private fun restoreTrash() {
         col.backend.restoreTrash()
     }
+
+    companion object {
+        // Upstream illegal chars defined on disallowed_char()
+        // in https://github.com/ankitects/anki/blob/main/rslib/src/media/files.rs
+        private val fIllegalCharReg = Pattern.compile("[\\[\\]><:\"/?*^\\\\|\\x00\\r\\n]")
+        private val fRemotePattern = Pattern.compile("(https?|ftp)://")
+        /*
+         * A note about the regular expressions below: the python code uses named groups for the image and sound patterns.
+         * Our version of Java doesn't support named groups, so we must use indexes instead. In the expressions below, the
+         * group names (e.g., ?P<fname>) have been stripped and a comment placed above indicating the index of the group
+         * name in the original. Refer to these indexes whenever the python code makes use of a named group.
+         */
+        /**
+         * Group 1 = Contents of [sound:] tag
+         * Group 2 = "fname"
+         */
+        // Regexes defined on https://github.com/ankitects/anki/blob/b403f20cae8fcdd7c3ff4c8d21766998e8efaba0/pylib/anki/media.py#L34-L45
+        private val fSoundRegexps = Pattern.compile("(?i)(\\[sound:([^]]+)])")
+        // src element quoted case
+        /**
+         * Group 1 = Contents of `<img>|<audio>` tag
+         * Group 2 = "str"
+         * Group 3 = "fname"
+         * Group 4 = Backreference to "str" (i.e., same type of quote character)  */
+        private val fImgAudioRegExpQ =
+            Pattern.compile("(?i)(<(?:img|audio)\\b[^>]* src=([\"'])([^>]+?)(\\2)[^>]*>)")
+        private val fObjectRegExpQ =
+            Pattern.compile("(?i)(<object\\b[^>]* data=([\"'])([^>]+?)(\\2)[^>]*>)")
+        // unquoted case
+        /**
+         * Group 1 = Contents of `<img>|<audio>` tag
+         * Group 2 = "fname"
+         */
+        private val fImgAudioRegExpU =
+            Pattern.compile("(?i)(<(?:img|audio)\\b[^>]* src=(?!['\"])([^ >]+)[^>]*?>)")
+        private val fObjectRegExpU =
+            Pattern.compile("(?i)(<object\\b[^>]* data=(?!['\"])([^ >]+)[^>]*?>)")
+        val REGEXPS =
+            listOf(
+                fSoundRegexps,
+                fImgAudioRegExpQ,
+                fImgAudioRegExpU,
+                fObjectRegExpQ,
+                fObjectRegExpU,
+            )
+    }
 }
 
 fun getCollectionMediaPath(collectionPath: String): String = collectionPath.replaceFirst("\\.anki2$".toRegex(), ".media")