import UIKit
import Darwin
 
/// iOS デバイスのシステム情報を取得するユーティリティ
struct SystemInfo {
 
    /// カーネルバージョンを取得
    static func kernelVersion() -> String {
        var size = 0
        // sysctl で XNU カーネルバージョンを取得
        sysctlbyname("kern.osrelease", nil, &size, nil, 0)
        var version = CChar
        sysctlbyname("kern.osrelease", &version, &size, nil, 0)
        return String(cString: version)
    }
 
    /// 物理メモリ量を取得
    static func physicalMemory() -> UInt64 {
        return ProcessInfo.processInfo.physicalMemory
    }
 
    /// アクティブプロセッサ数を取得
    static func processorCount() -> Int {
        return ProcessInfo.processInfo.activeProcessorCount
    }
 
    /// サーマル状態を監視
    static func thermalState() -> String {
        switch ProcessInfo.processInfo.thermalState {
        case .nominal:   return "通常"
        case .fair:      return "やや高温"
        case .serious:   return "高温 - パフォーマンス低下中"
        case .critical:  return "危険 - 緊急スロットリング"
        @unknown default: return "不明"
        }
    }
 
    /// デバイス情報のサマリー
    static func summary() -> String {
        """
        ===== iOS デバイス情報 =====
        カーネル: Darwin \(kernelVersion())
        メモリ: \(physicalMemory() / 1_073_741_824) GB
        プロセッサ数: \(processorCount())
        サーマル状態: \(thermalState())
        OS: \(UIDevice.current.systemName) \(UIDevice.current.systemVersion)
        モデル: \(UIDevice.current.model)
        ================================
        """
    }
}
 
// 使用例
// print(SystemInfo.summary())
// 出力例:
// ===== iOS デバイス情報 =====
// カーネル: Darwin 24.1.0
// メモリ: 6 GB
// プロセッサ数: 6
// サーマル状態: 通常
// OS: iOS 18.2
// モデル: iPhone
// ================================

import android.os.Build
import android.app.ActivityManager
import android.content.Context
import java.io.File
 
/**
 * Android デバイスのシステム情報を取得するユーティリティ
 *
 * Android では /proc ファイルシステムを通じて
 * Linux カーネルの情報に直接アクセスできる。
 */
object SystemInfoUtil {
 
    /** Linux カーネルバージョンを取得 */
    fun getKernelVersion(): String {
        return try {
            File("/proc/version").readText().trim()
        } catch (e: Exception) {
            "取得失敗: ${e.message}"
        }
    }
 
    /** CPU 情報を取得 */
    fun getCpuInfo(): Map<String, String> {
        val info = mutableMapOf<String, String>()
        try {
            File("/proc/cpuinfo").readLines().forEach { line ->
                val parts = line.split(":")
                if (parts.size == 2) {
                    info[parts[0].trim()] = parts[1].trim()
                }
            }
        } catch (e: Exception) {
            info["error"] = e.message ?: "不明なエラー"
        }
        return info
    }
 
    /** メモリ情報を取得 */
    fun getMemoryInfo(context: Context): String {
        val activityManager = context.getSystemService(
            Context.ACTIVITY_SERVICE
        ) as ActivityManager
        val memInfo = ActivityManager.MemoryInfo()
        activityManager.getMemoryInfo(memInfo)
 
        val totalMB = memInfo.totalMem / (1024 * 1024)
        val availMB = memInfo.availMem / (1024 * 1024)
        val usedMB = totalMB - availMB
        val usagePercent = (usedMB.toDouble() / totalMB * 100).toInt()
 
        return """
            |===== Android メモリ情報 =====
            |総メモリ: ${totalMB} MB
            |使用中:   ${usedMB} MB (${usagePercent}%)
            |空き:     ${availMB} MB
            |低メモリ状態: ${memInfo.lowMemory}
            |閾値:     ${memInfo.threshold / (1024 * 1024)} MB
            |==============================
        """.trimMargin()
    }
 
