개발 노트

함수를 호출한 부모 함수명 가져오기

노명규 — Mon, 11 Sep 2023 10:48:50 +0900

Thread.currentThread().getStackTrace()[3].getMethodName()

뎁스에 따라 2~4가 될수도 있을 것 같다,

앱에서 사용중인 퍼미션 가져오기

노명규 — Wed, 6 Sep 2023 10:17:25 +0900

String packageName = getPackageName();

try {
    // 패키지 정보 가져오기
    PackageManager packageManager = getPackageManager();
    // 패키지의 사용 퍼미션 목록 가져오기
    String[] permissions = packageManager.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS).requestedPermissions;

    if (permissions != null) {
        // 사용 중인 퍼미션 목록 출력 또는 다루기
        for (String permission : permissions) {
            System.out.println("사용 중인 퍼미션: " + permission);
        }
    }
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

di 패턴, dagger, hilt

노명규 — Tue, 4 Apr 2023 18:06:22 +0900

Dependency injection이란?

정의 : 의존성 주입의 줄임말

요약 : 필요로 하는 의존성을 외부(생성자, 파라미터 등)에서 전달받는것

안하면 안좋은 점 : 코드의 유연성과 확장성이 떨어짐 또한 기능 및 코드 변경 할 때 많은 코드를 수정해야 함

하면 좋은 점 : 안좋은점의 반대, + 테스트 코드 작성에 용이함

dagger 예제

1. @Component interface정의

@Component

2. 의존성 주입할 module 정의

@module

3. 데이터 가져올 ApiService 정의

4. 의존성 주입

@Inject

* DaggerAppComponent는 Dagger lib에서 자동으로 생성되며, 이름 규칙은 "{Dagger$@ComponentInterfaceName}

------------------------------------------------------------------------------------------------------

hilt 예제

1. @Component + @Singleton Interface 정의,

@Component, @Singleton

2. 데이터 가져올 ApiService 정의

3. 모듈 정의

@module, @installIn, @Provides, @Singleton

3. 의존성 주입

@AndroidEntryPoint, @Inject

힐트는 대거를 좀 더 편하게 사용하고자 탄생한 lib,

그런데 더 쉬운지는 잘 모르겠음,

주입부분에 Dagger-.inject(this) 코드만 @AndroidEntryPoint 으로 바뀐 느낌?

대거와 힐트의 요약

system screen rotate click listener

노명규 — Tue, 7 Mar 2023 18:09:27 +0900

private val autoRotateObserver = AutoRotateObserver(this, listener)

contentResolver.registerContentObserver(
    Settings.System.getUriFor(Settings.System.ACCELEROMETER_ROTATION),
    true, autoRotateObserver
)

override fun onDestroy() {
    super.onDestroy()
    contentResolver.unregisterContentObserver(autoRotateObserver)
}

class AutoRotateObserver(context: Context, listener: RotateConfigEventListener) : ContentObserver(null) {

    private val mContext: Context = context
    private val listener = listener

    override fun onChange(selfChange: Boolean) {
        super.onChange(selfChange)
        // 설정값이 변경되면 호출됨
        val autoRotateEnabled = Settings.System.getInt( mContext.contentResolver, Settings.System.ACCELEROMETER_ROTATION, 0) == 1

//        Log.d(LOGTAG,"AutoRotateObserver onChange selfChange : ${selfChange} / ${autoRotateEnabled}")
        listener.onChangeRotate(autoRotateEnabled)
    }
}

autoRoateEnabled이 true면 회전 on, false면 off

retrofit으로, rx and coroutine

노명규 — Fri, 3 Feb 2023 15:23:12 +0900

class MainViewModel(val app: Application) : AndroidViewModel(app) {
    val tagtag = "tag@"

    val retrofit: RetrofitApi = RetrofitBuilder.getApiService("https://api.bithumb.com/")

    init {
        initCoinRx()
        initCoinCoroutine()
    }

    @SuppressLint("CheckResult")
    fun initCoinRx() {
        retrofit.getCoinInfoRx("BTC")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe { coin ->
                Log.d(tagtag, "coin rx : ${coin.data.openingPrice}")
            }
    }

    var job: Job? = null

    @SuppressLint("CheckResult")
    fun initCoinCoroutine() {
        job = CoroutineScope(Dispatchers.IO).launch {
            val response = retrofit.getCoinInfoCoroutine("BTC")
            withContext(Dispatchers.Main) {
                if (response.isSuccessful) {
                    Log.d(tagtag, "coin coroutine : " + response.body()?.data?.openingPrice)
                    job?.cancel()
                }
            }
        }
    }
}

import io.reactivex.Single
import retrofit2.Response
import retrofit2.http.*

interface RetrofitApi {

    @GET("public/ticker/{path}")
    fun getCoinInfoRx(
        @Path("path") path:String?
    ):Single<CoinModel>

