“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

개인 프로젝트 앱에 새로운 쿼리를 추가하려는데 의도대로 동작이 안되는 거 같아서 Logging을 해보려는데 @Query 는 @Delete나 @Update처럼 성공 결과를 반환하지 않으니 Logging을 하기가 애매했다.

그래서 방법을 찾아보았는데 Query 처리에 대한 콜백을 제공하는 것을 발견, 여기서 Log를 찍어보기로 했다.

QueryCallback

이 방법은 Room 2.4.0 버전 이상부터 지원합니다.

우선 사용방법은 아래와 같이 setQueryCallback()이라는 메소드를 Room 객체를 생성할때 Builder에 추가해준다.

        Room.databaseBuilder(
            context,
            MyDatabase::class.java,
            "MyDB.db"
        )
            .addMigrations(*MIGRATIONS)
            .setQueryCallback({ query, args ->
                Log.d("query: $query\t\nargs: $args")
            }, Executors.newSingleThreadExecutor())
            .build()

        /**
         * Sets a [QueryCallback] to be invoked when queries are executed.
         *
         * The callback is invoked whenever a query is executed, note that adding this callback
         * has a small cost and should be avoided in production builds unless needed.
         *
         * A use case for providing a callback is to allow logging executed queries. When the
         * callback implementation logs then it is recommended to use an immediate executor.
         *
         * @param queryCallback The query callback.
         * @param executor The executor on which the query callback will be invoked.
         * @return This builder instance.
         */
        @Suppress("MissingGetterMatchingBuilder")
        open fun setQueryCallback(
            queryCallback: QueryCallback,
            executor: Executor
        ) = apply {
            this.queryCallback = queryCallback
            this.queryCallbackExecutor = executor
        }

매개변수를 보면 QueryCallback, Executor를 요구하는데 핵심은 QueryCallback 다.

    /**
     * Callback interface for when SQLite queries are executed.
     *
     * Can be set using [RoomDatabase.Builder.setQueryCallback].
     */
    fun interface QueryCallback {
        /**
         * Called when a SQL query is executed.
         *
         * @param sqlQuery The SQLite query statement.
         * @param bindArgs Arguments of the query if available, empty list otherwise.
         */
        fun onQuery(sqlQuery: String, bindArgs: List<Any?>)
    }

SQLite가 쿼리를 실행할때 이 인터페이스를 통해 콜백을 전달받는다. 그럼 그 콜백에서 Log를 작성해주면.. 쿼리가 실행될때마다 아래와 같이 Log가 출력된다.

23:37:50.733  D  [DHModule.kt::onQuery] query: BEGIN DEFERRED TRANSACTION    
                 args: []
23:37:50.734  D  [DHModule.kt::onQuery] query: INSERT OR IGNORE INTO room_table_modification_log VALUES(1, 0)    
                 args: []
23:37:50.734  D  [DHModule.kt::onQuery] query: CREATE TEMP TRIGGER IF NOT EXISTS `room_table_modification_trigger_charactersentity_UPDATE` AFTER UPDATE ON `charactersentity` BEGIN UPDATE room_table_modification_log SET invalidated = 1 WHERE table_id = 1 AND invalidated = 0; END    
                 args: []
23:37:50.735  D  [DHModule.kt::onQuery] query: CREATE TEMP TRIGGER IF NOT EXISTS `room_table_modification_trigger_charactersentity_DELETE` AFTER DELETE ON `charactersentity` BEGIN UPDATE room_table_modification_log SET invalidated = 1 WHERE table_id = 1 AND invalidated = 0; END    
                 args: []
23:37:50.736  D  [DHModule.kt::onQuery] query: CREATE TEMP TRIGGER IF NOT EXISTS `room_table_modification_trigger_charactersentity_INSERT` AFTER INSERT ON `charactersentity` BEGIN UPDATE room_table_modification_log SET invalidated = 1 WHERE table_id = 1 AND invalidated = 0; END    
                 args: []
23:37:50.737  D  [DHModule.kt::onQuery] query: TRANSACTION SUCCESSFUL    
                 args: []
23:37:50.737  D  [DHModule.kt::onQuery] query: END TRANSACTION    
                 args: []
23:37:50.738  D  [DHModule.kt::onQuery] query: SELECT * FROM CharactersEntity    
                 args: []

보다시피 트랜젝션의 결과도 알려주기 때문에 내가 만든 쿼리와 파라미터, 작동 여부도 모두 확인해 볼 수 있다.

만약 개발중인 앱에 DB 사용량이 많다면 이 방법을 사용해서 Logging을 하는 것도 괜찮을 것으로 생각된다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

Compose에서 각 Screen(Compsoable)이 전환될 때 Transition을 설정하고 싶을 때가 있다. Navigation을 사용 중이라면 NavHost에서 손쉽게 설정이 가능하다.

아래의 예제소스는 MainScreen을 시작으로 FirstScreen, SecondScreen으로 전환하는 소스이다.

NavHost에서 설정

@Composable
fun AppNavHost(
    navHostController: NavHostController,
    paddingValues: PaddingValues,
    viewModel: MainViewModel,
    stateViewModel: StateViewModel
) {
    NavHost(
            navController = navHostController,
            startDestination = Screen.Main.route,
            enterTransition = {
                slideIntoContainer(
                    AnimatedContentTransitionScope.SlideDirection.Left,
                    animationSpec = tween(300)
                )
            },
            exitTransition = {
                slideOutOfContainer(
                    AnimatedContentTransitionScope.SlideDirection.Left,
                    animationSpec = tween(300)
                )
            },
            popEnterTransition = {
                slideIntoContainer(
                    AnimatedContentTransitionScope.SlideDirection.Right,
                    animationSpec = tween(300)
                )
            },
            popExitTransition = {
                slideOutOfContainer(
                    AnimatedContentTransitionScope.SlideDirection.Right,
                    animationSpec = tween(300)
                )
            }
        ) {
            composable(Screen.Main.route) {
                MainScreen(navHostController)
            }
            composable(Screen.First.route) {
                FirstScreen(viewModel, stateViewModel)
            }
            composable(Screen.Second.route) {
                SecondScreen(viewModel, stateViewModel)
            }
        }
}

예를 들어 위와 같은 소스가 있다고 가정해보면 NavHost 의 파라미터를 지정하는 것으로 간단하게 Transition을 설정할 수 있다.

각 파라미터의 개념을 MainScreen에서 FirstScreen으로 전환된다는 가정 하에 아래와 같이 설명할 수 있다.

• enterTransition FirstScreen으로 진입 시 애니메이션
• exitTransition FirstScreen으로 진입할 때 MainScreen의 애니메이션
• popEnterTransition 뒤로가기 시 MainScreen의 애니메이션
• popExitTransition 뒤로가기 시 FirstScreen의 애니메이션

• slideIntoContainer 다음 Screen 진입 시 사용될 slide 애니메이션 객체, EnterTransition 을 반환한다.

• slideOutOfcontainer 이전 Screen으로 돌아갈 때 사용될 slide 애니메이션 객체, ExitTransition 을 반환한다.

composable에서 설정

NavHost가 아닌 composable에서 설정도 가능하다.

모든 Screen에 각 각 다른 transition을 설정하고 싶은 경우에 해당한다.