    /** ビルド情報を取得 */
    fun getBuildInfo(): String {
        return """
            |===== Android ビルド情報 =====
            |デバイス: ${Build.DEVICE}
            |モデル: ${Build.MODEL}
            |メーカー: ${Build.MANUFACTURER}
            |Android バージョン: ${Build.VERSION.RELEASE}
            |SDK レベル: ${Build.VERSION.SDK_INT}
            |セキュリティパッチ: ${Build.VERSION.SECURITY_PATCH}
            |ビルド番号: ${Build.DISPLAY}
            |ABI: ${Build.SUPPORTED_ABIS.joinToString(", ")}
            |===============================
        """.trimMargin()
    }
 
    /** SELinux の状態を取得 */
    fun getSeLinuxStatus(): String {
        return try {
            val process = Runtime.getRuntime().exec("getenforce")
            val result = process.inputStream.bufferedReader().readText().trim()
            "SELinux: $result"  // Enforcing, Permissive, or Disabled
        } catch (e: Exception) {
            "SELinux: 取得失敗"
        }
    }
}

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.ProcessLifecycleOwner
 
/**
 * Android Activity ライフサイクルの包括的な実装例
 *
 * 各コールバックがいつ呼ばれるかを理解することは、
 * メモリリークやクラッシュを防ぐ上で不可欠である。
 */
class MainLifecycleActivity : AppCompatActivity() {
 
    companion object {
        private const val TAG = "LifecycleDemo"
        private const val KEY_COUNTER = "counter"
    }
 
    private var counter = 0
 
    // =========================================================
    // Activity ライフサイクルコールバック
    // =========================================================
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
        // 状態の復元（画面回転等で再生成された場合）
        savedInstanceState?.let {
            counter = it.getInt(KEY_COUNTER, 0)
            Log.d(TAG, "状態復元: counter = $counter")
        }
 
        // プロセスレベルのライフサイクル監視
        ProcessLifecycleOwner.get().lifecycle.addObserver(
            AppLifecycleObserver()
        )
 
        Log.d(TAG, "onCreate: Activity が生成された")
    }
 
    override fun onStart() {
        super.onStart()
        // Activity が画面に表示される直前
        // ここで UI の更新やセンサーの登録を行う
        Log.d(TAG, "onStart: Activity が可視状態になった")
    }
 
    override fun onResume() {
        super.onResume()
        // Activity がフォアグラウンドに来た
        // ユーザ操作を受け付ける状態
        Log.d(TAG, "onResume: Activity がアクティブになった")
    }
 
    override fun onPause() {
        super.onPause()
        // 別の Activity が前面に来た (部分的に見える場合あり)
        // 重い処理をここで行ってはならない (ANR の原因)
        Log.d(TAG, "onPause: Activity が一時停止した")
    }
 
    override fun onStop() {
        super.onStop()
        // Activity が完全に非表示になった
        // データの保存やリソースの解放を行う
        Log.d(TAG, "onStop: Activity が停止した")
    }
 
    override fun onDestroy() {
        super.onDestroy()
        // Activity が破棄される
        // 最終的なクリーンアップ
        Log.d(TAG, "onDestroy: Activity が破棄された")
    }
 
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        // 構成変更 (画面回転等) 前に状態を保存
        outState.putInt(KEY_COUNTER, counter)
        Log.d(TAG, "状態保存: counter = $counter")
    }
 
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        // OS からのメモリ解放要求
        when (level) {
            TRIM_MEMORY_UI_HIDDEN ->
                Log.d(TAG, "UIが非表示 - UIキャッシュを解放可能")
            TRIM_MEMORY_RUNNING_LOW ->
                Log.w(TAG, "メモリ低下 - 不要なリソースを解放すべき")
            TRIM_MEMORY_RUNNING_CRITICAL ->
                Log.e(TAG, "メモリ危険 - 即座にリソースを解放")
            TRIM_MEMORY_COMPLETE ->
                Log.e(TAG, "バックグラウンドで最初にkillされる状態")
        }
    }
 
    // =========================================================
    // アプリケーション全体のライフサイクル監視
    // =========================================================
 
    /**
     * ProcessLifecycleOwner を使ったアプリ全体のライフサイクル監視
     * アプリがフォアグラウンド/バックグラウンドに遷移したことを検知する
     */
    inner class AppLifecycleObserver : LifecycleEventObserver {
        override fun onStateChanged(
            source: LifecycleOwner,
            event: Lifecycle.Event
        ) {
            when (event) {
                Lifecycle.Event.ON_START ->
                    Log.d(TAG, "アプリがフォアグラウンドに遷移")
                Lifecycle.Event.ON_STOP ->
                    Log.d(TAG, "アプリがバックグラウンドに遷移")
                else -> { /* その他のイベント */ }
            }
        }
    }
}

