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の更新
}

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 { 
        // ここで時間のかかるタスクを実行
        // このコードはコルーチンで実行
    } 
}

1
2
3
4
5
6
7
8

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

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)
        }
    }
}

1
2
3
4
5
6
7

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

 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

# 指令

- この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

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>

 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

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

 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()
        // クリーンアップ処理
    }
}

1
2
3

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

1
2
3
4
5
6

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

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);

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()
        }
    }
}

1
2
3
4
5
6
7

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

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)

 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")
    }
}

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を通じてグローバルな状態や方法にアクセス
    }
}

 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)
    }
}

 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()
        }
    }
}

 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")
    }
}

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) }
}

 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
        }
    }
}

 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")
    }
}

 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()
            }
          }
        }
    }
}

 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);
    }
}

 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全体をキャンセル

1
2
3
4

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

 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の更新
    }
}

1
2
3
4

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

WorkManager.getInstance(context).enqueue(uploadWorkRequest)

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
    }
}

 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
        }
    }
}

 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)
    }
}