Android Components

Predict Activity lifecycle callback sequences during launch, backgrounding, configuration change, multi-window use, and process recreation.

Implement and verify transient state restoration across configuration changes and process death using ViewModel, saved instance state, and SavedStateHandle appropriately.

Predict task and back-stack behavior produced by launch modes, document modes, and Intent flags.

Launch external components and return typed results with the Activity Result APIs.

Configure and validate deep links and verified Android App Links.

Implement predictive-back behavior that remains consistent with the Activity and navigation back stacks.

Handle configuration-dependent resources without suppressing necessary Activity recreation.

Implement and test a task-aware entry flow from the launcher, a deep link, and a notification.

Trace a View through measure, layout, draw, and input dispatch to diagnose UI behavior.

Implement a focused custom View with attribute parsing, measurement, drawing, and instance-state handling.

Add accessible semantics, focus behavior, and touch-target support to a custom View.

Distinguish the Fragment lifecycle from the Fragment view lifecycle when collecting data or retaining references.

Execute Fragment transactions while predicting their effects on lifecycle state and the back stack.

Implement type-safe navigation and argument passing between UI destinations.

Deliver one-time results between Fragments without coupling their view lifecycles.

Verify Fragment lifecycle and navigation behavior with FragmentScenario and a test navigation controller.

Explain how composition, recomposition, snapshots, and state reads determine which composables run again.

Hoist Compose state and choose appropriately among remember, rememberSaveable, ViewModel state, and persistent state.

Choose and implement the correct Compose side-effect API for a specified lifecycle-dependent operation.

Collect Kotlin Flow state in Compose with lifecycle awareness.

Embed Compose in a View-based screen and host an Android View inside Compose with correct lifecycle handling.

Diagnose and correct an avoidable recomposition or rendering bottleneck using Compose tooling, stability evidence, and derivedStateOf where appropriate.

Verify Compose state restoration and side-effect behavior across host recreation.

Implement and test accessible Compose semantics, traversal order, and touch targets.

Choose among a started service, foreground service, bound service, WorkManager, and an exact alarm for a specified task.

Implement a foreground service with an appropriate service type, ongoing notification, and safe stop behavior.

Implement a lifecycle-safe local bound service with Binder and identify when a cross-process API requires Messenger or AIDL.

Create constrained, retryable, and chained background work with WorkManager.

Explain how background-execution limits, Doze, App Standby, and process death affect scheduled work.

Test background work under constraint changes, cancellation, retries, and simulated process termination.

Choose and schedule an inexact or exact alarm while accounting for permission and power-management restrictions.

Create PendingIntents with correct identity, mutability, update behavior, and component targeting.

Implement a lifecycle-safe BroadcastReceiver using the correct manifest or context registration model and an appropriate synchronous or goAsync execution strategy.

Secure broadcasts using explicit targeting, package scoping, permissions, and exported settings.

Define a ContentProvider contract with content URIs, MIME types, columns, and operation semantics.

Implement validated and thread-safe ContentProvider query, insert, update, and delete operations over a local data source.

Access provider data through ContentResolver and react to changes with content observers.

Share files securely between apps using FileProvider and temporary URI permissions.

Audit manifest components for exported exposure, intent-filter risks, and least-privilege permission use.

Enforce caller authorization and URI-scoped access in a ContentProvider.

Diagnose component launches, tasks, services, broadcasts, and provider access using Android Studio and adb.

Produce and validate a component-interaction map that remains secure and correct across configuration changes, background restrictions, and process death.

Configure Network Security Config and verify that production traffic follows the intended HTTPS trust policy.

Implement a lifecycle-aware HTTP operation that propagates cancellation and distinguishes cancellation from failure.

Decode a server-sent event stream into a Kotlin Flow while handling partial frames and clean termination.

Persist operation identifiers and progress so interrupted work can resume without duplicating side effects.

Write an instrumentation test for a workflow spanning an Activity and a Worker or Service.

Profile the battery, memory, and network impact of a long-running cross-component workflow.

Interpret provider-neutral LLM responses containing message content, streaming deltas, tool calls, finish reasons, and usage metadata.

Design an Android-to-backend boundary that keeps model credentials and privileged policy enforcement out of the APK.

Model LLM requests and responses with Kotlin DTOs and sealed domain types that isolate provider-specific fields.

Execute a non-streaming LLM request from Android through a Kotlin Ktor gateway and map the result into UI state.

Render streamed LLM deltas incrementally in Compose without blocking the main thread.

Propagate cancellation, timeouts, and retry decisions across the Compose UI, ViewModel, Android network client, and backend.

Validate schema-constrained LLM output before converting it into Kotlin domain objects.

Redact or minimize sensitive Android data before sending model requests or recording diagnostic logs.

Measure prompt and completion token counts with a provider-compatible tokenizer.

Allocate a context budget across instructions, conversation history, retrieved data, tool results, and reserved output.

Record per-turn token usage, latency, and estimated cost for an Android conversation session.

Persist ordered conversation messages and generation metadata in Room and restore them after process death.

Build a sliding-window history policy that preserves required instructions and tool-call dependencies.

Replace older conversation turns with a bounded summary while retaining user constraints and unresolved tasks.

Assemble deduplicated retrieval context with source provenance and a deterministic size limit.

Test a context builder against overflow, missing tool results, stale retrieval data, and concurrent user turns.

Explain the roles of MCP host, client, and server and the lifecycle of capability negotiation, discovery, and invocation.

Choose an MCP transport and deployment topology for local development or a remote production environment.

Implement a schema-described MCP tool with a Kotlin handler and structured error responses.

Expose and retrieve an MCP resource and prompt using a Kotlin MCP framework.

Build a Kotlin MCP client that discovers capabilities, invokes a tool, and validates the returned content.

Mediate Android access to remote MCP servers through an authenticated backend rather than exposing privileged connectivity in the app.

Handle MCP initialization, cancellation, timeout, reconnect, and capability-change events.

Apply authentication, per-tool authorization, input validation, and user confirmation to an MCP deployment.

Implement a bounded LLM tool-calling loop that validates arguments and returns tool results to the model.

Represent an agentic workflow as an explicit state machine with resumable transitions and terminal conditions.

Implement a planner-executor workflow while constraining the plan to available tools and budgets.

Route a request to specialized agents using explicit selection criteria and a fallback path.

Run independent agent tasks concurrently and merge their outputs with deterministic conflict handling.

Define a multi-agent handoff contract containing task state, evidence, provenance, and completion criteria.

Enforce token, time, tool-call, and iteration limits with human approval for sensitive actions.

Implement an Android-facing agent workflow that pauses for permission or confirmation and resumes after lifecycle interruption.

Classify transport, provider, policy, parsing, tool, and orchestration failures into user-visible recovery paths.

Apply bounded retries with exponential backoff and jitter, circuit breaking, and idempotency keys to an LLM operation.

Repair or safely fall back from malformed structured model output without silently accepting invalid data.

Recover a partially completed tool workflow using checkpoints, deduplication, and compensating actions.

Defend an agent workflow against prompt injection, untrusted tool output, and unauthorized capability escalation.

Correlate Android and backend traces containing latency, token usage, model calls, MCP calls, and recovery decisions.

Create a representative evaluation dataset and scoring rubric for an Android LLM feature.

Compare prompt, model, context, and workflow variants and apply explicit quality, latency, cost, and safety release gates.