Android on M1KE BL0G

GalaxyS9をRoot化したときの備忘録

Fri, 01 May 2026 10:04:02 +0900

背景

古いAndroidをRoot化してCyberpunk Phoneにしたときのメモが残っていたので誰得だが残す
Boot animationを変更したかったのが一番の理由
おそらく、2022年の11月ごろの話
かなりRoot化に失敗もして、もはや記憶も曖昧なので、断片的にメモを貼り付けただけなので注意
デバイスは、Galaxy S9 (SM-G960F)

Cyberpunk化した結果

Cyberpunk化したBoot Animation

Your browser does not support the video tag.

起動後のアニメーションHome画面（video to wallpaperで変えました）

Your browser does not support the video tag.

Home画面（画像）

So Cool.

途中での画像

Samsungの4つのモード

4つのモードがSamsungのPhoneにはある。

System: いわゆる普通のモード
Power Off: 電源Off
Recovery: 黒いリカバリーモード (↑+Bixby+電源)
Download: 青いダウンロードモード (下+Bixby+電源)

前提

2つの方法がある

方法	特徴	対象OS
①：Magiskでパッチをあてたイメージを書き込む	動作が安定している	Android 9 / 10 / 11 / 12
②：TWRPでMagiskのZipをインストールする	作業手順がカンタン	Android 9 / 11 / 12

2番をやっている。

fastbootについて

Galaxyにfastbootはない。その代わり、download modeとodinがある。

adbでbootanimationの変更

adbで入る

suコマンドを打つには、Magiskで[SharedUID] Shellの権限をSuperuserにする。

1
2
3


PS C:\Users\mike\AppData\Local\Android\sdk\platform-tools> .\adb.exe shell
127|starlte:/ $ su
starlte:/ #

internal storageの中身は

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


starlte:/ # ls -al /sdcard/
total 64
drwxrwx--x 15 root sdcard_rw 4096 2022-11-20 08:34 .
drwx--x--x 3 root sdcard_rw 4096 2022-11-20 00:48 ..
drwxrwx--x 2 root sdcard_rw 4096 2022-11-20 08:34 .Samsung\ DeX
drwxrwx--x 4 root sdcard_rw 4096 2022-11-03 20:53 .face
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Alarms
drwxrwx--x 4 root sdcard_rw 4096 2022-11-03 20:53 Android
drwxrwx--x 3 root sdcard_rw 4096 2022-11-20 08:39 DCIM
drwxrwx--x 2 root sdcard_rw 4096 2022-11-19 21:20 Download
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Movies
drwxrwx--x 2 root sdcard_rw 4096 2022-11-20 00:35 Music
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Notifications
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Pictures
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Podcasts
drwxrwx--x 2 root sdcard_rw 4096 2022-11-03 20:53 Ringtones
drwxrwx--x 3 root sdcard_rw 4096 2022-11-03 20:53 Samsung

ここでマウントすると、

1
2


sailfish:/ # mount -o remount rw /system
mount: '/system' not in /proc/mounts

どうやらこのエラーはdm-verityの問題らしい。

adb disable-verity This can solve the problem, because this is a dm-verity problem

but, system don’t exist in /proc/mount

adb disable-verity can’t solve this problem

https://groups.google.com/g/android-platform/c/2Sxus8VNqc8

結論

/systemにファイル転送にはroot化だけではなく、superuserにならければならない。
ただし、db-verityが邪魔するので、それを無効化する必要がある。

samsung用のbootanimationファイルの作成方法

手順

bootanimation.zipをunzip
samsung theme designerをDL & 実行
Nontouch screen phoneでプロジェクトを開始。オプションは
- GT-S5520
- Default
名前は適当
左カラムからidle background
右カラムから次
Background type: animation
frame: 126 (自分の画像枚数)
Duration: 40 (40 ~50)
下カラムからファイルを全部ドラッグアンドドロップ
STのロゴからExport Theme
できたファイルの.smtファイルを7zipで解凍
中身のidleBgAnimObj.qmgをコピー
2つコピーして、bootsamsung.qmg, bootsamsungloop.qmgを用意する
それらをAndroidの/System/media/において、既存のを上書きする
さらにそれらのファイルのpermissionを644に変更する

ファクトリーリセット方法

サムスンのファームウェアをDLする

SamFirmというツールを使う。

Regionは元々フィリピンだったけど、イスラエルにしてみた
最新をインスコすれば間違いがない
古いバージョンの場合はエラーがでる

トラブルシューティング

sw rev check fail bootloader device 17 binary 12問題

sw rev check fail bootloader device 17 binary 12

と出て進まない。。。。これは識者によると次の意味らしい。

Hello! sw rev. check fail(bootloader) device 8 binary 6 means that the ROM you have downloaded has a binary 6 while the device has a binary 8. In Android, or at least Samsung phones you cannot go to a lower binary than the one present in your device.

つまり、自分のDLしたFirmwareがbinary 12で、deviceにあったのが17だったということ。

=> samfirmで最新をDLする。

SM-G960F_2_20220722002331_bk4xenjd19_fac.zipをためしたらOKだった。
これはSamfirmからダウンロードしたものでOKだった。

official released binaries are allowed to be flashed問題

Official Released Binaries Are Allowed To Be Flashed

download modeにして
samsungのodinで焼いた時に発生した問題

=> オフィシャルのを焼き直さないとだめっぽい。

odinを使うときの注意点

Adminとして起動する。
- Rightclick -> Run as administrator fixed this issue for me.
Download Modeの時に焼く。
- https://forum.xda-developers.com/t/odin-all-threads-completed-succeed-0-failed-1.915903/

もともとのFirmの焼き方

↓+電源+BixbyでDownload Modeになる
必要なファイルをSamfirmでDLする(SM-G960FのILO(イスラエル)にした)
Odin3で必要なファイルを全部書き込む。

なお、最新のbinaryでないとエラーがでるので注意。次のような感じになる。

ここでUserdataを焼かないと、デフォルトにリセットされた。

結局どうやったか？ (ある一日のstrugling)

1回目: 日本人ブログ => 失敗

最初はこの人のブログをもとにlineage OSを導入しようとした => TWRPが動かない

https://tsukapon-xbcc.hatenablog.com/entry/2021/05/24/234029

使ったファイル

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


mike@DESKTOP-F0UL539 /m/c/U/m/D/W/R/日本人のやり方> ls -al
total 901428
drwxrwxrwx 1 mike mike 512 Nov 19 19:03 ./
drwxrwxrwx 1 mike mike 512 Nov 19 19:04 ../
-rwxrwxrwx 1 mike mike 4447302 Nov 19 12:01 Disable_Force_Encryption_-_SM-G9600.zip*
-rwxrwxrwx 1 mike mike 11278270 Nov 19 12:02 Magisk-v25.2.apk*
-rwxrwxrwx 1 mike mike 565067057 Nov 19 12:00 lineage-17.1-20201113-UNOFFICIAL-starqltechn.zip*
-rwxrwxrwx 1 mike mike 671212 Nov 19 11:59 no-verity-opt-encrypt-6.1.zip*
-rwxrwxrwx 1 mike mike 303117390 Nov 19 12:06 open_gapps-arm64-10.0-nano-20220215.zip*
-rwxrwxrwx 1 mike mike 38471680 Nov 19 11:58 twrp-3.5.2_9-0-starqltechn.img.tar*

2回目: 外国人ブログ => 失敗

次にこの人の例を参考にやった。 1回目の人との違いはTWRPのファイル名だった。最初はtwrp-3.5.2_9-0-starqltechn.img.tarで、2回目はtwrp-3.7.0_9-0-starlte.img.tarだった。こっちはちゃんとTWRPが起動した。同じやり方で。

ただし、手順通りに進んでも、途中でループして動かなかった。 (ただし、もしかしたらUSBワイヤーを抜かないとだめだったのかもしれない。。。)

https://www.thecustomdroid.com/samsung-galaxy-s9-plus-root/

使ったファイル

1
2
3
4
5
6
7
8


$ mike@DESKTOP-F0UL539 /m/c/U/m/D/W/R/外国人のやり方> ls -al
total 57644
drwxrwxrwx 1 mike mike 512 Nov 19 19:14 ./
drwxrwxrwx 1 mike mike 512 Nov 19 19:04 ../
-rwxrwxrwx 1 mike mike 5065419 Nov 19 19:07 Disable_Dm-Verity_ForceEncrypt_10.28.2020.zip*
-rwxrwxrwx 1 mike mike 11278270 Nov 19 12:02 Magisk-v25.2.apk*
-rwxrwxrwx 1 mike mike 6377 Nov 19 19:02 RMM_Bypass_v3_corsicanu.zip*
-rwxrwxrwx 1 mike mike 42670080 Nov 19 18:37 twrp-3.7.0_9-0-starlte.img.tar*

3回目: Youtubeの動画 => 成功

Samsung S9 [G960F] U17 Android 10 Root With TWRP Easy Method [One Click] 2022

最後にこの人のをまねた。途中までうまくいかなかったが、USBワイヤーを抜いたらちゃんと起動するようになった。この人のやり方は、シンプルに次だった。

TWRPを起動した後に、
Magiskを入れて再起動
リカバリーモードで起動して、その後Wipe + yesするだけだった。
- (USBワイヤーは抜いて再起動しなければならない)
もしロゴで止まるなら、もう一度Downloadモードにすると、再起動が走る。そして、ちゃんと起動する。

https://youtu.be/spyNtTT_hAw

結論

めんどくさいし、もう二度とやりません。

参考文献

Kotlinのメモ

Tue, 16 Jul 2024 23:42:41 +0900

背景

AndroidアプリでKotlinを使用したので備忘録
Kotlinの概念がかなりAdvancedなのでまとめる

NOTE:

同じ用語でも日本語と英語が混ざっている

基本

変数・定数

1
2


var mutable = 20
val immutable = 10

`const`と`val`の違い

constは主にコンパイル時に値が確定している定数を定義する場合に使用し、valは変更不可能な変数を定義する際に広く使用する。

特性	const	val
宣言のタイミング	コンパイル時に値が決定	実行時に値が決定
使用可能な場所	トップレベルまたはobjectの中のみ	どこでも使用可能（クラス内、関数内、トップレベルなど）
使用可能な型	プリミティブ型とString型のみ	すべての型
初期化	宣言時に初期化必須	宣言後に初期化可能（ただし一度だけ）
パフォーマンス	コンパイル時決定のため若干向上	実行時に値が決定
参照の扱い	値そのものがインライン展開	参照として扱われる

1
2
3
4
5


// const の例
const val MAX_COUNT = 100
object Constants {
 const val API_KEY = "abcdef123456"
}

パターンマッチング

when式を使用して、関数型言語のパターンマッチングが可能。

1
2
3
4
5


when (x) {
 is Int -> println("It's an Int")
 is String -> println("It's a String")
 else -> println("Unknown type")
}

コレクション

1
2


val list = listOf(1, 2, 3)
val map = mapOf("a" to 1, "b" to 2)

Range

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


//1～10の範囲
for(i in 1..10){
 print(i) //「12345678910」
}

//2～10の範囲で2刻み
for(i in 2..10 step 2){
 print(i) //「246810」
}

//9～1の範囲（逆順）で2刻み
for(i in 9 downTo 1 step 2){
 print(i) //「97531」
}
println()

//1～10の範囲。ただし終わりの値（10）は含まない
for(i in 1 until 10){
 print(i) //「123456789」
}
println()

//a～zの範囲
for(i in 'a'..'z'){
 print(i) // 「abcdefghijklmnopqrstuvwxyz」
}

//A～zの範囲で2刻み
for(i in 'A' until 'z' step 2){
 print(i) // 「ACEGIKMOQSUWY[]_acegikmoqsuwy」
}

分解宣言と多重戻り値

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


fun addAndMul(a: Int, b: Int): Pair<Int, Int>{
 return Pair(a + b, a * b)
}

val (wa, seki) = addAndMul(2, 5)
println("和: $wa, 積: $seki") //「和: 7, 積: 10」

val result = addAndMul(2, 5)

//分解宣言は内部的にcomponentN関数を呼び出している
val wa2 = result.component1()
val seki2 = result.component2()
println("和: $wa2, 積: $seki2") //「和: 7, 積: 10」

data class

1
2
3
4
5
6
7
8


//データクラスは自動でcomponentNというメソッドが定義されているので分解宣言がそのまま使える
data class Person(val firstName: String, val lastName: String, val age: Int)
……
//データクラスのインスタンスを作る
val tanaka = Person("一郎", "田中", 25)
//データクラスのオブジェクトを複数の変数に分解して代入する
val (mei, sei, age) = tanaka
println("姓: $sei, 名: $mei, 年齢: $age") //「姓: 田中, 名: 一郎, 年齢: 25」

型

代数的データ型

代数的データ型には主に2種類ある。

直積型（Product Types）
- 複数の値を同時に持つ型
- Kotlinでは、data classがこれに相当
直和型（Sum Types）
- 複数の型の中から1つを選択する型
- Kotlinでは、sealedクラスがこれに相当

直積型（Product Types）の例は次。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Person(
 val name: String,
 val age: Int,
 val email: String
)

// 使用例
val john = Person("John Doe", 30, "john@example.com")

// デストラクチャリング
val (name, age, email) = john

println("Name: $name, Age: $age, Email: $email")

// コピーと修正
val olderJohn = john.copy(age = 31)

直和型の例

1
2
3
4
5


sealed class ApiResult<out T> {
 data class Success<out T>(val data: T) : ApiResult<T>()
 data class Error(val message: String) : ApiResult<Nothing>()
 object Loading : ApiResult<Nothing>()
}

このApiResultは、「成功」「エラー」「読み込み中」という3つの異なる状態のいずれかを必ず取る

シンプルに直和型を表現したいときは、enumでもできる。

1
2
3
4
5


enum class ApiResult {
 SUCCESS,
 ERROR,
 LOADING
}

型エイリアス

typealiasを用いて型に別名をつけることができる。

1
2


typealias Meter = Int
typealias Killometer = Int

型の確認（`is`）

is演算子で型チェックができる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


println("ABC" is String) // true
println("ABC" !is String) // false

open class ClassA() {}
class ClassB(): ClassA() {}
var a = ClassA()
var b = ClassB()
println(a is ClassA) // true
println(a is ClassB) // false
println(b is ClassA) // true
println(b is ClassB) // true

型のキャスト(`as`, `as?`)

asを用いて、スーパークラスをサブクラスにキャストできる。

1
2
3


open class Parent() {}
class Child(): Parent() {}
var c: Child = Parent() as Child

キャストできない場合は例外が発生するが、as?を用いるとキャストできない場合にnullを返す。

1
2


var n1: Short? = 123
var n2: Int? = n1 as? Int?

関数

基本的な関数定義

1
2
3
4


fun functionName(param1: Type1, param2: Type2): ReturnType {
 // 関数の本体
 return result
}

単一式関数

1

fun double(x: Int): Int = x * 2

デフォルト引数

1

fun greet(name: String = "Guest") = println("Hello, $name!")

名前付き引数

1
2


fun createUser(name: String, age: Int) = User(name, age)
val user = createUser(age = 25, name = "John")

可変長引数（vararg）

1

fun sum(vararg numbers: Int): Int = numbers.sum()

ローカル関数（関数内関数）

1
2
3
4


fun outer() {
 fun inner() = println("Inner function")
 inner()
}

拡張関数

拡張関数は、既存のクラスに新しいメソッドを追加する機能。

1

fun String.addExclamation() = this + "!"

インライン関数

インライン関数はコンパイル時に関数呼び出しの箇所に関数の中身が直接挿入される
パフォーマンス最適化が目的

1

inline fun operation(a: Int, b: Int, op: (Int, Int) -> Int): Int = op(a, b)

高階関数

関数を引数や戻り値として扱う関数の事。

1
2


fun operation(x: Int, y: Int, op: (Int, Int) -> Int): Int = op(x, y)
val result = operation(10, 20, { a, b -> a + b })

トレーリングラムダ（末尾ラムダ）

なお、高級関数の最後がラムダ式の場合は、そのラムダ式を括弧外に書ける。

1
2


fun operation(x: Int, y: Int, op: (Int, Int) -> Int): Int = op(x, y)
val result = operation(10, 20) { a, b -> a + b }

下のように引数に入れるべきものを外に書けるメリットがある。

