[1주차/필수 과제] 생명 주기 측면에서 어떤 것을 고려해야 할까요?

[jihyunniiii]

🎤 토론 과제 - 생명 주기 측면에서 어떤 것을 고려해야 할까요?

세미나 때 안정성 있는 앱을 만들기 위해서는 생명 주기를 잘 고려하는 것이 필수적이라고 했던 거 기억 나시나요?

Activity의 생명 주기에 대해 다시 한 번 복습 후 정리해보고, 어떤 것들을 고려하면 좋을지 자신의 의견을 작성해 주세요. 또는, 생명주기를 고려해서 개발해본 경험이 있으신 분들은 그 경험에 대해 공유해주셔도 좋습니다.

[boiledEgg-s]

Activity의 생명주기는 총 7개의 콜백으로 나눠져 있다고 하죠.

1. onCreate()는 액티비티가 처음 생성될 때 실행되는 콜백
2. onStart()는 앱이 액티비티가 포그라운드에 들어가 상호작용을 할 수 있도록 준비하는 콜백
3. onResume()는 실제로 앱이 사용자와 상호작용하는 콜백
4. onPause()는 액티비티가 포그라운드에 있지 않을 때 발생하는 콜백
5. onStop()은 액티비티가 화면에서 사라졌을 때 발생하는 콜백
6. onDestroy()는 액티비티가 완전히 소멸될 때 발생하는 콜백
7. onRestart()는 onStop() 상태에서 액티비티가 다시 화면에 등장할 때 발생하는 콜백으로 onStart()를 이어서 호출함

자원을 할당하고 해제하는 시점을 정할 때 여러 단계로 나눠진 생명주기를 잘 고려해야 합니다. 잘못하면 동일한 클래스의 객체가 여럿 생성되어 메모리가 낭비되는 상황이 발생할 수도 있다고 생각해요,,

실제로 예전에 카카오맵 api를 사용했을 때, 하나의 액티비티에 여러 개의 지도 객체가 동시에 생성되어 오류가 발생했던 적이 있었어요. 생명주기에 대한 이해가 없을 때라 대충 onResume에서 생성하고 onDestroy에서 해제해서 생긴 문제였는데, 해제하는 부분을 onStop으로 옮겨서 해결했던걸로 기억합니다!

[hwidung]

1. Activity의 생명주기 (7가지 callback)
   onCreate() - 전체 수명 주기 동안 한 번만 발생하는, Activity을 생성할 때 실행. ex) 데이터를 목록에 바인딩 하고, Activity을 ViewModel, 일부 클래스 범위 변수를 인스턴스화. RecyclerView에 데이터를 바인딩 한다거나의 동작!
   onStart() - Activity가 사용자에게 앱의 Activity이 foreground에 들어가 대화형이 될 수 있도록 준비. ex) UI가 초기화
   onResume() - 빠르게 onStart() 작업이 끝나고 종료 되면, 호출되는데 사용자와 상호작용 할 수 있게 됨. 다른 화면 전환, 기기 화면이 꺼지는 이벤트가 발생하지 않는 동안에 resume 상태에 머무름.
   onPause() - onResume()에서 사용자가 화면을 떠나면 호출 됨. 액티비티가 포그라운드에 있는 것이 아님. 가지고 있지 않아도 되는 리소스를 여기서 해제 해도 됨(부하가 작을 경우에만). 액티비티가 다시 시작 되면, pause 상태에 있던 액티비티는 다시 resume 상태로 돌아옴. (포커스 상실 상태)
   onStop() - 사용자가 화면을 아예 떠나 화면이 보이지 않을 때 호출. 리소스를 해제하거나, 조정할 필요가 있음. (백그라운드)
   onRestart() - stop 상태에서 다시 액티비티를 재개하는 상황에 호출됨.
   onDestroy() - 액티비티가 완전히 소멸하기 전에 호출 됨. 완전히 앱 종료 혹은 액티비티 내부의 finish() 호출. 액티비티가 완전히 소멸될 것이므로, onStop()에서 해제하지 않은 리소스들에 대해 모두 해제해 줘야 함.

2. 어떤 것들을 고려하면 좋을까?
   리소스를 효율적으로 관리하는 것이 중요합니다.
   ui 관련 중지 작업을 할 때는, onStop()에서 cpu를 비교적 많이 소모하는 작업을 종료한다고 합니다. 예를들어, 애니메이션을 일시중지하거나.. 또, 예를들어, 어떠한 정보를 DB에 저장할 타이밍을 모르겠다면 onStop() 상태일 때 저장하면 된다고 합니다
   또, onDestroy()가 호출되기 까지 해제되지 않은 리소스가 있다면, 이곳에서 모두 해제해주어야 메모리 누수를 예방할 수 있습니다.

3. 사용 경험
   그동안 생명주기를 고려해 본 적이 없었는데, 이번에 공부를 해보니, 그동안 왜 그렇게 앱이 강제 종료가 됐는지! 바인딩이 그렇게 느렸는지 이유를 조금 알 것 같습니다. 앞으로는 이러한 요소들을 고민하며 설계하는 것이 중요할 것 같습니다.

https://developer.android.com/guide/components/activities/activity-lifecycle?hl=ko 와 https://velog.io/@akcineg/안드로이드-액티비티-생명주기를-정확하게-이해하자 을 읽고 복습해 보았습니다.

[Hyobeen-Park]

1. onCreate() : 액티비티를 처음 생성할 때 실행되는 콜백 (구현 필수!)
2. onStart() : 액티비티를 사용자에게 표시 + 상호작용 준비
3. onResume() : 액티비티가 포그라운드에 표시되고 사용자와 상호작용함 (해당 액티비티에 포커스가 있는 상태)
4. onPause() : 액티비티에서 포커스가 떠날 때 + 아주 잠깐 실행, 액티비티가 다시 실행되면 onResume()으로 돌아감
5. onStop() : 액티비티가 더이상 사용자에게 표시되지 않는 경우
6. onDestroy() : 액티비티가 소멸되기 직전에 호출

생명주기는 잘 활용한다면 불필요한 리소스 낭비를 줄이고 성능을 높일 수 있지만 내가 원하는 기능이 정확하게 어떤 생명주기에 위치해야 하는지 잘 생각하지 않으면 오히려 기능이 제대로 돌아가지 않는 일이 생길 수 있어요