NavHost와 마찬가지로 파라미터로 설정할 수 있다.

            composable(
                route = Screen.First.route,
                enterTransition = {
                    slideIntoContainer(
                        AnimatedContentTransitionScope.SlideDirection.Left,
                        animationSpec = tween(300)
                    )
                },
                exitTransition = {
                    slideOutOfContainer(
                        AnimatedContentTransitionScope.SlideDirection.Left,
                        animationSpec = tween(300)
                    )
                },
                popEnterTransition = {
                    slideIntoContainer(
                        AnimatedContentTransitionScope.SlideDirection.Right,
                        animationSpec = tween(300)
                    )
                },
                popExitTransition = {
                    slideOutOfContainer(
                        AnimatedContentTransitionScope.SlideDirection.Right,
                        animationSpec = tween(300)
                    )
                }
            ) {
                FirstScreen(viewModel, stateViewModel)
            }

NavHost 예제와 마찬가지로 MainScreen, FirstScreen, SecondScreen이 있다고 가정해보자, 위 예제소스대로 작동해보면 FirstScreen의 transition만 적용되는 것을 확인할 수 있다

모든 Screen에 transition을 적용하고 특정 Screen만 transition을 다르게 하고 싶을 수도 있다. 이럴 때 NavHost에 transition을 지정 후 특정 Screen composable에만 transition을 다르게 적용하면 되나 싶지만 이럴 경우 transition이 중복되어 의도한 바와 전혀 다른 결과물이 나온다.

특정 Screen만 다른 transition을 적용할 때

이때에는 NavHost 의 transition 파라미터 분기에서 현재 route를 기준으로 분기문을 작성하여 처리하면 된다. 아래 예제를 살펴보지

@Composable
fun AppNavHost(
    navHostController: NavHostController,
    paddingValues: PaddingValues,
    viewModel: MainViewModel,
    stateViewModel: StateViewModel
) {
    NavHost(
            navController = navHostController,
            startDestination = Screen.Main.route,
            enterTransition = {
                when(targetState.destination.route) {
                    Screen.First.route -> EnterTransition.None
                    Screen.Second.route -> {
                        fadeIn(animationSpec = tween(300))
                    }
                    else -> {
                        slideIntoContainer(
                            AnimatedContentTransitionScope.SlideDirection.Left,
                            animationSpec = tween(300)
                        )
                    }
                }
            },
            exitTransition = {
                when(targetState.destination.route) {
                    Screen.First.route -> ExitTransition.None
                    Screen.Second.route -> {
                        fadeOut(animationSpec = tween(300))
                    }
                    else -> {
                        slideOutOfContainer(
                            AnimatedContentTransitionScope.SlideDirection.Left,
                            animationSpec = tween(300)
                        )
                    }
                }
            },
            popEnterTransition = {
                when(targetState.destination.route) {
                    Screen.First.route -> EnterTransition.None
                    Screen.Second.route -> {
                        fadeIn(animationSpec = tween(300))
                    }
                    else -> {
                        slideIntoContainer(
                            AnimatedContentTransitionScope.SlideDirection.Right,
                            animationSpec = tween(300)
                        )
                    }
                }
            },
            popExitTransition = {
                when(targetState.destination.route) {
                    Screen.First.route -> ExitTransition.None
                    Screen.Second.route -> {
                        fadeOut(animationSpec = tween(300))
                    }
                    else -> {
                        slideOutOfContainer(
                            AnimatedContentTransitionScope.SlideDirection.Right,
                            animationSpec = tween(300)
                        )
                    }
                }
            }
        ) {
            composable(Screen.Main.route) {
                MainScreen(navHostController)
            }
            composable(Screen.First.route) {
                FirstScreen(viewModel, stateViewModel)
            }
            composable(Screen.Second.route) {
                SecondScreen(viewModel, stateViewModel)
            }
        }
}

분기문을 살펴보면 targetState는 이동(전환)하려는 Screen의 BackStackEntry으로 route를 이용한 분기처리가 가능하다.

추가적으로 transitoin 애니메이션은 slide, fade, scale 등 다양한 방법을 지원하며 이 부분에 대해서는 추후 다시 포스팅을 작성해보도록 하겠다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

최근에 필자가 사용하던 갤럭시S23+ 을 Android 15로 업데이트 하였다. 업데이트 후 Compose로 만든 앱의 컨텐츠들이 상태바 영역부터 그려지는 일이 발생했다.

확인을 해보니 Android 15부터 API Level 35를 타겟팅하는 앱의 경우 기본적으로 edgeToEdge가 활성화된다는 것이다. 개발자 문서

결국 이에 대한 대응이 필요했다.

edgeToEdge

edgeToEdge란 상단 StatusBar 영역과 하단 NavigationBar 영역까지 컨텐츠가 표시되는 것을 의미한다. 더 넓은 영역까지 컨텐츠가 표시되니 더 많은 데이터를 표시할 수 있다는 이점이 있지만 디자인 설계에서 고려되지 않은 부분이 있다면 오히려 디자인을 해칠 수 있다. 그래서 적절한 처리가 필요하다.

다행히 Compose에서 Material3를 사용중이라면 자동 적용이 된다.

필자의 경우 Scaffold 내에서 NavigationBar를 사용중이었고 AppBar는 사용하지 않아서 상태바 영역 침범 문제에 대해서만 처리를 하였다.

상태바 영역만큼 Spacer 처리

다행히 WindowInsets 클래스를 사용하면 시스템 UI의 사이즈를 쉽게 가져올 수 있다. 아래의 적용한 소스를 같이 살펴보자

override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()     // 버전 상관없이 우선 일괄적으로 'edgeToEdge' 적용
        super.onCreate(savedInstanceState)

        initLauncher()
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            requestRole()
        }

        setContent {
            Scaffold(
                bottomBar = { BottomNavigationBar(navController = navHost, stateViewModel) },
                floatingActionButton = {
                    if(currentRoute == MCScreenRoute.SpamList.route) {
                      ExpandedFab(stateViewModel)
                    }
                }
            ) {
                    Column {
                        // Spacer를 상태바 크기로 지정하여 상태바 아래부터 컨텐츠가 그려지도록 구현
                        Spacer(modifier = Modifier.height(WindowInsets.statusBars.asPaddingValues().calculateTopPadding()))
                        AppNavHost(
                            navController = navHost,
                              paddingValues = it,
                              viewModel = viewModel,
                              stateViewModel = stateViewModel,
                              spamViewModel = spamInfoViewModel,
                              spamFilterViewModel = spamFilterViewModel
                        )
                    }
             }
       }
}

우선 enableEdgeToEdge()를 호출하여 버전 상관없이 일괄적으로 적용한 후 Scaffold Content에 Spacer를 적용하여 상태바 영역 아래부터 컨텐츠가 보여질 수 있도록 하였다.

Android 15에서만 예외처리를 하고싶은 경우