1

list.filter { it > 0 }.map { it * 2 }

Jetpack ComposeのsetContentは次のように使うが、これも末尾ラムダの例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


setContent {
 AppTheme {
 MainContent()
 }
}

// 下と同じ
setContent({
 EchoTimerTheme {
 MainContent()
 }
})

これは概ね次のように定義されている。

1

fun setContent(content: @Composable () -> Unit)

ラムダ式

{x -> xxx}がそのまま関数になる。

1

val sum = { x: Int, y: Int -> x + y }

関数型

型は(int) -> intのように定義する。

1

val multiply: (Int, Int) -> Int = { x, y -> x * y }

演算子オーバーロード

1

operator fun Point.plus(other: Point) = Point(x + other.x, y + other.y)

中置表記法

DSLをKotlinで作れる機能
timesオペレーターが定義された

1
2


infix fun Int.times(str: String) = str.repeat(this)
val result = 3 times "Hello "

テイルレック最適化

末尾再帰関数の定義も可能。

1
2


tailrec fun factorial(n: Int, acc: Int = 1): Int =
 if (n <= 1) acc else factorial(n - 1, n * acc)

ジェネリック関数

1
2
3


fun <T> printArray(array: Array<T>) {
 array.forEach { println(it) }
}

多重戻り値

KotlinにはTuple型はないため、戻り値が2つ、3つ、4つ以上で型を使い分ける
受け取る際は分解宣言して受け取る

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 2つ
fun returnPair(): Pair<Int, String> {
 return Pair(42, "Hello")
}

// 3つ
fun returnTriple(): Triple<Int, String, Boolean> {
 return Triple(42, "Hello", true)
}

// 4つ以上で別々の型
data class Result(val value1: Int, val value2: String)

fun multipleValues(): Result {
 return Result(42, "Hello")
}

// 4つ以上で同じ型
fun multipleValues2(): List<Int> {
 return listOf(1, 2, 3, 4, 5)
}

UnitとNothing

値を返却しない関数は Unit関数として扱われる。

1
2
3


fun printMessage(msg: String) {
 println(msg)
}

常に例外を返却し、戻り値を戻すことのない関数は Nothing型関数として定義される。

1
2
3


fun raiseError(msg: String): Nothing {
 throw MyException(msg)
}

関数参照(`::`)

関数名の前に::をつけると、関数を参照するオブジェクトを得ることができる。

1
2
3
4
5
6


fun add(x: Int, y: Int): Int = x + y

fun main() {
 val method = ::add
 println(method(3, 5))
}

移譲と遅延（`by`）

2つの委譲

2つの委譲とは

次の委譲で、クラスのアクセッサーやメソッドを委譲する事が可能。

プロパティ委譲（Property Delegation）
クラス委譲（Class Delegation）

プロパティ委譲

個々のプロパティの振る舞いを別のオブジェクト（デリゲート）に委譲する
byキーワードを使用して実装する
プロパティのgetter/setterの動作をカスタマイズするのに使用する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Example {
 var name: String by Delegate()
}

class Delegate {
 operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
 return "$thisRef, thank you for delegating '${property.name}' to me!"
 }

 operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
 println("$value has been assigned to '${property.name}' in $thisRef.")
 }
}

クラス委譲

インターフェースの実装を別のオブジェクトに委譲する
継承の代替手段として使用される
クラス宣言時にbyキーワードを使用して実装する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


interface Printer {
 fun print()
}

class PrinterImpl(val x: Int) : Printer {
 override fun print() { print(x) }
}

class SomeObject(b: Printer) : Printer by b

fun main() {
 val b = PrinterImpl(10)
 SomeObject(b).print() // 10を出力
}

SomeObjectのインスタンスのPrinterインターフェイスのメソッドはPrinterImplに委譲されているという事。

遅延初期化

遅延初期化とは

遅延初期化とは、オブジェクトの生成やプロパティの初期化を、それが実際に必要になるまで遅らせる技術。

遅延初期化の主な利点:

メモリ効率の向上
- 必要になるまでメモリを確保しない
初期化コストの削減
- 必要なときまで初期化処理を遅らせる
循環依存の解決
- 相互に依存するオブジェクト間の初期化問題を解決できる

`lateinit`

クラスのプロパティは初期化が必要だが、lateinit を用いることで初期化を遅らせることができる。

lateinitには、次の制約がある。

Int などのプリミティブ型には使用できない
Null許容型には使用できない
var 変数にしか使用できない

1
2
3
4


class Foo {
 lateinit var name: String // init()が呼ばれるまで初期化不要
 fun init(name: String) { this.name = name }
}

`by lazy`（デリゲート）

lateinitと似たものに by lazyがある。

読み取り専用（val）プロパティに使用
最初にアクセスされたときに初期化され、その後は同じ値を返す
スレッドセーフ

1
2
3
4
5
6


class Example {
 val lazyValue: String by lazy {
 println("Computed!")
 "Hello"
 }
}

クラスのプロパティだけではなく、ローカル変数も遅延初期化ができる。

1
2
3
4


val lazyValue: String by lazy {
 println("computed!")
 "Hello"
}

Observableの例。

1
2
3


var name: String by Delegates.observable("initial value") {
 prop, old, new -> println("$old -> $new")
}

Scoped Function

Scoped Functionとは

scoped functionは、オブジェクトのコンテキスト内で処理を行うための便利な関数群。

主に5つのスコープ関数がある。

let
run
with
apply
also

5つの関数の違い

それぞれの違いをまとめると次になる。

関数名	オブジェクトの参照方法	戻り値	主な使用目的
`let`	`it`	ラムダの結果	null安全な呼び出し、ローカルスコープでの変数利用
`run`	`this`	ラムダの結果	オブジェクトの初期化と結果の計算
`with`	`this`	ラムダの結果	オブジェクトのプロパティやメソッドを繰り返し使用
`apply`	`this`	オブジェクト自体	オブジェクトの設定、初期化
`also`	`it`	オブジェクト自体	追加の効果や検証、ロギング

itとthisの違い

it（暗黙の引数名）
- ラムダ式の引数として渡されるオブジェクトを指す
- オブジェクトを別の変数名で参照したい場合に便利
this（レシーバ）
- ラムダ式のレシーバとして渡されるオブジェクトを指す
- オブジェクトのメンバーに直接アクセスできる

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// itの使用（let）
person.let {
 println(it.name) // it.を使用
 it.age = 30 // it.を使用
}

// thisの使用（apply）
person.apply {
 println(name) // thisは省略可能
 age = 30 // thisは省略可能
}

`let`関数

オブジェクトをラムダ式の引数として提供
戻り値はラムダ式の結果
主にnull安全な呼び出しに使用

1

val length = str?.let { it.length } ?: 0

`run`関数

オブジェクトをレシーバ（this）として提供
戻り値はラムダ式の結果
オブジェクトの初期化と結果の計算を同時に行う場合に便利

1
2
3
4


val result = person.run {
 println(name)
 age * 2
}

`with`関数

オブジェクトをレシーバ（this）として提供
戻り値はラムダ式の結果
オブジェクトのプロパティやメソッドを繰り返し使用する場合に便利

1
2
3
4


with(person) {
 println(name)
 println(age)
}

`apply`関数

オブジェクトをレシーバ（this）として提供
オブジェクト自体を返す
オブジェクトの設定に便利

1
2
3
4


val person = Person().apply {
 name = "John"
 age = 30
}

`also`関数

オブジェクトをラムダ式の引数として提供
オブジェクト自体を返す
追加の効果や検証に使用

1
2
3


val numbers = mutableListOf(1, 2, 3)
numbers.also { println("The list elements are: $it") }
 .add(4)

Class

コンストラクタ（`constructor`）

2種類のコンストラクタ

Kotlin のクラスには2種類のコンストラクタがある。

プライマリコンストラクタ（クラスに1つだけ）
セカンダリコンストラクタ（0個以上持つことができる）

プライマリコンストラクタ

プライマリーコンストラクタの構文

クラス名に直接指定する事で、プライマリーコンストラクタの引数を設定できる
プライマリーコンストラクタは、以下のように記述する（constructorは省略するのが一般的）

1

class クラス名 constructor(引数: データ型) {}

プライマリーコンストラクタのパラメーター

プライマリーコンストラクタのパラメータでvalやvarを使用すると、自動的にクラスのプロパティとして定義される
また、プロパティにアクセス修飾子やデフォルト引数も付与できる
プライマリーコンストラクタ or プライマリーコンストラクタのパラメータと呼ぶ

1

class Person(private val name: String, public var age: Int = 10)

プライマリーコンストラクタの本体

プライマリーコンストラクタの本体はinitで定義する
このinitでプライマリーコンストラクタのパラメータ処理をしていた場合は実質プライマリーコンストラクタの本体

1
2
3
4
5
6
7


class Person(val name: String, var age: Int) {
 init {
 require(age >= 0) { "Age must be non-negative" }
 name = "bob"
 age = 10
 }
}

セカンダリコンストラクタ

セカンダリコンストラクタの構文

セカンダリーコンストラクタはクラス内にconstructorメソッドを使って定義するコンストラクタ
一般的なコンストラクタとの違いはthis(引数)構文によって、直接or間接的にプライマリーコンストラクタを呼ばなければならない点
セカンダリーコンストラクタの引数は、プライマリーコンストラクタの引数パラメータ（this(引数1, 引数2)）に渡される必要がある

1

constructor(引数: データ型): this(引数)

1
2
3
4


class Person(var name:String, var age: Int) {
 // name=引数のname, age=10でプライマリーコンストラクタに渡される
 constructor(name: String) : this(name, 10)
}

暗黙的なプライマリーコンストラクタ

一般的なクラス定義（this(引数)）抜きをすると、暗黙的なプライマリーコンストラクタとみなされる。

1
2
3
4
5
6
7
8
9


class Person {
 var name: String
 var age: Int

 constructor(name: String, age: Int) {
 this.name = name
 this.age = age
 }
}

直接呼び出し、関節呼び出し

Kotlinでは、セカンダリーコンストラクタは必ず直接的または間接的にプライマリーコンストラクタを this(引数)で呼び出す必要がある。

直接的な呼び出し

1
2
3
4
5
6
7
8


class Person(val name: String) {
 var age: Int = 0

 // ここのthis(name)でプライマリーコンストラクタを呼び出している
 constructor(name: String, age: Int) : this(name) {
 this.age = age
 }
}

間接的な呼び出し

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Person(val name: String) {
 var age: Int = 0
 var email: String = ""

 constructor(name: String, age: Int) : this(name) {
 this.age = age
 }

 // ここが2つめのコンストラクタを使った間接的なプライマリーコンストラクタの呼び出し
 constructor(name: String, age: Int, email: String) : this(name, age) {
 this.email = email
 }
}

初期化ブロック（`init`）

初期化ブロックとは

初期化ブロックは、プロパティの初期化を行うためのブロック
クラスに init { ... } で初期化ブロックを記述する
初期化ブロックはコンストラクタが呼び出されるよりも前に呼び出される

1
2
3
4
5


class Foo {
 init {
 println("Foo is created.")
 }
}

なぜ初期化ブロック（`init`）が必要か

それはプライマリーコンストラクタがあるから
プライマリーコンストラクタは実質的にコンストラクタの引数部分のみを宣言する
故にプライマリーコンストラクタの関数の本体としてinitが必要という事

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Person(val name: String, val age: Int = 0) { // ここがプライマリーコンストラクタの引数

 // このinitがプライマリーコンストラクタの本体
 init {
 require(age >= 0) { "Age must be non-negative" }
 }
}

// 使用例
val person1 = Person("Alice", 30)
val person2 = Person("Bob") // ageはデフォルト値の0が使用される

コンストラクタと初期化ブロックの違い

コンストラクタと初期化ブロックには以下のような違いがある。

承知しました。初期化ブロックとコンストラクターの主な違いを以下の表にまとめました。

特徴	初期化ブロック	コンストラクター
定義方法	`init` キーワードを使用	クラス名の後（プライマリ）または`constructor`キーワード（セカンダリ）
主な目的	共通の初期化ロジック	オブジェクト作成時の特定の初期化
パラメータ	直接受け取れない	受け取ることができる
実行タイミング	記述（宣言）前のプロパティの初期化の後	オブジェクト作成時
複数定義	可能（定義順に実行）	可能（オーバーロード）
再利用性	すべてのコンストラクターで共通	特定の初期化シナリオに対応
this キーワード	使用可能	使用可能（他のコンストラクター呼び出しにも使用）
戻り値	なし	なし（暗黙的にオブジェクトインスタンスを返す）
アクセス修飾子	不要	必要に応じて使用可能
プロパティ初期化との関係	プロパティ初期化と交互に実行	プロパティ初期化の後に実行

メンバの宣言順序と実行順序の注意

実行順番のルール

プロパティの初期化は次の3つの順番で行われる。

プライマリーコンストラクタのパラメータの評価
- これはセカンダリーコンストラクタのthis()呼び出しによるモノも含む
プロパティの初期化と初期化ブロック（init）のコード宣言準の実行
- これには、プライマリーコンストラクタで宣言されたプロパティも含む
- プロパティと初期化ブロックは宣言された順序で交互に実行される
セカンダリーコンストラクタの本体の実行（もし呼び出されていれば）

実行順序の例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Example(val input: String) { // プライマリーコンストラクタの引数
 // ファーストプロパティ
 val first = println("First property")

 // ファーストイニシャライザ
 init {
 println("First initializer block: $input")
 }

 // セカンダリープロパティ
 val second = println("Second property")

 // セカンダリーイニシャライザ
 init {
 println("Second initializer block")
 }

 // セカンダリーコンストラクタ
 constructor(input: String, second: Int): this(input) {
 println("Secondary constructor")
 }
}

プライマリーコンストラクタの実行結果

プライマリーコンストラクタが実行されるため、InputとしてHelloが入る
その後に、プロパティとinitが宣言順に評価される
セカンダリーコンストラクタはもちろん呼ばれない

1
2
3
4
5
6
7
8


fun main() {
 Example("Hello")
}

First property
First initializer block: Hello
Second property
Second initializer block

セカンダリーコンストラクタの実行結果

プライマリーコンストラクタ（this(引数)）が最初に評価される
その後に、宣言順にプロパティとinitが実行される
最終的にセカンダリーコンストラクタが実行される

1
2
3
4
5
6
7
8
9


fun main() {
 Example("Hello", 5)
}

First property
First initializer block: Hello
Second property
Second initializer block
Secondary constructor

アクセッサー

メンバ変数に添えて、インデントがずれたような形でgetter/setterを定義できる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Foo() {
 var name: String = ""
 set(value) {
 println("__set__")
 field = value
 }
 get() {
 println("__get__")
 return field
 }
}

fun main() {
 var a = Foo()
 a.name = "Yamada" // __set__
 println(a.name) // __get__
}

data class

1

data class User(val name: String, val age: Int)

extends

kotlinのクラスはデフォルトで継承不可能
そのため、openキーワードをつける

1
2
3
4
5
6
7
8
9


open class Animal {
 open fun makeSound() { println("Some sound") }
 fun eat() { println("Eating") } // このメソッドはオーバーライド不可
}

class Dog : Animal() {
 override fun makeSound() { println("Bark") } // OK
 // override fun eat() { } // コンパイルエラー
}

ただし、抽象クラスはデフォルトでopen。

1
2
3


abstract class Shape {
 abstract fun draw() // 抽象メソッドは自動的にopen
}

:と親クラス名を指定して継承する。

1
2


open class Animal(val name: String)
class Dog(name: String) : Animal(name)

なお、親クラスが引数なしのコンストラクタ（または引数がすべてデフォルト値を持つコンストラクタ）を持つ場合、括弧を省略できる。

1
2


open class Animal
class Dog : Animal

明示的に呼び出したい場合は空の括弧を使用できる。

1
2


open class Animal
class Dog : Animal()

implements

interfaceはabstrct classと同様にopen
kotlinのinterfaceは抽象プロパティも定義可能

1
2
3
4
5
6
7
8


interface Speakable {
 fun speak()
}
class Person : Speakable {
 override fun speak() {
 println("Hello!")
 }
}

sealed class

制限された階層構造を定義するために使用される特別な種類のクラス
sealedクラスのサブクラスは、同じファイル内か、ネストされたクラスとして定義する必要がある
when式でsealedクラスを使用する場合、コンパイラは全てのサブクラスが処理されているかチェックする

