feat: 検品レポート PDF とレポートのメール共有（iOS / Android）

android/app/src/main/AndroidManifest.xml

@@ -17,6 +17,15 @@
         android:name="android.hardware.camera.any"
         android:required="false" />
 
+    <!-- Package visibility for the report e-mail hand-off: the app only asks
+         which installed apps accept mailto:, it never talks to them itself. -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.SENDTO" />
+            <data android:scheme="mailto" />
+        </intent>
+    </queries>
+
     <application
         android:name=".CodeMatchApplication"
         android:allowBackup="false"

android/app/src/main/java/jp/rimtty/codematch/history/HistoryPdfBridge.kt

@@ -11,6 +11,9 @@ import java.io.File
 import java.io.OutputStream
 import java.time.ZoneId
 import jp.rimtty.codematch.core.export.HistoryPdfExporter
+import jp.rimtty.codematch.core.export.HistoryReportKind
+import jp.rimtty.codematch.core.export.ReportMail
+import jp.rimtty.codematch.core.export.ReportMailContent
 import jp.rimtty.codematch.core.model.AppLanguage
 import jp.rimtty.codematch.core.model.MatchSession
 
@@ -87,15 +90,16 @@ internal object HistoryPdfBridge {
         session: MatchSession,
         language: AppLanguage,
         zoneId: ZoneId = ZoneId.systemDefault(),
+        kind: HistoryReportKind = HistoryReportKind.MATCH_HISTORY,
     ): HistoryPdfResult<PendingHistoryPdf> = createDocument(
         session = session,
         language = language,
         zoneId = zoneId,
         generate = { currentSession, currentLanguage, currentZone ->
-            HistoryPdfExporter.generate(currentSession, currentLanguage, currentZone)
+            HistoryPdfExporter.generate(currentSession, currentLanguage, currentZone, kind)
         },
         fileName = { currentSession, currentLanguage, currentZone ->
-            HistoryPdfExporter.fileName(currentSession, currentLanguage, currentZone)
+            HistoryPdfExporter.fileName(currentSession, currentLanguage, currentZone, kind)
         },
     )
 