만일 필자처럼 모든 버전에 동일하게 적용하지 않고 Android 15 이상에서만 예외처리를 진행하고 싶다면 아래와 같이 분기를 추가하면 된다.

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

        initLauncher()
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            requestRole()
        }

        setContent {
            Scaffold(
                // Andorid 버전 분기하여 Modifier 할당
                modifier = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
                    Modifier
                        .fillMaxSize()
                        .windowInsetsPadding(WindowInsets.systemBars)
                } else {
                    Modifier.fillMaxSize()
                },
                bottomBar = { BottomNavigationBar(navController = navHost, stateViewModel) },
                floatingActionButton = {
                    if(currentRoute == MCScreenRoute.SpamList.route) {
                      ExpandedFab(stateViewModel)
                    }
                }
            ) {
                    Column {
                        AppNavHost(
                            navController = navHost,
                              paddingValues = it,
                              viewModel = viewModel,
                              stateViewModel = stateViewModel,
                              spamViewModel = spamInfoViewModel,
                              spamFilterViewModel = spamFilterViewModel
                        )
                    }
             }
       }
}

단, 이렇게 할 경우 endgeToEdge 자체는 여전히 적용되어 있는 상태로 StatusBar와 NavigationBar는 투명색으로 되어있기 때문에 Theme.kt로 이동하여 직접 색상을 추가적으로 지정해줘야한다.

edgeToEdge 자체를 해제하는 방법은 없는 것으로 보이고 구글에서도 정책적으로 강제하는 것처럼 보이기에.. 개발자가 직접 Insets을 제어하는 방법 밖에 없어보인다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

몇 년 전에 만들어 두었던 Play Console 계정이 있었는데 활동을 안하다보니.. 휴면 계정 정책(?)에 의해 해지되었다.

복구는 안된다고 하며 게시한 앱도 없어서 새로 만들기로 했다.

라이센스 비용을 결제하고 Console에 진입했더니 본인인증을 진행하라고 한다.

본인인증 방법

다른 절차는 핸드폰이나 이메일 인증 정도라서 문제가 없었지만 위와 같이 이름과 주소지 확인을 위한 증빙서류를 제공한다.

본인의 경우..

• 1. 전기, 수도 또는 공공요금 청구서 부모님과 같이 살기 때문에 이 방법은 사용할 수 없었다.
• 2. 신용카드 명세서 신용카드를 사용하기에 이 방법을 사용하고자 했지만 명세서에 주소는 나오지 않기에 사용할 수 없었다.
• 3. 은행 명세서 90일 이내에 명세서를 발급받을 만한 은행 거래를 한 적이 없어서 이 또한 사용할 수 없었다.
• 4. 임대 계약서 1번 항목과 마찬가지로 부모님과 같이 살고있기에 해당사항이 없었다.

그래서 다른 방법을 모색하던 중 등본이나 신분증을 제출해서 승인했다는 글들이 있었고 정부24에서 등본을 발급받아서 제출하였다.

그런데 등본을 발급받을 때 표시되는 정보에 따라서 거부될 수 있다고해서 한번 더 제출할 각오를 하고 최소한의 정보 만 출력하여 제출하였고

최소한의 정보 -> 발급 전에 표시할 정보를 선택할때 아무것도 선택하지 않음

다행히 2시간 뒤에 승인이 되었다. 이제 Play Store에 앱을 게시할 수 있게 되었다!

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

CoroutineScope 를 이용하여 프로그래밍을 할 때 주의해야할 것이 있다면 Job의 취소를 수명주기에 맞추어 작성해주어야 한다. 그렇지 않으면 앱이 종료되어도 Job은 종료되지 않고 유지되어 메모리 누수 및 배터리 드레인이 발생할 수 있다.

        CoroutineScope(Dispatchers.Main).launch {
            (1 .. 100).forEach {
                delay(1000)
                Log.d("$it")
            }
        }

위 소스를 실행시켜보자

위 캡쳐를 보면 onDestroy가 호출되어 앱이 종료되었음에도 Job은 종료되지 않고 프로세스를 완전히 종료시켜야 종료됨을 확인할 수 있다.

lifeCycleScope

Android 프레임워크에는 이를 방지하기 위해 lifeCycleScope 라는 API를 제공한다.

lifeCycleScope를 이용하면 Activity의 수명주기에 맞춰 Job을 종료시켜준다.

아래의 샘플 소스를 살펴보자

     private val sampleFlow = flow<Int> {
        (1 .. 10).forEach {
            delay(1000)
            emit(it)
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        lifecycleScope.launch {
            sampleFlow.collect {
                Log.d("collect value $it from flow")
            }
        }
    }

Flow를 통해서 방출되는 값들을 lifeCycleScope에서 받아서 로그로 출력하는 간단한 소스를 실행시켜보면 아래와 같다.

onDestroy가 호출되어 앱이 종료되면 Flow 스트림도 같이 종료되는 것을 확인할 수 있다.

onPause에선 중단되지 않는다

하지만 lifeCycleScope도 단점은 존재하였는데 앱이 백그라운드로 이동하여 Pause/Stop 상태에선 중단되지 않는다. 이로인해 메모리 누수가 발생할 수 있으니 특정 LifeCycle에서만 로직을 실행하고 싶다면 다른 방법이 필요하다.

이 또한 해결책이 있으니 아래를 살펴보자

repeatOnLifecycle

LifeCycle API 에는 repeatOnLifecycle 기능을 제공한다. 특정 LifeCycle에서만 로직을 실행하며 LifeCycle이 변하면 로직을 중단한다.

    val sampleFlow = flow<Int> {
        (1 .. 10).forEach {
            delay(1000)
            emit(it)
        }
    }

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

        lifecycleScope.launch {
            lifecycle.repeatOnLifecycle(Lifecycle.State.RESUMED) {
                sampleFlow.collect {
                    Log.d("collect value $it from flow")
                }
            }
        }
    }

Lifecycle.State에 대응되는 Lifecycle

• CREATED > onCreate
• STARTED > onStart
• RESUMED > onResume
• INITIALIZED > onAttach (Fragment only)
• DESTROYED > onDestroy

예제 소스를 실행하고 로그를 확인해보면 onStop 에 진입하면 Flow 수집이 중단되고 onResume 에 다시 진입하면 Flow 수집이 다시 시작되는 것을 볼 수 있다.

에제에서 쓰였던 것처럼 포그라운드 상태에서 Flow 수집이 필요하거나 주기적으로 변하는 값의 모니터링의 필요할 경우 사용하면 좋다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

개인적으로 만들어서 사용하는 웹페이지 북마크 앱이 있다. 이전에 OpenGraph 예제로 만들었던 앱인데 인스타그램의 URL을 저장했더니 og태그를 못찾아서 제대로 저장이 되질 않는다.

원인은 매우 간단하였는데 아래에서 같이 살펴보자

원인

우선 Jsoup에서 페이지의 태그 객체인 'Document' 객체를 가져올 때 Jsoup의 Connection 객체를 통해서 요청을 보내는데 이때 Connection 객체를 설정이 누락되어 있었다.

// 기존
document = Jsoup.connect(url).get()

// 수정
document = Jsoup.connect(url)
                .userAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64)")
                .followRedirects(true)
                .get()

정확한 원인은 요청을 보낼 때 userAgent를 따로 설정해주지 않으면 기본값인 "Java/1.x ....."으로 설정되어 요청을 보내게 되는데 이러한 형태의 userAgent를 차단하는 서버들이 있다고 한다. 필자의 경우 userAgent를 임시로 크롬과 같이 설정했더니 해결되었다.