例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


sealed class ApiResult<out T> {
 data class Success<out T>(val data: T) : ApiResult<T>()
 data class Error(val message: String) : ApiResult<Nothing>()
 object Loading : ApiResult<Nothing>()
}

fun handleApiResult(result: ApiResult<String>) {
 when (result) {
 is ApiResult.Success -> println("成功: ${result.data}")
 is ApiResult.Error -> println("エラー: ${result.message}")
 is ApiResult.Loading -> println("読み込み中...")
 }
}

// 使用例
val successResult = ApiResult.Success("データ取得成功")
val errorResult = ApiResult.Error("ネットワークエラー")
val loadingResult = ApiResult.Loading

handleApiResult(successResult)
handleApiResult(errorResult)
handleApiResult(loadingResult)

innnerクラス

innerはネストされたクラスが内部クラスであることを示す。

1
2
3
4
5


class A {
 inner class B { ... }
}

var obj = A().B()

Generics

型制約

Genericsでも型に制約をかけることができる
下記では、IntやDoubleなど、Numbe のサブクラスに制約している

1
2
3
4
5
6


class Foo<T: Number>(val value: T)

fun main() {
 val a1 = Foo(123)
 println(a1.value + 1) // 124
}

out

out キーワードはサブクラスをスーパークラスに入れられる。

Javaでは以下のGenericsのUp Castは許されていない。

1
2
3
4
5
6
7
8
9


// Java
interface Nextable<T> {
 T nextT();
}

void demo(Nextable<String> strs) {
 Nextable<Object> objects = strs; // !!! Not allowed in Java
 // ...
}

Kotlinはそれができる。

1
2
3
4
5
6
7
8


interface Nextable<out T> {
 fun nextT(): T
}

fun demo(strs: Nextable<String>) {
 val objects: Nextable<Any> = strs // This is OK
 // ...
}

in

in キーワードはスーパークラスをサブクラスに入れられる。

1
2
3
4
5
6
7
8
9


interface Comparable<in T> {
 operator fun compareTo(other: T): Int
}

// NOTE: Numberのsubtypeはdouble
fun demo(x: Comparable<Number>) {
 x.compareTo(1.0)
 val y: Comparable<Double> = x // ok
}

inとoutの違い

inとoutの違いは次になる。

特徴	`in`（反変性）	`out`（共変性）
キーワード	`in`	`out`
変性	反変性（Contravariance）	共変性（Covariance）
主な用途	コンシューマー（消費者）	プロデューサー（生産者）
許可される操作	引数として受け取る（入力）	戻り値として返す（出力）
禁止される操作	戻り値として返す（出力）	引数として受け取る（入力）
型の関係	スーパータイプを受け入れる	サブタイプを返すことができる
代入の方向	スーパータイプからサブタイプへ	サブタイプからスーパータイプへ
安全性の保証	入力の型安全性	出力の型安全性
コード例	`interface Comparable<in T>`	`interface List<out T>`

Object

Object式（匿名クラス）

Object式は、Kotlinで匿名クラスを作成するための機能
Java の匿名内部クラスに相当する

1
2
3
4


val myObject = object {
 val property = "Hello"
 fun method() = "World"
}

インターフェイスの実装

1
2
3
4
5
6
7
8
9


interface Greeter {
 fun greet()
}

val englishGreeter = object : Greeter {
 override fun greet() {
 println("Hello!")
 }
}

Object宣言（シングルトン）

Kotlinのobject宣言を使用すると、シングルトンオブジェクトを簡単に作成できる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


object MySingleton {
 val CONSTANT_VALUE = 42
 fun printHello() {
 println("Hello from Singleton")
 }
}

fun main() {
 println(MySingleton.CONSTANT_VALUE)
 MySingleton.printHello()
}

Companion Object（Static Member）

companion objectは、Kotlinの特有の機能で、Javaのstaticメンバーに似た機能を提供する
Kotlinでは静的メンバーという概念が直接存在しないため、companion objectを使ってこれを実現する

コンパニオンオブジェクトの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class MyClass {
 companion object {
 const val CONSTANT_VALUE = 42

 fun printHello() {
 println("Hello from Companion Object")
 }
 }
}

fun main() {
 println(MyClass.CONSTANT_VALUE) // 42
 MyClass.printHello() // Hello from Companion Object
}

名前付きコンパニオンオブジェクトの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class MyClass {
 companion object NamedCompanion {
 const val CONSTANT_VALUE = 42

 fun printHello() {
 println("Hello from Named Companion Object")
 }
 }
}

fun main() {
 println(MyClass.NamedCompanion.CONSTANT_VALUE) // 42
 MyClass.NamedCompanion.printHello() // Hello from Named Companion Object
}

Null対応

Any

Kotlinのクラスは全て「Any」というクラスを継承している
Anyクラスは非Null型として定義された全てのクラスのスーパークラス
つまり、Kotlinのクラスは全て非Null型になる
故に、KotlinではNull許容型であるJavaのObjectのサブクラスとなることはできない

`?`付きタイプ

?を型につけて宣言する事でnullable、オプショナル、null Unionな型にできる。

1
2


var a: String? = "はろー" //String型の変数
a = null // ok

`.?`演算子

セーフコールでアクセスするための演算子。

1
2
3
4
5


var d: String? = null
println(d?.length) //エラーは起きない。「null」が表示される

var e: String? = "はろはろ"
println(e?.length) //「4」が表示される

`:?`演算子

:?演算子（エルビス演算子）は参考演算子を短くしたようなデフォルト付きの演算子。

1
2
3


//?:演算子でgetName関数の結果がnullだった場合の値を設定
val name2 :String = getName() ?: "名なしの権兵衛"
println(name2)

`!!`演算子

NullPointerExceptionを発生する形でアクセスするための演算子。

1
2
3
4


//!!演算子を使ってnullの入ったNull許容型を無理やり非Null型に変換して参照
var f: String? = null
//コンパイルはできるが、実行時にめでたくNullPointerException発生
println(f!!.length)

Coroutineのアーキ

Structured Concurrency

Structured Concurrencyとは

Structured Concurrency（構造化並行処理）はプログラミング言語における並行処理、非同期処理のAPIのパラダイムの一つ
並行処理をより安全で予測可能にし、エラー処理や資源管理を改善することを目的としている
KotlinはStructured Concurrencyを採用している

以下が特徴となる。

階層構造：
- コルーチンは親子関係を持つ階層構造で組織される
- 子コルーチンは親コルーチンのコンテキスト内で実行される
ライフサイクル管理：
- 親コルーチンは、全ての子コルーチンが完了するまで終了しない
- これにより、処理の完了を確実に把握できる
エラー伝播：
- 子コルーチンで発生した未処理の例外は、親コルーチンに自動的に伝播する
- これにより、エラー処理が簡素化される
キャンセル伝播：
- 親コルーチンがキャンセルされると、そのすべての子コルーチンも自動的にキャンセルされる
スコープ：
- coroutineScope や supervisorScope などの関数を使用して、明示的にスコープを定義できる

Structured Concurrencyの例

coroutineScope 内で2つの非同期処理（async）を開始している
coroutineScope は、すべての子コルーチンが完了するまで終了しない
いずれかの子コルーチンで例外が発生した場合、他の子コルーチンはキャンセルされ、例外が親に伝播する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


suspend fun fetchUserData() = coroutineScope {
 val userDeferred = async { fetchUser() }
 val friendsDeferred = async { fetchFriends() }

 try {
 val user = userDeferred.await()
 val friends = friendsDeferred.await()
 // 両方のデータの処理
 } catch (e: Exception) {
 // エラー処理
 }
}

平行制御

4つの平行制御とは

Kotlinのコルーチンの平行制御には次の4つのタイプがある。

Channel
- 複数のコルーチン間でデータや信号を交換するためのパイプラインとして機能する
- 生産者-消費者パターンに適している
Flow
- 非同期に計算される値のシーケンスを表現する
- データ変換、フィルタリング、結合などの操作が容易
Mutex
- 一度に1つのコルーチンのみがクリティカルセクションにアクセスできるようにする
- 共有リソースへの同時アクセスを防ぐ
Semaphore
- 指定された数のコルーチンが同時にリソースにアクセスできるようにする
- リソースプールの管理に適している

4つの平行制御の比較

4つの平行制御があり、それぞれの違いは以下。

特性	Channel	Flow	Mutex	Semaphore
主な用途	コルーチン間の通信	非同期データストリーム処理	相互排他制御	リソースへのアクセス制限
データの流れ	生産者から消費者へ	上流から下流へ	N/A	N/A
ホット/コールド	ホット	コールド（デフォルト）	N/A	N/A
バックプレッシャー	自然にサポート	明示的に実装可能	N/A	N/A
複数の受信者	通常1つ（ファンアウトも可能）	複数可能	N/A	N/A
並行アクセス	安全	安全	1つのコルーチンのみ	指定数のコルーチン
キャンセル伝播	サポート	サポート	N/A	N/A
バッファリング	可能	可能	N/A	N/A
主な操作	send/receive	emit/collect	lock/unlock	acquire/release
用途例	タスクキュー、イベント配信	UI更新、データ変換	共有リソースの保護	接続プールの制御

Coroutineの種類

KotlinのCoroutinesは次を提供する。

名前	関数	返す型
ワンショット（戻り値なし）	`launch{}`	`Job`
ワンショット（戻り値あり）	`async{}`	`Deferred<T>`
ホットストリーム（複数の値）	`Channel`	`Channel<T>`
コールドストリーム（複数の値）	`Flow`	`Flow<T>`

ワンショット

ワンショットとは一度だけ実行される関数の事。

ホットストリームとコールドストリームの違い

ホットストリーム
- コレクターの有無に関わらず、データを生成し続ける
- 常にアクティブで、リソースを継続的に消費する
コールドストリーム
- コレクターが要求したときのみデータを生成する
- 必要なときのみリソースを使用し、それ以外はアイドル状態となる

FlowとChannel

FlowとChannelの違い

FlwoとChannelをよく使うが次の点が大きく違う。

Channel
- アクター
  - 送信者（sender）と受信者（receiver）の関係
- 関係
  - N:N
- 消費モデル
  - 競合的な消費モデル
  - 送信された値は、1つの受信者によってのみ消費される
  - つまり、複数のreceiverがいたら早い者勝ちになる
Flow
- アクター
  - 生産者（emitter）と収集者（collector）の関係
- 関係
  - 1:N
- 消費モデル
  - 非競合的な消費モデル
  - 送信された値は、全ての受信者に届く
  - つまり、複数のreceiverがいても確実に届く

FlowとChannneの図

Channelは値は早いもの勝ちになる
channelのキューの値を取得する
複数の受信者がある場合、各値は1つの受信者にのみ届く

Flowの値は全てのCollectorに届く
各Collectorは独立してFlowの全シーケンスを受け取る
複数のCollectorが同じFlowをcollectできるが、それぞれ独立した実行となる

SharedFlowは、分かりやすく言うと、Channelの非競合的な消費モデル版
実際的にはboradcast channelのように機能する
collect/collectorではなく、subscribe/subscriberと呼ばれる

Flow

Flwoのアクター

コレクター（Collector）
- ストリームのコレクター（Collector）は、ストリーム処理の終端操作の一つ
- ストリームの要素を集約して最終的な結果を生成するための機能
- collect()メソッドを使用する
エミッター（Emitter）:
- データを生成し、ストリームに送り出す役割を果たす
- 例: emit() 関数を使用してデータを送信する

Flowとは

Flowとは非同期に計算される値のシーケンスを表現するインターフェース
収集者が要求したときのみデータを生成する（コールドストリーム）

1
2
3
4
5
6


flow {
 for (i in 1..3) {
 delay(100)
 emit(i)
 }
}.collect { value -> println(value) }

StateFlowとMutableStateFlowとは

StateFlowの主な特徴

常に値を保持
- null値を許容しない。
ホットストリーム
- コレクターの有無に関わらず値を保持。
値の重複排除
- 同じ値が連続して設定されても、収集者には通知されない
最新値の即時提供
- 新しい収集者は即座に最新の値を受け取る
- stateFlowはcollectしたら必ずそのcollectした瞬間に一回データが流れてくる

MutableStateFlowの特徴

値の変更が可能
- valueプロパティを通じて直接値を更新できる
その他の特徴はStateFlowと同じ（常に値を保持、ホットストリーム、値の重複排除など）

StateFlowの例

以下はAndroidでViewModelとStateFlowを使ったFlowの例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// privateで変えられる、setter用
private val _keepScreenOn = MutableStateFlow(settingsPreferences.getBoolean("keepScreenOn", false))
// publicで変えられない、getter用
val keepScreenOn: StateFlow<Boolean> = _keepScreenOn

// 利用
lifecycleScope.launch { // AndroidのLifecycleのScope
 viewModel.keepScreenOn.collect { keepOn -> // collectorの処理となる
 if (keepOn) {
 xxx
 }
 }
}

Flowの種類

Flow, SharedFlow, StateFlowなどの違いは以下。

複数のcollectの注意点

1つのコルーチンビルダーで複数のflowをcollectすると、2個目以降はcollectされないので注意。

1つのcollectの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
 val scope = CoroutineScope(Dispatchers.Default)
 val myStateFlow = MutableStateFlow(0)

 scope.launch {
 myStateFlow.collect { value ->
 println("Collected value: $value")
 }
 }
 delay(200)
 // 出力: Collected value: 0 (即座に現在の値が発行される)

 myStateFlow.value = 1
 delay(200)
 // 出力: Collected value: 1

 myStateFlow.value = 1
 delay(200)
 // 重複値なので発行されない

 myStateFlow.value = 2
 delay(200)
 // 出力: Collected value: 2
}

その結果

1
2
3


Collected value: 0
Collected value: 1
Collected value: 2

2つのcollectの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38




import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
 val scope = CoroutineScope(Dispatchers.Default)
 val myStateFlow = MutableStateFlow(0)
 val myStateFlow2 = MutableStateFlow(0)

 scope.launch {
 myStateFlow.collect { value ->
 println("Collected myStateFlow: $value")
 }
 myStateFlow2.collect { value ->
 println("Collected myStateFlow2: $value")
 }
 }
 delay(200)
 // 出力: Collected myStateFlow: 0 (即座に現在の値が発行される)

 myStateFlow.value = 1
 delay(200)
 // 出力: Collected myStateFlow: 1

 myStateFlow.value = 1
 delay(200)
 // 重複値なので発行されない

 myStateFlow.value = 2
 delay(200)
 // 出力: Collected myStateFlow: 2

 myStateFlow2.value = 1
 delay(200)

 delay(2000)
}

その結果（myStateFlow2の現在の値とcollectが発生していない）

1
2
3


Collected myStateFlow: 0
Collected myStateFlow: 1
Collected myStateFlow: 2

myStateFlow2が動かない理由は、最初のcollectが完了（この場合は永続的な監視を終了）するまで、次のcollectは開始されないから。

Channel

Channelのアクター

プロデューサー（Producer）:
- 特にChannelにおいて、データを生成する側を指す
- send() メソッドを使用してデータを送信する
コンシューマー（Consumer）:
- データを受け取って処理する側を指す
- Collectorと同義で使われることもある

Channnelとは

Channelは、Kotlinのコルーチンライブラリで提供される、非同期通信のためのプリミティブ
主に複数のコルーチン間でデータを安全に受け渡すために使用される
Flowはコールドストリームだったが、Channelはホットストリーム

主な特徴：

ホットストリーム
- 受信者の有無に関わらずデータを生成可能
スレッドセーフ
- 複数のコルーチンから安全に操作可能
バッファリング
- 容量指定可能なバッファを持つ
バックプレッシャー（back pressure）
- バッファが一杯の場合、送信側の処理を一時停止

Channelの種類

Channelにはいくつかの種類がある。

Rendezvous (容量0)
- 送信者と受信者が同期する
Buffered
- 指定した容量のバッファを持つ
Unlimited
- 無制限のバッファを持つ
Conflated
- 最新の値のみを保持し、中間値を破棄

チャンネルの例

チャネル（Channel）とは、コルーチン間の通信に使用する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


val channel = Channel<Int>()

launch {
 for (i in 1..5) {
 channel.send(i)
 }
 channel.close()
}

