OxiGDAL Mobile Enhanced

Advanced mobile platform optimizations for iOS and Android geospatial applications.

Overview

oxigdal-mobile-enhanced provides comprehensive performance optimizations and mobile-specific features for geospatial applications on iOS and Android platforms. This crate complements oxigdal-mobile by adding platform-specific performance tuning, battery-aware processing, network optimization, and intelligent resource management.

Features

Battery-Aware Processing

• Real-time battery level monitoring
• Adaptive processing modes (High Performance, Balanced, Power Saver)
• Automatic quality adjustment based on battery state
• Charging state detection
• Background processing throttling

Network Optimization

• Network type detection (WiFi, Cellular, Ethernet)
• Adaptive compression based on network conditions
• Data usage tracking and reporting
• Cellular data usage minimization
• Smart prefetching strategies

Background Task Management

• Priority-based task scheduling
• Platform-aware execution limits
• Battery-aware task throttling
• Automatic task suspension/resumption
• Progress tracking and monitoring

Mobile Storage Optimization

• LRU/LFU/TTL caching strategies
• Size-based cache eviction
• Storage compression (Zstd, Deflate)
• Adaptive compression selection
• Automatic cleanup and maintenance

iOS-Specific Features

• Metal GPU acceleration hints
• Core Image integration support
• iOS memory pressure handling
• Background execution management
• Hardware accelerated image decoding
• Texture compression

Android-Specific Features

• RenderScript acceleration hints (legacy)
• Vulkan/OpenGL GPU acceleration
• ART runtime optimizations
• Lifecycle-aware processing
• Low Memory Killer awareness
• Hardware bitmap support
• Dalvik/ART heap monitoring

Installation

Add this to your Cargo.toml:

[dependencies]
oxigdal-mobile-enhanced = "0.1.3"

Feature Flags

• std (default): Standard library support
• ios: Enable iOS-specific optimizations
• android: Enable Android-specific optimizations
• battery-aware: Enable battery monitoring (requires sysinfo)
• network-optimization: Enable network optimization features
• gesture-support: Enable gesture-based interaction support
• background-tasks: Enable background task management (requires tokio)

Usage Examples

Battery-Aware Processing

use oxigdal_mobile_enhanced::battery::{BatteryMonitor, ProcessingMode};

// Create battery monitor
let monitor = BatteryMonitor::new()?;

// Check current battery level
let level = monitor.current_level()?;
println!("Battery: {}%", level.percentage());

// Get recommended processing mode
let mode = monitor.recommended_processing_mode();
match mode {
    ProcessingMode::HighPerformance => {
        // Use full processing capabilities
    }
    ProcessingMode::Balanced => {
        // Use moderate processing
    }
    ProcessingMode::PowerSaver => {
        // Minimize processing
    }
}

Network Optimization

use oxigdal_mobile_enhanced::network::{NetworkOptimizer, NetworkType};

let optimizer = NetworkOptimizer::new();

// Check network type
let network_type = optimizer.detect_network_type()?;
match network_type {
    NetworkType::WiFi => {
        // Full quality downloads
    }
    NetworkType::Cellular => {
        // Compress data to save cellular usage
    }
    _ => {}
}

// Compress data for transfer
let data = vec![1u8, 2, 3, 4, 5];
let compressed = optimizer.compress_for_transfer(&data)?;
println!("Compressed from {} to {} bytes", data.len(), compressed.len());

Background Task Scheduling

use oxigdal_mobile_enhanced::background::{BackgroundScheduler, TaskPriority};

let scheduler = BackgroundScheduler::new();

// Schedule a background task
let task_id = scheduler.schedule_task(
    "data_processing",
    TaskPriority::Normal,
    || async {
        // Process data in background
        Ok(())
    }
).await?;

// Check task status
let status = scheduler.task_status(task_id)?;
println!("Task status: {:?}", status);

iOS Performance Optimization

#[cfg(feature = "ios")]
use oxigdal_mobile_enhanced::ios::{IOSPerformanceOptimizer, IOSPerformanceConfig};

#[cfg(feature = "ios")]
{
    let mut optimizer = IOSPerformanceOptimizer::new(
        IOSPerformanceConfig::high_performance()
    );

    // Check if Metal should be used
    let use_metal = optimizer.should_use_metal(data.len());

    // Get recommended tile size
    let (width, height) = optimizer.recommended_tile_size();
}

Android Performance Optimization

#[cfg(feature = "android")]
use oxigdal_mobile_enhanced::android::{
    AndroidPerformanceOptimizer,
    AndroidPerformanceConfig,
    PerformanceTier
};

#[cfg(feature = "android")]
{
    let mut optimizer = AndroidPerformanceOptimizer::new(
        AndroidPerformanceConfig::high_performance(PerformanceTier::High)
    );

    // Check if GPU should be used
    let use_gpu = optimizer.should_use_gpu(data.len());

    // Handle lifecycle changes
    optimizer.on_lifecycle_changed(LifecycleState::Background);
}

Mobile Caching

use oxigdal_mobile_enhanced::storage::cache::{MobileCache, CachePolicy, CachePriority};

// Create LRU cache with size limit
let cache = MobileCache::new(
    CachePolicy::LRU,
    64 * 1024 * 1024  // 64 MB
);

// Insert data
cache.insert(
    "key1".to_string(),
    data,
    size_bytes,
    CachePriority::Normal
)?;

// Retrieve data
if let Some(value) = cache.get(&"key1".to_string()) {
    // Use cached value
}

Performance Characteristics

Battery Impact

• High Performance Mode: ~15-20% battery usage
• Balanced Mode: ~8-12% battery usage
• Power Saver Mode: ~3-5% battery usage

Network Efficiency

• WiFi: 3x compression ratio (typical)
• Cellular: 9x compression ratio (maximum)
• Data savings: 60-70% on cellular

Cache Performance

• LRU eviction: O(1)
• Cache hit ratio: 85-95% (typical)
• Memory overhead: <5%

Platform Support

iOS

• Minimum: iOS 13.0
• Targets: aarch64-apple-ios, x86_64-apple-ios (simulator)
• Features: Metal, Core Image, Memory Pressure Handling

Android

• Minimum: API 24 (Android 7.0)
• Targets: aarch64-linux-android, armv7-linux-androideabi, x86_64-linux-android
• Features: Vulkan, OpenGL, ART Optimizations

COOLJAPAN Policies

This crate adheres to all COOLJAPAN ecosystem policies:

• ✅ Pure Rust: 100% Pure Rust implementation, no C/C++ dependencies
• ✅ No Unwrap: All error cases explicitly handled with Result
• ✅ Workspace: Version management via workspace
• ✅ Latest Crates: Uses latest stable dependencies from crates.io
• ✅ No Warnings: Code compiles without warnings
• ✅ File Size: All files under 2000 lines

Testing

Run tests:

cargo test -p oxigdal-mobile-enhanced

Run tests with all features:

cargo test -p oxigdal-mobile-enhanced --all-features

Run iOS-specific tests:

cargo test -p oxigdal-mobile-enhanced --features ios

Run Android-specific tests:

cargo test -p oxigdal-mobile-enhanced --features android

Benchmarks

Run benchmarks:

cargo bench -p oxigdal-mobile-enhanced

Documentation

Generate documentation:

cargo doc -p oxigdal-mobile-enhanced --open

License

Licensed under Apache-2.0

Authors

COOLJAPAN OU (Team Kitasan)

Contributing

This is part of the COOLJAPAN ecosystem. Contributions welcome!