followRedirects()는 페이지의 최종 결과물이 요청 보낼때의 URL이 아니라 리디렉션을 통하여 URL이 변경된 후에 나타난다면 이 경우에도 og태그는 존재하지 않을 가능성이 있어 추가적으로 넣어주었다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

안드로이드에는 CallScreeningService라는 API를 제공한다.

API Level 29 부터 지원하며 Service 구현 만으로 통화필터링을 할 수 있도록 도와준다.

기존에는 통화필터링을 브로드캐스트 리시버를 구현하여 넘어오는 인텐트를 통해 이벤트를 처리했지만 이 CallScreeningService는 시스템에서 전화 화면(CallScreen)이 전환되는 시점에 서비스를 바인딩하는 방식으로 처리하게 된다.

에제소스

class ScreeningService : CallScreeningService() {
    override fun onScreenCall(callDetails: Call.Details) {
        if(callDetails.callDirection == Call.Details.DIRECTION_OUTGOING) {
            // 발신 전화는 리턴
            return
        }

        // 수신된 전화번호 가져오기
        val incomingNumber = callDetail.handle.schemeSpecificPart

        // 수신된 전화번호가 등록된 스팸번호인지 체크
        // checkSpamNumber() 함수는 예제를 위해 임의로 작성한 함수입니다.
        if(checkSpamNumber(incomingNumber)) {
            // 전화 차단 시 수행할 작동들 구현

            // 시스템에 전달할 수신전화에 대한 상호작용 설정
            val response = CallResponse.Builder()
                    .setDisallowCall(boolean) // 전화 거부
                    .setRejectCall(boolean)   // 발신자에게 수신거절에 대한 피드백 전달 여부
                    .setSkipCallLog(boolean) // 통화기록 남김 여부
                    .setSkipNotification(boolean) // 통화알림(부재중) 남김 여부
                    .build()

           // 시스템에 수신전화 전달
           respondToCall(callDetail, response)
        }
    }
}

setRejectCall(boolean)의 경우 자세히 설명해보자면 아래와 같다. 단말기에 전화가 수신되면 발신자에게 거절 피드백을 즉시 전달할지 여부를 설정하는 것으로 거절 피드백을 즉시 전달하면 발신자 입장에선 전화가 바로 거절된 것처럼 보이고 즉시 전달하지 않으면 수신자에겐 전화가 차단되었지만 발신자에겐 전화가 끊어지지 않고 통화연결음이 지속된다.

Service 클래스를 작성했다면 이제 AndroidManifest에 등록해주자.

<service
    android:name=".ScreeningService"
    android:permission="android.permission.BIND_SCREENING_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.CallScreeningService" />
    </intent-filter>
</service>

주의할점

스팸차단 기본앱 설정 필요

RoleManager를 통해 '스팸차단 기본앱'으로 설정이 필요하다. 아래 예제 소스를 참고해서 기본앱으로 설정하는 로직을 구현하면 된다.

private lateinit var requestRoleLauncher: ActivityResultLauncher<Intent>
private fun requestRole() {
        Logger.log("requestRole()")

        val roleManager = getSystemService(RoleManager::class.java)
        fun request() = requestRoleLauncher.launch(roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_SCREENING))

        requestRoleLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
            Logger.log("it result >> ${it.resultCode}")

            if(it.resultCode == RESULT_CANCELED) {
                AlertDialog.Builder(this)
                    .setMessage("기본 앱으로 지정하셔야 정상작동할 수 있습니다.")
                    .setPositiveButton("설정하기") { _, _ ->
                        request()
                    }
                    .setNegativeButton("앱 종료") { _, _ -> finishAffinity() }
                    .setCancelable(false)
                    .show()
            } else requestPermission()
        }

        request()
    }

'READ_CONTACTS' 권한 필요할 떄가 있음

기본적으로 CallScreeningService는 저장되지 않는 연락처에 한해서만 서비스가 바인딩된다. 단, READ_CONTACTS 권한이 허용된 경우 연락처에 있는 번호도 서비스가 바인딩된다.

저장되지 않은 번호 뿐만 아니라 사용자 주소록에 저장된 전화번호도 포함해서 서비스를 바인딩하려면 READ_CONTACTS 사용자에게 요청하도록 하자.

발신전화도 제어가 가능

위 예제 소스에서 눈치를 챘을 수도 있겠지만 아래 소스와 같이 발신전화에 대한 예외처리가 있었는데

if(callDetails.callDirection == Call.Details.DIRECTION_OUTGOING) {
    // 발신 전화는 리턴
    return
}

CallScreeningService는 전화화면이 전환될 때 서비스가 바인딩되는 형식이니 발신전화 또한 제어가 가능하다.

만약 전화상태(발신, 수신)를 다양하게 제어하고 싶다면 onScreenCall() 콜백 내에서 아래와 같이 분기처리를 해주면 될 것이다.

when(callDetail.callDirection) {
    Call.Details.DIRECTION_INCOMING -> {
        // 전화 수신
    }
    Call.Details.DIRECTION_OUTGOING -> {
        // 전화 발신
    }
    Call.Details.DIRECTION_UNKNOWN -> {
        // 알수없는 전화 방향
    }
}

5초 이내에 로직이 완료되어야 함

onScreenCall() 콜백이 호출된 후 5초 이내에 responseToCall() 함수를 호출하여 시스템에 응답을 전달해야 정상적으로 작동한다.

5초를 초과할 경우 respondToCall()함수를 호출해도 시스템으로 전달되지 않는다. 이로인해 발생하는 동작은 아래와 같다.

• respondToCall() 함수 호출 무시

• 수신 거부 대상인 번호이지만 시스템으로 설정을 전달하지 못했기 때문에 전화가 수신됨
• 시스템에서 서비스의 바인딩을 강제로 끊음

그래서 onScreenCall() 콜백에서 오버헤드가 많은 작업은 가급적 피하는 것이 좋을 것 같다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

프로젝트를 진행하다보면 앱에 사용된 오픈소스 라이브러리들을 리스트로 출력해야하는 경우가 있다. 라이센스 때문에 라이브러리 사용을 명시해야한다던가 ..

구글에서 지원하는 'play-services-oss-licenses' 라이브러리르 사용하면 아주 쉽게 Activity 자체로 만들어낼 수 있다.

사용법

먼저 build.gradle에서 의존성을 추가한다. project 와 app 레벨 양 쪽에 다 해주어한다.

// build.gradle(project)
// repositories 블록에 'mavenCentral()' 설정이 되어있는지 확인해야한다.
repositories {
    google()
    mavenCentral()
}
dependencies {
    classpath 'com.google.android.gms:oss-licenses-plugin:0.10.4'
}

// build.gradle(app)
// 추가적으로 pulgins 블록에 id를 추가해주어야 한다.
plugins {
    id 'com.google.android.gms.oss-licenses-plugin'
}

dependencies {
    implementation 'com.google.android.gms:play-services-oss-licenses:17.0.0'
}

build.gradle 설정이 끝났다면 sync를 진행하여 라이버리를 import 한 뒤 OssLicensesMenuActivity를 실행하면 끝이다.