저는 생명주기를 활용해서 룸디비에 데이터를 저장해본 경험이 있는데요! 액티비티를 떠날 때 데이터를 저장하는 로직이라 onPause()에서 데이터를 저장하는 기능을 구현했습니다 그때는 onResume() -> onPuase 순서로 실행되고, onPause()가 사용자가 액티비티를 떠날 때 실행되는 첫 번째 콜백이라 적절하다고 생각했었어요 그런데 자꾸만 저장이 제대로 안되는 문제가 생겼습니다. 원인은 저장이 완전히 종료되기 전에 onPause() 메소드가 종료되었기 때문이었어요!! 세미나 때도 언급되었는데 onPause()는 아주 잠깐 실행되기 때문에 저장작업에는 적절하지 못합니다... 당시에는 잘 모르겠어서 그냥 onCreate()에 다 구현했는데 프로젝트가 끝나고 다시 한번 복습해보니 onStop()에서 실행하면 더 좋았을 것 같다는 생각을 했답니다😅

[MinseoSONG]

1. onCreate(): 액티비티가 처음 생성될 때 호출됨 -> 레이아웃 설정 및 초기화 작업을 수행함
2. onStart(): 액티비티가 사용자에게 표시되기 직전에 호출됨 -> 액티비티가 포그라운드에 나와 상호작용할 준비를 함
3. onResume(): 액티비티가 포그라운드에 완전히 나와 사용자가 상호작용할 수 있을 때 호출됨 -> 애니메이션 시작이나 UI 업데이트와 같은 즉각적인 작업 처리
4. onPause(): 사용자가 앱을 떠나거나 다른 액티비티가 포그라운드로 이동할 때 호출됨 -> 데이터 저장이나 시스템 리소스를 반납하는 작업 수행
5. onStop(): 액티비티가 사용자에게 더 이상 보이지 않을 때 호출됨 -> CPU와 같은 자원 소모를 줄이기 위해 이 시점에서 리소스를 해제하는 것이 좋음
6. onDestroy(): 액티비티가 완전히 종료될 때 호출됨 -> 메모리 누수 방지를 위해 모든 자원을 해제해야 함
7. onRestart(): 액티비티가 onStop() 상태에서 다시 시작될 때 호출됨 -> onStart()가 다시 호출되기 전의 중간 단계

리소스 관리와 데이터 저장, 상태유지, 그리고 성능 최적화를 고려해야한다고 생각합니다.
리소스 관리는 자원을 생명 주기에 따라 적절하게 할당하고 해제해야하는데, 예를 들어 onResume()에서 네트워크 요청을 시작하고, onPause()에서 중단하는 과정을 거쳐야 합니다.
데이터 저장은 onPause() 또는 onStop() 상태로 액티비티가 들어갈 때 하고, 상태 유지는 onSaveInstanceState()를 활용하여 상태를 저장하고, onCreate()나 onRestoreInstanceState()에서 복원하는 방식이 유용합니다.

저는 생명 주기를 생각하지 못해 오류를 겪었던 적이 있습니다. 기기를 회전하였을 때, UI 상태를 저장하지 못해서 회전하지 않았을 때와 회전했을 때의 UI가 변경되는 현상을 발견했습니다. 그때 생명 주기에 대해 공부하게 되어 onSaveInstanceState()를 통해 상태를 저장하고, onRestoreInstanceState()를 통해 상태를 복원하며 문제를 해결했었습니다. 이 과정을 통해 생명 주기가 단순히 리소스 관리, 데이터 저장에만 중요한 개념이 아니라는 것을 깨닫고 생명 주기에 대하여 더 자세히 알아보게 되었던 것 같습니다!

[kamja0510]

[Activity의 생명 주기]

1. onCreate() : Activity를 생성할 때 가장 먼저 호출되고 생명 주기 동안 한번만 수행되거나 최초 실행에 해야하는 작업을 수행하기 적합하다.
2. onStart() : Activity가 화면에 표시되기 전에 호출되어 화면에 진입하기 전에 수행되어야 하는 작업을 수행하기 적합하다.
3. onResume() : Activity가 화면에 표시된 직후 호출된다. 앱이 사용자와 상호작용 하는 즉 포커스 되어있는 상태라 한다.
4. onPause() : 현재 Activity가 포커스 아웃 될 때 호출된다.
5. onStop() : 현재 Activity가 다른 Activity에 의해 완전히 가려졌을 경우 호출된다. 아예 보이지 않으므로 보이지 않는 동안 필요하지 않은 리소스는 해제하는 것이 좋다.
6. onRestart() : onStop() 이후 다시 기존 activity로 돌아오는 경우 호되고, 직후에 onStart()가 호출된다.
7. onDestroy() : Activity가 소멸되기 전에 호출된다.

[개발 시 생명 주기 측면에서 고려해야 할 점]

하나의 앱은 보여지는 측면 뒤에 백그라운드 작업이 더 많을 것 같습니다. 이때 이 백그라운드 작업들을 적절한 생명주기에 배치시켜서 onStart()처럼 화면이 배치되기 직전에 백그라운드 작업을 선행하거나, onStop() 처럼 activity가 아예 가려질 경우 불필요한 백그라운드 작업을 중단하며 효율적인 구현을 할 수 있을 것 같습니다.

[생명 주기를 고려해본 경험]

개발 시 생명 주기를 고려해본 적은 없습니다. 하지만 이번에 생명 주기에 대해 알게 되어 이때까지 앱 사용 경험들에서 생명 주기들이 어떻게 작용하는 지 생각해보게 되었습니다. 예시로 유튜브 영상 재생 시 폰 화면을 끄면 원래는 영상이 멈추는 데, 유튜브 프리미엄의 경우 영상이 멈추지 않고 소리가 나옵니다. 이 부분은 onPause()나 onStop()에 비디오를 중단하는 대신 Service 컴포넌트로 소리를 넘기는 작업을 한 것이라고 합니다. 이렇듯 실제 사용하는 앱들을 더 깊게 이해할 수 있게 되었고 이제 개발 시 생명주기를 고려해 보려고 합니다!

[jangsjw]

1. Activity의 생명 주기 주요 단계

