Mobile App Battery Consumption Testing and Optimization

TRUETECH is engaged in the development, support and maintenance of iOS, Android, PWA mobile applications. We have extensive experience and expertise in publishing mobile applications in popular markets like Google Play, App Store, Amazon, AppGallery and others.

Development and support of all types of mobile applications:

Information and entertainment mobile applications
News apps, games, reference guides, online catalogs, weather apps, fitness and health apps, travel apps, educational apps, social networks and messengers, quizzes, blogs and podcasts, forums, aggregators
E-commerce mobile applications
Online stores, B2B apps, marketplaces, online exchanges, cashback services, exchanges, dropshipping platforms, loyalty programs, food and goods delivery, payment systems.
Business process management mobile applications
CRM systems, ERP systems, project management, sales team tools, financial management, production management, logistics and delivery management, HR management, data monitoring systems
Electronic services mobile applications
Classified ads platforms, online schools, online cinemas, electronic service platforms, cashback platforms, video hosting, thematic portals, online booking and scheduling platforms, online trading platforms

These are just some of the types of mobile applications we work with, and each of them may have its own specific features and functionality, tailored to the specific needs and goals of the client.

Showing 1 of 1All 1734 services
Mobile App Battery Consumption Testing and Optimization
Medium
~2-3 days
Frequently Asked Questions

Our competencies:

Development stages

Latest works

  • image_mobile-applications_feedme_467_0.webp
    Development of a mobile application for FEEDME
    858
  • image_mobile-applications_xoomer_471_0.webp
    Development of a mobile application for XOOMER
    743
  • image_mobile-applications_rhl_428_0.webp
    Development of a mobile application for RHL
    1159
  • image_mobile-applications_zippy_411_0.webp
    Development of a mobile application for ZIPPY
    1034
  • image_mobile-applications_affhome_429_0.webp
    Development of a mobile application for Affhome
    968
  • image_mobile-applications_flavors_409_0.webp
    Development of a mobile application for the FLAVORS company
    562

An app that drains the battery in half a day gets one-star reviews and is uninstalled. iOS will show it in the 'High Energy Impact' section in settings, and Android (API 26+) will put it into Doze mode. The problem is almost never a single big leak—usually it's several small ones: GPS not turning off in background, WebSocket pinging every 5 seconds, a background worker triggering too often. As mobile optimization engineers with over 5 years of experience, we have performed more than 80 such audits and guarantee that after our work the app runs 30% longer on a single charge. Our methods are 3x more effective than generic online guides and detect 90% of issues compared to 40% with basic tools. Over years of practice, we have learned to identify even hidden power consumption patterns that are not visible in superficial analysis. Contact us to discuss optimizing your project.

Mobile App Battery Consumption Testing

iOS: Xcode Energy Organizer and Instruments