startActivity(
    Intent(this, OssLicensesMenuActivity::class.java)
)

실행하면 아래와 같은 결과를 볼 수 있다.

매우 간단하게 오픈소스 라이센스들을 출력할 수 있기 때문에 유용하게 사용할 수 있다.

리스트가 출력되지 않을 경우

필자는 처음 사용했을때 아래와 같이 리스트가 정상적으로 사용되지 않았다.

Debug 앱으로 실행시킨거라서 그런건가 싶기도 했지만 딱히 그런 이유일 거 같지는 않아서 좀 더 알아보았더니 빌드할 때 라이브러리에서 오픈소스 라이센스 목록을 json파일로 작성하고 OssLicensesMenuActivity에서 이 json파일을 토대로 리스트를 만든다는 것이다.

필자의 경우 이 json파일이 생성되지 않아서..

./gradlew clean
./gradlew build

Build를 다시 하였더니 정상적으로 리스트가 보였다. 간혹 이 방법도 안된다고 하면 AGP 버전이 낮아서 그런 것일수도 있다고 하니 AGP 버전을 업데이트 하는 것도 참고하면 좋겠다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

Compose를 사용하면 보통 Composable 함수들은 Class 외부에 선언을 주로 한다. 이때 Class 외부에 있다보니 context를 가져올 수가 없었는데 LocalContext 를 사용하면 context를 쉽게 가져올 수 있다.

예제

사용방법은 굉장히 간단하다. 아래 샘플 소스를 통해 살펴보자

@Preview(showSystemUi = true)
@Composable
fun ExampleComposable() {
    /**
     * 버튼을 누르면 Progress를 출력하고 터치방지 플래그를 3초간 설정한다.
     */
    val activity = (LocalContext.current as MainActivity)
    var isProgress by remember { mutableStateOf(false) }

    Column(
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.fillMaxSize()
    ) {
        Button(onClick = {
            isProgress = !isProgress
        }) {
            Text(text = "Progress")
        }

        if(isProgress) {
            CircularProgressIndicator(modifier = Modifier.align(Alignment.CenterHorizontally))
            LaunchedEffect(Unit) {
                activity.window.addFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
                delay(3000)
                activity.window.clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
            }
        }
    }
}

LocalContext는 프레임워크 내에 전역변수로 선언되어 있어 특별한 설정없이 바로 호출해주면 된다.

LocalContext.current 를 호출하면 현재 Context를 반환해주는데 Composable 함수 내에서만 호출이 가능하기 때문에 함수 상단에 변수로 할당해주고 사용해주는 것이 좋을 것 같다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

Kotlin에서는 Collection 객체들의 사용이 더욱 쉽도록 도와주는 함수들이 있다. 이를테면 map, filter.. 등이 있는데 Java Stream에 대응되는 함수들이다.

map

• 각 요소를 반환하여 새로운 컬렉션을 만듬

 fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    val sqaureList = list.map { it * it }
    print(sqaureList) // [1, 4, 9, 26, 25]
}

filter

• 조건을 만족하는 요소만 뽑아서 새로운 Collection을 반환

fun main() {
    val list = listOf(1, 2, 3, 4, 5, 6)
    val filterList = list.filter { it % 2 == 0 }
    print(filterList) // [2, 4, 6]
}

forEach

• 각 요소를 순회

fun main() {
    val names = listOf("Alice", "Bob", "Charlie")
    names.forEach { println(it) }
}

reduce

• 각 요소들을 순회하면서 요소들의 합을 반환

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val sum = numbers.reduce { acc, num -> acc + num }
    println("result > $sum") // result > 15
}

fold

• 초기값을 시작으로 각 요소들을 순회하면서 요소들의 합을 반환

fun main() {
    val numbers = listOf(1, 2, 3)
    val result = numbers.fold(10) { acc, num -> acc + num }
    println(result) // 16
}

find

• 조건을 만족하는 첫 요소를 반환

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    val result = list.find { it % 2 == 0 }
    println(result) // 2
}

groupBy

• 특정 키를 기준으로 요소들을 그룹화하여 Map으로 반환

fun main() {
    val list = listOf("abcde", "abc", "abdefg")
    val group = list.groupBy { it.length }
    println(group) // {5=[abcde], 3=[abc], 6=[abdefg]}
}

특정 조건을 기준으로 그룹화도 가능하지만 이 경우는 아래 'partition' 함수 사용을 권장

sortBy / sortedBy

• 요소가 단순 원시타입이 아닌 여러 데이터를 가지고 있는 객체일 때 객체 내 특정 데이터를 기준으로 요소들을 정렬
• sortBy는 mutable 객체, sortedBy는 immutable 객체에서 사용 가능

data class Person(val name: String, val age: Int)
fun main() {
    val people = listOf(
        Person("Alice", 30),
        Person("Bob", 25),
        Person("Charlie", 35)
    )
    val sortedByAge = people.sortedBy { it.age }
    println(sortedByAge) // [Person(name=Bob, age=25), Person(name=Alice, age=30), Person(name=Charlie, age=35)]
}

partition

• 조건을 기준으로 요소들을 두 그룹으로 나눔

fun main() {
    val list = listOf(1, 2, 3, 4, 5, 6)
    val (evens, odds) = list.partition { it % 2 == 0 }
    println(evens) // [2, 4, 6]
    println(odds) // [1, 3, 5]
}

zip

• 두 리스트를 합쳐서 Pair 를 반환

take / takeWhile

• take : 주어진 갯수의 요소를 반환
• takeWhile : 조건을 만족하는 요소들을 리스트로 반환

  find 는 첫 요소 하나만 반환 takeWhile은 조건을 만족하는 요소 모두를 반환

drop / dropWhile

• drop : 주어진 갯수의 요소를 제거
• dropWhile : 조건을 만족하는 요소들을 제외한 리스트를 반환

distinct

• 중복을 제거하고 새로운 Collection을 반환

any / all / none

• 조건을 만족하는지 확인
  • any : 요소 중에 하나라도 조건을 만족하면 true
  • all : 요소 중에 모든 요소가 조건을 만족하면 true
  • none : 요소 중에 조건을 만족하는 요소가 없으면 true

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

9월에 Play Console에 새로운 정책이 생긴 것을 발견했다. 요지는 '사진 및 동영상' 권한을 사용하려면 정책을 선언하고 제출하여 승인을 받으라는 것이다.

이번에 대응한 방식에 대해서 포스팅하고자 한다.

사진 및 동영상 권한이란?

사진 및 동영상 권한은 Android 13부터 새로 추가된 권한으로 기존의 READ_EXTERNAL_STORAGE 권한을 대체하는 권한이다.

단, Android 12 이하에선 그대로 사용 가능하다.

대체되는 권한은 아래와 같다.

READ_MEDIA_IMAGES → 이미지 읽기 권한 READ_MEDIA_VIDEOS → 동영상 읽기 권한 READ_MEDIA_AUDIO → 오디오(음성 파일) 읽기 권한

타임라인

구글에서 제시한 타임라인은 위와 같다. 연장 신청에 한해서 2025년 5월 28일까진 미룰 수 있지만 2025년 1월 22일부터 대응되지 않은 앱은 업데이트를 제출할 수 없으니 가급적 올 해 안에는 마무리하는 것으로 방향을 잡았다.