for (value in channel) {
 println(value)
}

suspend

suspendとは

suspendキーワードはcoroutineの中核のキーワード。

形式：suspendは関数修飾子
- suspend func getXXX(): String {}みたいに使用する
目的：非同期関数を定義する
- JSやPythonでいうasyncキーワードと同じ

特徴：

関数自体を中断可能（suspendable）にする
他のsuspend関数やCoroutineBuilder内でのみ呼び出せる
結果を直接返す（非同期的に）

suspend関数

suspend関数は、Kotlinのコルーチンシステムの中核をなす重要な概念
suspend関数はsuspendキーワードを使って定義される関数で、実行を一時停止し、後で再開することができる
JSでいう、async関数のようなもの

1
2
3
4
5
6


suspend fun fetchUserData(): UserData {
 // 非同期処理
 val userId = fetchUserId() // サスペンドポイント1
 delay(100) // サスペンドポイント2
 return fetchUserDetails(userId) // サスペンドポイント3
}

launchやasyncとsuspendの違い

asyncとlaunchは関数で、suspendは関数修飾子。

特性	async/launch	suspend
使用方法	直接呼び出して新しいコルーチンを開始する	関数を定義する際に使用し、その関数を中断可能にする
コンテキスト	CoroutineScope内でのみ使用可能	定義時に使用し、他のsuspend関数やコルーチン内から呼び出される
目的	新しいコルーチンを作成し、並行処理を開始する	既存の関数を非同期的に実行可能にする

suspendと`delay()`、`await()`

suspend修飾子を使用すると、delay()やawait()などの中断可能な関数を使用できるようになる
これらの関数は「サスペンドポイント」として機能し、コルーチンの実行を一時的に中断し、後で再開することができるようになる

サスペンドポイント

通常、他のサスペンド関数を呼び出す箇所がサスペンドポイントとなる
例えば、delay()、await()、他のカスタムサスペンド関数の呼び出しなど

違い

delay()
- 指定した時間だけコルーチンの実行を中断する
- スレッドをブロックせずに待機できる
await()
- Deferred<T>の結果を待つために使用する
- 結果が利用可能になるまでコルーチンを中断する

suspend関数の例

以下がdelayとawaitを使った例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


suspend fun fetchUserData(): UserData {
 delay(1000) // ネットワーク遅延をシミュレート
 return UserData("John", 30)
}

suspend fun processUser() {
 val deferred = async { fetchUserData() }
 val userData = deferred.await() // 結果が得られるまで中断
 println("User: ${userData.name}")
}

Coroutineの使い方

3つのSteps

3つのCoroutineのSteps

大まかに言うと次の3つの流れでコルーチンを使う。

ディスパッチャーの決定（どのスレッドを使うか）
スコープの決定（どのライフサイクルを使うか）
ビルダーの決定（どんなコルーチン処理をするか）

3つのStepsの例

次のViewModelの例はフローに従っている。

ディスパッチャー：Dispatchers.IO（ネットワーク呼び出し）とDispatchers.Main（UI更新）を使用
スコープ：viewModelScope（ViewModelのライフサイクルに紐づく）
ビルダー：launch（結果を直接返さない処理）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class MyViewModel : ViewModel() {
 fun loadData() {
 viewModelScope.launch(Dispatchers.IO) {
 val result = performNetworkCall()
 withContext(Dispatchers.Main) {
 updateUI(result)
 }
 }
 }
}

CoroutineDspatcher

CoroutineDspatcherとは

CoroutineDspatcherは、コルーチンがどのスレッドまたはスレッドプールで実行されるかを決定するコンポーネント
扱うタスクの性質に応じてディスパッチャーを選択する必要がある

CoroutineDspatcherの種類

Dispatchers.Default
- CPU集約型のタスクに適している
- バックグラウンドスレッドプールを使用する
- 複数のスレッドで並行実行される可能性が高い
Dispatchers.Main
- UI操作に適している（Android、JavaFXなど）
- メインスレッド（UIスレッド）上で実行される
- 同時に1つのタスクのみが実行される
Dispatchers.IO
- I/O操作（ファイル、ネットワーク）に適している

CoroutineDspatcherの例

次のように使用する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


launch(Dispatchers.IO) {
 // I/O操作を行うコード
}

withContext(Dispatchers.Default) {
 // CPU集約型の処理
}

val deferredCPU = async(Dispatchers.Default) {
 // CPU集約型の処理
}
val resultCPU = deferredCPU.await()

CoroutineScope

CoroutineScopeとは

CoroutineScopeは、コルーチンの実行範囲を定義し、その生存期間を管理するためのコンテキスト
キャンセル処理やポーズなどのコンテキストを決めるスコープ
Pythonで言うところのリソースの自動開放をするwithキーワードに近い

1
2
3
4


with open('file.txt', 'r') as file:
 content = file.read()
 print(content)
 # このブロックを抜けると自動でclose

CoroutineScopeの種類

GlobalScope
- アプリケーションの全生存期間に渡るスコープ
CoroutineScope
- カスタムスコープを作成する際に使用
lifecycleScope
- Android の LifecycleOwner に紐づいたスコープ
viewModelScope
- ViewModel に紐づいたスコープ

CoroutineScopeが必要な理由

CoroutineScopeは非同期処理の管理、制御、およびリソースの効率的な利用を可能にする為に必要。

構造化並行性
- コルーチンの階層構造を管理し、親子関係を確立する
- 親スコープがキャンセルされると、子コルーチンも自動的にキャンセルされる
ライフサイクル管理
- コルーチンの開始と終了を制御する
- アプリケーションの特定のライフサイクル（例：Androidのアクティビティ）に合わせてコルーチンを管理できる
リソース管理
- コルーチンが使用するリソースを適切に解放する
- メモリリークを防ぐために重要

CoroutineScopeの使用例

Dispatchers.DefaultはCPU 集約型タスクのために最適化されたスレッドプールを使用するディスパッチャー
つまり、Dispatcherを指定する事でコルーチンのスレッドを決定する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


val scope = CoroutineScope(Dispatchers.Default)

scope.launch {
 // この中で複数のコルーチンを起動できる
 val result1 = async { fetchData1() }
 val result2 = async { fetchData2() }
 println("Results: ${result1.await()}, ${result2.await()}")
}

// スコープのキャンセル（必要に応じて）
scope.cancel()

launchもasyncもCoroutineBuilder関数
一つの親コルーチン（launch）の中に、2つの子コルーチン（async）が存在する形になる

CoroutineBuilder

CoroutineBuilderとは

CoroutineBuilderは、Kotlinのコルーチンを作成し、開始するための関数
これらは新しいコルーチンを構築し、その実行を制御する -launch, asyncなどがある

CoroutineBuilderの使い方

launch

結果を返さない新しいコルーチンを開始する
Job オブジェクトを返す（キャンセルなどの制御に使用）
fire and forget（実行しっぱなし）タイプの非同期タスクに適している

1
2
3


val job = launch {
 // コルーチンの処理
}

async

結果を返すコルーチンを開始する。
Deferred<T> でT型の戻り値のオブジェクトを返す
await() メソッドで結果を取得できる

1
2
3
4


val deferred = async {
 return 42
}
val result = deferred.await() // 42

runBlocking

現在のスレッドをブロックし、その中でコルーチンを実行する
主にテストや main 関数でコルーチンを実行する際に使用

1
2
3
4


runBlocking {
 delay(1000L)
 println("After delay")
}

coroutineScope

新しいCoroutineScopeを作成し、すべての子コルーチンが完了するまで待機する
サスペンド関数内で使用され、親コルーチンのコンテキストを継承する

1
2
3
4


suspend fun doSomething() = coroutineScope {
 launch { task1() }
 launch { task2() }
}

supervisorScope

coroutineScope と似ているが、子コルーチンの例外が他の子や親に伝播しない
エラー耐性のある操作に適している

1
2
3
4


supervisorScope {
 launch { riskyTask1() }
 launch { riskyTask2() }
}

withContext

指定されたコンテキストで、コルーチンのブロックを実行する
主にディスパッチャーを切り替えるのに使用

1
2
3


withContext(Dispatchers.IO) {
 // I/O操作
}

CoroutineBuilderの使い分け

いくつかCoroutineBuilderがあるが、次のように使い分ける。

ビルダー	主な用途	戻り値	特徴	典型的な使用場面
launch	結果を返さない非同期タスク	Job	「発射して忘れる」タイプの処理	バックグラウンド処理、ログ記録、イベント送信
async	結果を返す非同期タスク	Deferred	並列処理、結果の取得が必要な場合	複数のAPIリクエスト、並列計算
runBlocking	メイン関数やテストでのコルーチン実行	T (ブロック内の最後の式の結果)	現在のスレッドをブロック	テスト、スクリプトのメイン関数
coroutineScope	複数の非同期操作のグループ化	T (ブロック内の最後の式の結果)	すべての子が完了するまで待機	関連する複数の非同期タスクの実行
supervisorScope	エラー耐性のある操作	T (ブロック内の最後の式の結果)	子の失敗が他に影響しない	独立した複数のタスク実行、エラー分離が必要な場合
withContext	特定のコンテキストでの実行	T (ブロック内の最後の式の結果)	コンテキスト（主にディスパッチャー）の切り替え	I/O操作、計算集約型タスク、UI更新

その他

アクターモデル

アクターモデルの基本概念
- アクターは独立した計算単位で、自身の状態を持ち、メッセージを受け取って処理する
- アクター同士は直接通信せず、メッセージパッシングを通じて相互作用する
- 各アクターは独自のメールボックス（メッセージキュー）を持つ

kotlinでのアクターモデルの例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

sealed class CounterMsg
object IncCounter : CounterMsg()
class GetCounter(val response: CompletableDeferred<Int>) : CounterMsg()

fun CoroutineScope.counterActor() = actor<CounterMsg> {
 var counter = 0 // アクターの状態
 for (msg in channel) { // メッセージの受信ループ
 when (msg) {
 is IncCounter -> counter++
 is GetCounter -> msg.response.complete(counter)
 }
 }
}

suspend fun main() = coroutineScope {
 val counter = counterActor() // アクターの作成
 withContext(Dispatchers.Default) {
 massiveRun { counter.send(IncCounter) } // 多数の増加メッセージを送信
 }
 // 最終的なカウンターの値を取得
 val response = CompletableDeferred<Int>()
 counter.send(GetCounter(response))
 println("Counter = ${response.await()}")
 counter.close() // アクターを終了
}

suspend fun massiveRun(action: suspend () -> Unit) {
 val n = 100 // 起動するコルーチンの数
 val k = 1000 // 各コルーチンで実行する繰り返しの回数
 val time = measureTimeMillis {
 coroutineScope {
 repeat(n) {
 launch {
 repeat(k) { action() }
 }
 }
 }
 }
 println("Completed ${n * k} actions in $time ms")
}

参考文献

Androidアプリ開発時のメモ

Fri, 05 Jul 2024 20:00:52 +0900

概要

Android Developer Accountを放置していたらPlay Console 要件に合うように更新する通知が来た
趣味として、久しぶりにAndorid開発を行い、アカウントを維持する事に決めた
最近のAndroid開発ではJetpack ComposeとKotlinで開発するのが主流らしいので色々メモを残す

Androidの全般

スレッド

メインスレッドとは

メインスレッドは、UIスレッドとも呼ばれる
アプリケーションの起動時に作成される最初のスレッド
ユーザーインターフェース（UI）の描画と更新を担当する
主な役割
- UIコンポーネントの描画と更新
- ユーザー入力（タッチ、クリックなど）のイベント処理
- Activityのライフサイクルメソッドの実行
重要性
- アプリケーションの応答性を維持するために重要
- メインスレッドがブロックされると、アプリがフリーズしたように見える（ANR: Application Not Responding）

バックグラウンドスレッド

アプリケーションのメインスレッド（UIスレッド）とは別に実行されるスレッドのこと
Service Componentは、デフォルトでバックグラウンドスレッドではなくメインスレッドで動くので注意
ThreadやHandlerThread、AsyncTask（現在は非推奨）、Executors、あるいはCoroutineなどを利用する必要がある

バックグラウンドスレッドは、以下のような処理に利用される。

ネットワーク通信
データベース操作
ファイルI/O
長時間かかる計算処理

ベストプラクティス

Applicationでシングルトンに管理するべき
- ViewModel, 常に動くforeground serviceなど
- 画面に関係ないのに、Activity頻繁にbindなどをして、別コンポーネントの作成と破棄を繰り返すと状態が複雑化する
- 普通にUI以外のコンポーネントはApplicationでシングルトンにしした方がいい
- つまり、できるだけ破棄再作成されないようなシンプルなStateにした方がいいですよね？
長時間実行される処理をメインスレッドで行うべきではない
- ネットワーク操作やデータベース処理などの時間のかかる操作は避ける
  - ちなみに、WebのJSのFetchは非同期処理
- 時間のかかる操作は別のスレッドで実行する（AsyncTask, Coroutines, WorkManagerなど）
UIの更新はメインスレッドで行う
- なぜなら、Android のUI コンポーネントはスレッドセーフではないから
- 複数のスレッドから同時にUIを操作すると、競合状態や予期せぬ動作が発生する可能性があるから
- そのため、runOnUiThread()やHandler.post()メソッドを使用して、バックグラウンドスレッドからメインスレッドに処理を戻す
- Android システムは、MainThread 以外からのUI操作を検出し、例外をスローする（CalledFromWrongThreadException）。

メインスレッドでの処理とバックグラウンド処理の例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)

 // メインスレッドでの処理（UIの更新）
 updateUI()

 // バックグラウンドスレッドでの処理
 Thread {
 // 時間のかかる処理
 val result = performLongRunningTask()

 // メインスレッドに戻ってUIを更新
 runOnUiThread {
 displayResult(result)
 }
 }.start()
 }

 private fun updateUI() {
 // UIの更新処理
 }

 private fun performLongRunningTask(): String {
 // 時間のかかる処理
 Thread.sleep(2000) // シミュレーション
 return "処理結果"
 }

 private fun displayResult(result: String) {
 // 結果をUIに表示
 }
}

もしくは下のような感じ。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


new AsyncTask<Void, Void, String>() {
 @Override
 protected String doInBackground(Void... voids) {
 return makeApiCall("https://api.example.com/data");
 }

 @Override
 protected void onPostExecute(String result) {
 // UIの更新
 }
}.execute();

lifecycleScope.launch {
 val result = withContext(Dispatchers.IO) {
 makeApiCall("https://api.example.com/data")
 }
 // UIの更新
}

ANR（Application Not Responding）

ANRは、Application Not Respondingの略

