Android Maps API and Data Sharing

Android provides multiple mechanisms for sharing persistent data between processes: Files (shared via file system or FileProvider), SQLite databases (via ContentProvider), and Android Properties (SharedPreferences - though primarily intra-app, can be made accessible). All three represent valid persistent data storage mechanisms.

A content URI follows the format: content://authority/data_path/id. The authority uniquely identifies the content provider, data_path specifies the type of data, and id (optional) points to a specific record. In the given format, A=authority, B=data_path, and C=id - NOT 'Data_Path' and 'Id Value' as stated. The statement incorrectly capitalizes and presents these as formal names rather than descriptions.

Content providers support multiple modification operations: insert() for adding new records, bulkInsert() for batch insertion, update() for modifying existing records (including batch updates), and delete() for removal. The statement correctly identifies that content providers can be modified by adding records, adding values to existing records, and batch updating.

The statement is FALSE because while column names and order are provider-specific, data types are NOT universal across content providers. Each content provider defines its own schema including column names, data types, and default ordering. There is no common data type convention enforced across all providers.

The ContentProvider abstract class requires implementing: onCreate(), query(), insert(), update(), delete(), and getType(). The statement's options are slightly mixed - 'Create()' is not the exact method name (it's onCreate()), but the key CRUD methods (query, update, insert) are correct abstract methods. Option F correctly identifies query(), update(), and insert() as abstract methods.

MapView is the Android widget class that displays the actual map tiles and provides the visual map surface. MapActivity is the Activity base class for hosting maps, MapController provides programmatic control over the map, and Overlay allows drawing on top of the map. MapView is the correct answer for the View that displays the map.

Overlays in Android Maps API allow you to draw graphical layers on top of a MapView. You can create custom overlays by extending the Overlay class to display items like markers, shapes, routes, or other visual elements. The MyLocationOverlay is a specific built-in overlay for showing device position.

When a user enters touch mode (by touching the screen), any currently focused widget loses focus. In touch mode, widgets don't maintain focus states since touch interaction doesn't use focus navigation like keyboard or trackball input. The focus system is primarily for non-touch input methods.

MyLocationOverlay is a built-in Android Maps overlay class that displays the user's current location and orientation on the map. It shows a compass indicator for direction and can animate to the current position. This is the correct native overlay for location display.

MapActivity is the base Activity class that provides access to a MapView. When you extend MapActivity, you can call getMapView() or access the map through layout inflation. The Activity hosts the map and provides the context in which the MapView operates. MapController is for controlling the map, Overlay is for drawing on it, but MapActivity provides the MapView itself.

The Google Maps library is NOT part of the standard Android SDK - it's an optional add-on library that must be explicitly declared in AndroidManifest.xml using the tag. This declaration tells the system that the app requires the Google Maps API to function. Without this declaration, the app won't have access to Maps classes.

LocationProvider is the abstract superclass for all location providers (GPS, Network, Passive) that deliver location information. It defines the common interface and behavior that specific provider implementations must follow.

GeoPoint represents a geographical position on a map using integer values for latitude and longitude in microdegrees. It's the fundamental class used in Android Maps API to mark specific coordinates.

While threads do have integer priorities (1-10), priority is only a hint to the thread scheduler. The actual CPU time allocation depends on many factors including scheduler policy, system load, and thread state. Priority doesn't guarantee proportional CPU time.

You CAN add multiple overlays to a single map. Android Maps API supports adding multiple overlay items (like markers, polygons, circles) using ItemizedOverlay, Overlay, or by implementing the Overlay interface. Each overlay can contain multiple items.

In Java virtual machines, multiple threads running within the same application share the heap memory and can interact and synchronize access using shared object monitors and synchronization blocks.

Accessing map tiles over the network requires internet connectivity, which in Android necessitates declaring the internet permission inside the application manifest file.