정책 대응

정책 선언만 하면 될 것으로 보이지만 아래 예외사항에 해당하는 앱만 정책 심사를 통과할 수 있다.

예외사항이 사실상 사진 편집이나 파일 관리자 앱에만 해당되는 것으로 보여 Android 사진 선택 도구(이하 PhotoPicker) 로 마이그레이션을 진행하기로 했다.

PhotoPicker란?

PhotoPicker란 Android 13부터 추가된 이미지 선택 API로 대략적으로 아래와 같이 작동하는 것 같았다.

PhotoPicker 실행 → 미디어 파일 선택 → PhotoPicker에서 미디어 파일 캐싱 → 캐싱된 파일의 컨텐츠 URI (content://……) 반환

자세한 사용 방법은 이전에 작성한 포스팅을 참고하면 좋을 것 같다.

대응 방식

이 정책은 아래 두 권한을 사용하는 앱이 대상이 된다.

• READ_MEDIA_IMAGES
• READ_MEDIA_VIDEOS

Andorid 12까지 사용되던 READ_EXTERNAL_STORAGE는 해당되지 않는다.

그래서 Android 13 이상은 PhotoPicker를 사용하고 Android 12 이하는 기존 로직을 그대로 사용하도록 분기처리를 하였다.

사실 PhotoPicker는 Android 12 이하 버전에서는 백포팅을 통해 지원한다고 해서 Android Devloper 가이드대로 적용을 해보았으나 작동하지는 않았다. 구글 이슈 트래커에도 백포팅이 작동하지 않는다는 내용으로 여러 개의 이슈가 등록된 것으로 보아 결함으로 보이며 아직 해결되지는 않은 것 같다.

이 외에도 PhotoPicker가 결함이 더 있는 것 같은데.. 나중에 정리하여 포스팅을 띠로 작성하고자 한다.

결론

Android 13 이상 -> PhotoPicker 사용 Android 12 이하 -> 기존 로직 사용

분기처리를 추가하고 Play Store 심사를 제출했더니 심사 통과가 되었고 정책도 해소된 것을 확인했다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

SAF와 PhotoPicker는 목적이 엄연히 다르기 때문에 비교하는 것은 무의미할 수 있으나 SAF에서 이미지파일의 Uri를 가져올 경우 PhotoPicker에서 가져오는 이미지파일의 Uri와 차이가 다소 존재하는 것 같아 정리해보았다.

SAF

SAF에서 반환하는 Uri의 특징은 아래와 같다.

1. content://로 시작하는 Uri를 반환하며 파일 접근 권한을 제공
2. 경로 정보는 제공하지 않기 때문에 경로를 알 수 없음
3. Uri가 아닌 File이 필요한 경우 ContentResolver를 이용하여 데이터 스트림을 읽어온 후 파일을 복사해야 한다.

PhotoPicker

1. PhotoPicker에서 반환되는 MediaStore 기반으로 실제 파일을 가리킨다.
2. 실제 파일이긴 하나 원본 파일을 가리키는 것이 아닌 캐싱된 파일을 가리킨다. -> 원본 파일의 경로를 알지 못하며 파일의 이름 또한 원본 이름이 아닌 임의의 이름이다.

이 글은 아직 미완성이며 차이점이 추가로 발견되면 업데이트할 예정입니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

일반적으로 잘 사용하지 않을 수 있지만 CPU의 아키텍쳐가 필요할 때가 있다. Android에서는 ABI (Application Binary Interface)를 이용하여 CPU의 아키텍쳐를 유추해볼 수 있다.

ABI (Application Binary Interface)

Android Devloper 문서에는 ABI의 내용을 아래와 같이 안내하고 있다.

쉽게 말하면 명령어 셋트를 포함하는 CPU 아키텍쳐라고 보면 될 것 같다.

아키텍쳐 종류 대해서 간단히 분류하자면 아래와 같다.

• CISC PC에서 주로 쓰이는 CPU (AMD, Intel) 들을 생각하면 된다.

  1. x86
  2. x86_64
  3. i686

• RISC 모바일에서 주로 사용되는 ARM 프로세서들을 생각하면 된다.

  1. AArch32
  2. AArch64

ABI의 종류는 아래와 같다.

• armeabi-v7a (32비트 RISC 아키텍쳐) 지원 명령어 셋트

  1. armeabi
  2. Thumb-2
  3. 네온

• arm64-v8a (64비트 RISC 아키텍쳐) 지원 명령어 셋트

  1. AArch64

• x86 (32비트 CISC 아키텍쳐) 지원 명령어 셋트

  1. x86(IA-32)
  2. MMX
  3. SSE/2/3
  4. SSSE3

• x86_64 (64비트 CISC 아키텍쳐)

가져오는 방법

System.getProperty("os.arch")

Java 라이브러리에서 가져오는 함수를 지원한다. System.getProperty("os.arch") 함수를 사용하면 JVM으로부터 아키텍쳐를 가져올 수 있다.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        // os.arch 값 출력
        MaterialAlertDialogBuilder(this)
            .setMessage("""
                os.arch : ${System.getProperty("os.arch")}
            """.trimIndent())
            .setPositiveButton("확인", null)
            .show()
    }

위 샘플 소스를 실행시켜 Dialog에 아키텍쳐를 출력해본다.

갤럭시 S24 플러스에서 실행한 사진

PC에서 실행한 사진

갤럭시S24 플러스의 경우 ARM 기반 퀄컴 프로세서가 탑재되어 'AArch64'가 출력되었고

PC의 경우 AMD CPU 프로세서가 탑재되어 'x86_64'가 출력되었다.

ABI

하지만 System.getProperty("os.arch")를 사용한 방법에는 맹점이 있다. JVM에서 아키텍쳐를 가져오기 때문에 NDK 사용을 위해 build.gradle에서 ABI를 별도로 설정한 상황이라면 설정된 ABI를 그대로 반환하기 때문에 의도한 동작이 되지 않을 수 있다.

이럴때는 Build.SUPPORTED_ABIS 를 사용하는 것이 좋다. Build.SUPPORTED_ABIS는 단말기에서 지원하는 모든 ABI를 반환하기 때문이다.

        MaterialAlertDialogBuilder(this)
            .setMessage("""
                os.arch : ${System.getProperty("os.arch")}
                ABIS    : ${Build.SUPPORTED_ABIS.toList()}
            """.trimIndent())
            .setPositiveButton("확인", null)
            .show()

최우선 ~ 호환되는 순서대로 ABI를 반환하므로 배열 내에 첫번째 요소를 가져온다면 CPU 아키텍쳐를 체크할 수 있다.

요약

프로젝트의 build.gradle에 ABI 설정이 되어있다면 -> Build.SUPPORTED_ABIS 를 사용해야 한다. ABI 설정이 되어있지 않다면 -> System.getProperty("os.arch")를 사용해도 무방하다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

JSONObject은 다른 Map 클래스와 마찬가지로 key들의 집합을 제공한다. 다른 점이라면 Map은 반환형이 Set이지만 JSONObject는 반환형이 Iterator 이다.