import Foundation
import os.log
 
/// iOS アプリのメモリ使用量を監視するユーティリティ
///
/// jetsam による強制終了を回避するため、
/// メモリ使用量を定期的に監視し、閾値を超えた場合に
/// キャッシュの解放等を行う。
class MemoryMonitor {
 
    private let logger = Logger(
        subsystem: "com.example.app",
        category: "memory"
    )
 
    private var timer: Timer?
    private let warningThreshold: UInt64  // バイト単位
 
    /// 警告閾値をMB単位で指定して初期化
    init(warningThresholdMB: UInt64 = 200) {
        self.warningThreshold = warningThresholdMB * 1024 * 1024
    }
 
    /// 現在のアプリメモリ使用量を取得 (バイト)
    func currentMemoryUsage() -> UInt64 {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(
            MemoryLayout<mach_task_basic_info>.size
        ) / 4
 
        let result = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(
                to: integer_t.self,
                capacity: Int(count)
            ) {
                task_info(
                    mach_task_self_,
                    task_flavor_t(MACH_TASK_BASIC_INFO),
                    $0,
                    &count
                )
            }
        }
 
        guard result == KERN_SUCCESS else {
            return 0
        }
        return info.resident_size
    }
 
    /// メモリ使用量を MB 単位で返す
    func currentMemoryMB() -> Double {
        Double(currentMemoryUsage()) / (1024.0 * 1024.0)
    }
 
    /// 定期監視を開始 (指定間隔ごとにチェック)
    func startMonitoring(intervalSeconds: TimeInterval = 5.0) {
        timer = Timer.scheduledTimer(
            withTimeInterval: intervalSeconds,
            repeats: true
        ) { [weak self] _ in
            guard let self = self else { return }
            let usage = self.currentMemoryUsage()
            let usageMB = Double(usage) / (1024.0 * 1024.0)
 
            self.logger.info("メモリ使用量: \(usageMB, format: .fixed(precision: 1)) MB")
 
            if usage > self.warningThreshold {
                self.logger.warning(
                    "メモリ警告: \(usageMB, format: .fixed(precision: 1)) MB " +
                    "(閾値: \(Double(self.warningThreshold) / (1024.0 * 1024.0)) MB)"
                )
                // キャッシュの解放やリソースの縮小を実行
                self.handleMemoryPressure()
            }
        }
    }
 
    /// 監視を停止
    func stopMonitoring() {
        timer?.invalidate()
        timer = nil
    }
 
    /// メモリ圧力への対処
    private func handleMemoryPressure() {
        // 画像キャッシュのクリア
        URLCache.shared.removeAllCachedResponses()
 
        // カスタムキャッシュの解放
        NotificationCenter.default.post(
            name: .init("MemoryPressureWarning"),
            object: nil
        )
 
        logger.info("メモリ圧力対応: キャッシュをクリアしました")
    }
}
 
// 使用例:
// let monitor = MemoryMonitor(warningThresholdMB: 500)
// monitor.startMonitoring(intervalSeconds: 3.0)
// print("現在のメモリ: \(monitor.currentMemoryMB()) MB")

import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.os.Build
import android.util.Log
import androidx.core.app.NotificationCompat
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
 
/**
 * Firebase Cloud Messaging (FCM) の通知受信サービス
 *
 * このサービスは以下の2種類のメッセージを処理する:
 * 1. 通知メッセージ (notification) - OS が自動表示
 * 2. データメッセージ (data) - アプリが処理を制御
 *
 * Doze モード中でも High Priority メッセージは配信される。
 */
class AppFirebaseMessagingService : FirebaseMessagingService() {
 
    companion object {
        private const val TAG = "FCMService"
        private const val CHANNEL_ID = "default_channel"
        private const val CHANNEL_NAME = "一般通知"
    }
 
    /**
     * FCM トークンが更新された時に呼ばれる
     * 新しいトークンをアプリサーバに送信する必要がある
     */
    override fun onNewToken(token: String) {
        super.onNewToken(token)
        Log.d(TAG, "FCM トークン更新: $token")
        sendTokenToServer(token)
    }
 