![ANRのダイアログ(image-8.png)

ANRの発生条件は以下の2つ。

入力イベント（キーの押下や画面タッチなどのイベント）に対する応答が 5 秒以内にない
BroadcastReceiverの実行が 10 秒以内に終了しない

スレッド vs. コルーチン

スレッドとコルーチンの図

Process > Thread > Coroutineの階層
KotlinはStructured Coroutineを採用しているのでCoroutineはさらに階層構造を持つ
AndroidはMain Thread（UI Thread）とそれ以外のBackground Threadがある
- ちなみに、AndroidのServiceは、MainThreadで実行される

コルーチンのメリット

Kotlinの場合は階層構造のcoroutine構造を持つ事によるグループ処理が可能
また、Threadと違い、一時停止と再開、取り消しなどが可能となる

スレッドの例

Android でスレッドを使用する例。

スレッド関数を使用して新しいスレッドを作成し、指定されたタスクを非同期で実行する
ただし、競合状態、デッドロック、スレッド同期などの問題により、スレッドを直接操作することが困難な場合がある

1
2
3
4
5
6
7
8


import kotlin.concurrent.thread

fun performTask () {
 thread {
 // ここで時間のかかるタスクを実行
 // このコードは別のスレッドで実行
 }
}

コルーチンの例

コルーチンは、並行処理をより構造化して効率的に処理する方法を提供する

1
2
3
4
5
6
7
8


import kotlinx.coroutines.*

fun performTask () {
 GlobalScope.launch {
 // ここで時間のかかるタスクを実行
 // このコードはコルーチンで実行
 }
}

画像をDLして表示する例

スレッドの例

1
2
3
4
5
6
7
8


fun loadImage() {
 thread { // ここでbackground threadで動かしている
 val image = downloadImageFromServer()
 runOnUiThread { // メインスレッドに戻している
 imageView.setImageBitmap(image)
 }
 }
}

Coroutinesの例

withContextを使用してIO Dispatchersに切り替えてイメージをダウンロードしている
その後Mainディスパッチャーに戻って UI を更新

1
2
3
4
5
6
7
8


suspend fun loadImage() {
 withContext(Dispatchers.IO) { // background threadで動かしている
 val image = downloadImageFromServer()
 withContext(Dispatchers.Main) { // main threadで動かしている
 imageView.setImageBitmap(image)
 }
 }
}

versionCodeとversionName

versionCode
- 整数で設定。
- ユーザーには表示されない。
- リリースのたびにIncrementする必要がある
versionName
- 文字列で設定。
- 例えば、1.1とか2.1.4のような値が設定できる
- ユーザーに表示される

APK vs. AAB

AABファイルは、Google Playが最適化されたAPKを生成するためのパッケージフォーマット
ユーザーがアプリをインストールする際に、Google Playはデバイスに最適なAPKを生成して配布する
そのため、例えば、Google DriveからインストールしたかったらAPKを選ぶ

Androidアプリの設計思想

コンポーネントベース
- Androidアプリは主に4つの基本コンポーネント（Activity、Service、BroadcastReceiver、ContentProvider）から構成されている
イベント駆動
- ユーザー操作やシステムイベントに応じて動作する
インテント通信
- コンポーネント間やアプリ間の通信にはIntentシステムを使用する
ライフサイクル管理
- 各コンポーネントには明確なライフサイクルがある
- それらはシステムによって管理される
UIスレッドとバックグラウンド処理
- メインスレッド（UIスレッド）とバックグラウンドスレッドの分離を推奨している

アイコンの生成

アイコンの作成方法は次の手順。

Menu > File > new > Vector Asset

アイコンは次の2種類のclipartを用意する。

ic_launcher
- size: 24dp x 24dp
- アプリ全般用
ic_notification
- size: 48dp x 48dp
- 通知バー用のアイコン

Store用のアイコンは次を使う。

Storeでのアプリのアイコン
- AndroidStudioProjects\XXX\app\src\main\ic_launcher-playstore.png
フィーチャーグラフィック
- https://hotpot.ai/
スクリーンショット
- EmulatorでSSを撮る

Lifecycle

Lifecycleとは

Androidの各コンポーネント（Activity、Fragment、Service等）は異なるライフサイクルを持つ
ただし、課題が多いため、AndroidはLifecycleOwnerやViewModel、LiveDataなどのJetpack Componentsを推奨している

Lifecycleの違いによる問題は以下

複雑性の増加
- 各コンポーネントのライフサイクルが異なるため、開発者は各々の挙動を理解し、適切に処理する必要がある
- 複数のコンポーネントを組み合わせて使用する際、それぞれのライフサイクルの相互作用を考慮する必要がある
メモリーリーク
- ライフサイクルの理解が不十分だと、不適切なタイミングでリソースの解放を忘れ、メモリリークを引き起こす可能性がある
- 例：Activityが破棄されても、長時間実行されるバックグラウンドタスクがActivityへの参照を保持し続ける場合など
リソース管理
- カメラやGPS等のシステムリソースの使用開始/終了タイミングを、各コンポーネントのライフサイクルに合わせて適切に管理する必要がある

Componentのライフスパン

Application
- プロセスと同等
Activity, Service, Foreground Service
- メインスレッド
AsyncTask, Kotlin Coroutines, HandlerThread
- バックグラウンドスレッド

Lifecycleのデバッグ

tagを決めて全メソッドに下を入れてtagでグルーピングしてデバッグするのが一番良い。

1
2
3
4
5
6
7


class Activity: ComponentActivity() {
 override fun onStart() {
 super.onStart()
 Log.d("myLog", "${javaClass.simpleName}::${object{}.javaClass.enclosingMethod?.name}")
 // 処理
 }
}

ChatGPTでログをシーケンス図にするのが良い
以下はそのプロンプト

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# 指令

- このAndroidのLogcatをマーマメイドのシーケンス図にしてください
- クラスに関係ない行は無視してください
- アクターを追加してください
- コンポーネントは`MainActivity->>MainActivity`のようにself messageのみで作ってください。

# 例

## 例1

### 入力

2024-07-16 20:13:50.873 2946-2946 myLog org.m1ke.xxx D MyApplication::onCreate

### 出力

MainActivity->>MainActivity: onCreate

## 例2

### 入力

2024-07-16 20:13:51.205 2946-2946 myLog org.m1ke.xxx D MainActivity::onResume::viewModel::timerFinished::observe, language=ja

### 出力

MainActivity->>MainActivity: onResume::viewMoodel::timerFinished::observe, language= ja

Andorid Component

代表的なコンポーネント一覧

Androidの代表的なコンポーネントは以下の通り。

Activity
- ユーザーインターフェースを提供する単一の画面
- ユーザーと直接対話する部分を担当
Service
- バックグラウンドで動作するコンポーネント
- ユーザーインターフェースを持たず、長時間実行されるタスクや他のコンポーネントと通信を行うタスクに使用される
Broadcast Receiver
- システムや他のアプリからのブロードキャストメッセージを受信する
- ブロードキャストは、システムイベントやアプリからのカスタムイベントを通知するために使用される
- システムイベントは、例えば、バッテリーが低下やWi-Fiの接続など
Content Provider
- アプリ間でデータを共有するための仕組みを提供する
- 例えば、連絡先アプリやメディアファイルへのアクセスなどがこれに該当する
Fragment
- アクティビティの一部として動作するUIコンポーネント
- アクティビティ内での再利用可能なUI部分を作成するために使用される
ViewModel
- アクティビティやフラグメントにおけるUIデータの管理を担当する
- ライフサイクルを考慮して設計されている
- 画面回転や他のライフサイクルイベントによってUIコントローラが再作成されても、データを保持する
- これにより、データの保存と復元のためのコードが簡素化される
Application
- アプリケーションの全体的な状態を管理するためのベースクラス
- アプリケーション全体の初期化処理やグローバルな状態を保持するために使用される
- Applicationクラスを拡張し、必要に応じてカスタム初期化コードを追加できる
LiveData
- ライフサイクルに依存したデータホルダーで、データが変更されると自動的に観察者に通知する
- ViewModelと一緒に使用されることが多く、UIのデータ更新を簡素化する
Navigation
- アプリ内の画面遷移を管理するためのコンポーネント
- ナビゲーショングラフを使用して、アプリのフローを定義し、アクションや遷移を視覚的に設計することができる
Repository
- データ操作を行うクラスで、データソースとViewModelの間の抽象層として機能する
- クリーンアーキテクチャの一部として使用されることが多い

Activity

Activityとは

Activityは、AndroidアプリケーションのUIを持つ構成要素
レイアウトファイル（XML）と関連付けられる
明確に定義されたライフサイクルを持ち、画面回転などの設定変更時に再作成される
システムはActivityをバックスタックで管理し、ユーザーのナビゲーション履歴を維持する

Activityの例

1
2
3
4
5
6
7


class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)
 // UIの初期化やイベントリスナーの設定など
 }
}

マニュフェスト

1
2
3
4
5
6


<activity android:name=".MainActivity">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
 <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
</activity>

ライフサイクルの状態遷移図

Activityのライフサイクル

アプリ起動

Androidのホーム画面からアプリのアイコンをクリックするとアプリが起動し、最初のアクティビティが画面上に表示される。

「アクティビティが開始」されると次の3つのメソッドが実行される。

onCreate()
onStart()
onResume()

その後、「実行中」の状態になる。

別のアクティビティを開始

同じアプリの別のアクティビティが開始されようとしたり、別のアプリのアクティビティが開始されようとすると、元のアクティビティは他のアクティビティによって見えなくなる。

この時、別のアクティビティが画面に表示される前に「onPause()」メソッドが呼び出さる。

元のアクティビティが再び画面に表示される場合
- 右のルートを通って「onResume()」メソッドが呼ばれた上で「実行中」の状態に戻る
新しいアクティビティが画面に表示され元のアクティビティが見えなくなった場合
- 下のルートを通って「onStop()」メソッドが呼ばれて「停止中」の状態となる

再び表示される時

アクティビティは他のアクティビティの裏に隠れて表示されていない状態でも終了してはいない（停止の状態のまま）。

ユーザーによって非表示の状態から再び画面に表示されようとした場合次の3つのメソッドを実行した後に「実行中」になる。

onRestart()
onStart()
onResume()

ただし、停止中でもアクティビティは終了はしていないが、Androidのメモリが足りなくと、メモリを確保するために実行中でないアクティビティが強制的に終了となる場合がある。

この場合、アクティビティはいったん終了する。この状態からユーザーが再びアクティビティを表示させようとした場合は「onCreate()」メソッドから改めて呼び出されることになる。

アクティビティの終了

アクティビティが終了する場合には最後に「onDestroy()」メソッドが呼ばれて終了する。

いつActivityは落ちるのか

結論、AndroidアプリはOSの都合で勝手に終了する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


class MainActivity : AppCompatActivity() {
 private val tag = this::class.simpleName

 private val handler = Handler(Looper.getMainLooper())
 private var count = 0

 private val task = object : Runnable {
 override fun run() {
 Log.d(tag, "count=$count")
 count++
 handler.postDelayed(this, 1000)
 }
 }

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)

 task.run()
 }

 override fun onPause() {
 super.onPause()
 Log.d(tag, "onPause:")
 }

 override fun onStop() {
 Log.d(tag, "onStop:")
 super.onStop()
 }

 override fun onDestroy() {
 Log.d(tag, "onDestroy:")
 super.onDestroy()
 }
}

上のアプリのログ。

1
2
3
4
5
6
7
8


D/MainActivity: count=6
D/MainActivity: count=7
D/MainActivity: onPause: ← バックキー押下
D/MainActivity: onStop: ← Activity停止
D/MainActivity: onDestroy: ← Activity破棄
D/MainActivity: count=8 ← 動き続けている
D/MainActivity: count=9
D/MainActivity: count=10

つまり、Activity が破棄された後もカウントアップが続いてる
アプリ内の全Activityが破棄されたからといって、すぐにアプリのプロセスが終了するわけではない

ではいつアプリがいつ死ぬのか？

1
2
3
4
5


D/MainActivity: count=30
D/MainActivity: count=31
D/MainActivity: count=32
I/ActivityManager: Force stopping com.ishihatta.terminationtest appid=10080 user=0: from pid 744
I/ActivityManager: Killing 9768:com.ishihatta.terminationtest/u0a80 (adj 903): stop com.ishihatta.terminationtest

つまり、Activity が残っているかどうかに関係なく、画面表示されていないアプリ（=フォアグラウンドな ActivityやService がないアプリ）のプロセスは、いつkill されてもおかしくないということ。

Service

Serviceとは

Serviceはアプリケーションがバックグラウンドで長時間実行する処理を実装するためのコンポーネント
あくまで画面のない、Userとの対話で動かないActivityという理解が正しい
なぜなら、Service 自体はバックグラウンドスレッドではなくメインスレッドで実行されるから

特徴

バックグラウンド処理
- Activityとは異なり、ユーザーインターフェースがない
- そのため、ユーザーの操作に依存しないバックグラウンド処理を行うことができる
長時間実行
- タスクの完了まで長時間実行し続けることが可能
- 例として、音楽プレーヤーやデータのダウンロード・アップロードなどがある

Serviceの種類

Started Service -startService()メソッドで開始されるサービス
- このサービスは、タスクが完了するまでバックグラウンドで実行される
- タスクが完了した後にstopSelf()やstopService()メソッドを呼び出して停止する必要がある
- 一定の時間ごとに何らかの処理を行う場合
Bound Service
- bindService()メソッドを使用して他のアプリケーションコンポーネントにバインドされるサービス
- このタイプのサービスは、クライアントと対話するためにインターフェースを提供する
- すべてのクライアントがバインドを解除するとサービスは停止する
- 他のアプリケーションコンポーネント（例: Activity）と対話しながら、定期的なタイマー処理を行う場合
Foreground Serviceとは
- Foreground Serviceとは、通常のサービスと違い、通知を表示し、バックグラウンドで実行している事をユーザに認識させた状態で実行するService
- Foreground serviceが動いている間はサービスがシステムのリソースを消費し続けている事実をユーザーに認識させるために、専用の通知を通知領域に表示し続ける必要がある

Serviceの実装例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class MyService : Service() {

 override fun onCreate() {
 super.onCreate()
 // 初期化処理
 }

 override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
 // バックグラウンド処理の開始
 return START_STICKY // サービスがシステムによって再起動されるべきであることを示す
 }

 override fun onBind(intent: Intent): IBinder? {
 // バインド処理
 return null // バインドサービスではない場合
 }

 override fun onDestroy() {
 super.onDestroy()
 // クリーンアップ処理
 }
}

Serviceのライフサイクル

次の2系統がある。

Started
- startService()メソッドで開始され、停止されるまで実行され続ける
Bound
- bindService()メソッドで他のコンポーネントにバインドされ、バインドが解除されるまで実行される

Intent

Intentとは

Web敵に言うと、Itentはハイパーリンクみたいなもの
さらに、インテントは、アクティビティやサービスの開始、ブロードキャストの送信など、より広範な機能を持つ

Explicit Intent（明示的インテント）

1
2
3


// 明示的に特定のコンポーネントを指定して操作を開始するためのインテント
Intent intent = new Intent(this, TargetActivity.class);
startActivity(intent);

Implicit Intent（暗黙的インテント）

1
2
3
4
5
6


// 実行したい動作を指定するが、特定のコンポーネントを指定しないインテント
// システムは、指定された動作を処理できるコンポーネントを見つけ出して実行する
// 例えば、ウェブページを開く、電話をかける、写真を撮るなど
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.example.com"));
startActivity(intent);

Intentの例

1
2
3
4
5
6


Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.example.com"));
intent.addCategory(Intent.CATEGORY_BROWSABLE);
intent.putExtra("key", "value");
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

Intentが必要な理由

AndroidでActivityとServiceやViewModelが通信するのにIntentを使うのは、結局コンポーネントが別々のライフサイクルを持っている事に起因する
コンポーネントがかってに作られたり消されたりしたときに、直接参照を持つとメモリーリークになる
故に、メッセージパッシングで通信するためにIntentなどを使って疎結合に通信する

Context

Contextとは

Contextは、アプリケーションやアクティビティのライフサイクルを管理する抽象クラス
ActivityもApplicationもContextクラスを継承している

Contextは3つの種類がある。

Application Context
- アプリケーションのライフサイクル全体に関連している
- アプリケーション全体にわたるリソースやクラスへのアクセスを提供する
- 通常、getApplicationContext()メソッドで取得する
Activity Context
- 特定のアクティビティに関連している
- そのアクティビティのライフサイクルに依存する
- 通常、アクティビティ内でthisを使用して取得する
Service Context
- 特定のサービスに関連している
- そのサービスのライフサイクルに依存する
- 通常、サービス内でthisを使用して取得する

Contextの注意点

メモリリークの回避
- 長時間保持されるオブジェクト（例えば、静的フィールドやシングルトン）にActivity Contextを保持すると、
- アクティビティが破棄されてもガベージコレクションされず、メモリリークの原因となる
- この場合、Application Contextを使用することが推奨される
適切なコンテキストの選択
- アクティビティ固有の操作（例えば、UI操作やダイアログの表示など）にはActivity Contextを使用するのが良い
- アプリケーション全体に影響を与える操作にはApplication Contextを使用するのが一般的

ContextとIntent

Intent
- アプリケーション内やアプリケーション間で動作を開始するためのメカニズムを提供するオブジェクト
Context
- アプリケーション環境に関する情報を提供するインターフェース
- アプリケーションのリソースやクラスにアクセスするためのメソッドを提供する

ContextはIntentを使用してアクティビティやサービスを起動するためのメソッドを提供する。

1
2
3
4
5
6
7


// Contextを使用してアクティビティを起動
Intent intent = new Intent(this, TargetActivity.class);
Context.startActivity(intent);

// Contextを使用してサービスを開始
Intent serviceIntent = new Intent(this, MyService.class);
Context.startService(serviceIntent);

Fragment

Fragmentとは

Fragmentは、アクティビティ内で再利用可能なUIコンポーネント
複数の画面サイズに対応するレイアウトを作成する際に特に有用

