I'm creating this repository after getting rejected from ShareChat
App components are the essential building blocks of an Android app. Each component is an entry point through which the system or a user can enter your app. There are four different types of app components :
- Activities - An activity is the entry point for interacting with the user. It represents a single screen with a user interface.
- Services - A service is a general-purpose entry point for keeping an app running in the background for all kinds of reasons. It is a component that runs in the background to perform long-running operations or to perform work for remote processes.
- Broadcast receivers - A broadcast receiver is a component that enables the system to deliver events to the app outside of a regular user flow, allowing the app to respond to system-wide broadcast announcements.
- Content providers - A content provider manages a shared set of app data that you can store in the file system, in a SQLite database, on the web, or on any other persistent storage location that your app can access.
An activity provides the window in which the app draws its UI. This window typically fills the screen, but may be smaller than the screen and float on top of other windows. Generally, one activity implements one screen in an app. For instance, one of an app’s activities may implement a Preferences screen, while another activity implements a Select Photo screen.
| Method | Called When |
|---|---|
| onCreate() | Activity is first created. |
| onStart() | Activity is becoming visible to the user. |
| onResume() | Activity will start interacting with the user. |
| onPause() | Activity is not interactable to the user. |
| onStop() | Activity is no longer visible to the user. |
| onRestart() | After activity is stopped, prior to start. |
| onDestroy() | Before activity is destroyed. |
*Note - The onCreate() and onDestroy() methods are called only once throughout the activity lifecycle.
onCreate()
onStart()
onResume()Here A == first activity and B == second activity
onPause() - (A)
onCreate() - (B)
onStart() - (B)
onResume() - (B)
onStop() - (A)onPause() - (B)
onRestart() - (A)
onStart() - (A)
onResume() - (A)
onStop() - (B)
onDestroy() - (B)onStart() -> called when the activity becomes visible, but might not be in the foreground (e.g. an AlertFragment is on top or any other possible use case).
onResume() -> called when the activity is in the foreground, or the user can interact with the Activity.
onPause() -> If you can still see any part of it (Activity coming to foreground either doesn't occupy the whole screen, or it is somewhat transparent).
onStop() -> If you cannot see any part of it
A dialog, for example, may not cover the entire previous Activity, and this would be a time for onPause() to be called
- Using base classes: Causes the tight coupling
- Putting all dependencies in AppModule: Hard to read and during testing, we can't get the specific module
- Using one activity per screen: Activity is heavy as it uses intent to open which internally talks to the android system and the fragment is similar to displaying a layout.
- Hardcoding dispatchers: It forces the coroutine to use the particular dispatcher whereas in testing we need to pass the test dispatcher.
- Using GlobalScope: Its keeps running during the application process and doesn't care about the lifecycle of the component which causes memory leak or dead object exception.
Thanks to Philipp Lackner for making a video on this - Link
- Singleton
- Factory
- Builder
- Facade
- Dependency Injection
- Adapter
Thanks to Philipp Lackner for making a video on this - Link
S - Single-responsiblity Principle
O - Open-closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle
Summary: We can say that the Single Responsibility Principle is about actors and high level architecture. The Open/Closed Principle is about class design and feature extensions. The Liskov Substitution Principle is about subtyping and inheritance. The Interface Segregation Principle (ISP) is about business logic to clients communication. And the Dependency Inversion Principale (DIP) is about leads or helps us respect all the other principles.
Thanks to Abderrazak Laanaya for writing a article on this - Link
- Tell me about Jetpack Libraries
- Why shoud we use an app architecture and what are the best practices? read
- What are Services, Broadcast receivers and Content providers? read
- Tell me about the Manifest file, what is it's role? read
- Difference between const and val? - val variable is initialized at runtime and const at compile time. Read more here
- Diffrence between sp and dp - sp is same as dp, just android resizes it based on font size set by user.
- What are diffrent Launch modes in android? read
- What are implicit and explicit intents? read
- What makes kotlin the best language for native development? read
- Explain the internal working of a RecyclerView. read
- On which thread would you update the UI components?- Main thread.
- What are companion objects? read
- Fragment lifecycle read
- What are the diffrences between MVVM, MVC and MVP? read
- How would you implement DI in your preferred architechure.
- How is Interface useful in your architechure.
- How to interact with other apps? read
- How to use vibration in our app? read
- Tell me about Dependency Injection
- What is NDK and why is it used?read
- What is the diffrence between .apk and .aab? read
- What is databinding? read
- What is a multi-modular app? read
- What is KAPT? read
- What is Diamond problem in Java? read
- Basics of oops classes, inheritance, encapsulation, polymorphism and all of that stuff
- Basic Data sturctures knowledge and problem solving skills
- Basics of Database (eg SQL)
- Basic Operating System knowledge (eg. Threads, cpu scheduling)
- Basic Computer Science curriculum knowledge
- Design patterns
- Standard library functions of Java/Kotlin
- Major Views and how to load data in them
- Internal Working of Activities, Tasks & Stacks