    /**
     * メッセージを受信した時に呼ばれる
     *
     * 注意:
     * - フォアグラウンド: notification + data 両方ここで処理
     * - バックグラウンド: notification は OS が表示、data のみここ
     */
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)
 
        Log.d(TAG, "送信元: ${remoteMessage.from}")
        Log.d(TAG, "メッセージID: ${remoteMessage.messageId}")
 
        // データペイロードの処理
        if (remoteMessage.data.isNotEmpty()) {
            Log.d(TAG, "データ: ${remoteMessage.data}")
            handleDataMessage(remoteMessage.data)
        }
 
        // 通知ペイロードの処理 (フォアグラウンド時)
        remoteMessage.notification?.let { notification ->
            Log.d(TAG, "通知タイトル: ${notification.title}")
            Log.d(TAG, "通知本文: ${notification.body}")
            showNotification(
                title = notification.title ?: "通知",
                body = notification.body ?: "",
                data = remoteMessage.data
            )
        }
    }
 
    /**
     * データメッセージの処理
     * バックグラウンド同期やサイレント更新に使用
     */
    private fun handleDataMessage(data: Map<String, String>) {
        val type = data["type"] ?: return
        when (type) {
            "sync" -> {
                // バックグラウンドデータ同期をスケジュール
                Log.d(TAG, "同期リクエスト受信")
            }
            "update" -> {
                // アプリ内データの更新
                val payload = data["payload"]
                Log.d(TAG, "更新データ: $payload")
            }
            "silent" -> {
                // サイレント通知 (UI表示なし)
                Log.d(TAG, "サイレント処理実行")
            }
        }
    }
 
    /**
     * 通知の表示
     * Android 8.0+ では NotificationChannel が必須
     */
    private fun showNotification(
        title: String,
        body: String,
        data: Map<String, String>
    ) {
        val notificationManager = getSystemService(
            Context.NOTIFICATION_SERVICE
        ) as NotificationManager
 
        // Android 8.0+ 用の通知チャンネル作成
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                CHANNEL_ID,
                CHANNEL_NAME,
                NotificationManager.IMPORTANCE_HIGH
            ).apply {
                description = "アプリの一般通知"
                enableVibration(true)
            }
            notificationManager.createNotificationChannel(channel)
        }
 
        // タップ時に開くActivityの設定
        val intent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_CLEAR_TOP
            data.forEach { (key, value) -> putExtra(key, value) }
        }
        val pendingIntent = PendingIntent.getActivity(
            this, 0, intent,
            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE
        )
 
        // 通知の構築と表示
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle(title)
            .setContentText(body)
            .setAutoCancel(true)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setContentIntent(pendingIntent)
            .build()
 
        notificationManager.notify(
            System.currentTimeMillis().toInt(),
            notification
        )
    }
 
    /** FCM トークンをアプリサーバに送信 */
    private fun sendTokenToServer(token: String) {
        // 実装: APIサーバにHTTPS POSTで送信
        // RetrofitやOkHttpを使用するのが一般的
        Log.d(TAG, "トークンをサーバに送信: $token")
    }
}

import CoreMotion
import Foundation
 
/**
 * CoreMotion を使ったデバイスの動き検知
 *
 * Motion Coprocessor により、アプリがバックグラウンドでも
 * 低消費電力でセンサーデータを収集できる。
 *
 * 歩数計測、階段昇降検知、車両乗車検知などに利用する。
 */
class MotionDetector {
 
    private let motionManager = CMMotionManager()
    private let pedometer = CMPedometer()
    private let activityManager = CMMotionActivityManager()
    private let altimeter = CMAltimeter()
 
    // ===================================================
    // 加速度・ジャイロの生データ取得
    // ===================================================
 
    /// 加速度センサーを開始 (ゲーム、AR 用)
    func startAccelerometer(
        interval: TimeInterval = 0.1,
        handler: @escaping (CMAccelerometerData) -> Void
    ) {
        guard motionManager.isAccelerometerAvailable else {
            print("加速度センサーが利用不可")
            return
        }
 
        motionManager.accelerometerUpdateInterval = interval
        motionManager.startAccelerometerUpdates(
            to: .main
        ) { data, error in
            guard let data = data, error == nil else { return }
            // data.acceleration.x/y/z は重力加速度を含む (-1.0 ~ +1.0 G)
            handler(data)
        }
    }
 