Fragmentの特徴

モジュール性：UIの一部を再利用可能なコンポーネントとして定義できる
ライフサイクル：独自のライフサイクルを持ち、アクティビティのライフサイクルと連動する
状態保持：構成変更（画面回転など）時にも状態を保持できる
通信：ホストアクティビティや他のフラグメントと通信が可能

Fragmentの例

Fragmentクラスの定義。

1
2
3
4
5


class MyFragment : Fragment() {
 override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
 return inflater.inflate(R.layout.fragment_my, container, false)
 }
}

アクティビティでのフラグメントの使用の例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)

 if (savedInstanceState == null) {
 supportFragmentManager.beginTransaction()
 .add(R.id.fragment_container, MyFragment())
 .commit()
 }
 }
}

Broadcast Receiver

Broadcast Receiverとは

Broadcast Receiverは、システム全体やアプリケーション間でのメッセージ（ブロードキャスト）の送受信を可能にするもの。

主な役割

システムイベントやアプリケーションイベントを受信する
バックグラウンドで動作し、特定のイベントが発生したときに反応する

使用例

デバイスの起動完了通知
バッテリー残量の変化
ネットワーク接続状態の変化
アプリのアップデート完了
時間帯の変更
言語設定の変更
カスタムイベントの送受信

Broadcast Receiverの例

コード例

1
2
3
4
5
6
7


class MyReceiver : BroadcastReceiver() {
 override fun onReceive(context: Context, intent: Intent) {
 if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
 // デバイス起動時の処理
 }
 }
}

AndroidManifest.xml

1
2
3
4
5


<receiver android:name=".MyReceiver">
 <intent-filter>
 <action android:name="android.intent.action.BOOT_COMPLETED"/>
 </intent-filter>
</receiver>

使用例

1
2


val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
registerReceiver(myReceiver, filter)

Content Provider

Content Providerとは

Content Providerは、アプリ間でのデータ共有を可能にする重要なコンポーネント
AndroidでDBにデータを取得/保存する時に利用するクラス
あるアプリが持っているデータを他のアプリも使用できるようになったりする
もともと用意されているものとしては、着信ログや電話帳、ブラウザのブックマークなど

URI

データは Uniform Resource Identifier (URI) を通じてアクセス
Content ProviderのURIは3つの要素から構成されている

(例) content://packagename.providername/sample

prefix：“content://”
authority(パッケージ名+任意のprovider名)：“packagename.providername”
table：“sample”

Content Providerの例

連絡先プロバイダー

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


val projection = arrayOf(ContactsContract.CommonDataKinds.Phone.NUMBER)

// DB操作と同じようにカーソルオブジェクトを使う
val cursor = contentResolver.query(
 ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
 projection,
 null,
 null,
 null
)
cursor?.use {
 while (it.moveToNext()) {
 val phoneNumber = it.getString(0)
 println("Phone Number: $phoneNumber")
 }
}

Application

Applicationとは

ApplicationクラスはAndroidアプリケーションのライフサイクル全体を管理するコンポーネント。

次の特徴を持つ。

アプリケーション全体の基本クラス
アプリの他のすべてのコンポーネントよりも先に作成される
アプリケーションプロセスが存在する限り、単一のインスタンスとして維持される

主な用途:

アプリケーション全体で共有されるグローバルな状態の管理
アプリケーション起動時の初期化処理
アプリケーション全体で使用されるリソースの管理

Applicationの主要メソッド

onCreate(): アプリケーション起動時に一度だけ呼ばれる
onTerminate(): アプリケーション終了時に呼ばれる（エミュレータでのみ動作）
onLowMemory(): システムのメモリが少なくなった時に呼ばれる
onTrimMemory(): システムがメモリを解放する必要がある時に呼ばれる

Applicationの例

1
2
3
4
5
6


class MyApplication : Application() {
 override fun onCreate() {
 super.onCreate()
 // アプリケーション全体の初期化コードをここに記述
 }
}

マニュフェスト

1
2
3
4
5


<application
 android:name=".MyApplication"
 ...>
 <!-- その他のコンポーネント -->
</application>

使用例

1
2
3
4
5
6
7


class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 val myApplication = application as MyApplication
 // myApplicationを通じてグローバルな状態や方法にアクセス
 }
}

NOTE:

applicationはContextのプロパティ
MainActivityはContextを継承している
故に、applicationにアクセスできる

コンポーネント間通信

Android IPCの方法

AndroidのIPCの仕組みは2つある。

Binder
- 同一プロセス内のサービスとクライアント間の通信を簡単にするためのメカニズム
AIDL（Android Interface Definition Language）
- 異なるプロセス間での通信をサポートするためのメカニズム

Binderの例

サービスの作成。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class MyService : Service() {
 // バインダーのインスタンスを作成
 private val binder = LocalBinder()

 // バインダーの内部クラス
 inner class LocalBinder : Binder() {
 // サービスのインスタンスを返すメソッド
 fun getService(): MyService = this@MyService
 }

 // サービスがバインドされた時に呼ばれる
 override fun onBind(intent: Intent): IBinder {
 return binder
 }

 // サービスの他のメソッド
 fun someServiceMethod() {
 // サービスの具体的な処理
 }
}

クライアントからサービスにバインド。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class MainActivity : AppCompatActivity() {

 private var myService: MyService? = null

 // サービス接続のためのコールバック
 private val serviceConnection = object : ServiceConnection {
 override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
 // バインダーからサービスのインスタンスを取得
 val binder = service as MyService.LocalBinder
 myService = binder.getService()
 // サービスのメソッドを呼び出し
 myService?.someServiceMethod()
 }

 override fun onServiceDisconnected(name: ComponentName?) {
 myService = null
 }
 }

 override fun onStart() {
 super.onStart()
 // サービスをバインド
 Intent(this, MyService::class.java).also { intent ->
 bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
 }
 }

 override fun onStop() {
 super.onStop()
 // サービスのバインドを解除
 unbindService(serviceConnection)
 }
}

通信手段の比較

以下に、通信手段を比較した表を示す。

Binder
- 同一プロセス内での直接通信に適している
- 例: アプリ内のサービスとアクティビティ間の通信
AIDL
- 異なるプロセス間の複雑な通信に適している
- 例: サービスとクライアントが異なるアプリで動作する場合
Messenger
- シンプルなメッセージベースの通信
- 例: サービスがバックグラウンドで動作し、アクティビティに結果を通知する場合
BroadcastReceiver
- 一方向の非同期通信に適している
- 例: システムイベント（ネットワーク状態の変化、バッテリーの低下）の通知
ContentProvider
- 永続データの共有に適している
- 例: 連絡先データベース、メディアストア
Shared Preferences
- 小規模なデータ共有に適している
- 例: ユーザー設定、アプリの状態保存
LiveData
- ライフサイクル対応のデータホルダーで、UIとデータの同期を簡素化する（同期）
- 例: ViewModelからアクティビティやフラグメントへのデータ通知
EventBus
- アプリ内の疎結合なコンポーネント間通信
- 例: フラグメント間でのデータやイベントのやり取り
Intent
- コンポーネント間通信（同期）
- 例: 新しいアクティビティを開始する、サービスを開始する
JobScheduler
- バックグラウンドでのジョブスケジューリング
- 例: ネットワークが利用可能なときにデータを同期するジョブ
WorkManager
- 信頼性の高いバックグラウンドジョブ
- 例: 定期的にサーバーとデータを同期する
Socket通信
- リアルタイム通信

Android Jetpack

Android Jetpackとは

Android Jetpackは、Googleが提供する一連のライブラリ、ツール、およびガイドラインのコレクション。

Foundation
- コアのライブラリ（AppCompat、Android KTX、Testなど）を含み、アプリの互換性やテストを容易にする
Architecture
- アプリの設計を助けるライブラリ（ViewModel、LiveData、Room、DataBindingなど）で、データの管理やUIの更新を簡素化する
Behavior
- ユーザーインターフェイスとユーザーの相互作用を向上させるライブラリ（Navigation、Paging、WorkManagerなど）を含む
UI
- 洗練されたユーザーインターフェースの構築を助けるライブラリ（RecyclerView、Fragment、Layout、Animationsなど）を提供する

Android JetpackとJetpack Composeの違い

Android Jetpackはアプリ全体の開発をサポートする包括的なツールセット
Jetpack Composeは、Googleが提供する最新のUIツールキット

Jetpack Composeとは

元々AndroidはActivityとXMLレイアウトファイルで構成されていた
ActivityはUIロジックを管理し、XMLファイルはUIレイアウトを定義していた
Jetpack Composeは、XMLファイルを使用せずにKotlinコードのみでUIを定義できるようにした

Composable関数

Composable関数とは

Composable関数は、Jetpack Composeを使用してUIを構築するための基本的な構成要素
これらの関数は、宣言的なUIフレームワークであるJetpack Composeの一部で、UIコンポーネントを作成するために使用する
Composable関数の特長
- 宣言的アプローチ
  - Composable関数はUIの状態を宣言的に定義する
  - UIは状態に基づいて自動的に再描画されるため、UIの更新が簡単に管理できる
- 再利用可能
  - Composable関数は再利用可能なUIコンポーネントを作成するために使用される
  - これにより、UIの一貫性を保ち、コードの重複を減らすことができる
- 状態管理
  - Composable関数は状態を持つことができ、その状態に基づいてUIを動的に変更できる
  - Jetpack Composeは状態の変更を検知してUIを再描画する

Composable関数の例

Composable関数の呼び出し

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import androidx.compose.runtime.Composable
import androidx.compose.material3.Surface
import androidx.compose.material3.MaterialTheme

@Composable
fun MyApp() {
 MaterialTheme {
 Surface {
 Counter()
 }
 }
}

Composable関数の定義

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import androidx.compose.runtime.*
import androidx.compose.material3.Button
import androidx.compose.material3.Text

@Composable
fun Counter() {
 var count by remember { mutableStateOf(0) }

 Button(onClick = { count++ }) {
 Text(text = "Clicked $count times")
 }
}

rememberとは

rememberはJetpack Composeにおける状態の管理方法。

rememberは、Composeがコンポジションの間に値を記憶しておくために使用する
これにより、再コンポーズ時に値がリセットされないようにする

例

1
2
3
4
5
6
7
8


import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import androidx.compose.runtime.remember

@Composable
fun TimerScreen() {
 var shouldRestartTimer by remember { mutableStateOf(false) }
}

mutableStateOf
- mutableStateOfは、Composeで状態を保持するためのクラス
- 状態が変更されると、Composeはその変更を検知し、自動的にUIを再コンポーズする
by
- byキーワードは、Kotlinのデリゲーションプロパティを使用して、プロパティのゲッターとセッターをカスタマイズする
- remember { mutableStateOf(false) }の結果を直接shouldRestartTimerとして扱えるようにする

ViewModel

ViewModelとは

ViewModelは、UI関連のデータを保存し管理するためのクラス
ActivityやFragmentのライフサイクルとは独立して動作する

目的

UI関連のデータをライフサイクルの変更（画面回転など）から保護する
ビジネスロジックをUIコントローラー（ActivityやFragment）から分離する

ライフサイクル

ViewModelは、関連するUIコンポーネント（ActivityやFragment）が完全に破棄されるまで存在し続ける
画面回転などの設定変更では破棄されない

注意

ViewModelはあくまくでViewのModel
ViewModelでServiceの状態まで管理するのは得策ではない
ViewModelにServiceの状態を伝えたかったらBinderを使う

ViewModelの利用例

ViewModelの定義

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class CounterViewModel : ViewModel() {
 private val _count = MutableStateFlow(0)
 val count: StateFlow<Int> get() = _count

 fun increment() {
 viewModelScope.launch {
 _count.value += 1
 }
 }
}

Composable関数の定義

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.compose.material3.Button
import androidx.compose.material3.Text

@Composable
fun Counter(viewModel: CounterViewModel = viewModel()) {
 val count by viewModel.count.collectAsState()

 Button(onClick = { viewModel.increment() }) {
 Text(text = "Clicked $count times")
 }
}

Activityの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent

class MainActivity : ComponentActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContent {
 MaterialTheme {
 Surface {
 Counter()
 }
 }
 }
 }
}

ViewModelを使わないと

もしViewModelを使わずActivityのPrivateメンバにデータを保存すると、画面を回転させるとActivityが再度生成されるので、データが保持されず、リセットされる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


@data
public class Person {
 private String name;
 private int age;
}

public class MainActivity extends AppCompatActivity {

 private Person person;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 person = new Person("John Doe", 30);
 }
}

AndroidのScope

Scopeとは

AndroidのScopeは、主にKotlin Coroutinesと関連して使用される概念
Scopeは非同期処理の範囲を定義し、管理するために使用される

Scopeの目的は以下。

リソース管理
- Scopeが終了すると、その中で実行中のすべてのCoroutineがキャンセルされる
メモリリーク防止
- ライフサイクルに紐づくことで、不要になった処理を自動的に停止
構造化並行性
- 関連する非同期処理をグループ化し、管理を容易にする

Scopeの種類

CoroutineScope
- 一般的なScope
- 自由に定義可能
ViewModelScope
- ViewModelのライフサイクルに紐づく
- publicプロパティ
LifecycleScope
- ActivityやFragmentのライフサイクルに紐づく
- publicプロパティ

Scopeの例

使用例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
 // コルーチンの処理
}

class MyViewModel : ViewModel() {
 fun loadData() {
 viewModelScope.launch {
 // 非同期処理
 }
 }
}

キャンセル処理

1
2
3


val job = scope.launch { /* ... */ }
job.cancel() // 特定のジョブをキャンセル
scope.cancel() // Scope全体をキャンセル

scope.launch

Kotlin の coroutine を使用するための構文
scope は CoroutineScope のインスタンス
launch は coroutine を開始するための関数
scope.launch { … } は、指定されたスコープ内で新しい coroutine を開始

scope.launch を使用する主な理由は以下：

非同期処理: UI スレッドをブロックせずに、時間のかかる処理を実行
構造化並行性: coroutine は階層的に管理され、親 coroutine がキャンセルされると、その子 coroutine も自動的にキャンセルされる

例えば、下の操作は非同期で実行されるため、UI スレッドをブロックせずに音を再生し、音声入力を促すことができる。

1
2
3
4


scope.launch {
 viewModel.playSound()
 promptSpeechInput(textToSpeech.language)
}

Jetpack Room

Jetpack Roomとは

Jetpack Roomは、Android開発においてSQLiteデータベースの操作を簡素化するための永続性ライブラリ。

次の利点がある。

SQLiteの低レベルAPIを直接扱う必要がない
コンパイル時のSQL検証
非同期処理との連携が容易
データベース操作のボイラープレートコードを削減

Jetpack Roomの例

EntityとDaoの定義して非同期でアクセスする。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


@Entity(tableName = "users")
data class User(
 @PrimaryKey val id: Int,
 @ColumnInfo(name = "name") val name: String,
 @ColumnInfo(name = "email") val email: String
)

@Dao
interface UserDao {
 @Query("SELECT * FROM users")
 fun getAll(): List<User>

 @Insert
 fun insert(user: User)

 @Delete
 fun delete(user: User)
}

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

 companion object {
 private var instance: AppDatabase? = null

 fun getInstance(context: Context): AppDatabase {
 if (instance == null) {
 instance = Room.databaseBuilder(
 context.applicationContext,
 AppDatabase::class.java,
 "app_database"
 ).build()
 }
 return instance!!
 }
 }
}

使用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


val db = AppDatabase.getInstance(context)
val userDao = db.userDao()

// 非同期で操作を行う
lifecycleScope.launch(Dispatchers.IO) {
 // データの挿入
 userDao.insert(User(1, "John Doe", "john@example.com"))

 // データの取得
 val users = userDao.getAll()
 withContext(Dispatchers.Main) {
 // UIの更新
 }
}

WorkManager

WorkManagerとは

WorkManagerは、延期可能な非同期タスクを簡単にスケジュールするためのAPIを提供する
バックグラウンドで実行する必要がある作業に適している

WorkManagerの例

1
2
3
4


val uploadWorkRequest: WorkRequest =
 OneTimeWorkRequestBuilder<UploadWorker>().build()

WorkManager.getInstance(context).enqueue(uploadWorkRequest)

LiveData