1. onCreate(): Activity가 처음 생성될 때 호출되며, 초기화 작업을 수행합니다.
   2)onStart(): Activity가 사용자에게 보여지기 직전에 호출되며, 아직 사용자가 상호작용하지 않는 상태입니다.
   3)onResume(): Activity가 화면에 완전히 나타나고 사용자가 상호작용할 수 있는 상태가 되면 호출됩니다.
   4)onPause(): 다른 액티비티가 전면에 나타나거나 사용자가 앱을 떠날 때 호출되며, 일반적으로 UI 관련 리소스를 해제하거나 상태를 저장합니다.
   5)onStop(): Activity가 더 이상 화면에 표시되지 않을 때 호출되며, 메모리 해제 등 더 많은 리소스 해제를 할 수 있습니다.
   6)onDestroy(): Activity가 종료되거나 시스템에서 메모리를 회수할 때 호출되며, 마지막으로 필요한 청소 작업을 수행합니다.
   7)onRestart(): Activity가 중단되었다가 다시 시작될 때 호출되며, 재시작 관련 작업을 처리합니다.

2. 안정적인 앱을 만들기 위해 생명 주기에서 고려할 점
   고려해야할 점은 크게 세 부분이며, onPause()와onStop()에서 데이터 저장 및 복구, 리소스를 관리해야 합니다. 다음으로 onCreate()와 onRestoreInstanceState()에서 UI 상태를 유지해야 합니다. 마지막으로 onResume()에서 사용자 세션 관리를 해야 합니다.

3. 생명 주기를 고려해본 경험
   생명 주기를 고려해본 경험은 없지만, 안정성 있는 앱을 만들기 위해서는 Activity의 생명 주기가 중요하고 안정성 뿐만 아니라 앱의 성능도 최적화할 수 있음을 알게 됐습니다.

[Roel4990]

기본적인 Activity 생명주기

Activity의 생명주기는 총 7개의 콜백을 가지고 있습니다.

1. onCreate() : 액티비티가 생성될 때 호출되는 메소드
2. onStart() : 액티비티가 화면에 보여지기 직전에 호출되는 메소드
3. onResume() : 액티비티가 사용자와 상호작용을 시작하고 활동 상태에 들어갈 때 호출되는 메소드
4. onPause() : 액티비티가 일시 중지되거나 다른 액티비티가 화면을 가리는 등 포그라운드에서 벗어나기 전에 호출되는 메소드
5. onStop() : 액티비티가 더 이상 사용자에게 보여지지 않고 화면에서 완전히 가려질 때 호출되는 메소드
6. onRestart() : 액티비티가 onStop() 상태에서 다시 시작되기 전에 호출되는 메소드
7. onDestroy() : 액티비티가 소멸될 때 호출되는 메소드

onPause() 가 되었다가 다시 화면으로 돌아올 경우

onPause() ⇒ onResume()

onStop() 가 되었다가 다시 화면으로 돌아올 경우

onRestart() ⇒ onStart() ⇒ onResume()

개발 시 생명 주기 측면에서 고려해야 할 점

일단 리소스 관련해서 정확한 시기 예를 들어 onDestroy 쪽에 필요 없는 소켓통신 같은거는 잘 끊어줘야될 것 같습니다. 또한 위에 적은 앱이 백그라운드로 갈때 onDestroy 되지않고 onRestart 되는 경우에 다양한 부분에서 다양한 오류가 날 것으로 예상되기 때문에 클라이언트의 요구사항에 따라 그러한 부분을 생명 주기 측면에서 잘 고려해야될 것 같습니다.

생명 주기를 고려해본 경험

안드로이드 개발을 해본 경험이 없기때문에 생명 주기를 고려해본 경험은 없지만, 추후에 다양한 분들에게 경험을 통한 조언을 구하고, 제가 직접 다양한 프로젝트를 진행해보면서 생명주기에 따라 어떠한 문제가 생기고, 어떤식으로 처리를 해야되는지 공부하고 정리하도록 하겠습니다.

[imtaejugkim]

Activity의 생명 주기는 총 7개로 다음과 같습니다.

1. onCreate() : activity를 생성할 때 실행되는 것으로, 애플리케이션 시작 로직을 활동의 전체 수명 주기 동안 한번만 발생합니다.
2. onStart() : activity가 시작됨 상태로 전환되면 onStart()를 호출합니다. 호출을 통해 활동이 foreground에 들어가 대화형이 될 수 있도록 준비합니다.
3. onResume() : activity가 재개됨 상태로 전환되면 foreground로 나와 onResume()을 호출합니다.
4. onPause() : activity가 더이상 foreground에 있지 않음을 나타내며, 소멸되지는 않고 정지 상태에 있습니다.
5. onStop() : activity가 더 이상 표시되지 않는 상태를 의미합니다. 해당 콜백을 통해 불필요한 리소스를 모두 회수할 수 있습니다.
6. onRestart() : onStop() 상태에서 다시 시작되어 사용자와 상호작용될 때 호출됩니다.
7. onDestroy() : activity가 소멸될 때 호출합니다. 생명 주기 구성 요소가 시작하기 전에 필요한 모든 것을 정리할 수 있습니다.

어떤 것들을 고려하면 좋을지

해당 view에 대한 리소스가 계속 남아있는 상태로 다른 뷰를 계속 그릴 수 있기 때문에생명 주기를 고려하는 것은 중요하다고 생각합니다. 회원가입 같은 경우, 한번 실행후에는 main 화면 진입 후에는 더 이상 필요 없기 때문에 이런 리소스를 줄여 앱을 가볍게 만들 수 있다고 생각하빈다.

생명 주기를 고려해본 경험

프로젝트에서 생명 주기를 고려해본 경험이 있습니다. 위와 마찬가지로 회원가입 같은 화면은 한번 사용되고 사용되지 않기 때문에 고려했던 기억이 있습니다. 또한 서버에서 받은 데이터 호출 시, 해당 activity가 완료되면 이전 activity의 데이터를 업데이트 해야했던 경험이 있습니다. 이 경우, onResume 과 생명주기를 적절히 사용하여 데이터를 업데이트 시킨 기억이 있습니다.

[t1nm1ksun]

Activity 생명주기

