Kotlin App Development
Senior native Android engineers. Production Kotlin apps. Google Play delivery without cross-platform trade-offs.
Cross-platform frameworks reach most of the Android SDK. Kotlin reaches all of it. When your Android application requires deep integration with hardware APIs, manufacturer-specific device capabilities, Android system services, background processing that survives device restarts, or custom Android launchers and overlays, native Kotlin app development is the only engineering approach that delivers it without a workaround. NextEnvision builds native Kotlin Android applications for businesses and agencies in Australia, the United Kingdom and Singapore. Jetpack Compose UI, coroutine-based async architecture, full Android Jetpack component library, and Google Play submission on every engagement. Kotlin app development at the depth the Android platform demands.
Why Kotlin Became the Language of Android App Development
Google declared Kotlin a first-class language for Android app development at Google I/O 2017. By 2019, Kotlin was declared the preferred language for Android, with the Android Jetpack libraries and all new Google sample code written in Kotlin rather than Java. By 2024, the majority of new Android applications submitted to Google Play were written in Kotlin, and Google’s own first-party Android applications including Google Maps, Google Home and Google Drive had been fully or substantially rewritten in Kotlin. The adoption is not coincidental. Kotlin solves the most persistent problems in Java-based Android app development with language-level mechanisms rather than library workarounds. Null safety is enforced at compile time rather than producing NullPointerExceptions at runtime, which is the most common source of Android app crashes in Java codebases. Kotlin coroutines provide structured concurrency for asynchronous Android app development that replaces AsyncTask, RxJava and callback chains with sequential-reading code that compiles to efficient non-blocking execution on Android’s threading model. Extension functions allow adding behaviour to Android framework classes without inheritance, reducing the boilerplate that Java Android app development required for every SDK interaction. Data classes with auto-generated equals, hashCode and copy functions eliminate the hundreds of lines of boilerplate that Java Android app development required for model objects. Sealed classes with exhaustive when expressions make state modelling in Android app development explicit and compiler-checked rather than implicit and prone to unhandled cases. Kotlin is not an improvement on Java for Android app development in the sense that a faster car is an improvement on a slower one. It is a different engineering approach that produces Android applications with fewer crash vectors, more maintainable async architecture, and less boilerplate to read and maintain over the lifetime of the Android product.
Kotlin App Development Services
Six native Android engineering capabilities. Kotlin from greenfield to migration to maintenance. Google Play delivery on every engagement.
Native Android App Development in Kotlin
We build native Android applications in Kotlin from first principles: architecture decisions using MVVM or MVI with Android Jetpack components, Jetpack Compose UI with a custom design system implementing your brand specification, coroutine-based async architecture for network, database and file operations, Room database for structured local persistence, Retrofit or Ktor for backend API integration, and full Google Play submission including metadata, screenshots, data safety form and content rating. Every native Kotlin Android app development engagement begins with a paid architecture phase that documents the technology decisions and their rationale before a line of Kotlin is written. We deliver Android applications that pass Google Play review, perform on the Android device distribution your users actually run, and implement the full depth of Android platform capabilities your product requires.
Jetpack Compose UI Development
Jetpack Compose is Android’s modern declarative UI toolkit, written in Kotlin, and the approach Google now recommends for all new Android UI development. We build Compose-first Android applications with a composable design system that maps to your brand specifications: custom composable components, a MaterialTheme implementation with your colour scheme, typography and shape tokens, animated state transitions using Compose animation APIs, adaptive layouts for phone, tablet and foldable form factors, and full integration with the Compose Navigation library for type-safe navigation between screens. For organisations with existing View-based Android applications, we implement Compose interoperability, migrating screen by screen from XML layouts to composables without a full application rewrite, using ComposeView and ViewCompositionStrategy to run both systems in the same activity and fragment host.
Kotlin Multiplatform Mobile App Development
Kotlin Multiplatform Mobile allows sharing business logic, data models, network layer and repository implementations between an Android application written in Kotlin and an iOS application written in Swift, while keeping the native UI layer for each platform entirely in the platform-native language. KMM is the right Kotlin app development approach when the business logic is complex and must be consistent across both platforms, the iOS and Android UIs need to follow their respective platform conventions rather than a shared design system, and the organisation wants to avoid the test maintenance cost of keeping two separate business logic implementations in synchronisation. We scope KMM engagements carefully, identifying which code genuinely benefits from sharing and which platform-specific layers should remain entirely separate, rather than forcing everything into the shared module and producing platform-native feel on neither platform.
Java to Kotlin Android App Migration
Android applications built in Java accumulate technical debt at a faster rate than Kotlin applications because Java’s verbosity discourages the refactoring that keeps codebases maintainable, and Java’s lack of null safety allows null reference bugs to accumulate invisibly until they surface as production crashes. We migrate Java Android applications to Kotlin incrementally, file by file, using Kotlin’s 100 percent Java interoperability to run both languages in the same codebase throughout the migration without disrupting the production application. Migration includes replacing AsyncTask and RxJava async patterns with Kotlin coroutines, adding null safety annotations and fixing the latent null reference bugs that Kotlin’s type system surfaces during migration, converting Java model classes to Kotlin data classes, and updating build configuration to the Kotlin DSL where the project is ready for it.
Enterprise Android App Development with Kotlin
Enterprise Kotlin Android app development carries requirements that consumer applications do not: distribution through mobile device management platforms including Jamf, Microsoft Intune and VMware Workspace ONE rather than the public Google Play store, enterprise SSO integration with Active Directory, Okta and Azure AD through SAML and OAuth 2.0, Android for Work profile support for separating personal and corporate data on employee-owned devices under BYOD policies, integration with enterprise backend systems through APIs that were designed for web access, compliance with enterprise data handling policies for data at rest using Android Keystore encryption and in transit using certificate pinning, and custom Android launcher or kiosk mode implementations for dedicated-device deployments. We have delivered enterprise Kotlin Android applications for Australian and UK organisations in logistics, healthcare and financial services where every one of these requirements was a contractual baseline.
White Label Kotlin Android App Development
Our complete Kotlin Android app development capability is available as a white label service for digital agencies and mobile studios in Australia, the UK and Singapore. You scope the Android app development brief and manage the client relationship. We deliver the complete Kotlin engineering execution from architecture through Google Play submission under your agency brand. The Google Play developer account belongs to your agency or end client. The Kotlin codebase carries no NextEnvision identifiers. All source code, Jetpack Compose component libraries, architecture documentation and submission materials transfer on completion under mutual NDA. AEST and GMT engineering coverage for Australian and UK agency clients.
Industries Where Native Kotlin Android App Development Matters
Native Kotlin Android app development has a decisive advantage over cross-platform alternatives in industries where the Android device is a work tool rather than a consumer device, where the application needs to integrate with Android hardware capabilities that cross-platform frameworks cannot reach, or where the business user base is predominantly on Android. In logistics and field services, enterprise Android devices from Zebra, Honeywell and Datalogic run a customised Android build with barcode scanner APIs, rugged hardware abstraction layers and MDM configurations that require native Kotlin app development to access fully. Cross-platform frameworks have no packages for Zebra DataWedge or Honeywell Scanning SDK integration. In healthcare, clinical Android devices used in Australian and UK hospital networks frequently run manufacturer-locked Android versions with restricted system access that native Kotlin app development navigates correctly and cross-platform runtimes navigate with workarounds. In fintech, Android’s StrongBox hardware security module for cryptographic key storage and its biometric authentication APIs at the BiometricManager level provide security guarantees that cross-platform bridges approximate but do not match. In retail and point-of-sale, Android POS devices running payment terminal firmware require native Kotlin integration with proprietary payment SDKs that have no Flutter or React Native wrappers. In IoT and connected devices, Bluetooth Low Energy GATT profile implementation, USB host mode for peripheral communication and Android Things or custom Android BSP integration all require native Kotlin app development for reliable operation.
Four Core Capabilities Behind Our Kotlin Android App Development
Kotlin Coroutines and Async Architecture
Android Jetpack Architecture Components
Android app development is inherently asynchronous: network calls, database reads and writes, file operations and sensor data streams all happen on background threads that must not block the main thread or Android’s Application Not Responding watchdog will terminate the app. Kotlin coroutines provide the structured concurrency primitives to manage this complexity: CoroutineScope tied to Android lifecycle components, viewModelScope for operations that should cancel when a ViewModel is cleared, lifecycleScope for operations tied to an Activity or Fragment lifecycle, Flow for reactive data streams that replace LiveData in new Android app development, and StateFlow and SharedFlow for UI state management. Senior Kotlin app development engineers design coroutine scope and dispatcher architecture deliberately at the start of an engagement, not reactively when async bugs surface in QA.
Android Hardware and System Integration
Android Jetpack is the suite of libraries Google maintains for modern Android app development, and correct use of its architecture components determines whether a Kotlin Android application remains maintainable as it grows. ViewModel separates UI state from UI rendering and survives configuration changes such as screen rotation that destroy and recreate the Activity. Room provides a type-safe SQLite abstraction with compile-time query verification that catches SQL errors before the application runs. WorkManager schedules deferrable background work that survives process death and device restarts with guaranteed execution. Navigation component provides type-safe navigation with SafeArgs, backstack management and deep link handling. Hilt provides compile-time verified dependency injection that replaces manual dependency wiring. Each component has a correct usage pattern that senior Kotlin app development engineers implement from the architecture phase.
Google Play Submission and Policy Compliance
Native Kotlin app development reaches Android hardware and system capabilities that cross-platform frameworks cannot access through their standard package ecosystems. Camera2 API and CameraX for camera control at the hardware level including manual exposure, focus, white balance and RAW capture. BluetoothLE GATT profile implementation for custom BLE peripheral communication. USB host mode for communicating with USB devices connected to the Android device. NFC tag reading and Android Beam for proximity data exchange. Android Keystore for hardware-backed cryptographic key storage that never exposes private keys to application code. BiometricPrompt with fallback authentication for secure biometric flows. Custom accessibility service implementation for apps that need system-level UI interaction. Android Enterprise API for managed device configuration. Every one of these requires Kotlin platform code, not a cross-platform package wrapper.
Flutter Performance Engineering
Google Play review and policy compliance for Kotlin Android applications has grown significantly more complex in recent years. The data safety section of the Play Console requires accurate declaration of every category of data the application collects, whether each data category is shared with third parties, and whether collection is optional or required. The target API level requirement advances with each Android release and affects published applications, not just new submissions. The sensitive permissions policy restricts which applications can request READ_CALL_LOG, ACCESS_BACKGROUND_LOCATION, MANAGE_EXTERNAL_STORAGE and other sensitive permissions and requires a permission declaration form for those that qualify. We treat Google Play compliance as a Kotlin Android app development responsibility beginning at the architecture phase, not as a submission-stage checklist that produces rejection delays after the engineering work is complete.
White Label Kotlin Android App Development for Agencies
Digital agencies in Australia and the UK that receive client briefs for native Android app development in Kotlin face the same build-or-partner decision as those receiving Flutter briefs, with a more acute talent constraint: senior Kotlin Android engineers are a smaller hiring pool than Flutter or React Native engineers in both markets, and the device lab and Google Play account infrastructure required for professional Android app development adds overhead that project-by-project demand rarely justifies. Our white label Kotlin Android app development service provides the full engineering capability on a per-engagement basis: architecture, Jetpack Compose UI development, backend integration, QA on a real Android device library and Google Play submission, all under your agency brand with zero NextEnvision footprint in the deliverable.
Mutual NDA is signed before any client brief or project information is shared. The Google Play developer account belongs to your agency or end client throughout the engagement. The Kotlin codebase, Jetpack Compose component library, architecture documentation, Google Play submission materials and data safety form responses carry no NextEnvision identifiers. Complete IP and source code transfer to the agency or end client on project completion with no retained licence conditions. Our Kotlin Android app development engineers operate on AEST and GMT, attend client sprint reviews and respond to agency communications within the same business day. You retain the client relationship, the margin and the delivery credit.
Kotlin Native vs Kotlin Multiplatform vs Flutter: Choosing the Right Android Stack
Businesses commissioning Android app development in 2025 have three serious Kotlin-related engineering paths and choosing between them has long-term cost and capability implications that a technology preference at the pitch stage will not surface. Pure native Kotlin Android app development with Jetpack Compose is the right choice when the Android application requires deep integration with Android hardware APIs, manufacturer device SDKs or Android system services that cross-platform frameworks cannot reach, when the application will only ever target Android and there is no iOS requirement, when the Android experience requires full control over Android’s platform UI conventions including Material Design 3 components and Android-specific navigation patterns, or when the engineering team that will maintain the application after delivery has strong Kotlin Android expertise. Kotlin Multiplatform Mobile is the right choice when both iOS and Android are required but the business logic layer is complex and must be identical across both platforms, when the platforms genuinely benefit from native UI layers for iOS in Swift and Android in Jetpack Compose rather than a shared UI framework, and when the engineering team has or can hire both Kotlin Android and Swift iOS engineers. KMM is not a replacement for native development on either platform: it shares business logic only, so the UI, navigation and platform integration layers still require full platform expertise on both sides. Flutter is the right choice when a single codebase covering both iOS and Android from one engineering team is the priority, when the application requires a custom design system that neither Material Design nor Apple HIG satisfies, when web or desktop from the same codebase is a genuine business requirement, and when the performance ceiling of cross-platform rendering is acceptable for the application’s specific UI workload. Flutter cannot replace pure native Kotlin Android app development for applications requiring deep Android hardware API access, manufacturer SDK integration or Android enterprise device management features that have no Flutter platform channel implementation. We build in all three stacks and will recommend the correct one for your Android app development brief during the discovery call, with the reasoning documented in writing before any commitment is made.
Kotlin App Development Engagement Models
Fixed Scope Kotlin Android App Delivery
Dedicated Kotlin Android Engineer
A defined Android app brief, a screen-level scope covering all Jetpack Compose screens and navigation flows, a fixed price and a committed Google Play submission date. We produce the scope and fixed-price proposal after the paid discovery and architecture phase, not before it. The scope covers the full Kotlin Android app development engagement: architecture, Compose UI, backend integration, real device QA across the target Android version and device range, Google Play submission materials and a 30-day post-launch warranty covering defects against the agreed specification on the supported Android OS versions.
White Label Kotlin Android Agency Delivery
One or more senior Kotlin Android engineers embedded in your product team on a monthly retainer, participating in sprint planning, standups and reviews as a continuous extension of your Android app development capability. The same engineers remain on account across every sprint, building knowledge of the Kotlin codebase, the Jetpack architecture patterns, the Android device targeting requirements and the product roadmap that makes them more effective over time. Suited to product companies with an active Android feature roadmap, businesses that need senior Kotlin engineering depth without permanent employment overhead, and organisations migrating a Java Android application to Kotlin incrementally across a sustained period.
Kotlin Android Maintenance and Support Retainer
Full Kotlin Android app development delivered under your agency brand. Discovery, Jetpack Compose UI development, backend integration, real Android device QA and Google Play submission all managed by our Kotlin engineering team. Mutual NDA. Zero NextEnvision branding in the codebase, repository or submission materials. Google Play developer account remains with the agency or end client. Full IP and source code transfer on completion. AEST and GMT coverage for Australian and UK agency clients. You manage the client relationship and the margin. We deliver the Kotlin Android app development that justifies both.
Flutter Maintenance and Support Retainer
A structured monthly retainer covering the ongoing engineering obligations of a live Kotlin Android application: Kotlin and dependency library updates, target API level advancement to meet Google Play requirements as each Android version is released, Jetpack library migration as Android deprecates older components, Google Play data safety form updates when data handling changes, performance regression testing on new Android device models, bug remediation and incremental feature development. Monthly written reports cover work completed, library versions updated, Google Play compliance status and recommended priorities. Prevents the emergency cost of a Play Store compliance hold when target API level falls behind Google’s requirement.
Our Kotlin App Development Process
Android Requirements and Technology Assessment
Paid Discovery and Kotlin Architecture Phase
Before any Kotlin Android app development commitment is made, we review the brief to assess whether native Kotlin, Kotlin Multiplatform or Flutter is the right Android engineering approach for the specific requirements. This assessment covers hardware API requirements, manufacturer device SDK requirements, enterprise distribution requirements, iOS requirement, backend API posture, target Android version range and the engineering team that will maintain the application after delivery. The technology recommendation is documented in writing with its rationale before any engagement is structured or priced.
Jetpack Compose UI Design and Component Library
The Kotlin Android app development architecture phase produces a written architecture decision record covering: MVVM or MVI pattern selection with rationale, ViewModel and state management approach, coroutine scope and dispatcher design, Room database schema and DAO architecture, Retrofit or Ktor network layer design, Hilt dependency injection module structure, navigation graph and deep link specification, WorkManager job topology for background processing, Android Keystore usage for sensitive data, and target Android API level range. This document is reviewed and approved before sprint one begins. Architecture decisions that are wrong at this stage cost more to correct after ten sprints than the discovery phase cost in total.
Kotlin Android Development Sprints
Android UI design for Jetpack Compose is specified at composable component level in Figma, with each Figma component mapping to a Kotlin composable function with explicit parameters for each state variant. The MaterialTheme is configured with your brand’s colour scheme using Material Design 3’s dynamic colour and custom colour roles, typography with your brand typeface mapped to Material typescale roles, and shape tokens mapping to component border radii. The Compose component library is built and reviewed against the Figma specifications on real Android devices before screen assembly begins.
Android Device QA and Google Play Compliance
Kotlin Android app development proceeds in two-week sprints with a working build delivered via the Google Play internal testing track at the end of every sprint. The client reviews the actual Kotlin Android application on a real Android device, not an emulator or a screen recording. Sprint builds include working API integration, real local database reads and writes, actual push notification delivery from the notification infrastructure, and live hardware API integration for camera, Bluetooth, NFC or other peripherals in scope. Feedback from sprint reviews is incorporated in the following sprint.
Google Play Submission, Launch and Handover
Pre-submission QA runs across a real Android device library covering the Android OS versions, screen densities and device manufacturers that represent the target user installed base, including mid-range devices where memory, thermal throttling and manufacturer Android skin modifications produce conditions absent from emulators and flagship hardware. QA covers all functional flows, Jetpack Compose rendering at multiple screen sizes and font scales, TalkBack accessibility traversal, Google Play data safety form accuracy, permission declaration compliance for sensitive permissions, and target API level compliance before any Google Play submission is prepared.
From Flutter Architecture to App Store
We prepare all Google Play Console submission materials: store listing metadata and localised descriptions, screenshots sized for phone and tablet, feature graphic, content rating questionnaire responses, data safety form declarations for every data category collected or shared, and the signed release APK or AAB. We manage the review process and respond to any Play policy reviewer queries. Formal handover covers the Kotlin codebase architecture document, the Jetpack Compose component library, the Hilt module graph, the Room database schema, the CI/CD pipeline configuration, the Google Play Console account and the dependency map with upgrade path notes. You own the code, the account and the knowledge of how to operate and extend the Kotlin Android application independently.
Kotlin App Development: Frequently Asked Questions
Technical and commercial questions about Kotlin Android app development, answered for businesses and agencies evaluating native Android engineering.
What is Kotlin app development and why did Google make it the preferred Android language?
Kotlin app development is the practice of building Android applications using Kotlin, a statically typed, null-safe programming language that compiles to JVM bytecode and runs on Android’s runtime. Google declared Kotlin the preferred language for Android app development at Google I/O 2019 for two interconnected reasons. The first is null safety: Kotlin’s type system distinguishes nullable and non-nullable types at compile time, eliminating the NullPointerException crashes that were the leading cause of Android app development instability in Java codebases. The second is developer productivity: Kotlin reduces the boilerplate code that Java Android app development required by 40 percent on average, with data classes that auto-generate equals, hashCode and copy, extension functions that add behaviour to existing Android classes without inheritance, and coroutines that replace the callback chains and RxJava reactive streams that made async Android app development in Java difficult to read and maintain. Every Android Jetpack library, every Google sample application and every Android developer documentation page is now written in Kotlin, making Java-based Android app development progressively harder to support as the ecosystem moves exclusively to Kotlin.
What is the difference between Kotlin and Java for Android app development?
Kotlin and Java are both JVM languages that produce Android applications, but the engineering differences affect every aspect of an Android app development engagement. Null safety: Kotlin enforces null safety at compile time through its nullable and non-nullable type distinction, eliminating the category of runtime crash that NullPointerException represents in Java Android app development. Kotlin code that could produce a null reference error does not compile; Java code with the same error compiles and crashes at runtime in production. Coroutines: Kotlin provides structured concurrency through coroutines, which simplify asynchronous Android app development to sequential-reading code that the Kotlin compiler transforms into non-blocking execution. Java Android app development used AsyncTask (now deprecated), RxJava or callback interfaces to achieve the same result with significantly more code and more error-prone lifecycle management. Data classes: Kotlin data classes auto-generate equals, hashCode, copy and toString from the constructor parameters. Java Android app development required manually writing or generating these for every model class, adding hundreds of lines of boilerplate across a large codebase. Interoperability: Kotlin is 100 percent interoperable with Java, which means existing Java Android codebases can be migrated to Kotlin file by file without requiring a full rewrite.
When should I choose native Kotlin over Flutter for my Android app?
Native Kotlin Android app development is the correct choice when the Android application requires capabilities that Flutter cannot reach through its platform channel architecture or community package ecosystem. Specific cases include: enterprise Android device SDK integration with Zebra DataWedge, Honeywell Scanning SDK or Datalogic proprietary APIs that have no Flutter packages; Android Keystore StrongBox hardware security module usage for cryptographic operations that must never expose keys to application code; custom Android accessibility service implementations that require system-level UI interaction; Android Enterprise managed device API usage for BYOD or corporate-owned device deployment; Bluetooth Low Energy GATT profile implementations for custom peripheral hardware; and custom Android launcher or kiosk mode implementations for dedicated device deployments. Flutter is the correct choice when the application targets both iOS and Android from one codebase, when the design system diverges significantly from Material Design conventions, and when the Android-specific API requirements can be satisfied through Flutter’s platform channel architecture or community packages. We assess which approach is correct for your specific Android app development brief during the discovery phase and document the recommendation before any engineering commitment is made.
What is Jetpack Compose and how does it change Kotlin Android UI development?
Jetpack Compose is Android’s modern declarative UI toolkit, written in Kotlin and maintained by Google as the recommended approach for all new Android UI development. It replaces the View system that has been the basis of Android UI development since Android 1.0, where UI was defined in XML layout files and manipulated through Java or Kotlin imperative code. Compose instead defines UI as composable functions: Kotlin functions annotated with @Composable that describe what the UI should look like for a given state. When state changes, Compose’s runtime recomposes only the composable functions affected by the state change rather than redrawing the entire View hierarchy. The practical effect on Kotlin Android app development is that UI code is written in Kotlin rather than split between XML and Kotlin, state management is explicit and testable rather than implicit in View properties, UI components are composable functions rather than classes, and the Android Studio preview renders composables without running the application on a device or emulator. Jetpack Compose reached stable release in 2021 and is now the primary UI toolkit for all new Kotlin Android app development at NextEnvision.
What is Kotlin Multiplatform Mobile (KMM) and when is it the right choice?
Kotlin Multiplatform Mobile is a Kotlin technology that allows sharing business logic, data models, repository implementations and network layer code between an Android application written in Kotlin and Jetpack Compose and an iOS application written in Swift and SwiftUI, while keeping the native UI layer entirely separate on each platform. KMM is not a cross-platform UI framework: it does not render a shared UI on both platforms, which means the Android application uses Jetpack Compose and Material Design conventions, and the iOS application uses SwiftUI and Apple Human Interface Guidelines, with the shared Kotlin module providing the business logic layer that both platform UIs consume. KMM is the right choice when the shared business logic is complex and the cost of maintaining it correctly in both Kotlin and Swift outweighs the cost of building and maintaining two native UI layers. It is not the right choice when the UI needs to be visually consistent across platforms, when the organisation cannot staff both Kotlin Android and Swift iOS engineers simultaneously, or when a single-codebase cross-platform framework like Flutter would serve the requirements adequately at lower engineering cost.
How long does Kotlin Android app development take and what does it cost?
A native Kotlin Android application with a defined feature set, a complete Jetpack Compose UI design and a ready backend API typically takes between eight and sixteen weeks from the start of the architecture phase to Google Play submission. Applications that require a backend API to be built alongside the Kotlin Android app, extensive hardware API integration or enterprise MDM configuration typically require between four and six months. Cost for a production Kotlin Android application in the Australian and UK market typically falls between AUD 30,000 and AUD 140,000 for a defined feature set with a ready backend, with the range driven by screen count, custom Jetpack Compose component complexity, hardware integration scope and the Android device and OS version range that must be supported. Kotlin Multiplatform Mobile engagements covering both Android and iOS are priced as separate but coordinated Android and iOS development streams with a shared module architecture cost. The most accurate estimate for your specific Android app development brief comes from a discovery conversation where the requirements are assessed against the architecture decision space rather than estimated from screen count alone.