Skip to main content

Emulator Solutions

Null Autos provides a comprehensive suite of emulator solutions beyond Cuttlefish, including custom Android builds, specialized configurations, and third-party emulator support.

Overview​

Our emulator platform supports:

  • Multiple Emulator Types: Cuttlefish, custom AOSP, and third-party emulators
  • Device Categories: Phone, tablet, automotive, TV, wearables, IoT
  • Android Versions: Android 11 through latest Android 14+
  • Custom Builds: Support for custom Android builds and forks

Emulator Types​

Cuttlefish (Primary)​

Google's reference virtual device implementation.

Learn more about Cuttlefish →

Custom AOSP Builds​

Run your own Android Open Source Project builds:

  • Custom System Images: Upload and use your AOSP builds
  • Modified Frameworks: Test framework modifications
  • Custom HALs: Hardware abstraction layer customization
  • Kernel Modules: Custom kernel support

Android Automotive OS​

Specialized automotive configurations:

  • IVI Systems: In-vehicle infotainment
  • Instrument Clusters: Digital gauge clusters
  • HUD: Head-up display emulation
  • Vehicle HAL: Complete vehicle hardware abstraction layer

Android TV​

Television and set-top box emulation:

  • TV Launcher: Android TV home screen
  • Leanback UI: TV-optimized interfaces
  • HDMI CEC: Consumer electronics control
  • Voice Input: Remote control simulation

Wear OS​

Smartwatch and wearable device emulation:

  • Circular Displays: Round watch faces
  • Health Sensors: Heart rate, step counter
  • Companion App: Phone pairing simulation
  • Watch Faces: Customizable watch displays

Configuration Options​

Display Settings​

{
  "display": {
    "width": 1920,
    "height": 1080,
    "dpi": 160,
    "orientation": "landscape",
    "touchscreen": true,
    "multitouch": true
  }
}

Hardware Configuration​

{
  "hardware": {
    "cpus": 4,
    "memory": 4096,
    "storage": 16384,
    "gpu": {
      "enabled": true,
      "model": "virtio-gpu",
      "vram": 512
    }
  }
}

Sensor Configuration​

{
  "sensors": {
    "accelerometer": true,
    "gyroscope": true,
    "magnetometer": true,
    "gps": {
      "enabled": true,
      "latitude": 37.7749,
      "longitude": -122.4194
    },
    "temperature": true,
    "pressure": true
  }
}

Network Configuration​

{
  "network": {
    "wifi": {
      "enabled": true,
      "ssid": "TestNetwork",
      "quality": "excellent"
    },
    "cellular": {
      "enabled": true,
      "type": "5G",
      "carrier": "Test Carrier"
    },
    "bluetooth": {
      "enabled": true,
      "version": "5.2"
    }
  }
}

Automotive Configurations​

IVI System (In-Vehicle Infotainment)​

const iviDevice = await ctrl.devices.create({
  type: 'automotive',
  profile: 'ivi',
  display: {
    width: 1920,
    height: 1080,
    dpi: 160,
  },
  vehicle: {
    make: 'Example',
    model: 'Sedan',
    year: 2024,
    features: ['hvac', 'radio', 'navigation', 'climate'],
  },
});

Instrument Cluster​

const clusterDevice = await ctrl.devices.create({
  type: 'automotive',
  profile: 'cluster',
  display: {
    width: 1280,
    height: 480,
    dpi: 240,
    orientation: 'landscape',
  },
  vehicle: {
    speed: 0,
    rpm: 0,
    fuelLevel: 100,
    engineTemp: 90,
  },
});

Custom Image Support​

Uploading Custom Images​

# Upload system image
ctrl images upload \
  --name "my-custom-android" \
  --version "14.0-custom" \
  --file ./system.img \
  --type "system"

# Upload kernel
ctrl images upload \
  --name "my-custom-android" \
  --version "14.0-custom" \
  --file ./kernel \
  --type "kernel"

Using Custom Images​

const device = await ctrl.devices.create({
  type: 'custom',
  image: {
    name: 'my-custom-android',
    version: '14.0-custom',
  },
  hardware: {
    cpus: 4,
    memory: 4096,
  },
});

Performance Profiles​

Balanced (Default)​

Standard configuration for most workloads:

  • CPU: 2 vCPUs
  • Memory: 2 GB
  • GPU: Enabled
  • Boot Time: ~30 seconds

High Performance​