    @GET("public/ticker/{path}")
    suspend fun getCoinInfoCoroutine(
        @Path("path") path:String?
    ): Response<CoinModel>

}

import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory

object RetrofitBuilder {
    private fun getRetrofit(url: String?):Retrofit {
        val httpLoggingInterceptor = HttpLoggingInterceptor()
        httpLoggingInterceptor.level = HttpLoggingInterceptor.Level.BODY

        val client = OkHttpClient.Builder().addInterceptor(httpLoggingInterceptor).build()

        val retrofit = Retrofit.Builder().
                        baseUrl(url).
                        addConverterFactory(GsonConverterFactory.create()).
                        addCallAdapterFactory(RxJava2CallAdapterFactory.create()).
                        client(client).build()

        return retrofit;
    }
    
    fun getApiService(url:String?) : RetrofitApi {
        return getRetrofit(url).create(RetrofitApi::class.java)
    }
}

android mvvm 예제

노명규 — Mon, 30 Jan 2023 10:17:45 +0900

본 예제에 model 부분은 없습니다.

data 관련 핸들링은 모두 model에서 해야하고, viewmodel에선 view에 로직만 담당합니다.

databinding, kotlin을 사용합니다.

사용 파일들은 아래와 같습니다.

* AActivity.kt
* A1Viewmodel.kt

* A2Viewmodel.kt
* a_activity.xml
* a1_viewmodel.xml
* a2_viewmodel.xml

1. AActivity.kt

class AActivity :AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        DataBindingUtil.setContentView<AActivityBinding>(this, R.layout.a_activity).apply {
            lifecycleOwner = this@AActivity
            a1ViewModel = ViewModelProvider(this@AActivity).get(A1ViewModel::class.java);
            a2ViewModel = ViewModelProvider(this@AActivity).get(A2ViewModel::class.java);
        }
    }
}

2. A1ViewModel.kt

class A1ViewModel(val app: Application) : AndroidViewModel(app) {
    init {
        Toast.makeText(app,"A1ViewModel ", Toast.LENGTH_LONG).show()
    }
}

3. A2ViewModel.kt

class A2ViewModel(val app: Application) : AndroidViewModel(app) {
    init {
        Toast.makeText(app,"A2ViewModel", Toast.LENGTH_LONG).show()
    }
}

4. a_activity.xml

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:tools="http://schemas.android.com/tools">

    <data>
        <variable
            name="a1ViewModel"
            type="com.example.A1ViewModel" />
        <variable
            name="a2ViewModel"
            type="com.example.A2ViewModel" />
    </data>

    <LinearLayout
        xmlns:bind="http://schemas.android.com/apk/res-auto"
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <include
            android:id="@+id/a1"
            layout="@layout/a1_viewmodel"
            bind:a1vm="@{a1ViewModel}" />

        <include
            android:id="@+id/a2"
            layout="@layout/a2_viewmodel"
            bind:a2vm="@{a2ViewModel}" />

    </LinearLayout>

</layout>

5. a1_viewmodel.xml

<?xml version="1.0" encoding="utf-8"?>

<layout>
    <data>
        <variable
            name="a1vm"
            type="com.example.A1ViewModel" />
    </data>

    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="a1_vm"
            tools:ignore="MissingConstraints" />

    </androidx.constraintlayout.widget.ConstraintLayout>

</layout>

6. a2_viewmodel.xml

<?xml version="1.0" encoding="utf-8"?>

<layout>
    <data>
        <variable
            name="a2vm"
            type="com.example.A2ViewModel" />
    </data>

    <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="a2_vm"
            tools:ignore="MissingConstraints" />

    </androidx.constraintlayout.widget.ConstraintLayout>

</layout>

// onCreate에서 항상 vm을 초기화해버리면, ui에 state가 바뀌면 vm의 데이터가 날라가지 않을까?

그럴 경우에

class AActivity :AppCompatActivity() {
    private lateinit var binding: AActivityBinding

    private val a1ViewModel: A1ViewModel by viewModels()
    private val a2ViewModel: A2ViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        binding = DataBindingUtil.setContentView<AActivityBinding>(this, R.layout.a_activity).apply {
            lifecycleOwner = this@AActivity
            aViewModel = ViewModelProvider(this@AActivity).get(AViewModel::class.java);
            a1ViewModel = this@AActivity.a1ViewModel
            a2ViewModel = this@AActivity.a2ViewModel
        }
    }
}

로 사용하면 될 것 같음,

groupBy, Pair, collection.sort, reduce, fold

노명규 — Tue, 29 Nov 2022 17:45:01 +0900