1. onCreate(): Activity가 처음 생성될 때 호출됩니다. UI 구성 요소를 초기화하고 데이터를 설정하는 데 사용됩니다.
2. onStart(): Activity가 사용자에게 보이기 시작할 때 호출됩니다. UI가 화면에 나타나지만, 아직 사용자와 상호작용할 수는 없습니다.
3. onResume(): Activity가 포그라운드에 들어와 사용자와 상호작용할 수 있게 될 때 호출됩니다.
4. onPause(): 다른 Activity가 시작되기 전에 호출됩니다. 이 메서드에서는 데이터 저장 및 리소스 정리를 수행합니다.
5. onStop(): Activity가 더 이상 사용자에게 보이지 않게 될 때 호출됩니다. 이때 리소스를 해제하거나 데이터를 저장할 수 있습니다.
6. onRestart(): 중지된 Activity가 다시 시작될 때 호출됩니다. onStart()가 호출되기 전에 실행됩니다.
7. onDestroy(): Activity가 종료될 때 호출됩니다. 리소스를 해제하거나 마지막 정리를 수행하는 데 사용됩니다.

고려사항

• 리소스 관리: Activity가 중지되거나 종료될 때 메모리와 리소스를 적절히 해제하는 것이 중요합니다. 이로 인해 앱의 성능과 안정성을 높일 수 있습니다.
• 비동기 작업: 네트워크 호출이나 데이터베이스 작업 등 비동기 작업을 수행할 때, Activity의 생명 주기를 고려하여 작업을 시작하고 종료해야 합니다.

적용경험

안드로이드 전공 과목 과제를 수행할 때 사용자가 홈버튼을 눌러 앱을 백그라운드로 보내거나 종료했을때 onPause()나 onStop()이 실행됩니다. 이 때 관련 데이터들을 저장하도록 하여 데이터가 손실되지 않도록 했습니다.

[serioushyeon]

1. Activity 생명 주기
   onCreate(): Activity가 처음 생성될 때 호출
   onStart(): Activity가 화면에 보여질 준비가 되었을 때 호출, 상호작용은 불가능
   onResume(): Activity가 사용자와 상호작용 가능한 상태로 전환
   onPause(): Activity가 일시정지될 때 호출, 보통 화면이 일부 가려지거나 새로운 화면이 나타날 때 발생
   onStop(): Activity가 더 이상 사용자에게 보이지 않을 때 호출, 필요하지 않은 리소스를 해제하는 데 적합
   onDestroy(): Activity가 소멸될 때 호출

2. 생명 주기에서 고려해야 할 것들
   onPause()의 실행 시간은 굉장히 짧기때문에 부하가 큰 작업은 액티비티가 비활성 상태로 전환된 이후 실행되는 onStop() 메소드에서 처리해야 합니다!

3. 생명 주기를 고려한 개발 경험
   아직은 잘 없는 것 같습니다. 앞으로는 생명주기를 고려하면서 개발해보려합니다!

[wjdrjs00]

Activity 생명주기 단계

1. onCreate()
   • Activity가 시작되기 전 즉 화면이 처음 생성됐을 때 호출됩니다.
2. onStart()
   • Activity가 사용자에게 표시되기 직전에 호출됩니다.
   • UI가 화면에 표시되기 시작하지만 아직 상호작용할 준비가 된 상태는 아닙니다.
3. onResume()
   • Activity의 일부가 보일때 쯤에 호출되며 사용자와 상호작용할 준비가 되었음을 나타내며,
   • 이 시점에 사용자는 UI와 상호작용이 가능합니다.
4. onPause()
   • Activity가 사용자와 상호작용 중단 시 (Activity가 다른 Activity로 넘어가기전 즉, 일부의 화면만 보일 때) 호출됩니다.
   • Activity는 여전히 화면에 표시되지만 상호작용이 중지됩니다.
5. onStop()
   • Activity가 더 이상 사용자에게 표시되지 않을 때(완전히 다른 Activity로 덮혔을 때) 호출됩니다.
   • Activity가 백그라운드에 있을 때 실행되며, 메모리가 부족할 경우 시스템은 이 시점에서 프로세스를 종료할 수 있다고 합니다.
   • 네트워크 연결 해제, 데이터베이스 닫기와 같은 무거운 리소스 해제와 같은 작업을 주로 합니다.
6. onRestart()
   • 이미 onStop()이 호출된 Activity가 다시 시작될 때(즉, Activity 가 완전히 가려졌다가 다시 재실행될 때) 호출 됩니다.
   • onStart() 전에 호출되며, 백그라운드에서 포그라운드로 돌아올 때 실행됩니다.
7. onDestroy()
   • Activity 가 종료 되었을 때 finish() 등의 스택 정리시에 호출됩니다.

---

고려사항

• 가로모드와 같이 시스템이 Activity를 강제 종료하고 다시 생성할 수 있기 때문에, 데이터를 적절히 저장해두는 것이 중요합니다.
• 불필요한 리소스를 적절하게 해제하여 낭비가 없도록 고려해야합니다. (강제종료될 수 있음)

적용 경험

• 아직 이러한 고려사항을 실제로 적용해본 경험은 없지만, 프로젝트를 진행하게 되면 이러한 점을 신경쓰면서 개발해보겠습니다!

[hyoeunjoo]

1. Activity 생명주기

• onCreate() : 단 한 번만 수행되는 메소드이며 Activity의 최초 실행에 수행되어야 하는 작업이 호출됨
• onStart() : 앱의 활동이 포그라운드에 들어가 대화형이 될 수 있도록 함. UI를 새로 그림.
• onResume() : 활동이 재개된 상태, 사용자와 상호작용하고 있는 상태
• onPause() : 구성요소가 포그라운드에 있지 않음, 그 때 사용되지 않는 기능을 정지시킬 수 있음
• onStop() : 사용자에게 해당 화면이 더 이상 보여지지 않는 상태, 기능을 모두 정지시킴
• onDestroy(): 활동이 소멸되기 전에 호출됨

2. 생명주기에서 무엇을 고려해야할까?
   액티비티의 context를 정적 변수에 저장하면 Activity가 소멸된 이후에도 계속 메모리에 남아있을 수 있다. 앱이 종료되기 전까지 남아있기 때문에 메모리 누수가 발생하게 된다.