이 Iterator를 사용해서 각 요소들을 순회할 수 있다.

        val mJsonObj = JSONObject(
            """
                {
                    A: "1",
                    B: "2",
                    C: "3",
                    D: "4",
                    E: "5"
                }
            """.trimIndent()
        )
        val mKeys = mJsonObj.keys()
        while(mKeys.hasNext()) {
            val key = mKeys.next()
            Log.e(TAG, "json element > ${mJsonObj[key]}")
        }

forEach

Java 8 이상부터는 Iterator 에서 forEach문을 지원한다. 덕분에 좀 더 쉽게 순회가 가능하다.

        val mJsonObj = JSONObject(
            """
                {
                    A: "1",
                    B: "2",
                    C: "3",
                    D: "4",
                    E: "5"
                }
            """.trimIndent()
        )
        val mKeys = mJsonObj.keys()
        mKeys.forEach { key ->
            Log.e(TAG, "json element > ${mJsonObj[key]}")
        }
    }

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

루팅(Rooting)이란?

루팅(root + ing)이란 UNIX 계열 운영체제에서 최고 관리자 권한인 root 권한을 취득하는 것을 의미합니다.

일반적으로 루팅이라 함은 Android 환경에서 이루어지는 행위를 일컫는 용어입니다.

Android는 다른 리눅스와 달리 기본적으로 root 접근을 막고 있으며

이는 소비자(사용자)에게 예상치 못한 시스템 파일 손상을 방지하고 안정적인 사용자 경험을 제공하기 위함입니다.

따라서 대부분의 루팅 방법은 단말기 제조사에서 적합한 방법으로 제공하는 방법이 아니며

대부분의 루팅은 보안 취약점을 공격하여 부트로더 언락을 통해 권한을 취득하는 방식입니다.

루팅은 제조사에서 권장하는 방법이 아니기 때문에 루팅으로 인해 발생하는 피해는 제조사에서 보증하지 않습니다.

루팅 탐지

루팅은 여러가지 방법으로 탐지가 가능합니다.

자세한 설명은 아래 코드와 주석을 통해 설명하겠습니다.

    private fun isRooted(): Boolean {
        try {
            // test-keys 태그가 있는지 확인
            val buildTags = Build.TAGS
            if (buildTags != null && buildTags.contains("test-keys")) {
                return true
            }

            // Superuser.apk 파일이 있는지 확인
            // Superuser.apk는 루팅된 디바이스를 제어할 수 있도록 개발된 오픈소스 앱으로
            // 해당 앱이 설치되었다는 것은 루팅된 단말기로 판단할 수 있습니다.
            val file = File("/system/app/Superuser.apk")
            if (file.exists()) {
                return true
            }

            // su, busybox 바이너리가 해당 경로에 있는지 확인
            // 아래 바이너리들은 부트로더 언락을 위해 필요한 바이너리들로
            // 부트로더 언락이 되었다는 것은 루팅이 된 것으로 판단할 수 있습니다.
            val paths = arrayOf(
                "/system/bin/",
                "/system/xbin/",
                "/sbin/",
                "/system/sd/xbin/",
                "/system/bin/failsafe/",
                "/system/bin/.ext/",
                "/system/usr/we-need-root/",
                "/data/local/xbin/",
                "/data/local/bin/",
                "/data/local/"
            )
            for (path in paths) {
                if (File(path + "su").exists() || File(path + "busybox").exists()) {
                    return true
                }
            }

            // su 명령이 실행 가능한지 확인
            // su 명령은 리눅스에서 계정을 전환하여 명령을 내릴 수 있는 명령어로
            // root 권한으로써 명령을 내릴 수 있기 때문에
            // su 명령이 실행된다면 루팅된 단말기로 판단합니다.
            var process: Process? = null
            try {
                process = Runtime.getRuntime().exec("su")
                return true
            } catch (e: Exception) {
            } finally {
                if (process != null) {
                    try {
                        process.destroy()
                    } catch (e: Exception) {
                    }
                }
            }
        } catch (e: Exception) {
        }
        return false
    }

위 4가지 방법 중 하나라도 해당된다면 루팅된 단말기로 판단이 가능합니다.

실행 결과

루팅된 단말기

정상 단말기

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

프로젝트를 빌드하다가 아래와 같은 에러가 발생했다.

ParseError at [row,col]:[109,1] Message: 예기치 않은 파일의 끝입니다.

위 메세지 외에는 발생경로 조차 알려주지 않아서 상당히 헤매고 있었는데 끝없는 구글링 끝에 원인을 찾을 수 있었다.

해결

xml 파일에 태그가 제대로 닫혀있지 않거나 잘못된 형식의 오타 등이 있으면 빌드 중 xml파일 파싱 과정에서 발생하는 에러라고 한다.

필자도 레이아웃을 수정했었던게 생각이나 소스를 찾아들어가니 일부 소스를 주석처리 한다는 것이 부모 레이아웃의 닫는 부분까지 주석처리 되어 에러가 발생한 것이다.

주석처리를 수정한 후 다시 빌드해보니 정상적으로 빌드가 되었다.

앞으로 xml파일을 수정할 일이 있다면 태그를 잘 확인해보자 ..

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

특정 branch를 그대로 복사하여 새로운 Repository를 만들고 싶을 때가 있다. Git 명령을 통해 간편하게 가능하니 아래와 같이 따라해보자

1. 복사하려는 Branch를 Clone

   > git clone -b 브랜치명 --single-branch --mirror Repository 주소
   

ex) git clone -b Sample --single-branch --mirror https://github.com/LeeJaeWon14/ClubHouse.git

2. Clone한 (Repository 이름).git을 '.git'으로 변경

mv Repository.git .git (리눅스/MAC) ren Repository.git .git (윈도우)

3. Remote 저장소를 옮기려는 Repository로 변경

git remote set-url Repository URL

ex) git remote set-url origin https://github.com/LeeJaeWon14/BranchCloneSample.git

4. Push 하기

git push --mirror