Optimized for demanding applications:

  • CPU: 4 vCPUs with dedicated cores
  • Memory: 4-8 GB
  • GPU: Dedicated GPU with passthrough
  • Boot Time: ~20 seconds

Resource Efficient​

Minimal resources for simple testing:

  • CPU: 1 vCPU
  • Memory: 1 GB
  • GPU: Disabled
  • Boot Time: ~45 seconds

Integration Examples​

CI/CD Pipeline​

# GitLab CI
test:automotive:
  stage: test
  script:
    - ctrl devices create --profile automotive --wait
    - adb install app.apk
    - adb shell am instrument -w com.example.test
  after_script:
    - ctrl devices delete --all

Automated Testing​

import ctrl

# Test across multiple configurations
configs = [
    {'type': 'phone', 'android': '13'},
    {'type': 'phone', 'android': '14'},
    {'type': 'automotive', 'profile': 'ivi'},
]

for config in configs:
    device = ctrl.devices.create(**config)
    device.adb.install('app.apk')
    results = device.run_tests()
    device.delete()
    
    assert results['passed'] > 0, f"Tests failed on {config}"

Load Testing​

// Spin up 100 devices for load testing
const devices = await Promise.all(
  Array.from({ length: 100 }, (_, i) =>
    ctrl.devices.create({
      type: 'phone',
      name: `load-test-${i}`,
    })
  )
);

// Run load test
await runLoadTest(devices);

// Cleanup
await Promise.all(devices.map(d => d.delete()));

Advanced Features​

Device Snapshots​

Save and restore device state:

// Create snapshot
const snapshot = await device.snapshots.create({
  name: 'app-installed',
  description: 'Device with app installed and configured',
});

// Restore from snapshot
const newDevice = await ctrl.devices.create({
  snapshot: snapshot.id,
});

Device Cloning​

Clone existing device configuration:

const clonedDevice = await device.clone({
  count: 5, // Create 5 clones
  prefix: 'test-device',
});

Custom Scripts​

Run custom initialization scripts:

const device = await ctrl.devices.create({
  type: 'automotive',
  postBoot: {
    script: `
      adb install /apps/my-app.apk
      adb shell settings put global auto_time 0
      adb shell input keyevent KEYCODE_HOME
    `,
  },
});

Monitoring & Metrics​

Device Metrics​

Real-time metrics for each device:

  • CPU Usage: Per-core utilization
  • Memory: Used, free, cached
  • Disk I/O: Read/write throughput
  • Network: Bandwidth and latency
  • GPU: GPU utilization (if enabled)

Performance Profiling​

// Start profiling
await device.profiler.start({
  duration: 60, // seconds
  metrics: ['cpu', 'memory', 'gpu', 'network'],
});

// Get profile results
const profile = await device.profiler.getResults();
console.log(profile.averageCpu); // Average CPU usage

Pricing​

Emulator pricing is based on:

FactorPricing
CPU$0.10 per vCPU hour
Memory$0.01 per GB hour
Storage$0.10 per GB/month
GPU$0.25 per GPU hour
Data Transfer$0.09 per GB

Example: A 2 vCPU, 2 GB RAM device with GPU costs ~$0.45/hour.

View Full Pricing →

Best Practices​

Resource Management​

  1. Right-size Your Devices: Choose appropriate resources for your workload
  2. Use Snapshots: Save common states for faster setup
  3. Auto-cleanup: Set timeouts to prevent forgotten devices
  4. Pool Management: Reuse devices when possible

Performance Optimization​

  1. Enable GPU: For graphical applications
  2. Use SSD Storage: Faster I/O performance
  3. Network Optimization: Co-locate with your services
  4. Pre-warm Devices: Keep a pool of ready devices

Cost Optimization​

  1. Schedule Usage: Run tests during off-peak hours
  2. Batch Operations: Test multiple apps on same device
  3. Efficient Cleanup: Delete devices immediately after use
  4. Reserved Capacity: Pre-purchase for discounts

Troubleshooting​

Boot Issues​

  • Verify image compatibility
  • Check resource allocation
  • Review boot logs
  • Try different Android version

Performance Issues​

  • Increase CPU/memory allocation
  • Enable GPU acceleration
  • Check host node capacity
  • Monitor resource metrics

Network Issues​

  • Verify network configuration
  • Check firewall rules
  • Test connectivity
  • Review DNS settings

Support​

For emulator-specific questions:

Next Steps​