3. 생명주기를 고려해여 개발해본 경험
   Activity와 Fragment들 사이에서 ViewModel을 공유해서 사용할 수 있는 activityViewModels를 사용한 적이 있다. 해당 ViewModel은 Activitiy의 생명주기를 따르고 있는데, 백버튼을 눌렀을 때 해당 값이 초기화 되어있는 상태를 원했지만 Activity가 소멸되기 전까지는 해당 값이 그대로 남아있었기에 해당 Fragment의 onDestroy에서 초기화를 시켜줘야 했던 적이 있었다.

[kangyein9892]

Activity 생명주기

onCreate(): 액티비티가 시작될 때 레이아웃을 구성하면서 한 번 실행

onStart(): 액티비티가 사용자에게 보이기 직전에 실행.

onResume(): 사용자가 액티비티와 상호작용하는 기능을 넣는 곳으로, 무조건 실행되어야 하는 기능이 들어감

onPause(): 포커스를 잃어 화면이 부분적으로는 보이지만 곧 사라질 때 실행

onStop(): 사용자에게서 화면이 완전히 사라지고, 다른 액티비티가 보여질 때 호출

onDestroy(): (화면회전 혹은)화면이 완전히 종료되기 직전에 호출

고려사항

• 생명주기를 고려하지 않고 리소스들을 사용하면 activity가 소멸 된 이후에도 메모리에 계속 남아있어, 메모리 누수가 발생할 수 있다.
• 화면 회전이나 일시적인 프로세스 종료와 같은 상황에서 사용자 상태를 저장하고 복원할 수 있도록 고려해야한다.

개발해본 경험

a activity에서 글들을 보여주고, b activity로 이동하여 에서 글을 작성한 후에 다시 a activity로 돌아왔을때, 새로 작성한 글이 보이지 않았습니다.
그 이유는 서버에서 썼던 글들을 가져오는 함수를 onCreate에서 호출했기 때문입니다.
다시 돌아왔을때, 메모리에 이미 a activity가 존재하여 백그라운드에 있기 때문에 onCreate가 호출되지 않고 onResume부터 호출됩니다.
그래서 함수를 onResume에서 호출해서 해결해줬던 경험이 있습니다.

[angryPodo]

Activity의 생명 주기 (Activity Lifecycle)

Activity는 앱에서 화면을 담당하는 중요한 요소. 이 Activity는 생성되고 종료되기까지 여러 단계를 거치면서 동작하고, 이 과정을 생명 주기라고 부름. 안정적인 앱을 만들려면 이 생명 주기를 잘 이해하는 게 필수임.

주요 생명 주기 단계:

1. onCreate():

   • Activity가 처음 생성될 때 호출됨. 화면 초기화나 데이터 초기 작업을 여기서 함.

2. onStart():

   • 화면이 사용자에게 보여지기 직전에 호출됨. UI 업데이트 같은 작업을 처리함.

3. onResume():

   • 화면이 사용자에게 완전히 보여지고 상호작용이 가능해지는 단계임. 실시간 처리나 애니메이션 같은 걸 여기서 처리함.

4. onPause():

   • Activity가 일시적으로 다른 화면으로 전환되거나, 멈췄을 때 호출됨. 여기서 빠르게 데이터 저장하거나 리소스 정리함.

5. onStop():

   • Activity가 화면에서 완전히 사라질 때 호출됨. 애니메이션 중지, 네트워크 작업 중단 등 리소스 해제를 여기서 처리함.

6. onDestroy():

   • Activity가 완전히 종료될 때 호출됨. 메모리 해제나 비동기 작업 정리 같은 걸 처리함.

7. onRestart():

   • 중지된 Activity가 다시 시작될 때 호출됨. 다시 보여질 준비를 여기서 함.

고려해야 할 사항: 메모리 관리

메모리 누수를 막는 게 정말 중요함. Activity가 종료되거나 화면에서 사라질 때 사용한 리소스나 메모리를 적절하게 해제하지 않으면 메모리 누수가 생길 수 있음. 특히 **onDestroy()**나 **onStop()**에서 사용하던 비동기 작업, 리스너, 애니메이션 등을 꼭 해제해야 함. 그래야 앱이 오래 실행되도 메모리 부족 문제를 피할 수 있음.
평소에도 운동관련 앱을 사용하다가 리프레쉬 당하면 매우 화가 나기 때문에...메모리 관리를 잘해야 한다!

[jm991014]

Activity 생명주기

onCreate(): Activity가 시작(생성)될 때 호출되며, 전체 생명주기 동안 한 번만 수행

onStart(): Activity가 사용자에게 표시되기 직전에 호출, 이 때 상호작용은 불가

onResume(): Activity가 foreground에 표시되어 사용자와 상호작용이 가능

onPause(): Activity가 foreground에서 사라기 직전에 호출, 잠깐의 시간이기에 저장과 같은 작업은 onStop()에서 수행

onStop(): Activity가 완전히 foreground에서 사라질 때 호출, 이 때 리소스 해제 수행

onDestroy(): Activity가 소멸되기 전에 호출

고려해야 할 사항

수행해야 할 작업을 생명주기에 맞게 적절히 배치해야 메모리 누수와 같은 문제가 생기지 않는다.

생명주기를 고려해본 경험

특별히 고려해본 경험은 없던 것 같습니다..! 앞으로 신경써서 개발해보도록 하겠습니다ㅎㅎ

[ThirFir]

1. onCreate()

• 시스템에서 액티비티를 생성할 때 실행되는 것으로, 반드시 구현해야 한다.
• 전체 생명 주기 동안 한 번만 발생해야 하는 기본 앱 시작 로직을 작성한다.

2. onStart()

• 액티비티가 사용자에게 표시되고, 앱은 액티비티를 포그라운드에 보내 상호작용할 수 있도록 준비한다.
• 화면에 진입할 때마다 호출되어야 할 코드를 작성한다.

3. onResume()

• 액티비티가 재개되었을 때 호출된다.
• 이 메서드가 호출된 상태에서 앱이 사용자와 상호작용하고, 앱에서 포커스가 떠날 때까지 앱은 이 상태에 머무른다.

4. onPause()

• 사용자가 액티비티를 떠날 때 첫 번째 신호로 이 메서드가 호출된다.
• 액티비티가 포그라운드에 있지 않게 되었다는 것을 나타낸다

5. onStop()

• 액티비티가 사용자에게 더 이상 표시되지 않을 때 호출된다.
• 예를 들어 새로 시작된 액티비티가 화면 전체를 차지할 경우에 호출된다.

