Web-Based Practice Test Software - ExamsNest

ExamsNest

Home All Exams My Account Contact

Home All Exams My Account Contact

Buy Full Access

Android AND-801 Demo Practice Test

Time limit: 0

Quiz-summary

0 of 10 questions completed

Questions:

1
2
3
4
5
6
7
8
9
10

Information

Pass your Android AND-801 Exam Today!

You have already completed the quiz before. Hence you can not start it again.

Quiz is loading...

You must sign in or sign up to start the quiz.

You have to finish following quiz, to start this quiz:

Results

0 of 10 questions answered correctly

Your time:

Time has elapsed

You have reached 0 of 0 points, (0)

Average score
Your score

Categories

Not categorized 0%

Press the View Answers button to see the Correct Answers

1
2
3
4
5
6
7
8
9
10

Answered
Review

Question 1 of 10

1. Question
You’re working on a feature that requires a user to grant location permission only while the app is in use. During testing, you notice that on some older devices, the permission dialog still asks for ‘Allow all the time’ as an option, which contradicts your app’s privacy policy. What’s the most likely cause of this behavior, and how should you address it to ensure the correct permission request is shown?
- The device is running a version of Android that doesn't support the 'While in use' permission level. You must check the OS version and handle the legacy behavior in your code.
- You are using the wrong permission constant in your manifest. Replace `ACCESS_FINE_LOCATION` with `ACCESS_COARSE_LOCATION`.
- The `targetSdkVersion` in your app's build.gradle file is set to a version lower than Android 10 (API 29). You need to update it to at least 29.
- The user has previously denied the permission request. You need to guide the user to manually change the permission in system settings before requesting it again.
Correct

The ‘Allow only while using the app’ (foreground-only) location permission was introduced in Android 10 (API 29). If your app’s `targetSdkVersion` is below 29, the system will present the legacy permission dialog, which includes the ‘Allow all the time’ option. Updating `targetSdkVersion` to 29 or higher ensures the system uses the new, scoped permission model.

Incorrect

The ‘Allow only while using the app’ (foreground-only) location permission was introduced in Android 10 (API 29). If your app’s `targetSdkVersion` is below 29, the system will present the legacy permission dialog, which includes the ‘Allow all the time’ option. Updating `targetSdkVersion` to 29 or higher ensures the system uses the new, scoped permission model.
Question 2 of 10

2. Question
Imagine your team is implementing a new login screen. A colleague suggests storing the user’s authentication token in `SharedPreferences` for simplicity. While this works, you’re concerned about security. What is the most significant security risk of this approach, and what is a more secure alternative you should recommend?
- The token is vulnerable to loss if the app is uninstalled. The alternative is to use a local SQLite database.
- The token is stored in plain text and is easily accessible to any other app on the device. The alternative is to use the `AndroidKeystore` system to encrypt the token before storage.
- `SharedPreferences` files are cleared during a system update. The alternative is to store the token in a remote server cache.
- Reading from `SharedPreferences` is a slow, blocking operation that can cause ANRs. The alternative is to use `DataStore` for its coroutines support.
Correct

`SharedPreferences` are not designed for secure storage. They are stored as an unencrypted XML file in the app’s data directory, which, on a rooted device, can be read by other apps or users. The `AndroidKeystore` system provides a hardware-backed secure container for generating and storing cryptographic keys, which can then be used to encrypt sensitive data like tokens before storing them.

Incorrect

`SharedPreferences` are not designed for secure storage. They are stored as an unencrypted XML file in the app’s data directory, which, on a rooted device, can be read by other apps or users. The `AndroidKeystore` system provides a hardware-backed secure container for generating and storing cryptographic keys, which can then be used to encrypt sensitive data like tokens before storing them.
Question 3 of 10

3. Question
Your app needs to perform a long-running network operation to sync user data. You’ve implemented this in a `ViewModel` using a Kotlin coroutine launched with `viewModelScope.launch`. During testing, you rotate the device and notice the network call is restarted, causing duplicate data. What is the fundamental issue, and what coroutine builder should you use within `viewModelScope` to prevent this?
- The issue is that `viewModelScope` is cancelled on configuration changes. You should use `GlobalScope.launch` instead.
- The issue is that the coroutine is launched in the wrong context. You should use `lifecycleScope.launch` in your Activity.
- The issue is that the coroutine is not surviving the configuration change. You should use `viewModelScope.launch` with a `SupervisorJob`.
- The issue is that the coroutine is using a non-cancellable context. You should use `viewModelScope.launch` with `Dispatchers.IO`.
Correct

