Kotlinを活用したデータ保存のたった12の方法

import android.content.Context

// SharedPreferencesを初期化
val sharedPref = context.getSharedPreferences("my_app", Context.MODE_PRIVATE)

// データを保存する
val editor = sharedPref.edit()
editor.putString("username", "tanaka")
editor.putInt("age", 25)
editor.apply()

import android.content.Context
import com.google.gson.Gson

// 保存するリストデータ
val listData = listOf("apple", "banana", "cherry")

// Gsonライブラリを使ってリストをJSON形式の文字列に変換
val jsonData = Gson().toJson(listData)

// SharedPreferencesにJSON文字列として保存
val sharedPref = context.getSharedPreferences("my_app", Context.MODE_PRIVATE)
val editor = sharedPref.edit()
editor.putString("fruit_list", jsonData)
editor.apply()

import android.content.Context
import com.google.gson.Gson

// Userオブジェクトの作成
val user = User(name = "山田太郎", age = 30, email = "taro.yamada@example.com")

// Gsonを使用してオブジェクトをJSON形式の文字列に変換
val jsonString = Gson().toJson(user)

// SharedPreferencesに保存
val sharedPref = context.getSharedPreferences("my_app_data", Context.MODE_PRIVATE)
val editor = sharedPref.edit()
editor.putString("saved_user", jsonString)
editor.apply()

import java.util.Base64
import javax.crypto.Cipher
import javax.crypto.spec.SecretKeySpec

object CryptoUtil {
    private const val ALGORITHM = "AES"
    private val keyValue = byteArrayOf('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P')

    fun encrypt(dataToEncrypt: String): String {
        val key = SecretKeySpec(keyValue, ALGORITHM)
        val c = Cipher.getInstance(ALGORITHM)
        c.init(Cipher.ENCRYPT_MODE, key)
        val encVal = c.doFinal(dataToEncrypt.toByteArray())
        return Base64.getEncoder().encodeToString(encVal)
    }

    fun decrypt(encryptedData: String): String {
        val key = SecretKeySpec(keyValue, ALGORITHM)
        val c = Cipher.getInstance(ALGORITHM)
        c.init(Cipher.DECRYPT_MODE, key)
        val decodedValue = Base64.getDecoder().decode(encryptedData)
        val decValue = c.doFinal(decodedValue)
        return String(decValue)
    }
}

val dataToSave = "秘密の情報"
val encryptedData = CryptoUtil.encrypt(dataToSave)

val sharedPref = context.getSharedPreferences("secure_data", Context.MODE_PRIVATE)
val editor = sharedPref.edit()
editor.putString("encrypted_data_key", encryptedData)
editor.apply()

dependencies {
    implementation "androidx.room:room-runtime:2.3.0"
    kapt "androidx.room:room-compiler:2.3.0"
}

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity
data class UserEntity(
    @PrimaryKey(autoGenerate = true) val id: Int,
    val name: String,
    val age: Int
)

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query

@Dao
interface UserDao {
    @Insert
    fun insert(user: UserEntity): Long

    @Query("SELECT * FROM UserEntity")
    fun getAllUsers(): List<UserEntity>
}

import androidx.room.Database
import androidx.room.RoomDatabase

@Database(entities = [UserEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

import androidx.room.Entity
import androidx.room.ForeignKey

@Entity(foreignKeys = [ForeignKey(entity = UserEntity::class,
                                  parentColumns = ["id"],
                                  childColumns = ["userId"],
                                  onDelete = ForeignKey.CASCADE)])
data class BookEntity(
    @PrimaryKey(autoGenerate = true) val bookId: Int,
    val userId: Int,
    val title: String
)

import android.Manifest
import android.content.pm.PackageManager
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

// 権限のリクエストコード
private val PERMISSION_REQUEST_CODE = 100

// 権限をチェックする
if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
    // 権限がなければリクエスト
    ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE), PERMISSION_REQUEST_CODE)
}

import android.graphics.Bitmap
import android.os.Environment
import java.io.File
import java.io.FileOutputStream

fun saveBitmapToExternalStorage(bitmap: Bitmap, fileName: String) {
    val directory = File(Environment.getExternalStorageDirectory(), "MyApp")
    if (!directory.exists()) {
        directory.mkdir()
    }

    val file = File(directory, fileName)
    val outStream = FileOutputStream(file)
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, outStream)
    outStream.flush()
    outStream.close()
}

import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.FileReader
import java.io.FileWriter

// ファイルへの書き込み
fun writeToFile(filePath: String, content: String) {
    val file = File(Environment.getExternalStorageDirectory(), filePath)
    val writer = BufferedWriter(FileWriter(file))
    writer.write(content)
    writer.close()
}

// ファイルからの読み込み
fun readFromFile(filePath: String): String {
    val file = File(Environment.getExternalStorageDirectory(), filePath)
    val reader = BufferedReader(FileReader(file))
    val content = reader.readText()
    reader.close()
    return content
}

import android.content.Context
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.nio.channels.FileChannel

fun backupData(context: Context, backupFileName: String) {
    val currentDBPath = context.getDatabasePath("your-database-name").absolutePath
    val backupDBPath = File(context.getExternalFilesDir(null), backupFileName)

    val src = FileInputStream(currentDBPath).channel
    val dst = FileOutputStream(backupDBPath).channel
    dst.transferFrom(src, 0, src.size())
    src.close()
    dst.close()
}

import com.google.firebase.firestore.FirebaseFirestore

val db = FirebaseFirestore.getInstance()

fun saveToCloud(data: Map<String, Any>) {
    db.collection("your-collection-name")
        .add(data)
        .addOnSuccessListener { documentReference ->
            println("DocumentSnapshot added with ID: ${documentReference.id}")
        }
        .addOnFailureListener { e ->
            println("Error adding document: $e")
        }
}

import java.lang.ref.WeakReference

class DataSaver(context: Context) {
    private val mContextRef: WeakReference<Context> = WeakReference(context)

    fun saveData(data: String) {
        val context = mContextRef.get()
        context?.let {
            // ここでデータ保存の処理
        }
    }
}

import android.database.sqlite.SQLiteDatabase

val database: SQLiteDatabase = // データベースの取得
database.beginTransaction()
try {
    // ここでデータの更新や追加などの操作
    database.setTransactionSuccessful()
} finally {
    database.endTransaction()
}

import java.io.ByteArrayOutputStream
import java.util.zip.GZIPOutputStream

fun compressData(input: String): ByteArray {
    val bos = ByteArrayOutputStream()
    GZIPOutputStream(bos).bufferedWriter().use { it.write(input) }
    return bos.toByteArray()
}

import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class UserData(val name: String, val age: Int)

fun convertToJson(data: UserData): String {
    return Json.encodeToString(data)
}

fun convertFromJson(json: String): UserData {
    return Json.decodeFromString<UserData>(json)
}