@@ -155,9 +159,10 @@ internal object HistoryPdfBridge {
         session: MatchSession,
         language: AppLanguage,
         zoneId: ZoneId = ZoneId.systemDefault(),
+        kind: HistoryReportKind = HistoryReportKind.MATCH_HISTORY,
     ): HistoryPdfResult<File> = try {
         HistoryPdfResult.Success(
-            HistoryPdfExporter.writeToCache(context, session, language, zoneId),
+            HistoryPdfExporter.writeToCache(context, session, language, zoneId, kind),
         )
     } catch (_: Exception) {
         HistoryPdfResult.Failure(HistoryPdfFailure.CACHE_WRITE_FAILED)
@@ -187,6 +192,59 @@ internal object HistoryPdfBridge {
         HistoryPdfResult.Failure(HistoryPdfFailure.FILE_PROVIDER_FAILED)
     }
 
+    /**
+     * The e-mail hand-off for a report: a mail app opens with the recipient,
+     * subject, body and the PDF attached, and the operator only has to send.
+     * When no mail app can take the intent the plain share chooser is used so
+     * the PDF can still leave the device.
+     */
+    fun createMailOrShareChooser(context: Context, file: File, mail: ReportMail): HistoryPdfResult<Intent> =
+        createMailOrShareChooser(
+            file = file,
+            mail = mail,
+            uriForFile = { current ->
+                FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", current)
+            },
+            hasMailApp = { intent ->
+                // A resolver failure only means "no mail app to hand off to"; the
+                // share chooser must still open, so it is not a provider failure.
+                runCatching { context.packageManager.queryIntentActivities(intent, 0).isNotEmpty() }
+                    .getOrDefault(false)
+            },
+        )
+
+    /** Injectable URI and resolver seams so both branches are testable without a real FileProvider root. */
+    internal fun createMailOrShareChooser(
+        file: File,
+        mail: ReportMail,
+        uriForFile: (File) -> Uri,
+        hasMailApp: (Intent) -> Boolean,
+    ): HistoryPdfResult<Intent> = try {
+        val uri = uriForFile(file)
+        val mailIntent = createMailIntent(uri, mail)
+        HistoryPdfResult.Success(
+            if (hasMailApp(mailIntent)) mailIntent else Intent.createChooser(createShareIntent(uri), null),
+        )
+    } catch (_: Exception) {
+        HistoryPdfResult.Failure(HistoryPdfFailure.FILE_PROVIDER_FAILED)
+    }
+
+    /**
+     * `ACTION_SEND` carrying the PDF plus the mail fields, restricted to mail
+     * apps through a `mailto:` selector. The system resolver lets the operator
+     * pin one mail app ("always") when several are installed.
+     */
+    internal fun createMailIntent(uri: Uri, mail: ReportMail): Intent = Intent(Intent.ACTION_SEND).apply {
+        type = PDF_MIME_TYPE
+        putExtra(Intent.EXTRA_EMAIL, ReportMailContent.recipients)
+        putExtra(Intent.EXTRA_SUBJECT, mail.subject)
+        putExtra(Intent.EXTRA_TEXT, mail.body)
+        putExtra(Intent.EXTRA_STREAM, uri)
+        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        clipData = ClipData.newRawUri(null, uri)
+        selector = Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:"))
+    }
+
     internal fun launchShare(context: Context, chooser: Intent): HistoryPdfResult<Unit> = try {
         context.startActivity(chooser)
         HistoryPdfResult.Success(Unit)

android/app/src/main/java/jp/rimtty/codematch/history/HistoryRoute.kt

@@ -28,6 +28,8 @@ import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
 import jp.rimtty.codematch.R
+import jp.rimtty.codematch.core.export.HistoryReportKind
+import jp.rimtty.codematch.core.export.ReportMailContent
 import jp.rimtty.codematch.core.model.AppLanguage
 import jp.rimtty.codematch.core.model.MatchSession
 import jp.rimtty.codematch.feature.history.HistoryContent
@@ -65,6 +67,7 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
     // intentionally not persisted; an interrupted picker flow is regenerated
     // from the current Room session when the user retries.
     var latestSaveSessionId by rememberSaveable { mutableStateOf<String?>(null) }
+    var latestSaveKind by rememberSaveable { mutableStateOf(HistoryReportKind.MATCH_HISTORY) }
     var exportGeneration by remember { mutableStateOf(0L) }
     var launchSavePicker: ((PendingHistoryPdf) -> Unit)? = null
 
@@ -77,35 +80,37 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
         feedback = HistoryPdfFeedback(message = message, retry = retry)
     }
 
-    fun startSave(session: MatchSession) {
+    fun startSave(session: MatchSession, kind: HistoryReportKind) {
         feedback = null
         latestSaveSessionId = session.id
+        latestSaveKind = kind
         val generation = exportGeneration + 1L
         exportGeneration = generation
         pendingDocument = null
         preparePdfForSave(
             session = session,
             language = state.language,
+            kind = kind,
             scope = scope,
         ) { result ->
             if (generation != exportGeneration) return@preparePdfForSave
             when (result) {
                 is HistoryPdfResult.Success -> {
                     val launch = launchSavePicker
                     if (launch == null) {
-                        reportPdfFailure(saveErrorMessage) { startSave(session) }
+                        reportPdfFailure(saveErrorMessage) { startSave(session, kind) }
                     } else {
                         launch(result.value)
                     }
                 }
                 is HistoryPdfResult.Failure -> {
-                    reportPdfFailure(saveErrorMessage) { startSave(session) }
+                    reportPdfFailure(saveErrorMessage) { startSave(session, kind) }
                 }
             }
         }
     }
 
-    fun startShare(session: MatchSession) {
+    fun startShare(session: MatchSession, kind: HistoryReportKind) {
         feedback = null
         val generation = exportGeneration + 1L
         exportGeneration = generation
@@ -114,6 +119,7 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
             context = context,
             session = session,
             language = state.language,
+            kind = kind,
             scope = scope,
         ) { result ->
             if (generation != exportGeneration) return@preparePdfForShare
@@ -122,12 +128,12 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
                     when (HistoryPdfBridge.launchShare(context, result.value)) {
                         is HistoryPdfResult.Success -> Unit
                         is HistoryPdfResult.Failure -> {
-                            reportPdfFailure(shareErrorMessage) { startShare(session) }
+                            reportPdfFailure(shareErrorMessage) { startShare(session, kind) }
                         }
                     }
                 }
                 is HistoryPdfResult.Failure -> {
-                    reportPdfFailure(shareErrorMessage) { startShare(session) }
+                    reportPdfFailure(shareErrorMessage) { startShare(session, kind) }
                 }
             }
         }
@@ -175,7 +181,8 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
             }
             HistoryPdfPickerResult.MissingPendingDocument -> {
                 val retrySession = state.sessions.firstOrNull { it.id == latestSaveSessionId }
-                reportPdfFailure(saveErrorMessage, retrySession?.let { session -> { startSave(session) } })
+                val retryKind = latestSaveKind
+                reportPdfFailure(saveErrorMessage, retrySession?.let { session -> { startSave(session, retryKind) } })
             }
             is HistoryPdfPickerResult.Selected -> {
                 val generation = exportGeneration
@@ -211,7 +218,8 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
             is HistoryPdfResult.Failure -> {
                 pendingDocument = null
                 val retrySession = state.sessions.firstOrNull { it.id == latestSaveSessionId }
-                reportPdfFailure(saveErrorMessage, retrySession?.let { session -> { startSave(session) } })
+                val retryKind = latestSaveKind
+                reportPdfFailure(saveErrorMessage, retrySession?.let { session -> { startSave(session, retryKind) } })
             }
         }
     }