`viewModelScope` is automatically cancelled when the `ViewModel` is cleared (when the associated Activity/Fragment is finished). However, during a configuration change like rotation, the `ViewModel` is retained, but the `viewModelScope` is cancelled and a new one is created. This cancels the ongoing network coroutine. To have a coroutine survive configuration changes, you must use a scope that is not tied to the `ViewModel`’s lifecycle, such as a custom scope or `GlobalScope` (though the latter requires careful management to avoid leaks). A better pattern is to use a persistent work manager like `WorkManager` for such tasks.

Incorrect

`viewModelScope` is automatically cancelled when the `ViewModel` is cleared (when the associated Activity/Fragment is finished). However, during a configuration change like rotation, the `ViewModel` is retained, but the `viewModelScope` is cancelled and a new one is created. This cancels the ongoing network coroutine. To have a coroutine survive configuration changes, you must use a scope that is not tied to the `ViewModel`’s lifecycle, such as a custom scope or `GlobalScope` (though the latter requires careful management to avoid leaks). A better pattern is to use a persistent work manager like `WorkManager` for such tasks.
Question 4 of 10

4. Question
A user reports that after accepting a software update on their device, your app crashes immediately on launch. You check the crash logs and see a `SecurityException` related to `android.permission.REQUEST_INSTALL_PACKAGES`. Your app uses this permission to prompt for updates. What is the most probable reason for this new crash?
- The user manually revoked the permission in Settings. You need to catch the `SecurityException` and re-request the permission.
- Starting with Android 11 (API 30), apps cannot request the `REQUEST_INSTALL_PACKAGES` permission at runtime; it must be declared and granted differently.
- The permission is now a signature-level permission. You must sign your app with the same key as the system to use it.
- The crash log is misleading; the real issue is a missing `` tag in the `AndroidManifest.xml`. You should add it and release a new update.
Correct

In Android 11 (API 30) and higher, the `REQUEST_INSTALL_PACKAGES` permission behavior changed. Apps targeting API 30+ that need to request app installs must declare the permission in the manifest, but they can no longer request it via `ActivityCompat.requestPermissions`. Instead, you must guide the user to enable “Allow from this source” in the system settings for your app, typically by using an `Intent` to open the app’s specific settings page. Your code must handle the absence of this permission gracefully.

Incorrect

In Android 11 (API 30) and higher, the `REQUEST_INSTALL_PACKAGES` permission behavior changed. Apps targeting API 30+ that need to request app installs must declare the permission in the manifest, but they can no longer request it via `ActivityCompat.requestPermissions`. Instead, you must guide the user to enable “Allow from this source” in the system settings for your app, typically by using an `Intent` to open the app’s specific settings page. Your code must handle the absence of this permission gracefully.
Question 5 of 10

5. Question
You are designing the architecture for a new app and want to ensure your UI state is always consistent with your data source, even after configuration changes. You decide to use a `StateFlow` in your `ViewModel` to expose UI state. What is the key advantage of using `StateFlow` over a standard `LiveData` object for this specific purpose?
- `StateFlow` is part of the AndroidX libraries, while `LiveData` is not, making `StateFlow` more future-proof.
- `StateFlow` requires less boilerplate code and automatically manages lifecycle awareness without an observer.
- `StateFlow` always holds and replays the latest state value to new collectors, ensuring the UI has the most recent data immediately upon subscription, even after recreation.
- `StateFlow` can be collected from any thread safely, whereas `LiveData` must be observed on the main thread.
Correct

The primary advantage of `StateFlow` in this scenario is its **state-holding** characteristic. It stores the last emitted value. When a new UI component (like a recreated Fragment) starts collecting from the `StateFlow`, it immediately receives the latest state, ensuring the UI is restored correctly. While `LiveData` also does this when observed with a `LifecycleOwner`, `StateFlow` provides a more consistent and coroutine-integrated API within a Kotlin-first codebase.

Incorrect

The primary advantage of `StateFlow` in this scenario is its **state-holding** characteristic. It stores the last emitted value. When a new UI component (like a recreated Fragment) starts collecting from the `StateFlow`, it immediately receives the latest state, ensuring the UI is restored correctly. While `LiveData` also does this when observed with a `LifecycleOwner`, `StateFlow` provides a more consistent and coroutine-integrated API within a Kotlin-first codebase.
Question 6 of 10