LiveDataとは

LiveDataは観測可能なデータホルダークラス
ライフサイクルを意識したデータ保持の仕組みを提供し、主にUIとデータの同期に使用される

主な特徴：

ライフサイクル認識：ActivityやFragmentのライフサイクルに応じてデータの更新を管理する
メモリリーク防止：ライフサイクルが終了すると自動的に購読を解除する
常に最新のデータ：設定変更（画面回転など）後も最新のデータを保持する
UIとの一貫性：メインスレッドでデータ更新を行う

LiveDataの例

LiveDataの定義

1
2
3
4
5
6
7
8


class MyViewModel : ViewModel() {
 private val _data = MutableLiveData<String>()
 val data: LiveData<String> = _data

 fun updateData(newValue: String) {
 _data.value = newValue
 }
}

LiveDataの利用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class MyActivity : AppCompatActivity() {
 private val viewModel: MyViewModel by viewModels()

 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 setContentView(R.layout.activity_main)

 viewModel.data.observe(this) { newValue ->
 // UIの更新
 textView.text = newValue
 }
 }
}

LifecycleOwner

LifecycleOwnerとは

LifecycleOwner は Android Jetpack の Lifecycle コンポーネントの一部
オブジェクトのライフサイクル状態を持つクラスを表すインターフェース
つまり、MainActivityやServiceなどのコンポーネントの状態を抽象化したものがLifecycleOwner

目的

コンポーネントのライフサイクル状態を観察可能にする
ライフサイクルに応じた処理を簡単に実装できるようにする

ライフサイクル状態

INITIALIZED
CREATED
STARTED
RESUMED
DESTROYED

LifecycleOwnerの例

以下の例では、MyLocationTrackerは具体的なActivityやFragmentに依存せず、LifecycleOwnerインターフェースを通じてライフサイクルに応じた処理を行っている
つまり、これにより、同じMyLocationTrackerをActivity, Fragment, Serviceなど、LifecycleOwnerを実装する任意のコンポーネントで再利用できる

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// コンポーネントの定義
class MyLocationTracker(private val lifecycleOwner: LifecycleOwner) {
 init {
 lifecycleOwner.lifecycle.addObserver(object : LifecycleObserver {
 @OnLifecycleEvent(Lifecycle.Event.ON_START)
 fun start() {
 // 位置追跡開始
 }

 @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
 fun stop() {
 // 位置追跡停止
 }
 })
 }
}

// 使用例
class MainActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
 val tracker = MyLocationTracker(this)
 }
}

参考文献

久々のJavaの備忘録

Sun, 30 Jun 2024 20:56:11 +0900

背景

SpringでAPIを管理する必要があった
Javaは十年ぶりなので備忘録をまとめた

Javaとは

Javaのエディション

Java SE（Java Platform, Standard Edition）
- 標準的なエディション
Java EE（Java Platform, Enterprise Edition）
- 企業向け大規模エディション
Java ME（Java Platform, Micro Edition）
- 組み込み向けエディション

なお、Java 9 以降はJava EE は Jakarta EE の名称に変更された。
開発の管理は、OracleからEclipse Foundationになった。

JDKとJRE

JRE（Java Runtime Environment）
- Javaの実行環境
JDK（Java Development Kit）
- Javaの開発環境。JREを含む

Oracle JDKとOpenJDK

Oracle JDKは最初は無償だったが2018年に有償化された
OpenJDKは、Oracleの他、Red Hat、IBM、Apple、SAPなども参加するコミュニティで開発

文法

リテラル

リテラルは次の4つ。

数字リテラル
- 整数リテラル: int型として扱われるが、接尾辞を付けることでlong型としても扱える（例：123L）
- 浮動小数点リテラル: double型として扱われるが、接尾辞を付けることでfloat型としても扱える（例：1.23f）
文字・文字列リテラル
- 文字リテラル: 単一のUnicode文字を表現し、char型として扱われる（例: 'あ'）
- 文字列リテラル: 複数の文字を連結したものを表現し、String型として扱われる（例: "あ"）
- テキストブロック: Java 13以降で導入され、複数行の文字列を簡単に扱うことができる（例: """あ"""）
論理値リテラル
- boolean型として扱われ、trueまたはfalseの値を取る
特殊リテラル
- nullリテラル: オブジェクト参照が存在しないことを示し、nullとして扱われる

プリミティブ

プリミティブ型（基本データ型）の一覧は以下。

種別	型	説明
論理値	boolean	真偽値。true または false。
文字	char	2バイトUNICODE文字。’\u0000’～’\uffff’。
整数	byte	1バイト符号付整数。-128～127。
	short	2バイト符号付整数。-32768～32767。
	int	4バイト符号付整数。-2147483648～2147483647。
	long	8バイト符号付整数。約-922京～約922京。
浮動小数	float	4バイト浮動小数点数。
	double	8バイト浮動小数点数。

列挙型

Java5からサポートされた列挙型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public enum Day {
 SUNDAY,
 MONDAY,
 TUESDAY,
 WEDNESDAY,
 THURSDAY,
 FRIDAY,
 SATURDAY
}

Day today = Day.WEDNESDAY;
System.out.println("Today is " + today);

引数を設定する事もできる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


public enum Day {
 SUNDAY(true),
 MONDAY(false),
 TUESDAY(false),
 WEDNESDAY(false),
 THURSDAY(false),
 FRIDAY(false),
 SATURDAY(true);

 private final boolean isWeekend;

 Day(boolean isWeekend) {
 this.isWeekend = isWeekend;
 }

 public boolean isWeekend() {
 return isWeekend;
 }
}

Day today = Day.WEDNESDAY;
System.out.println("Today is " + today);

if (today.isWeekend()) {
 System.out.println(today + " is a weekend day.");
} else {
 System.out.println(today + " is a weekday.");
}

型の調べ方

instanceofを使う方法

1
2
3
4


Object obj = "Hello, World!";
if (obj instanceof String) {
 System.out.println("The variable is of type String.");
}

getClassを使う方法

1
2


Object obj = "Hello, World!";
System.out.println("The type of obj is: " + obj.getClass().getName());

その他にはReflectionを使う方法もある。

キャスト

値型（プリミティブ型）

明示的なキャスト（大きな型から小さな型）

1
2


double d = 123.45;
int j = (int) d;

暗黙的なキャスト（小さな型から大きな型）

1
2


int j = 123;
double d = j;

参照型（オブジェクト）

アップキャスト（サブクラスからスーパークラスへ）される。

1

Animal animal = new Dog();

ダウンキャスト（スーパークラスからサブクラスへ）は明示的に型を指定する。

1
2


Animal animal = new Dog();
Dog dog = (Dog) animal;

ボクシング

Boxingは、基本データ型（int、double、booleanなど）を、対応するラッパークラス（Integer、Double、Booleanなど）に変換すること。

1
2


int primitiveInt = 10;
Integer wrapperInt = Integer.valueOf(primitiveInt);

メソッドやコレクションの要素は、ラッパークラスを使うことが推奨される。

1
2


ArrayList<Integer> list = new ArrayList<>();
list.add(20); // Boxing: int -> Integer

修飾子

修飾子一覧

以下が修飾子一覧。

修飾子	クラス	インタフェース	メソッド	コンストラクタ	ブロック	変数	説明
public	○	○	○	○	×	○	アクセス修飾子
protected	×	×	○	○	×	○	アクセス修飾子
private	×	×	○	○	×	○	アクセス修飾子
static	×	×	○	×	×	○	スタティック修飾子
final	○	×	○	×	×	○	ファイナル修飾子
abstract	○	○	○	×	×	×	抽象修飾子
native	×	×	○	×	×	×	ネイティブ修飾子
synchronized	×	×	○	×	○	×	同期修飾子
transient	×	×	×	×	×	○	一時的修飾子
volatile	×	×	×	×	×	○	揮発性修飾子
strictfp	○	○	○	×	×	×	厳密浮動小数修飾子

アクセス修飾子

Javaはアクセス修飾子による制限は、パッケージの階層に関係なく同一パッケージか異なるパッケージかで決まる。

アクセス修飾子	自クラス	同パッケージ	サブクラス（同パッケージ）	他クラス（同パッケージ）	サブクラス（他パッケージ）	他クラス（他パッケージ）
public	○	○	○	○	○	○
protected	○	○	○	○	○	×
なし（package-private）	○	○	○	○	×	×
private	○	×	×	×	×	×

なお、interfaceはデフォルトでabstructであり、メソッドはデフォルトでpublic abstructになっている。

1
2
3


public interface XXXInterface {
 void testFunction(int a); // メソッドは自動的にpublic abstractになる
}

const

実質的に、final + static = const。

1

public static final int CONSTANT_VALUE = 42;

クラス

クラスは、オブジェクト（インスタンスとも）が持つ、フィールド（属性、アトリビュート、プロパティ、メンバ変数）や、メソッド（関数、メンバ関数）などを定義する。

1
2
3
4


class TestClass {
 TypeName FieldName;
 TypeName MedhotdName(Args) { ... }
}

インスタンス化

1

TestClass o = new TestClass();

コンストラクタはあるがデストラクタはない。

1
2
3
4
5
6


class Person {
 String myName;
 Person(String myName) {
 this.myName = myName;
 }
}

クラス修飾子

クラスの修飾子には、public、final、abstract、strictfp を指定することができる
インナークラスでは、protected、private、static を指定することが可能となる

継承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class SuperClass {
 void method1() { System.out.println("method1"); }
}

class SubClass extends SuperClass {
 void method2() { System.out.println("method2"); }
}

SubClass o = new SubClass();
o.method1();
o.method2();

superで親クラスを呼び出せる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class SuperClass {
 String name;
 SuperClass(String name) { this.name = name; }
 void printName() { System.out.println(this.name); }
}

class SubClass extends SuperClass {
 SubClass(String name) {
 super(name); // 親クラスのコンストラクタを呼び出す
 System.out.println(super.name); // 親クラスのフィールドを参照する
 super.printName(); // 親クラスのメソッドを呼び出す
 }
}

インスタンスが、指定したクラスまたはその上位のクラスに属しているかどうかはinstanceofを使う。

1
2
3
4


SubClass obj = new SubClass();
if (obj instanceof SuperClass) {
 System.out.println("属してます");
}

匿名内部クラス

次の場面では、クラスに名前をつけること無くクラスを定義してインスタンスを生成する事が可能

あるクラスの派生クラスのオブジェクトを一つだけインスタンス化する場合
あるインターフェイスを実装して一つだけインスタンスを作成する場合

例

1
2
3
4
5
6
7
8
9


public interface MyInterface1 {
 void foo();
}

MyInterface1 mi = new MyInterface1() {
 public void foo() {
 System.out.println("Hello, anon class!");
 }
}

ジェネリクス

ジェネリクスの例

任意の型を受け付けるクラス・メソッドに対して特定の型を割り当てて、型専用のクラスを生成する。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Test<T> {
 T value;
 Test(T value) {
 this.value = value;
 }
}

Test<String>t1 = new Test<String>("ABC");
Test<Integer>t2 = new Test<Integer>(123);
System.out.println(t1.value);
System.out.println(t2.value);

ジェネリクスの用語

用語	例	説明
ジェネリック型（generic type）	`List<T>`	型引数を持つクラスやインタフェース。
仮型パラメータ（type parameter）	`T`	ジェネリック型の宣言時に使われる型のプレースホルダー。
パラメータ化された型（parameterized type）	`List<String>`	実際の型引数を使用してインスタンス化されたジェネリック型。
実型パラメータ（actual type parameter）	`String`	パラメータ化された型の具体的な型引数。
原型（raw type）	`List`	型引数を使用しないジェネリック型。非ジェネリック型と同様に扱われる。
境界型パラメータ（bounded type parameter）	`<E extends Number>`	特定のクラスやインタフェースを拡張または実装する型に制限された型パラメータ。
非境界ワイルドカード型（unbounded wildcard type）	`List<?>`	任意の型を許容するワイルドカード型。
境界ワイルドカード型（bounded wildcard type）	`List<? extends Number>`, `List<? super Number>`	特定のクラスやインタフェースを拡張する型を許容するワイルドカード型。

原型の注意

なお、原型ではコンパイラによる型安全性は提供されない
そのため、原型よりも非境界型ワイルドカードを利用することが推奨されている
原型がJavaに残っているのは、Java 4以前への後方互換性を維持するため

ワイルドカード型

3つのワイルドカード型

Javaには次の3つのワイルドカード型（<?>）がある。

非境界ワイルドカード型 (unbounded wildcard type)
- 具体例：List<?> list
境界ワイルドカード型 (bounded wildcard type)
- 上限境界ワイルドカード型 (upper bounded wildcard type)
  - 具体例：List<? extends Number> list
- 下限境界ワイルドカード型 (lower bounded wildcard type)
  - 具体例：List<? super Number> list

ジェネリック型の継承関係

Javaでは型パラメータ同士に継承関係があっても、ジェネリックス型自体には継承関係はない。

このジェネリックス型の性質（変性）を不変という。

1
2
3


ArrayList<Number> numbers = new ArrayList<Number>(); // => 問題無し

numbers = new ArrayList<Object>(); // => コンパイルエラー

非境界ワイルドカード型

しかし、非境界ワイルドカード型はすべてのパラメータ化された型のスーパータイプとなる。

そのため、どんなListも、List<?>に代入できる。

1
2
3


ArrayList<?> list = new ArrayList<Number>(); // => 問題無し

list = new ArrayList<Object>(); // => 問題無し

これがワイルドカード型の正体。

非境界ワイルドカード型の制限

非境界ワイルドカード型は、任意のパラメータ化された List のスーパータイプとなり便利に利用できる一方、以下のような制限がある。

メソッドの戻り値に使われているTはObject型になる
メソッドの引数に使われているTにはnullリテラルしか渡せない

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


static class Holder<T> {
 private T value;

 public Holder(T value) {
 this.value = value;
 }

 public T getValue() {
 return value;
 }

 public void setValue(T value) {
 this.value = value;
 }
}

getValueの例

1
2
3
4
5
6
7
8
9


Holder<?> holder = new Holder<String>("Value");

String string = holder.getValue();
// => コンパイルエラー
// 非境界ワイルドカード型は型パラメータが不明なため、型パラメータを String だと保障できない

Object object = holder.getValue();
// => 問題なし
// 非境界ワイルドカード型は型パラメータが不明なため何が入っているか分からないが、すべての参照型のスーパータイプである Object なら絶対に ClassCastException は発生しないため

非境界ワイルドカード型のメソッドの戻り値として許されるのは Object のみという事
何が入っているかは分からないが、すべての参照型は Object のサブタイプであるから

次はsetValueの例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


Holder<?> holder = new Holder<String>();

holder.setValue(new String("String"));
// => コンパイルエラー
// 非境界ワイルドカード型は型パラメータが不明なため、String を this.value に代入可能だと保障できない
// たとえば、this.value は Integer 型かもしれない。

holder.setValue(new Object());
// => コンパイルエラー
// 非境界ワイルドカード型は型パラメータが不明なため、Object を this.value に代入可能だと保障できない
// たとえば、this.value は Integer 型かもしれない。

holder.setValue(null);
// => 問題なし
// 非境界ワイルドカード型は型パラメータが不明なため this.value の型が何か分からないが、null はどんな変数にも代入できるので ClassCastException は発生しない

非境界ワイルドカード型のメソッドの引数に使われているT型にはnullリテラルしか代入できない
なぜなら、nullはJavaの仕様上、null型という特殊な型の唯一の値であり、どんな参照型の変数に代入できることが定められているから

境界型ワイルドカード型

境界ワイルドカード型はパラメータ化されたそのジェネリックス型の一部のスーパータイプの事。

このとき、境界型ワイルドカードは以下のように定義される。

上限境界
- ある型のサブタイプでパラメータ化された、そのジェネリックス型のスーパータイプ
- 具体例：List<? extends Number>
  - Numberのサブタイプでパラメータ化されたListのスーパータイプとなる型
下限境界型
- ある型のスーパータイプでパラメータ化された、そのジェネリックス型のスーパータイプ
- 具体例：List<? super Number>
- Numberのスーパータイプでパラメータ化されたListのスーパータイプとなる型

上限境界型の性質は次の図となる。

一方、下限境界型の性質は次の図となる。

コードとしては次となる。

1
2
3
4
5
6
7