@@ -285,8 +293,10 @@ fun HistoryRoute(modifier: Modifier = Modifier) {
                 },
                 onEntrySelected = { entryId -> selectedEntryId = entryId },
                 onBack = goBack,
-                onSavePdf = ::startSave,
-                onSharePdf = ::startShare,
+                onSavePdf = { session -> startSave(session, HistoryReportKind.MATCH_HISTORY) },
+                onSharePdf = { session -> startShare(session, HistoryReportKind.MATCH_HISTORY) },
+                onSaveInspectionReport = { session -> startSave(session, HistoryReportKind.INSPECTION) },
+                onShareInspectionReport = { session -> startShare(session, HistoryReportKind.INSPECTION) },
                 onShareAllHistory = ::startShareAllHistory,
                 modifier = Modifier.fillMaxSize(),
             )
@@ -369,11 +379,12 @@ internal fun HistoryPdfFeedbackHost(
 private fun preparePdfForSave(
     session: MatchSession,
     language: AppLanguage,
+    kind: HistoryReportKind,
     scope: kotlinx.coroutines.CoroutineScope,
     onResult: (HistoryPdfResult<PendingHistoryPdf>) -> Unit,
 ) {
     scope.launch(Dispatchers.IO) {
-        val result = HistoryPdfBridge.createDocument(session, language)
+        val result = HistoryPdfBridge.createDocument(session, language, kind = kind)
         withContext(Dispatchers.Main.immediate) { onResult(result) }
     }
 }
@@ -382,12 +393,19 @@ private fun preparePdfForShare(
     context: Context,
     session: MatchSession,
     language: AppLanguage,
+    kind: HistoryReportKind,
     scope: kotlinx.coroutines.CoroutineScope,
     onResult: (HistoryPdfResult<Intent>) -> Unit,
 ) {
     scope.launch(Dispatchers.IO) {
-        val result = when (val cacheResult = HistoryPdfBridge.writeShareCache(context, session, language)) {
-            is HistoryPdfResult.Success -> HistoryPdfBridge.createShareChooser(context, cacheResult.value)
+        val result = when (
+            val cacheResult = HistoryPdfBridge.writeShareCache(context, session, language, kind = kind)
+        ) {
+            is HistoryPdfResult.Success -> HistoryPdfBridge.createMailOrShareChooser(
+                context,
+                cacheResult.value,
+                ReportMailContent.build(session, kind, cacheResult.value.name, language),
+            )
             is HistoryPdfResult.Failure -> HistoryPdfResult.Failure(cacheResult.reason)
         }
         withContext(Dispatchers.Main.immediate) {

android/app/src/test/java/jp/rimtty/codematch/history/HistoryPdfBridgeTest.kt

@@ -10,6 +10,9 @@ import java.io.ByteArrayOutputStream
 import java.io.File
 import java.time.ZoneId
 import jp.rimtty.codematch.core.export.HistoryPdfExporter
+import jp.rimtty.codematch.core.export.HistoryReportKind
+import jp.rimtty.codematch.core.export.ReportMail
+import jp.rimtty.codematch.core.export.ReportMailContent
 import jp.rimtty.codematch.core.model.AppLanguage
 import jp.rimtty.codematch.core.model.MatchSession
 import org.junit.Assert.assertArrayEquals
@@ -52,6 +55,23 @@ class HistoryPdfBridgeTest {
         assertFalse(fileName.contains(".."))
     }
 
+    @Test
+    fun inspectionReportDocumentUsesTheInspectionPrefixAndStaysAPdf() {
+        val session = MatchSession(startedAt = 0L, name = "morning")
+
+        val fileName = HistoryPdfExporter.fileName(
+            session,
+            AppLanguage.ENGLISH,
+            ZoneId.of("UTC"),
+            HistoryReportKind.INSPECTION,
+        )
+        val document = PendingHistoryPdf(bytes = "%PDF-test".toByteArray(), fileName = fileName)
+
+        assertTrue(fileName, fileName.startsWith("InspectionReport_") && fileName.endsWith(".pdf"))
+        assertFalse(fileName.contains("morning"))
+        assertEquals(HistoryPdfBridge.PDF_MIME_TYPE, document.mimeType)
+    }
+
     @Test(expected = IllegalArgumentException::class)
     fun pendingDocumentRejectsPathTraversal() {
         PendingHistoryPdf(
@@ -245,6 +265,49 @@ class HistoryPdfBridgeTest {
         )
     }
 
+    @Test
+    fun mailIntentCarriesRecipientSubjectBodyAttachmentAndMailtoSelector() {
+        val uri = Uri.parse("content://${context.packageName}.fileprovider/history_pdf/report.pdf")
+        val mail = ReportMail(subject = "[CodeMatch] 検品レポート 朝便", body = "本文")
+
+        val intent = HistoryPdfBridge.createMailIntent(uri, mail)
+
+        assertEquals(Intent.ACTION_SEND, intent.action)
+        assertEquals(HistoryPdfBridge.PDF_MIME_TYPE, intent.type)
+        assertEquals(listOf(ReportMailContent.RECIPIENT), intent.getStringArrayExtra(Intent.EXTRA_EMAIL)?.toList())
+        assertEquals(mail.subject, intent.getStringExtra(Intent.EXTRA_SUBJECT))
+        assertEquals(mail.body, intent.getStringExtra(Intent.EXTRA_TEXT))
+        @Suppress("DEPRECATION")
+        assertEquals(uri, intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM))
+        assertTrue(intent.flags and Intent.FLAG_GRANT_READ_URI_PERMISSION != 0)
+        assertEquals(uri, intent.clipData?.getItemAt(0)?.uri)
+        val selector = requireNotNull(intent.selector)
+        assertEquals(Intent.ACTION_SENDTO, selector.action)
+        assertEquals("mailto", selector.data?.scheme)
+    }
+
+    @Test
+    fun mailHandOffOpensTheMailIntentWhenAMailAppExistsAndTheChooserOtherwise() {
+        val uri = Uri.parse("content://${context.packageName}.fileprovider/history_pdf/report.pdf")
+        val file = File(context.cacheDir, "report.pdf")
+        val mail = ReportMail(subject = "s", body = "b")
+
+        val withMailApp = HistoryPdfBridge.createMailOrShareChooser(file, mail, { uri }, { true })
+        val withoutMailApp = HistoryPdfBridge.createMailOrShareChooser(file, mail, { uri }, { false })
+        val providerFailure = HistoryPdfBridge.createMailOrShareChooser(file, mail, { error("no root") }, { true })
+
+        assertTrue("result=$withMailApp", withMailApp is HistoryPdfResult.Success)
+        val mailIntent = (withMailApp as HistoryPdfResult.Success).value
+        assertEquals(Intent.ACTION_SEND, mailIntent.action)
+        assertEquals(mail.subject, mailIntent.getStringExtra(Intent.EXTRA_SUBJECT))
+
+        assertTrue("result=$withoutMailApp", withoutMailApp is HistoryPdfResult.Success)
+        assertEquals(Intent.ACTION_CHOOSER, (withoutMailApp as HistoryPdfResult.Success).value.action)
+
+        assertTrue(providerFailure is HistoryPdfResult.Failure)
+        assertEquals(HistoryPdfFailure.FILE_PROVIDER_FAILED, (providerFailure as HistoryPdfResult.Failure).reason)
+    }
+
     @Test
     fun shareChooserUsesFileProviderUriPdfTypeClipDataAndReadGrant() {
         val directory = File(context.cacheDir, HistoryPdfExporter.CACHE_DIRECTORY)