    /// デバイスモーション (センサーフュージョン結果)
    func startDeviceMotion(
        interval: TimeInterval = 0.05,
        handler: @escaping (CMDeviceMotion) -> Void
    ) {
        guard motionManager.isDeviceMotionAvailable else { return }
 
        motionManager.deviceMotionUpdateInterval = interval
        motionManager.startDeviceMotionUpdates(
            using: .xArbitraryZVertical,
            to: .main
        ) { motion, error in
            guard let motion = motion, error == nil else { return }
            // motion.attitude    : 姿勢 (roll, pitch, yaw)
            // motion.rotationRate: 角速度
            // motion.gravity     : 重力成分
            // motion.userAcceleration: ユーザの加速度 (重力除去済み)
            handler(motion)
        }
    }
 
    // ===================================================
    // 歩数計測 (Motion Coprocessor 利用)
    // ===================================================
 
    /// 歩数のリアルタイム計測を開始
    func startPedometer(
        handler: @escaping (Int, Double) -> Void
    ) {
        guard CMPedometer.isStepCountingAvailable() else {
            print("歩数計測が利用不可")
            return
        }
 
        pedometer.startUpdates(from: Date()) { data, error in
            guard let data = data, error == nil else { return }
            let steps = data.numberOfSteps.intValue
            let distance = data.distance?.doubleValue ?? 0
            handler(steps, distance)
        }
    }
 
    // ===================================================
    // アクティビティ認識 (歩行/走行/自動車/自転車)
    // ===================================================
 
    /// ユーザのアクティビティタイプを検知
    func startActivityRecognition(
        handler: @escaping (String) -> Void
    ) {
        guard CMMotionActivityManager.isActivityAvailable() else {
            return
        }
 
        activityManager.startActivityUpdates(
            to: .main
        ) { activity in
            guard let activity = activity else { return }
            var type = "不明"
            if activity.walking   { type = "歩行" }
            if activity.running   { type = "走行" }
            if activity.cycling   { type = "自転車" }
            if activity.automotive{ type = "自動車" }
            if activity.stationary{ type = "静止" }
            handler(type)
        }
    }
 
    // ===================================================
    // クリーンアップ
    // ===================================================
 
    func stopAll() {
        motionManager.stopAccelerometerUpdates()
        motionManager.stopDeviceMotionUpdates()
        pedometer.stopUpdates()
        activityManager.stopActivityUpdates()
    }
}
 
// 使用例:
// let detector = MotionDetector()
// detector.startPedometer { steps, distance in
//     print("歩数: \(steps), 距離: \(distance)m")
// }
// detector.startActivityRecognition { type in
//     print("現在の活動: \(type)")
// }

import android.content.Context
import android.hardware.Sensor
import android.hardware.SensorEvent
import android.hardware.SensorEventListener
import android.hardware.SensorManager
import android.util.Log
import kotlin.math.sqrt
 
/**
 * Android SensorManager を使った加速度とシェイク検知
 *
 * HAL を通じてベンダー固有のセンサーハードウェアに
 * 統一的にアクセスする例を示す。
 *
 * 電力効率のため、不要になったら必ず unregister すること。
 */