6. Question
Your app uses WorkManager to schedule a daily data backup. You’ve configured a `UniqueWorkRequest` with `ExistingWorkPolicy.REPLACE`. You notice that sometimes, if the user opens the app while a backup is running, a second backup worker starts, leading to conflicts. Why is this happening despite using the `REPLACE` policy?
- `ExistingWorkPolicy.REPLACE` only applies to **pending** work. It cannot cancel work that is already in a `RUNNING` state.
- WorkManager requires the `android.permission.SCHEDULE_EXACT_ALARM` permission to properly manage unique work, which you have not declared.
- You are enqueuing the work request from the main thread. You must use `WorkManager.getInstance(context).enqueue(request)` within a coroutine or background thread.
- The conflict is due to device Doze mode. You need to use an `Exact` periodic work request instead of a flexible one.
Correct

The `ExistingWorkPolicy.REPLACE` policy cancels any existing work with the same unique name **only if it is not already in a `RUNNING` state**. If the previous work request has already started execution (its `doWork()` method is running), the `REPLACE` policy will not stop it. Instead, it will schedule the new request to run after the currently running one finishes, which can lead to the observed overlap. To prevent this, you need to implement your own logic within the worker to check for concurrent execution or use a different work chaining strategy.

Incorrect

The `ExistingWorkPolicy.REPLACE` policy cancels any existing work with the same unique name **only if it is not already in a `RUNNING` state**. If the previous work request has already started execution (its `doWork()` method is running), the `REPLACE` policy will not stop it. Instead, it will schedule the new request to run after the currently running one finishes, which can lead to the observed overlap. To prevent this, you need to implement your own logic within the worker to check for concurrent execution or use a different work chaining strategy.
Question 7 of 10

7. Question
While reviewing your app’s memory usage with the Memory Profiler, you see a steady increase in the number of `Bitmap` objects that never seem to be garbage collected, even after the `Activity` that displayed them is destroyed. The `Activity` uses a `RecyclerView` to display a grid of images. What is the most common cause of this kind of memory leak in this context?
- The `Bitmap` objects are stored in a static field or a long-lived singleton, preventing the Garbage Collector from reclaiming them.
- The `RecyclerView.Adapter` is holding references to the bitmaps. You must call `adapter.clear()` in the `Activity's onDestroy()`.
- The images are being loaded on the main thread, which creates a memory leak due to the UI thread's Looper holding references.
- The `RecyclerView` is not using `setHasFixedSize(true)`, causing it to measure its contents incorrectly and hold onto bitmaps.
Correct

The classic cause of bitmap memory leaks is holding references in a context with a longer lifecycle than the UI component that needs them. Common culprits are static fields, singleton repositories, or misconfigured caching libraries that retain references beyond the lifecycle of the `Activity` or `Fragment`. When the `Activity` is destroyed, these long-lived references prevent the bitmaps (which are large memory objects) from being garbage collected.

Incorrect

The classic cause of bitmap memory leaks is holding references in a context with a longer lifecycle than the UI component that needs them. Common culprits are static fields, singleton repositories, or misconfigured caching libraries that retain references beyond the lifecycle of the `Activity` or `Fragment`. When the `Activity` is destroyed, these long-lived references prevent the bitmaps (which are large memory objects) from being garbage collected.
Question 8 of 10

8. Question
You are implementing deep linking in your app. A user clicks a link like `https://yourapp.com/products/123` in their email. The link opens your app, but instead of navigating to the product detail screen for ID ‘123’, it always opens the app’s home screen. Your intent filter in the manifest appears correct. What is the most crucial step you must perform in your `Activity’s onCreate()` or `onNewIntent()` to handle the incoming deep link data correctly?
- Check if the `Intent` action is `Intent.ACTION_VIEW` and then extract the data URI using `intent.data`.
- Call `intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)` to ensure the deep link starts a new task.
- Use `PackageManager.getLaunchIntentForPackage()` to get the correct launcher intent first.
- Check for the presence of the `Intent.EXTRA_STREAM` extra, which contains the deep link URL.
Correct

When an `Activity` is launched via a deep link, the system delivers an `Intent` with the action `Intent.ACTION_VIEW`. The actual URL that was clicked is contained within the `Intent`’s `data` property (a `Uri` object). The primary task of your launch `Activity` is to inspect `intent.action` and `intent.data`, parse the URI (e.g., extract the path and product ID ‘123’), and then route the user to the appropriate destination within your app. Failing to do this check will result in the app launching via its default launcher behavior (the home screen).