Holder<? extends Number> upper1 = new Holder<Object>(); // => コンパイルエラー
Holder<? extends Number> upper2 = new Holder<Number>(); // => 問題なし
Holder<? extends Number> upper3 = new Holder<Integer>(); // => 問題なし

Holder<? super Number> lower1 = new Holder<Object>(); // => 問題なし
Holder<? super Number> lower2 = new Holder<Number>(); // => 問題なし
Holder<? super Number> lower3 = new Holder<Integer>(); // => コンパイルエラー

境界型ワイルドカード型の制限

境界ワイルドカード型を使うと、型安全のために存在している非境界ワイルドカード型の制限を緩和することができる。

上限境界型のメリット

「メソッドの戻り値に使われているTはObject型になる」という制限が緩和される
つまり、「メソッドの戻り値に使われているTはNumber型になる」
理由
- 上限境界型ワイルドカード（<? extends Number>）は、指定された型Tまたはそのサブタイプを表す
- そのため、コンパイラはその型がNumber型またはそのサブタイプであることを保証できる

下限境界型のメリット

「メソッドの引数に使われている Tにはnullリテラルしか渡せない」という制限が緩和される
つまり、「メソッドの引数に使われているTにはNumberが渡せる」
理由
- 限境界型ワイルドカード（<? super Number>）は、指定された型Tまたはそのスーパータイプを表す
- そのため、Number型またはそのスーパータイプ（Object等）のオブジェクトを引数として渡すことができる

これが境界型ワイルドカード型の利点。

変性

3つの変性

変性（variance）とは、ジェネリクスにおいて、異なる型パラメータを持つ型の間で、代入の可能性や互換性を表す概念。

変性	例
共変/共変性（Covariance）	`List<Integer>` が`List<Number>`のサブタイプ
反変/反変性（Contravariance）	`List<Number>` が`List<Integer>`のサブタイプ
非変/非変性（Invariance）	`List<Number>`と`List<Integer>`の継承関係はない

NOTE: IntegerクラスはNumberクラスのサブクラス

Javaは非変タイプのジェネリクスになる
つまり、List<Integer>はList<Number>のサブクラスとはならない
故に、下のコードはコンパイルエラーになる

1
2
3
4


List<Integer> intList = new ArrayList<>();
List<Number> numList = new ArrayList<>();

numList = intList; // コンパイルエラー 

Put/Get 原則

このPut/Getの原則は、共変性（covariance）と反変性（contravariance）をどのように適用するかを説明するための用語。

PECS（Producer Extends, Consumer Super）:
- Producer Extends: 何かを生成する（出力する）場合は、extends キーワードを使う
- Consumer Super: 何かを消費する（入力する）場合は、super キーワードを使う

Producer Extendsパターン

1
2
3
4
5


public void processNumbers(List<? extends Number> list) {
 for (Number number : list) {
 System.out.println(number);
 }
}

Consumer Superパターン

1
2
3
4


public void addNumbers(List<? super Integer> list) {
 list.add(1);
 list.add(2);
}

レコードクラス

Java 16 でサポートされた機能で、下記の特徴を持つクラスを生成する

コンストラクタで指定した値をイミュータブル（変更不可）なフィールドとして保持する
フィールド名と同じアクセッサメソッドを持つ
toString(), equals(), hashCode() メソッドを持つ

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


final class Book {
 private final String title;
 private final String author;

 public Book(String title, String author) {
 this.title = title;
 this.author = author;
 }

 public String title() {
 return title;
 }

 public String author() {
 return author;
 }

 @Override
 public String toString() {
 return "Book [title=" + title + ", author=" + author + "]";
 }

 @Override
 public boolean equals(Object o) {
 return (this.title == ((Book)o).title) && (this.author == ((Book)o).author);
 }

 @Override
 public int hashCode() {
 return super.hashCode();
 }
}

上のコードは下と同じ

1

record Book (String title, String author) { }

lombok

lombokのアノテーションでもrecordクラスと同じ事ができるので、それでも良い。

1
2
3
4
5
6
7


import lombok.Data;

@Data
public class User {
 private String name;
 private int age;
}

これは次のコードと同等の定義となる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


import java.util.Objects;

public class User {
 private String name;
 private int age;

 // デフォルトコンストラクタ
 public User() {}

 // コンストラクタ
 public User(String name, int age) {
 this.name = name;
 this.age = age;
 }

 // GetterとSetter
 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public int getAge() {
 return age;
 }

 public void setAge(int age) {
 this.age = age;
 }

 // equalsメソッドのオーバーライド
 @Override
 public boolean equals(Object obj) {
 if (this == obj) return true;
 if (obj == null || getClass() != obj.getClass()) return false;
 User user = (User) obj;
 return age == user.age && Objects.equals(name, user.name);
 }

 // hashCodeメソッドのオーバーライド
 @Override
 public int hashCode() {
 return Objects.hash(name, age);
 }

 // toStringメソッドのオーバーライド
 @Override
 public String toString() {
 return "User{name='" + name + "', age=" + age + "}";
 }
}

ラムダ式

Java 8 でラムダ式がサポートされた。

1
2
3
4
5
6
7
8
9


class LocalClass implements Runnable {
 @Override
 public void run() {
 System.out.println("Hello!");
 }
}

Runnable r = new LocalClass();
r.run();

上のコードは下のlambda式でかける。

1
2
3
4


Runnable r = () -> {
 System.out.println("Hello!");
};
r.run();

JavaのLambdaは、単一の抽象メソッドを持つインタフェースを実装した無名クラスのインスタンスを生成する式となる。

関数型インタフェース

関数型インタフェースは「抽象メソッドをひとつのみ持つインタフェース」の事。

1
2
3
4


@FunctionalInterface
interface MyFunctionalInterface {
 public abstract int run(String arg);
}

下のように使える。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Function<String, Integer> strLength = (str) -> { return str.length(); };
int len = strLength.apply("ABC");
System.out.println(len);

BiFunction<String, Integer, Character> charAt = (str, n) -> { return str.charAt(n); };
char c = charAt.apply("ABCDEFG", 3);
System.out.println(c);

BiPredicate<String, String> strEqual = (str1, str2) -> { return str1 == str2; };
boolean b = strEqual.test("ABC", "ABC");
System.out.println(b);

関数型インターフェイスのまとめ。

関数型インタフェース	引数の型	戻り値の型	メソッド名	説明
`Function<T, R>`	T	R	R apply(T t)	T型の引数を受け取り、R型の戻り値を返す。
`BiFunction<T, U, R>`	T, U	R	R apply(T t, U u)	T型とU型の2つの引数を受け取り、R型の戻り値を返す。
`UnaryOperator<T>`	T	T	T apply(T t)	T型の引数を1つ受け取り、T型の戻り値を返す（Function<T, T>のサブインタフェース）。
`BinaryOperator<T>`	T, T	T	T apply(T t1, T t2)	T型の引数を2つ受け取り、T型の戻り値を返す（BiFunction<T, T, T>のサブインタフェース）。
`Consumer<T>`	T	なし	void accept(T t)	T型の引数を受け取り、値を返さない。
`BiConsumer<T, U>`	T, U	なし	void accept(T t, U u)	T型とU型の2つの引数を受け取り、値を返さない。
`Predicate<T>`	T	boolean	boolean test(T t)	T型の引数を受け取り、真偽を返す。
`BiPredicate<T, U>`	T, U	boolean	boolean test(T t, U u)	T型とU型の2つの引数を受け取り、真偽を返す。
`Supplier<R>`	なし	R	R get()	引数を受け取らず、R型の戻り値を返す。

インターフェイス

インタフェース修飾子

インタフェースの修飾子には、public、abstract、strictfp を指定することができる
インタフェースをクラス内に定義する場合には protected、private、static を指定することも可能

継承と実装

継承

1
2
3


public interface ActionListener extends EventListener {
 public void actionPerformed(ActionEvent e);
}

実装

1
2
3
4
5


class Test implements InterfaceA {
 public void methodA(String msg) {
 System.out.println(msg);
 }
}

Java8以降のinterface

Java 8以降は、インターフェースはデフォルトメソッド（default）や静的メソッド（static）を持つことができるようになった。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public interface MyInterface {
 void myMethod();

 // デフォルトメソッド
 default void defaultMethod() {
 System.out.println("This is a default method.");
 }

 // 静的メソッド
 static void staticMethod() {
 System.out.println("This is a static method.");
 }
}

抽象クラス

抽象クラス vs. Interface

そうすると、abstruct classとの違いは何かと言うと次になる。

継承:
- インターフェース: 多重継承が可能
- 抽象クラス: 単一継承のみ
フィールド:
- インターフェース: インスタンスフィールドを持てない（static finalのみ）
- 抽象クラス: インスタンスフィールドを持てる
メソッドの実装:
- インターフェース: デフォルトメソッドを持てるが、基本的にはメソッドのシグネチャのみを定義
- 抽象クラス: 具象メソッドと抽象メソッドの両方を持てる
コンストラクタ:
- インターフェース: 持てない
- 抽象クラス: 持てる

使用感としては次になる。

インターフェースを使用する場合:
- クラス間で共通の契約や振る舞いを定義したい
- 多重継承が必要な場合
- 既存のクラスに新しい振る舞いを追加したい
抽象クラスを使用する場合:
- 部分的な実装を提供したい
- クラス群に共通の状態や動作を持たせたい
- コンストラクタや状態を持つ必要がある場合

抽象クラス vs. 具象クラス

抽象クラスを使用する場合:
- 部分的な実装や共通の状態・動作を提供する必要があるとき
- 基底クラスとしてのみ使用され、インスタンス化されないことを意図するとき
- テンプレートメソッドパターンを実装するとき
具象クラスを使用する場合:
- 完全な実装を持ち、直接インスタンス化されることを意図するとき
- 他のクラスや抽象クラスに依存せず、独立して機能するクラスを定義するとき
- 特定のオブジェクトの具体的なインスタンスを作成するとき

コレクション

代表的なコレクション

次のようなコレクションが代表的。

カテゴリ	クラス	説明
List系	ArrayList	動的配列を扱う。ランダムアクセスが高速だが、挿入・削除はリストの末尾以外では遅くなることがある
	LinkedList	双方向連結リストを扱う。挿入・削除が高速ですが、ランダムアクセスは遅くなる
	Vector	動的配列を扱う。スレッドセーフだが、パフォーマンスが悪いため、現在ではあまり推奨されない古いクラス
Set系	HashSet	値の重複を許さない順不同の要素集合を扱う。内部的にハッシュテーブルを使用している
	TreeSet	値の重複を許さないソートされた要素集合を扱う。内部的に赤黒木を使用する
Map系	HashMap	キーと値の組からなる要素の集合を扱う。順序は保証されない。内部的にハッシュテーブルを使用している
	LinkedHashMap	キーと値の組からなる要素の集合を扱う。挿入順序が保証されいる
	TreeMap	キーと値の組からなる要素の集合を扱う。キーでソートされている。内部的に赤黒木を使用している
Queue系	Deque	両端からの挿入・削除が可能なキューやスタックを扱う。`Deque`はインタフェースであり、`ArrayDeque`や`LinkedList`がその実装クラス

パッケージ

Import

import文を使用することで、繰り返し書く必要がなくなるのが目的
故に、importを使わずとも、クラスの完全修飾名でアクセスすればアクセスできる
当然、同一packageからは、そのままアクセスできる

1
2
3
4


java.util.ArrayList<String> list = new java.util.ArrayList<>();
list.add("Hello");
list.add("World");
System.out.println(list);

例外

例外のクラス

以下のようなタイプのエラーがある。

クラス	説明
Error	Java仮想マシン（JVM）によって検出される致命的なエラー。通常、プログラムで回復不可能であり、例外ハンドラを記述しても処理を継続できないことが多い。例：`OutOfMemoryError`（メモリ枯渇）、`StackOverflowError`（スタックオーバーフロー）など
RuntimeException	実行時に発生するプログラムエラー。チェックされない例外（Unchecked Exception）であり、例外ハンドラは省略可能。例：`ArithmeticException`（ゼロ除算）、`IllegalArgumentException`（引数不正）、`NullPointerException`（NULLポインタ参照）、`ArrayIndexOutOfBoundsException`（不正インデックスによる配列参照）など
Exception	一般的な例外。チェックされる例外（Checked Exception）であり、例外ハンドラを記述しないとコンパイルエラーとなる。例：`IOException`、`SQLException`など

検査例外と非検査例外

検査例外（Checked Exception）はコンパイル時にチェックされる例外
プログラムの外部的な要因（例えば、ファイルの存在しないことや、ネットワークの障害など）によって発生する可能性のある問題を扱う

下のように検査例外である、IOExceptionなどをtry-catchで捕まえないといけない。さもなければメソッドでthrowsする必要がある。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 try {
 FileReader reader = new FileReader("nonexistentfile.txt");
 BufferedReader bufferedReader = new BufferedReader(reader);
 String line = bufferedReader.readLine();
 System.out.println(line);
 bufferedReader.close();
 } catch (FileNotFoundException e) {
 System.out.println("File not found: " + e.getMessage());
 } catch (IOException e) {
 System.out.println("IO error: " + e.getMessage());
 }

検査例外は処理の奥深く（例えばDB付近）で発生し、上部（例えばAPIのController）でハンドルする場合、
中間で例外をthrowsでバケツリレーしなければならない時は、非検査例外を使うのがベター
もしくは、下のようにエラーを変換する

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


// カスタム非検査例外
public class DatabaseException extends RuntimeException {
 public DatabaseException(String message, Throwable cause) {
 super(message, cause);
 }
}

// データベース層のメソッド
public void fetchData() {
 try {
 // データベース操作
 } catch (SQLException e) {
 throw new DatabaseException("Database error occurred", e);
 }
}

// サービス層のメソッド
public void processData() {
 fetchData(); // DatabaseExceptionがスローされる可能性あり
}

// コントローラー層のメソッド
public void handleRequest() {
 try {
 processData();
 } catch (DatabaseException e) {
 // 例外処理（ログ出力、エラーレスポンスの返却など）
 }
}

Android on M1KE BL0G

GalaxyS9をRoot化したときの備忘録

背景

Cyberpunk化した結果

途中での画像

Samsungの4つのモード

前提

2つの方法がある

fastbootについて

adbでbootanimationの変更

adbで入る

samsung用のbootanimationファイルの作成方法

手順

ファクトリーリセット方法

サムスンのファームウェアをDLする

トラブルシューティング

sw rev check fail bootloader device 17 binary 12問題

official released binaries are allowed to be flashed問題

odinを使うときの注意点

もともとのFirmの焼き方

結局どうやったか？ (ある一日のstrugling)

1回目: 日本人ブログ => 失敗

2回目: 外国人ブログ => 失敗

3回目: Youtubeの動画 => 成功

結論

参考文献

Kotlinのメモ

背景

基本

変数・定数

constとvalの違い

パターンマッチング

コレクション

Range

分解宣言と多重戻り値

型

代数的データ型

型エイリアス

型の確認（is）

型のキャスト(as, as?)

関数

基本的な関数定義

単一式関数

デフォルト引数

名前付き引数

可変長引数（vararg）

ローカル関数（関数内関数）

拡張関数

インライン関数

高階関数

トレーリングラムダ（末尾ラムダ）

ラムダ式

関数型

演算子オーバーロード

中置表記法

テイルレック最適化

ジェネリック関数

多重戻り値

UnitとNothing

関数参照(::)

移譲と遅延（by）

2つの委譲

2つの委譲とは

プロパティ委譲

クラス委譲

遅延初期化

遅延初期化とは

lateinit

by lazy（デリゲート）

Scoped Function

Scoped Functionとは

5つの関数の違い

itとthisの違い

let関数

run関数

with関数

apply関数

also関数

Class

コンストラクタ（constructor）

`const`と`val`の違い

型の確認（`is`）

型のキャスト(`as`, `as?`)

関数参照(`::`)

移譲と遅延（`by`）

`lateinit`

`by lazy`（デリゲート）

`let`関数

`run`関数

`with`関数

`apply`関数

`also`関数

コンストラクタ（`constructor`）

初期化ブロック（`init`）

なぜ初期化ブロック（`init`）が必要か

`?`付きタイプ

`.?`演算子

`:?`演算子

`!!`演算子

suspendと`delay()`、`await()`