6. onDestroy()

• 액티비티가 소멸되기 전에 호출된다.

고려사항

• 화면 전환이나 멀티 윈도우 모드 진입 등의 동작 시에 액티비티가 재생성되므로 예기치 않게 데이터가 초기화될 수 있습니다. 이런 경우에 데이터가 보존되도록 적절하게 데이터 관리를 하는 것이 중요합니다.
• 적절하게 리소스 할당을 해제해주지 않으면 메모리 누수의 위험이 있습니다.

개발 경험

ViewPager에 스크롤 리스너를 등록했을 때 화면이 포그라운드 상태가 아닐 때 리스너를 해제하도록 설계하여 불필요한 메모리 점유를 줄이고자 했습니다.

[SYAAINN]

Activity의 생명주기
노션 링크

고려할 점
Activity의 생명주기를 고려해야하는 이유 : 안정적인 앱 동작 + 효율적인 리소스 관리 + 메모리 누수 방지
그렇다면 어떤 것을 고려해야 할까?

1. 대응해야할 특정 동작(화면 가로/세로 전환, 앱 백그라운드 전환, 멀티스크린 등)에 관련된 생명주기 파악
2. 백그라운드에서도 계속 돌아가야 하는 작업인지에 대한 판단
3. 그렇다면 -> 사용자에게 어떻게 알릴 것인가
   그렇지 않다면 -> 어떻게 해제할 것인가
4. 메모리 누수가 발생하진 않는지 점검
5. 더 효율적으로 개선할 방안 모색

개발경험
아직 생명주기를 고려한 개발 경험은 없고, 유일하게 관련된 것이라면 화면 가로/세로 전환으로 인한 화면 재생성을 막기 위해 androidManifest 파일에서 screenOrientation을 portrait(세로)만 가능하도록 제어한 적이 있습니다. 추후 프로젝트의 크기가 커지거나 필요성이 느껴진다면 상기 서술한 고려할 점에 따라 고려해보아야 할 것 같습니다!

[hyeeum]

Activity의 생명 주기
onCreate : 시스템이 생성될 때 실행되는 콜백
-> 생명 주기 동안 딱 한 번만 실행된다는 특징이 있다.
onStart : 활동이 시작됨 상태로 전환되면서 실행되는 콜백
-> ex) 이 콜백이 실행되면서 UI가 초기화된다.
onResume : 사용자와 상호작용하는 동안 실행되는 콜백
onPause : 현재의 활동을 일시중지할 때 실행되는 콜백
onStop : 사용자에게 더 이상 표시되지 않을 때 실행되는 콜백
onDestroy : 소멸되기 직전에 실행되는 콜백
-> 모든 리소스를 해제한다는 특징이 있다.
따로 생명 주기를 고려하면서 개발한 적은 없습니다.
하지만 화면 회전이나 사용자가 앱을 사용하는 경우,사용하지 않는 경우 등의 상황에서 생명주기를 적절히 활용해야 가장 최적화된 서비스를 만들 수 있으므로 앞으로 계속 중요하게 여겨야 한다고 생각합니다.

[sayyyho]

생명주기

onCreate(): Activity가 처음 생성될 때 호출됩니다. 초기화 작업을 수행하고, 화면 구성 요소들을 설정합니다. 데이터 초기화나 화면 로직을 설정하는 것이 주된 역할입니다.

onStart(): Activity가 사용자에게 표시되기 직전에 호출됩니다. 사용자에게 보이기 전, 화면 구성이나 리소스 준비를 완료해야 합니다.

onResume(): Activity가 재개되어 사용자와 상호작용할 준비가 되었을 때 호출됩니다. 이 시점에서 앱은 포커스와 인터랙션을 담당하게 됩니다.

onPause(): 사용자가 다른 Activity로 이동하거나, 앱이 일부 가려질 때 호출됩니다. 빠르게 데이터를 저장하거나 필요한 작업을 마무리하는 단계입니다.

onStop(): Activity가 완전히 사용자에게 보이지 않게 되면 호출됩니다. 리소스를 해제하거나 앱이 더 이상 필요하지 않은 데이터를 삭제하는 작업을 수행할 수 있습니다.

onDestroy(): Activity가 완전히 소멸되기 전에 호출됩니다. 이 시점에서 모든 리소스를 해제하고, 종료 전 필요한 마무리 작업을 처리합니다.

고려사항

비동기 작업이나 백그라운드에서 계속 실행되는 리스너는 onStop, onDestroy에서 해제하여 메모리 누수를 방지해야 합니다.

관련 경험

아직 개발 경험은 없습니다. 앞으로 잘 고려하여 경험하고자 합니다.

[chrin05]

Activity의 생명 주기
onCreate(): Activity가 처음 생성될 때 호출되고, UI를 설정하고 초기화 작업을 수행을 함
onStart(): Activity가 화면에 나타나기 직전에 호출되고, 화면이 사용자에게 보이기 시작함
onResume(): Activity가 상호작용 가능한 상태로 진입하는 시점에 호출되고, 사용자가 UI와 상호작용 가능
onPause(): 다른 Activity가 포커스를 가져갈 때 호출됨
onStop(): Activity가 사용자에게 더 이상 보이지 않을 때 호출되고, 백그라운드로 전환된 상태
onRestart(): onStop() 이후 다시 Activity가 화면에 나타나기 직전에 호출됨 (즉, Activity 재시작)
onDestroy(): 앱이 종료되거나 시스템이 메모리 부족으로 Activity를 완전히 종료할 때 호출

고려사항

1. 데이터 저장 및 복원 - 앱이 백그라운드로 전환되었다가 다시 포그라운드로 올 때, 기존 입력 데이터가 보존되어야하는 경우 Activity 생명 주기를 고려하여 상태정보를 저장해야 합니다.
2. 리소스 관리 - 불필요한 리소스를 적절히 해제하여 배터리 소모와 메모리 사용량을 줄여야합니다.

개발경험
1번 화면에서 2번화면으로 넘어가고 2번에서 값을 입력하고, 뒤로가기 또는 finish()하여 1번으로 다시 돌아갔을 때 입력했던 값이 반영되게 하기 위해서 생명주기를 고려하여 api를 호출하는 함수를 onResume()에 두어서 개발했던 것 같습니다.