class ShakeDetector(
    private val context: Context,
    private val onShake: () -> Unit
) : SensorEventListener {
 
    companion object {
        private const val TAG = "ShakeDetector"
        private const val SHAKE_THRESHOLD = 12.0f  // m/s^2
        private const val MIN_TIME_BETWEEN_SHAKES = 1000L  // ms
    }
 
    private val sensorManager: SensorManager =
        context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
 
    private var lastShakeTime = 0L
 
    /** センサーの登録と開始 */
    fun start() {
        val accelerometer = sensorManager.getDefaultSensor(
            Sensor.TYPE_LINEAR_ACCELERATION  // 重力成分を除去済み
        )
        if (accelerometer != null) {
            sensorManager.registerListener(
                this,
                accelerometer,
                SensorManager.SENSOR_DELAY_UI  // 約60ms間隔
            )
            Log.d(TAG, "加速度センサー開始")
        } else {
            Log.w(TAG, "LINEAR_ACCELERATION センサーが利用不可")
        }
    }
 
    /** センサーの登録解除 */
    fun stop() {
        sensorManager.unregisterListener(this)
        Log.d(TAG, "加速度センサー停止")
    }
 
    override fun onSensorChanged(event: SensorEvent) {
        val x = event.values[0]
        val y = event.values[1]
        val z = event.values[2]
 
        // 3軸の合成加速度を計算
        val magnitude = sqrt(x * x + y * y + z * z)
 
        if (magnitude > SHAKE_THRESHOLD) {
            val now = System.currentTimeMillis()
            if (now - lastShakeTime > MIN_TIME_BETWEEN_SHAKES) {
                lastShakeTime = now
                Log.d(TAG, "シェイク検知: 加速度 = $magnitude m/s^2")
                onShake()
            }
        }
    }
 
    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        Log.d(TAG, "精度変更: ${sensor.name} → $accuracy")
    }
 
    /** 利用可能な全センサーを列挙 */
    fun listAllSensors(): List<String> {
        return sensorManager.getSensorList(Sensor.TYPE_ALL).map {
            "${it.name} (type=${it.type}, vendor=${it.vendor}, " +
            "power=${it.power}mA, resolution=${it.resolution})"
        }
    }
}
 
// 使用例 (Activity 内):
// val shakeDetector = ShakeDetector(this) {
//     Toast.makeText(this, "シェイクを検知しました", Toast.LENGTH_SHORT).show()
// }
// override fun onResume() { super.onResume(); shakeDetector.start() }
// override fun onPause() { super.onPause(); shakeDetector.stop() }

// app/build.gradle.kts
// Android アプリのビルド設定
 
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.hilt)
    alias(libs.plugins.ksp)
}
 
android {
    namespace = "com.example.mobileapp"
    compileSdk = 35
 
    defaultConfig {
        applicationId = "com.example.mobileapp"
        minSdk = 26          // Android 8.0 以上
        targetSdk = 35       // 最新 API レベル
        versionCode = 1
        versionName = "1.0.0"
 
        testInstrumentationRunner =
            "androidx.test.runner.AndroidJUnitRunner"
 
        // BuildConfig にビルド情報を埋め込む
        buildConfigField(
            "String", "BUILD_TIME",
            "\"${java.time.Instant.now()}\""
        )
    }
 
    // ビルドバリアント: debug / staging / release
    buildTypes {
        debug {
            isDebuggable = true
            applicationIdSuffix = ".debug"
            versionNameSuffix = "-debug"
        }
        create("staging") {
            isDebuggable = false
            applicationIdSuffix = ".staging"
            signingConfig = signingConfigs.getByName("debug")
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
        release {
            isMinifyEnabled = true    // R8 によるコード縮小
            isShrinkResources = true  // 未使用リソース削除
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
 
    // Jetpack Compose 設定
    buildFeatures {
        compose = true
        buildConfig = true
    }
 
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget = "17"
    }
}
 
dependencies {
    // Jetpack Compose
    implementation(platform(libs.compose.bom))
    implementation(libs.compose.ui)
    implementation(libs.compose.material3)
    implementation(libs.compose.navigation)
 
    // ライフサイクル
    implementation(libs.lifecycle.viewmodel.compose)
    implementation(libs.lifecycle.runtime.compose)
 
    // DI (Hilt)
    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)
 
    // ネットワーク
    implementation(libs.retrofit)
    implementation(libs.okhttp)
 
    // テスト
    testImplementation(libs.junit)
    testImplementation(libs.mockk)
    androidTestImplementation(libs.compose.ui.test)
}

// NG: メインスレッドでネットワーク通信
// Android では NetworkOnMainThreadException が発生する
fun loadDataBad() {
    val url = URL("https://api.example.com/data")
    val data = url.readText()  // メインスレッドをブロック
    textView.text = data
}

// OK: コルーチンでバックグラウンド処理
fun loadDataGood() {
    viewModelScope.launch {
        val data = withContext(Dispatchers.IO) {
            // IO ディスパッチャでネットワーク通信
            repository.fetchData()
        }
        // メインスレッドで UI 更新 (自動的に Dispatchers.Main)
        _uiState.value = UiState.Success(data)
    }
}