Incorrect

When an `Activity` is launched via a deep link, the system delivers an `Intent` with the action `Intent.ACTION_VIEW`. The actual URL that was clicked is contained within the `Intent`’s `data` property (a `Uri` object). The primary task of your launch `Activity` is to inspect `intent.action` and `intent.data`, parse the URI (e.g., extract the path and product ID ‘123’), and then route the user to the appropriate destination within your app. Failing to do this check will result in the app launching via its default launcher behavior (the home screen).
Question 9 of 10

9. Question
Your app has a service that plays audio in the background. You’ve created a foreground service with a notification to comply with Android 8.0+ requirements. However, on some devices running Android 12+, the service is being stopped by the system after a short time, and the user sees a message about an app using battery in the background. What additional step must you take for long-running foreground services on Android 12?
- You must declare a new permission, `android.permission.SCHEDULE_EXACT_ALARM`, in your manifest.
- You must call `Service.startForeground()` twice: once immediately and again after a 10-second delay.
- You must request the user's approval for long-running background activity by calling a specific system API before starting the service.
- Foreground services are no longer allowed for media playback on Android 12. You must switch to using `MediaSession` with a `MediaBrowserService`.
Correct

Android 12 introduced a new restriction for long-running foreground services. If your app targets Android 12 (API 31) or higher and starts a foreground service while the app is in the background, the system delays service creation for several seconds and may display a warning to the user. To avoid this, you must request the `SCHEDULE_EXACT_ALARM` permission (for precise alarms) or, more relevantly, you can start the service from a user-initiated action or use a WorkManager task for deferrable work. For unavoidable long-running tasks, you may need to guide the user to grant special app access in battery settings, though this is not a direct API call.

Incorrect

Android 12 introduced a new restriction for long-running foreground services. If your app targets Android 12 (API 31) or higher and starts a foreground service while the app is in the background, the system delays service creation for several seconds and may display a warning to the user. To avoid this, you must request the `SCHEDULE_EXACT_ALARM` permission (for precise alarms) or, more relevantly, you can start the service from a user-initiated action or use a WorkManager task for deferrable work. For unavoidable long-running tasks, you may need to guide the user to grant special app access in battery settings, though this is not a direct API call.
Question 10 of 10

10. Question
You’re working on a feature that requires a user to grant location permission only while the app is in use. During testing, you notice that on some older devices, the permission dialog still asks for ‘Allow all the time’ as an option, which contradicts your app’s privacy policy. What’s the most likely cause of this behavior, and how should you address it to ensure the correct permission request is shown?0
- Use the Repository pattern and then employ mocking in your tests to provide a fake implementation of the repository that returns predefined data.
- Use the Singleton pattern for your repository and reset its state in the `@Before` test method.
- Use a local emulator with no internet connection to physically block network calls during instrumented tests.
- Use the Strategy pattern and create a separate 'TestNetworkStrategy' class that you compile only for your test builds.
Correct

The ‘Allow only while using the app’ (foreground-only) location permission was introduced in Android 10 (API 29). If your app’s `targetSdkVersion` is below 29, the system will present the legacy permission dialog, which includes the ‘Allow all the time’ option. Updating `targetSdkVersion` to 29 or higher ensures the system uses the new, scoped permission model.0

Incorrect

The ‘Allow only while using the app’ (foreground-only) location permission was introduced in Android 10 (API 29). If your app’s `targetSdkVersion` is below 29, the system will present the legacy permission dialog, which includes the ‘Allow all the time’ option. Updating `targetSdkVersion` to 29 or higher ensures the system uses the new, scoped permission model.0

ExamsNest

Your trusted source for certification exam preparation with a 98% first-time pass rate among our users. Empowering professionals worldwide with up-to-date practice tests and expert-crafted study materials for guaranteed success.

Quick Links

Home All Exams My Account Success Stories

Support

Contact Us FAQs Privacy Policy Guarantee and Refund

© 2025 ExamsNest. All rights reserved.

ExamsNest is not affiliated with (or Endorsed by) PECB, SAP SE, CompTIA, Cisco, or Amazon in any way.
All Trademarks, Service Marks, Trade Names, Product Names And Logos appearing On The site Are the property of their Respective Owners.

Scroll to Top