[0se0]

1. Activity 생명 주기 단계
onCreate(): Activity가 생성될 때 호출되며, 초기화 작업을 수행하는 곳입니다. 뷰를 설정하고 리소스를 로드합니다.
onStart(): Activity가 사용자에게 보이기 시작할 때 호출되며, 아직 사용자와 상호작용할 수 있는 상태는 아닙니다.
onResume(): Activity가 포커스를 얻고 사용자와 상호작용 가능한 상태가 됩니다.
onPause(): Activity가 포커스를 잃거나 화면에서 일부 가려질 때 호출됩니다. 데이터 저장 또는 UI 업데이트를 일시적으로 중지해야 할 시점입니다.
onStop(): Activity가 사용자에게 더 이상 보이지 않을 때 호출됩니다. 리소스 해제와 같은 작업을 여기서 수행합니다.
onDestroy(): Activity가 완전히 종료되기 전에 호출되며, 메모리 누수를 방지하기 위해 리소스를 완전히 정리하는 것이 중요합니다.

2. 생명 주기에서 고려할 사항
데이터 저장 및 복원: 화면 회전 또는 다른 시스템 이벤트로 인해 Activity가 종료되거나 재시작될 때, 상태 데이터를 저장하고 복원하는 것이 중요합니다. 이를 위해 onSaveInstanceState()와 onRestoreInstanceState() 메서드를 활용해 상태를 유지할 수 있습니다.
자원 관리: Activity의 생명 주기에 맞춰 리소스를 적절히 관리하는 것이 중요합니다. 예를 들어, 네트워크 연결, 센서 데이터 수집 등의 리소스는 onPause()에서 일시 중지하고, onResume()에서 다시 시작해야 합니다. 이를 통해 배터리 소모나 메모리 누수를 방지할 수 있습니다.
백그라운드 작업 처리: 앱이 백그라운드로 이동하거나 Activity가 onPause() 상태로 들어가면, 불필요한 작업을 멈추거나 백그라운드 작업을 효율적으로 처리해야 합니다. 특히 네트워크 호출이나 파일 입출력 작업이 비효율적으로 수행될 경우, 사용자 경험에 부정적인 영향을 줄 수 있습니다.
메모리 관리: 리소스 해제와 메모리 누수를 방지하는 것은 중요한 고려 사항입니다. onStop() 또는 onDestroy()에서 리소스를 해제하지 않으면 메모리 누수가 발생해 앱이 느려지거나 비정상 종료될 수 있습니다.

3. 경험 공유
저는 따로 생명주기를 생각해서 구현했다기 보다 이전 xml 개발 시 onCreate(), onDestroy() 만을 주로 사용했던 것 같습니다. 추가적으로 onSaveInstanceState()에서 UI 상태를 저장하고, onRestoreInstanceState()를 사용해 이 상태를 복원하는 방법을 적용하여 사용자 경험을 향상시킬 수 있는 개발을 진행해보고 싶습니다.

[HAJIEUN02]

액티비티와 프래그먼트에 대해 공부한 내용을 노션에 정리해두었습니다.
https://statuesque-newt-c60.notion.site/0abb9e7a5d3049518c8be4caf977579e#f72c0f1201ca43fd929d5050102bf1c1

액티비티는 생명 주기 전체 기간에 걸쳐 상태가 계속 변화합니다. 변화하는 상태에 맞춰 작업을 처리할 때 앱이 비정상적인 종료가 되거나, 계획한 리소스보다 많은 양을 잡아 먹어 제대로 동작하지 않는 일이 발생할 수 있으므로 각 상태마다 콜백 메소드를 통해 분리하여 작업해야 합니다.

xml로 프로젝트를 진행할 때 onDestroy()에서 adapter를 해제하는 과정을 꼭 거쳤습니다. 어댑터가 제대로 해제되지 않아 리소스 낭비가 발생하는 상황을 방지하기 위함이었습니다. 컴포즈에서는 @composable 함수가 뷰가 그려지는 순서나 언제 컴포지션 되는지를 고려하여 개발해야 할 것 같습니다.

[gitsuhyun]

Activity의 생명주기

• onCreate

액티비티가 생성될 때 최초로 실행됨
Layout, View생성 등은 이곳에 구현

단 한번만 수행되는 메소드

• onStart

화면에 보여지기 시작하는 상태
화면에 진입할때마다 실행되어야 하는 작업을 구현

• onResume

화면에 나타나 있고 실행중인 상태
현재 activity가 사용자에게 포커스인 되어있는 상태

• onPause

화면의 일부가 다른 액티비티에 가려짐
현재 activity가 사용자에게 포커스아웃 되어있는 상태

영구적은 data 저장

• onStop

다른 액티비티의 실행으로 완전히 가려짐
홈 키를 누르고 activity를 호출했을때, onRestart가 호출

• onDestroy

액티비티 종료
메모리 부족이 발생하면 스킵될 수 있음

• onRestart

onStop이 호출된 이후 다시 기존 activity로 돌아오는 경우에 호출되는 메소드
onRestart가 호출된 이후 이어서 onStart가 호출

생명주기를 고려해서 개발해 본 경험
지난 프로젝트에서 카카오맵을 구현할 때, 공식문서에서 지도의 라이프사이클에 문제가 생겨 알 수 없는 크래쉬가 발생 방지를 위해 Activity 나 Fragment 의 onResume/onPause 시점에 맞춰 MapView.resume(), MapView.pause() 를 꼭 호출해줘야 한다는 문구를 본 적이 있습니다. 이 때 당시에는 그런가보다 하고 넘어갔지만, 시연 중에 예기치 못한 문제가 발생했을 때 라이프 사이클을 고려하지 못한 것이 문제였는지 고민한 적이 있습니다. 이를 통해 생명주기를 더욱 세심히 고려하여 개발을 진행해야한다는 것을 깨달았습니다.

[yihwanggeun]

