20+ Armstrong International Interview Questions and Answers

The view is attached to the Fragment during the onAttach() lifecycle event.

• The onAttach() method is called when the Fragment is associated with its host Activity.

• This is the first lifecycle method called after the Fragment is created.

• The onAttach() method receives the Activity as a parameter, allowing the Fragment to interact with its host.

To set a view in the middle in ConstraintLayout, use layout_constraintStart_toStartOf, layout_constraintEnd_toEndOf, layout_constraintTop_toTopOf, and layout_constraintBottom_toBottomOf attributes.

• Use layout_constraintStart_toStartOf and layout_constraintEnd_toEndOf to align horizontally in the middle.

• Use layout_constraintTop_toTopOf and layout_constraintBottom_toBottomOf to align vertically in the middle.

• Set both horizontal and vertical constraints to center the view.

The components of an Android app include activities, services, broadcast receivers, and content providers.

• Activities: UI components that represent a single screen with a user interface.

• Services: Background tasks that run independently of the UI.

• Broadcast Receivers: Respond to system-wide broadcast announcements.

• Content Providers: Manage a shared set of app data.

Yes, I have experience working with ViewPager2 and ListAdapter.

• Implemented ViewPager2 to create swipeable screens in Android apps.

• Utilized ListAdapter to efficiently manage data for RecyclerViews.

• Used ListAdapter's DiffUtil to efficiently update RecyclerView items.

Syntax for HashMap in Kotlin and Java with values.

• In Kotlin:

• val hashMap = hashMapOf<String, Int>()

• hashMap.put("key1", 1)

• hashMap.put("key2", 2)

• In Java:

• HashMap<String, Integer> hashMap = new HashMap<>();

• hashMap.put("key1", 1);

• hashMap.put("key2", 2);

Yes, an activity can exist without a view in Android.

• An activity can perform background tasks without displaying any UI elements.

• For example, a music player app may have an activity to handle playback controls in the background.

• Activities without views are commonly used for tasks like data processing, network operations, or service handling.

Use runOnUiThread or withContext(Dispatchers.Main) to update UI in coroutine scope.

• Use runOnUiThread to update UI from a background thread.

• Use withContext(Dispatchers.Main) to switch to the main thread in coroutine scope.

• Example: runOnUiThread { textView.text = "Updated text" }

• Example: withContext(Dispatchers.Main) { textView.text = "Updated text" }

Data can be sent between two activities in Android using Intent with putExtra() method.

• Create an Intent object in the sending activity

• Use putExtra() method to add data to the Intent

• Start the second activity with startActivity() method, passing the Intent

• Retrieve the data in the receiving activity using getIntent() and getExtra()

Hot and Cold Flow is a design pattern used in Android development to manage the flow of data between components.

• Hot Flow refers to the flow of data that is actively being observed and updated in real-time.

• Cold Flow refers to the flow of data that is not actively being observed and updated, but can be retrieved when needed.

• Hot Flow is typically used for real-time updates, while Cold Flow is used for fetching data on demand.

Hashcode is a unique identifier for an object, equals() compares the content of two objects, and == checks if two references point to the same object.

• Hashcode is an integer value generated by a hashing algorithm to uniquely identify an object.

• equals() method is used to compare the content of two objects for equality.

• == operator checks if two references point to the same object in memory.

• Example: String class overrides equals() method to compare the content of two strings, whi...read more

Activity is a single focused thing that user can do, while Fragment is a modular section of an activity.

• Activity represents a single screen with a user interface, while Fragment represents a behavior or a portion of user interface in an Activity.

• An Activity can contain multiple Fragments, but a Fragment cannot exist independently without an Activity.

• Fragments have their own lifecycle, while they are dependent on the lifecycle of the Activity they are attached to.

• Fragments are...read more

A broadcast receiver is an Android component that allows the system to deliver events or messages to the app.

• Broadcast receivers can be used to listen for system-wide broadcast announcements, such as when the device is booted or when the battery is low.

• They can also be used to receive custom broadcast messages sent by other apps or components within the same app.

• Broadcast receivers are registered in the AndroidManifest.xml file or dynamically in code using the registerReceive...read more

Pagination in Android can be achieved by using libraries like Paging Library or implementing custom pagination logic.

• Use Paging Library provided by Android Architecture Components

• Implement custom pagination logic by loading data in chunks

• Update RecyclerView adapter with new data as user scrolls

A suspend function is a function that can be paused and resumed at a later time without blocking the main thread.

• Suspend functions are used in Kotlin coroutines to perform asynchronous operations.

• They are defined using the 'suspend' keyword in the function signature.

• Suspend functions can only be called from within another suspend function or a coroutine builder like 'launch' or 'async'.

Coroutines in Android can be launched using the 'launch' function from the CoroutineScope.

• Use the 'launch' function from the CoroutineScope to start a coroutine.

• Specify the context in which the coroutine should run, such as Dispatchers.Main for the main thread.

• Handle exceptions within the coroutine using try-catch blocks.

• Example: CoroutineScope(Dispatchers.Main).launch { // coroutine code here }

Sealed classes are used to restrict inheritance in Kotlin, allowing a class to have a fixed set of subclasses.

• Sealed classes are declared using the 'sealed' keyword.

• They can only be extended within the same file where they are declared.

• Sealed classes are often used in conjunction with when expressions for exhaustive checking.

I have worked on various layouts including linear, relative, grid, and constraint layouts.

• Implemented linear layouts to arrange views in a single column or row.

• Utilized relative layouts to position views relative to each other.

• Used grid layouts for displaying data in a grid-like structure.

• Implemented constraint layouts for creating complex and flexible UI designs.

Databinding is a feature that allows you to bind UI components in your layout to data sources in your app.

• Databinding eliminates the need for boilerplate code to update UI components with data.

• It allows for easier communication between UI components and data sources.

• Databinding can improve code readability and maintainability.

• Example: Binding a TextView directly to a ViewModel property in an Android app.

Back stack is a stack of activities in Android that keeps track of the navigation history.

• Back stack is managed by the Android system to handle the navigation flow of activities.

• When a new activity is started, it is pushed onto the back stack.

• Pressing the back button pops the top activity off the stack and navigates to the previous activity.

• Activities in the back stack can be brought to the foreground by using the appropriate navigation methods.

Let and apply are scoped functions in Kotlin used for executing a block of code on an object.

• Let function is used to execute a block of code on a non-null object and return the result.

• Apply function is used to initialize an object and perform operations on it without explicitly returning a value.

HashMap is unordered, LinkedHashMap maintains insertion order.

• HashMap does not maintain insertion order, LinkedHashMap maintains insertion order.

• HashMap allows one null key and multiple null values, LinkedHashMap allows one null key and multiple null values.

• HashMap is faster for iteration, LinkedHashMap is slower due to maintaining order.

RecyclerView is more efficient for displaying large datasets and supports various layout managers, while ListView is simpler and easier to implement.

• RecyclerView is more efficient for displaying large datasets as it only creates enough views to fill the screen, while ListView creates all views at once.

• RecyclerView supports various layout managers like LinearLayoutManager, GridLayoutManager, and StaggeredGridLayoutManager, allowing for more complex layouts.

• RecyclerView has bui...read more

LateInit is used for non-nullable properties that are initialized later, while Lazy is used for properties that are initialized only once when accessed.

• LateInit is used for non-nullable properties that are initialized later in the code.

• Lazy is used for properties that are initialized only once when accessed, making it suitable for expensive operations.

• LateInit properties must be initialized before accessing, while Lazy properties are initialized only when accessed.