```

Push를 하면 위와 같이 소스가 업로드된다. 만약 Push하려는 Repository가 Private이라면 로그인이나 인증처리를 진행하면 Push가 완료된다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

“Android 로봇은 Google에서 제작하여 공유한 저작물을 복제하거나 수정한 것으로 Creative Commons 3.0 저작자 표시 라이선스의 약관에 따라 사용되었습니다.”

개요

Android는 iOS에 비해 상대적으로 단말기 특성이 존재하는 편이다. 내가 가지고 있는 단말기들로 테스트를 완벽하게 했을 수도 있겠지만 나에게 없는 단말기에서 오류가 발생하는 경우도 간혹 발생한다.

이럴 때마다 단말기를 새로 사기엔 부담스럽고.. 삼성전자에서 이를 위해 실제 단말기를 원격으로 테스트할 수 있는 솔루션을 제공한다.

Remote Test Lab 이라는 솔루션인데 삼성전자에서 각 지역(나라) 별로 테스트를 위해 실제 단말기를 여러 대 준비하고 개발자가 원격을 통해 해당 단말기에 접근하여 테스트할 수 있는 솔루션이다.

이를 사용하기 위해선 삼성 개발자 계정 등록이 필요한데.. 필자는 이미 등록이 되어있어 이 부분은 다른 분의 자료를 참고하는 것이 좋겠다.

지원 단말기

선택한 국가에서 최근 3 ~ 4년 내에 출시된 단말기는 모두 있다고 봐도 무방할 것 같다. 심지어 TV도 있다..!

단말기 실행

원하는 단말기를 클릭하면 아래와 같은 창이 실행된다.

Location: 단말기가 위치한 지역(국가) Duration: 단말기 사용할 시간 Available Device: 현재 사용 가능한 단말기 수

지역은 접속한 나라 사용 가능한 지역으로 자동으로 필터링되어 보여주는 것 같다.

사용 가능한 단말기 수가 없으면 다른 사람의 사용 시간이 끝날 때까지 기다려야하지만 단말기 종류가 워낙 많고 보유 수도 각 모델 별로 3 ~ 5대 이상은 있어서 기다릴 일은 거의 없다고 봐도 될 것 같다.

단말기 목록에서 선택 가능한 나라 외에 다른 나라 단말기도 실행은 가능하지만 속도가 굉장히 느리기 때문에 가급적 한국으로 설정하는 것이 좋다.

단말기를 실행하면 위와 같은 창이 나온다.

Device Information: 모델명부터 펌웨어 버전, Android 버전 등 단말기 정보를 보여준다. Languages: 단말기의 언어 설정을 바꾼다. 기본값은 영어이다. Applications: 단말기에 설치된 앱의 목록을 보여주며 apk파일을 업로드하여 설치 및 실행도 가능하다. Clipboard: 단말기 > 컴퓨터 또는 컴퓨터 > 단말기 방향으로 클립보드를 복사한다. File Browser: 단말기의 스토리지를 뷰어로 제공한다. Remote Debug Bridge: ADB와 연결하기 위해 제공하는 원격 브릿지, 설정 방법은 아래 서술

Remote Debug Bridge 설정

RDB가 설정되어있지 않으면 설치와 설정을 하라는 창이 뜰 것이다. 다운로드를 클릭하여 압축파일을 받도록 하자

다운로드 받은 압축파일을 풀어 rdb.exe를 실행한다.

실행한 뒤 단말기 화면으로 돌아와서 'connect' 버튼을 클릭해주면 ADB connected to RDB 메세지와 함께 브릿지가 연결된다.

브릿지가 연결되면 Android Studio에도 정상적으로 인식이 되며 디버깅 앱으로 바로 실행하거나 디버거를 걸 수도 있다.

ADB 또한 지원한다.

Log

단말기 페이지 우측에 'Logs' 버튼을 눌러 로그를 볼 수도 있지만 Android Studio에도 연결이 된 만큼 Logcat으로 보는게 더 편한 거 같다.

개인적으로 공부했던 것을 바탕으로 작성하다보니 잘못된 정보가 있을수도 있습니다. 인지하게 되면 추후 수정하겠습니다. 피드백은 언제나 환영합니다. 읽어주셔서 감사합니다.

회사에서 서비스 중인 앱 하나를 유지보수하는데 Rest API 요청할 때 Exception을 뱉어내는 일이 발생했다.

java.lang.runtimeexception: Stub!

이걸로 무려 4시간을 삽질한 결과 원인은 Apache 라이브러리였다.

Apache Library

Apache 라이브러리는 okhttp3가 등장하기 전 Android에서 Rest API를 사용하기 위해 사용하던 라이브러리이다. 근데 Apache 라이브러리는 android.jar 내에 내장되어있다.

Apahce 라이브러리 내에 모델 클래스인 BasicNameValuePair

Stub

우선 Stub은 라이브러리에서 구현체가 존재하지 않아 클래스를 사용할 수 없을 때 뱉어내는 일종의 경고 메세지다. Android의 경우 라이브러리로서 android.jar 파일이 존재하는데 안드로이드 스튜디오 상으론 껍데기만 있고 실제 구현체는 AOSP 내에 존재한다. 마찬가지로 Apache 라이브러리 또한 일종의 껍데기만 android.jar 내에 존재하고 실제 구현체는 AOSP가 가지고 있어야하는데.. Android 14부터는 Apache 라이브러리의 지원이 전면 중단되어 AOSP 내에서도 제거되었다.

지원 중단은 Android 6 부터 되었고 Android 9 부터는 기본적으로 사용이 불가능했지만 가이드에 따라 Android 13 까지는 예외처리하여 사용이 가능하였다.

해결방법

okhttp3 사용

기존 Apache 라이브러리를 사용하던 로직을 okhttp3로 마이그레이션 하는 방법이다. 이 방법이 가장 안전하고 효과적이라고 생각한다.

Target SDK 조정

개발자 문서에 따르면 Target SDK를 28로 조정하고 기존의 예외처리를 적용하라고 가이드하고 있다.

취사선택

마이그레이션 할 수고를 덜어주는 방법은 2번째인 TargetSDK을 조정하는 방법이지만 PlayStore 정책으로 인해 작성일인 2024.01.05 기준 TargetSDK이 33 이하일 경우에는 앱을 배포할 수 없다. 그래서 PlayStore에 배포하는 앱이라면 okhttp3로 마이그레이션 하는 수 밖에 없다.

결론

필자의 경우 서비스하는 앱이 사설 배포이기에 TargetSDK를 신경쓸 필요가 없어 마이그레이션 없이 TargetSDK만 조정하는 방향으로 해당 현상을 해결하였다.

Android 프로젝트에는 assets 디렉토리를 생성할 수 있다. 이 assets 디렉토리는 앱에서 사용해야할 파일을 미리 저장해놓고 앱 내에서 필요할 때 꺼내서 사용할 수 있도록 도와주는 디렉토리이다.

우선 assets 디렉토리 만드는 방법부터 알아보겠다.

assets 생성

main 패키지에서 마우스 우클릭을 통해 Directory를 클릭한다.

아래 리스트 중 assets를 클릭한 뒤 엔터를 눌러 디렉토리를 생성한다.

main 패키지 내에 assets 디렉토리가 생성된 것을 확인할 수 있다.

AssetManager 사용하여 파일 읽기

샘플 코드는 txt파일을 읽어와서 TextView에 넣어주는 방식으로 작성했다. 사용할 txt파일의 내용은 아래와 같다.

text.txt : 안녕하세요. 테스트 파일입니다.

                val assetManager = resources.assets
                val file = File(filesDir.path.plus("/text.txt")).also {
                    it.createNewFile()
                    it.deleteOnExit()
                }
                assetManager.open("text.txt", AssetManager.ACCESS_BUFFER).use { ins ->
                    val tempData = ByteArray(ins.available())
                    ins.read(tempData)
                    FileOutputStream(file).use {
                        it.write(tempData)
                    }

                    FileReader(file).use { reader ->
                        tvText.text = reader.readText()
                    }
                }

resources.assets 를 통해 assetManager의 인스턴스를 가져올 수 있다. assemtManager.open(파일이름, AccessMode) 를 통해 열려는 파일의 inputStream을 가져올 수 있다. 이 inputStream을 통해 임시 파일로 쓰일 File 객체를 생성한 뒤 파일을 읽어서 TextView에 내용을 넣어준다.

예제는 텍스트파일이지만 다른 파일도 위 에제 코드와 동일한 형식으로 사용이 가능하다.