1. Activity 생명 주기 단계
   onCreate(): Activity가 처음 생성될 때 호출되고 UI나 초기 로직을 실행합니다!
   onStart(): Activity가 사용자에게 보이기 시작할 때 호출됩니다!
   onResume(): UI가 완전하게 사용자에게 보이는 상태입니다 그리고 사용자가 다른 앱으로 전환하거나 다른 Activity에 의해 가려지고 나서 돌아올 때 다시 실행됩니다!
   onPause(): 사용자가 다른 앱으로 전환하거나 현재의 Activity가 다른 Activity에 의해 가려질 때 호출됩니다!(아주 잠깐)
   onStop(): Activity가 더 이상 사용자에게 보이지 않을 때 호출됩니다 다른 Activity가 완전히 화면을 가릴 때, 홈화면으로 나갈 때 실행됩니다!
   onDestroy(): Activity가 종료될 때 호출되고 이때는 Activity가 완전히 닫히거나 종료될 때 호출됩니다.

2. 고려해야 할 사항
   onStop과 onDestory에서는 이제 더이상 필요하지 않은 리소스를 해제하거나 나 저장되어야 하는 데이터를 꼭 저장을 해야합니다.
   onPause와 onStop에서는 사용자의 진행사항과 데이터를 저장해서 사용자가 다시 돌아왔을 때 이전 상태를 복구할 수 있어야 합니다.

3. 경험 공유
   BenchMark 어플리케이션을 제작한 적이 있는데 의도적으로 반복적인 행동을 해서 핸드폰의 수명을 없애는 것이었어요.
   근데 핸드폰의 사양의 따라서 테스팅이 예상치 못하게 종료되는 경우가 생겼는데 이럴 때 생명주기에서 기록을 하고 다시 복구를 할 수 있게 구현했습니다!

[beom84]

1. Activity 생명주기
   Activity의 생명주기에 대해 공부한 내용을 노션에 정리해두었습니다!
   https://www.notion.so/Android-lifecycle-0ff99c2ffa568020a4f5e841f724a283?pvs=4

2. 생명 주기에서 고려할 사항
   데이터 저장 : 불필요한 데이터가 생기지 않도록 쓰지않는 데이터는 생명주기 부분에서 잘 처리해주는 것이 중요하다고 생각합니다.

[yskim6772]

Activity 생명 주기

1. onCreate() : Activity를 처음 실행시킬 때 한 번만 호출되며, Activity 구현에 필요한 구성 요소를 초기화하고, UI를 구성하는 작업을 한다.
2. onStart() : Activity가 화면에 보여지기 시작할 때 호출되며, Activity가 foreground로 이동하기 전에 필요한 작업을 한다.
3. onResume() : Activity가 사용자와 상호작용을 시작하기 직전에 호출되며, Activity가 포커스를 다시 받았을 때 필요한 작업을 수행하기에 적합하다.
4. onPause() : Activity가 포커스를 잃었을 때 호출되며, Activity가 일시 중지 되기 전 상태를 저장하고, 자원을 해제하는 등의 작업을 수행하기에 적합하다.
5. onStop() : Activity가 더 이상 화면에 보이지 않을 때 호출되며, Activity가 보이지 않을 때 필요 없는 자원을 해제하는 등의 기능을 수행한다.
6. onDestroy() : Activity가 파괴되기 전에 호출되며, 모든 메모리 및 리소스가 해제된다.
7. onRestart() : Activity가 정지된 후 다시 시작하기 전에 호출되며, onStop()이던 action이 재시작되는 단계이다.

고려사항 및 주의할 점

1. Activity가 재생성되는 경우에 데이터가 안전하게 저장되게끔 하는 것이 중요하다고 생각합니다. 화면 회전이나 다크 모드 전환과 같은 액션에도 Activity가 파괴되고 다시 생성되기 때문에, 앱의 상태 및 데이터가 일관되게 유지되게끔 해야 합니다.
2. 비동기 작업을 처리하는 과정에서도 Activity의 생명 주기 상태를 고려하여, 리소스 소모가 필요 이상으로 발생하지 않게끔 주의하는 것도 중요합니다.

[1971123-seongmin]

1. onCreate() : 화면이 생성됨 -> 액티비티가 생성될 때 최초로 호출됨

2. onStart() : 화면에 나타남 -> 액티비티가 사용자에게 표시되기 시작하는 단계

3. onResume() : 현재 실행 중 -> 화면에 완전히 나타나서 실행 중인 상태

4. onPause() : 화면이 가려짐 -> 액티비티(화면)의 일부가 다른 액티비티에의해 가려질 때 호출됨

5. onStop() : 화면이 완전히 가려짐 -> 다른 액티비티의 실행으로 화면이 완전히 가려짐

6. onDestroy() : 완전히 종료됨 -> 액티비티가 완전히 종료됨

7. 경험 공유
   카메라 액티비티에서 메인 액티비티로 되돌아 올 때 화면에 데이터를 유지해야 했는데 onResume()에 값을 유지하는 코드를 넣어서 화면 데이터를 유지해본 경험이 있습니다.

[tunaunnie]

Activity 생명 주기 (Lifecycle)

1. onCreate() : Activity가 처음 생성될 때 호출되며, 초기 설정 및 레이아웃 초기화가 이루어진다.

2. onStart() : Activity가 화면에 표시되기 직전에 호출된다. 사용자가 Activity를 볼 수 있지만, 아직 상호작용할 수 없는 상태이다.

3. onResume() : Activity가 사용자와 상호작용할 수 있는 상태가 된다.

4. onPause() : 다른 Activity가 시작되거나 화면이 꺼질 때 호출된다.

5. onStop() : Activity가 더 이상 화면에 보이지 않을 때 호출된다.
   시스템 리소스가 부족한 경우 메모리를 확보하기 위해 이 시점에서 Activity를 종료할 수 있습니다.

6. onDestroy() : Activity가 완전히 종료되기 직전에 호출되고, 이때 메모리 정리, 리소스 해제 등의 작업이 이루어진다.

7. onRestart() : 일시 중지되었던 Activity가 다시 시작될 때 호출된다.

8. 생명 주기를 고려해 본 경험: 이전에 flutter를 이용해서 앱을 구현했을 때, 화면의 생명 주기를 잘못 고려해서 회원가입 후 메인 화면에서 뒤로가기를 누르면 회원가입까지 다 풀리는 버그를 마주했던 적이 있었습니다ㅎㅎㅜㅜ 이때 경험을 통해서 스크린이 쌓이는 스택을 언제 적절히 비우고 다시 쌓기 시작해야 하는지에 대해 감을 잡을 수 있었습니다!