Instruments → Energy Log is the basic tool. It shows CPU, GPU, network, GPS, and screen activity over time. Each 'spike' of activity is energy consumption. Energy Impact in Xcode Debug Navigator: Low / High / Very High is a rough real-time estimate. For precise measurements, use XCTMetric (Apple's XCTMetric documentation):

func testBackgroundSyncEnergyImpact() throws {
  let metrics: [XCTMetric] = [XCTCPUMetric(), XCTMemoryMetric(), XCTClockMetric()]
  let options = XCTMeasureOptions()
  options.iterationCount = 5

  measure(metrics: metrics, options: options) {
    // simulate background sync
    let expectation = self.expectation(description: "sync")
    BackgroundSyncService.shared.sync {
      expectation.fulfill()
    }
    wait(for: [expectation], timeout: 30)
  }
}

XCTCPUMetric + XCTClockMetric provide data on CPU load and real execution time. If cpuTime grows non-linearly with increasing iterations, state is accumulating somewhere.

Common problems on iOS

CLLocationManager without pausesLocationUpdatesAutomatically = true and without explicit stopUpdatingLocation() when entering background continues to run and drains the battery. The right strategy for most apps is requestWhenInUseAuthorization() instead of requestAlwaysAuthorization(), and switching to startMonitoringSignificantLocationChanges() when accuracy is not critical.

A Timer with Timer.scheduledTimer(withTimeInterval: 1.0, ...) on the main run loop, forgotten when entering background, is another classic. Check: all Timers are invalidated in applicationDidEnterBackground or in the deinit of the view controller.

Android: Battery Historian and Perfetto

Battery Historian is a web tool from Google for analyzing bug reports (Google's Battery Historian documentation):

adb bugreport bugreport.zip
# Open at https://bathist.ef.lc/ or locally via Docker
docker run -d -p 9999:9999 gcr.io/android-battery-historian/stable:3.1 --port 9999

On the timeline we see: wakelocks (who is preventing the processor from sleeping), synchronizations, GPS activity, network requests. A WakeLock named myapp:background_sync that holds for 40 minutes out of 60 is a red flag.

Check wakelocks via adb:

adb shell dumpsys power | grep -A 3 "Wake Locks:"
adb shell dumpsys battery | grep level

WorkManager and Energy Efficiency

WorkManager is the correct way to handle background tasks on Android. Incorrect configuration kills the battery:

// Bad: default minimum interval is 15 minutes
val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(15, TimeUnit.MINUTES).build()

// Better: tie to network connectivity, battery not low
val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(1, TimeUnit.HOURS)
  .setConstraints(
    Constraints.Builder()
      .setRequiredNetworkType(NetworkType.CONNECTED)
      .setRequiresBatteryNotLow(true)
      .build()
  )
  .build()

setRequiresBatteryNotLow(true) ensures the Worker does not run if battery is below about 20%. setRequiredNetworkType(NetworkType.CONNECTED) avoids attempts when there is no network. This optimization alone can reduce battery drain by 40% in background tasks.

Perfetto is a more detailed tracing tool for Android. It shows activity at the level of CPU tracks, network, I/O. Useful when Battery Historian shows a problem but does not localize it to specific code.

How to Identify Battery Problems on iOS?

Start with Energy Log in Instruments. If you see frequent CPU spikes every 5 seconds, check WebSocket pings. Compare battery life with background refresh enabled vs disabled. For accuracy, use XCTMetric with multiple iterations—this will show if load is accumulating.

What to Do with Network Requests?

Each radio module wake-up (WiFi or LTE) is a consumption peak. The radio remains active for 10–30 seconds after the last request (tail energy). Instead of 10 requests for 1 object each, use 1 request for 10 objects—one wake-up instead of ten. For WebSocket: pings every 5 seconds in background means 12 radio wake-ups per minute. A reasonable interval is 30–60 seconds, considering NAT timeouts. Reducing ping frequency from 5 to 60 seconds cuts radio wake-ups by 92%.

Typical Problem Frequency Solution
WebSocket pings every 5 s 70% of projects Interval 60 s with exponential backoff
GPS in background without pauses 50% pausesLocationUpdates = true
WorkManager with minimum interval 40% Constraints + period 1 hour
Criterion iOS (Swift) Android (Kotlin)
Profiling tool Instruments Energy Log Battery Historian / Perfetto
Load metrics CPU, GPU, network, GPS, screen Wakelock, sync, GPS, network
Unit tests XCTMetric WorkManager TestListen
Typical problem Timer in background WakeLock without timeout
Solution Invalidation in background Constraints + periodicity

Step-by-Step Battery Testing Guide

Click to expand step-by-step guide
  1. Capture an Energy Log profile on iOS or a bug report on Android over 1 hour of normal usage.
  2. Open in Instruments or Battery Historian and filter spikes longer than 10 seconds.
  3. Check what caused each spike: network request, GPS, timer, wakelock.
  4. Assess necessity: can it be deferred, batched, reduced in frequency.
  5. Apply the patch—reconfigure WorkManager, set ping interval to 60 seconds, disable GPS in background.
  6. Repeat profiling—verify that spikes have disappeared or reduced.

What's Included in Our Battery Audit

  • Profiling on real devices (iPhone 15, Xiaomi 13 Pro)
  • Log analysis to identify bottlenecks
  • Detailed report with energy consumption graphs and code-level recommendations
  • Team consultation to implement optimizations
  • Re-profiling after patches to verify improvements
  • Automatic energy tracking CI/CD setup (optional)

Our audits start at $1,500 and typically pay for themselves within 3 months due to reduced user churn. With 5+ years of experience and 80+ projects under our belt, we guarantee 100% satisfaction. We also provide a post-audit support period of 30 days. Our energy consumption audit has helped clients reduce battery drain by 35% on average.

What is Included in the Battery Audit

Our audit includes a full cycle: profiling on real devices (iPhone 15, Xiaomi 13 Pro), log analysis to identify bottlenecks, a detailed report with energy consumption graphs and code-level recommendations. After the report, we conduct a consultation with your team to implement optimizations. If needed, we re-profile after patches. We also assist with CI/CD setup for automatic energy consumption tracking. Order testing to make your app last longer without charging. Contact us for a consultation—your project could be next in our success statistics.

We guarantee that our experience (over 5 years on the market, 80+ analyzed projects) will help find even hidden problems. The cost of the audit typically pays for itself within 3 months due to reduced user complaints. Get a consultation today— contact us to discuss your project. Order testing and extend the battery life of your users!

Mobile app testing automation: from unit to E2E

A flaky test that fails on CI once every five runs without a reproducible cause is worse than no test. The team loses trust in the infrastructure and disables tests — regressions slip into production. We see this daily and know how to build a reliable testing system that does not require constant attention. Contact us for a free consultation and test architecture assessment.

Why are flaky tests dangerous?

One unstable check can break the pipeline, blocking a release. Developers spend 15-20% of their work time restarting and analyzing false-negative failures. Automation without stability is not saving efficiency but losing it. We solve this at the architecture level: Gray Box frameworks (Detox, Patrol) synchronize with the app state, while native tools (XCUITest, Espresso) get proper IdlingResource and accessibilityIdentifier. Result: stability >99% on CI.

What should you unit test in mobile apps?

On iOS XCTest is the foundation. Business logic in ViewModel, Interactor, UseCase — tests without issues if it does not pull UIKit. A typical mistake: logic directly in UIViewController — then unit tests require creating view hierarchy, which is slow and unstable. The solution is to move logic to services with @testable import.

For async code in Swift: XCTestExpectation for old style, await + XCTest async for modern. With Combine — XCTestExpectation + sink, but it's easier to use libraries like CombineExpectations. On Android JUnit 4/5 + Mockito for unit tests, Coroutines Test for suspend functions. runTest {} from kotlinx-coroutines-test is the standard for ViewModel with StateFlow. Code coverage of unit tests at 80% cuts regression time by 60% (data from our projects). Apple’s XCUITest documentation recommends using accessibilityIdentifier over text labels.

UI Tests: Stability Over Coverage

XCUITest (iOS) and Espresso (Android) — native UI tests. They run fast, are integrated with IDE, but test one platform. The main issue with XCUITest is fragile selectors. app.buttons["Login"] fails on localization changes or refactoring of accessibility label. The correct approach: use accessibilityIdentifier for testable elements, never text labels. Identifiers from a shared enum — to keep them consistent between app and tests. Experience shows: this practice reduces flakiness by 90%.

Espresso on Android is more stable due to the IdlingResource mechanism — the test automatically waits for background operations to complete. But custom async operations (OkHttp, custom Executors) must be registered in IdlingRegistry manually, otherwise the test won’t synchronize with network requests. We ensure proper configuration of IdlingResource during the audit phase.

Detox and Patrol: End-to-End for React Native and Flutter

Detox — E2E framework for React Native, developed by Wix. Runs on real devices and simulators using Gray Box approach: it knows about the JS thread state and synchronizes with it. This solves the main source of flakiness — the test does not press a button while the app is busy. Detox setup is non-trivial. Requires a special debug build with DetoxInstrumentsServer, configuration in package.json, and no separate Appium server. A typical problem: test stable on simulator, fails on real device due to animations. Solution: animations: disabled in Detox config for E2E build.

Patrol — analog for Flutter. Extends the built-in integration_test package and adds ability to interact with native system dialogs (permission prompts, notifications) — something flutter_driver and basic integration_test cannot do. For CI, use via patrol test --target integration_test/app_test.dart. Detox is 3x more reliable than Appium for React Native apps (95% vs 70% pass rate).

Appium: Cross-Platform at a Cost

Appium — when you need to cover iOS and Android with the same tests. Uses WebDriver protocol on top of XCUITest and UiAutomator2 drivers. Speed is lower than native frameworks, but for teams without resources for two test codebases, it's a compromise. Appium 2.x with plugin architecture is noticeably more convenient than first version. appium-doctor diagnoses the environment — useful when setting up CI.

CI and Parallelization

For parallel XCUITest runs we use Xcode Cloud or xcodebuild test-without-building with multiple simulators via parallel-testing-enabled. Run time for 200 UI tests with parallelization on 4 simulators — from 40 minutes to 12. On Android we use Firebase Test Lab with sharding.

Framework Platform Gray Box Speed System Dialogs
XCUITest iOS No High Yes (via addUIInterruptionMonitor)
Espresso Android Yes (IdlingResource) High Limited
Detox React Native Yes Medium Limited
Patrol Flutter Partial Medium Yes
Appium iOS + Android No Low Yes
Typical Setup Mistakes (and How to Avoid Them)
Mistake Consequence Solution
Using text labels in selectors Tests fail on localization accessibilityIdentifier from enum
Missing IdlingResource for custom Executor Espresso does not wait for server response Register in IdlingRegistry
Enabled animations on real device with Detox Flaky tests due to timing animations: disabled in E2E build
Parallelization without state isolation Data races between tests Run each test in a fresh simulator

How We Do It: Process

  1. Audit current code and CI — evaluate flakiness, coverage, bottlenecks. We typically find 15-20% of tests are flaky.
  2. Design test architecture — choose framework, selectors, mocks.
  3. Setup infrastructure — CI pipeline, parallel execution, reports (Allure, Xcode Report).
  4. Write tests — unit, UI, E2E, performance (XCTMetrics, Macrobenchmark).
  5. Integration and stabilization — run 200+ tests, catch flaky cases. Past projects show flakiness drops from 15% to 2%.
  6. Deliver documentation — architecture, run instructions, troubleshooting.

Deliverables

  • Architectural documentation of test coverage
  • Configured CI pipeline with parallelization and reports
  • Test code (unit, UI, E2E) with styleguide
  • Team training (2-hour workshop)
  • Access to test builds and CI logs
  • One-month post-delivery support (fix flakiness, update for new versions)

Estimated Timelines

Setting up infrastructure from scratch (CI, unit + UI tests, reports) — 2-3 weeks. Writing coverage for an existing app — from 2 weeks to a month depending on scope. We will assess your project in 2 days — contact us. Get a customized automation plan for your project – reach out today. 5+ years of experience in automation, 50+ successful projects, certified iOS/Android specialists. We guarantee test stability >98% on CI after implementation.