val group = intArrayOf(1,1,1,2,2,3).groupBy { it }
group.apply {
    println("this : $this") // {1=[1, 1, 1], 2=[2, 2], 3=[3]}
    println("group.keys : $keys") // [1, 2, 3]
    println("group.values : $values") // [[1, 1, 1], [2, 2], [3]]
    println("group.values.sort 1 : ${values.sortedByDescending { it.size }}") // [[1, 1, 1], [2, 2], [3]]
    println("group.values.sort 2 : ${values.sortedBy { it.size }}") // [[3], [2, 2], [1, 1, 1]]
}

groupBy를 이용한 이것저것

val pair = arrayOf("a","b","c").mapIndexed { i, d -> Pair(i,d) }
println("Pair : ${pair}") // [(0, a), (1, b), (2, c)]

key value를 만들때 Pair활용,

val numbers = listOf(10000, 1000, 100)
val sum = numbers.reduce { total, num -> total + num }
println("reduced: $sum") // reduced: 11100
val sum2 = numbers.fold(10) { total, num -> total + num }
println("folded: $sum2") // folded: 11110

val strings = listOf("a","b","c")
val string = strings.reduce { total, peace -> total + peace }
println("string reduced: $string") // reduced: abc
val string2 = strings.fold("d") { total, peace -> total + peace}
println("string fold: $string2") // reduced: dabc

reduce는 배열의 첫번째 값이 최초 첫번째 파라미터로 전달,

fold는 첫번째 파라미터에 값 지정 가능,

Codility MissingInteger

노명규 — Tue, 1 Nov 2022 20:56:14 +0900

fun MissingInteger(A: IntArray):Int {
    val set = HashSet<Int>()
    set.addAll(A.toList())

    var value = 1

    for (i in 1 .. 1000000) {
        if (!set.contains(i)) {
            value = i
            break;
        }
    }
    return value
}

100%성공함ㅋㅋㅋㅋㅋㅋ

이건 아닐텐데 하면서 한건데 어이가 없네..

kotlin with, also, apply, let, run

노명규 — Thu, 29 Sep 2022 10:30:47 +0900

with 사용 규칙

Non-nullable (Null 이 될수 없는) 수신 객체 이고 결과가 필요하지 않은 경우에만 with 를 사용합니다.

-> 리턴이 없을때 사용

also 사용 규칙

수신 객체 람다가 전달된 수신 객체를 전혀 사용 하지 않거나 수신 객체의 속성을 변경하지 않고 사용하는 경우 also 를 사용합니다.

-> 객체 내부 값을 바꾸기 싫을 때

apply 사용 규칙

수신 객체 람다 내부에서 수신 객체의 함수를 사용하지 않고 수신 객체 자신을 다시 반환 하려는 경우에 apply 를 사용합니다.

-> 객체의 내부 값을 바꾸고 싶을 때

let 사용 규칙

다음과 같은 경우에 let 을 사용합니다.

지정된 값이 null 이 아닌 경우에 코드를 실행해야 하는 경우.
Nullable 객체를 다른 Nullable 객체로 변환하는 경우.
단일 지역 변수의 범위를 제한 하는 경우.

-> 널체크

run 사용 규칙

어떤 값을 계산할 필요가 있거나 여러개의 지역 변수의 범위를 제한하려면 run 을 사용합니다.

-> 함수처럼 쓴다.

kotlin 배열 선언 및 반복문 문법

노명규 — Thu, 29 Sep 2022 10:25:55 +0900

배열 선언 하는 법

var intArr:Array<Int> = arrayOf(1, 2, 3, 4)
var intArr2 = arrayOfNulls<Int>(5)
var anyArr : Array<Any> = arrayOf(1, "awd", 3.2, 4)

반복문 쓰는 법

for(i: Int in 1..10)
    print("$i ")    //output : 1, 2, 3, 4, 5 ... 10

val len: Int = 5
for(i in 1..len)
    print("$i ")    //output : 1, 2, 3, 4, 5

for(i in 1 until len)
    print("$i ")    //output : 1, 2, 3, 4

for(i: Int in 1..10 step(2))
    print("$i ")    //output : 1, 3, 5, 7, 9

for(i in 10 downTo 1)    //output : 10, 9, 8, 7 ... 1
    print("$i ")

for(i in 10 downTo 1 step(2))    //output : 10, 8, 6, 4, 2
    print("$i ")

val arr: IntArray = intArrayOf(10, 20, 30, 40, 50)

for(i in arr)
    print("$i ")    //output : 10, 20, 30, 40, 50

for(i in arr.reversed())
    print("$i ")    //output : 50, 40, 30, 20, 10

val list = listOf<String>("korea", "salmon", "T_T")
for(i in list)
    print("$i ")    //output : korea, salmon, T_T

for(i in 0 until list.count())
    print("${list[i]} ")    //output : korea, salmon, T_T

for (i in tl2.indices) {
    // i는 0이고, size는 보통 1부터 시작하니 항상 끝에가 1개가 많은 이슈를 알아서 해결해줌,
}