Android Evolution: A Technical Deep Dive into 1.0 vs 1.1 Differences

Table of Contents#

1. Core Architecture Differences
2. API & Framework Updates
3. User-Facing Feature Comparison
4. Development Toolchain Evolution
5. Best Practices for Targeting Early Android
6. Real-World Code Comparison
7. Conclusion
8. References

1. Core Architecture Differences#

Android 1.0 (API Level 1)#

• Linux Kernel: 2.6.25 with custom Binder IPC driver
• Dalvik VM: Initial implementation (non-JIT)
• Storage: SQLite 3.5.9 with basic ContentProvider support
• Security: Single-permission model at install time

Android 1.1 (API Level 2)#

• Linux Kernel: Patched to 2.6.27 with stability fixes
• Dalvik Optimizations: Bytecode verification improvements
• ContentProviders: Expanded URI operation support
• Security: Introduced android.permission.ACCESS_LOCATION_EXTRA_COMMANDS

Key Insight: 1.1 focused on hardening foundational components rather than major redesigns.

2. API & Framework Updates#

New Packages in 1.1#

android.webkit.CacheManager // Web cache control

Modified Classes#

Development Impact: 1.1 required defensive coding for backward compatibility:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.CUPCAKE) {
    // Use cancellationSignal in queries
} else {
    // Fallback to basic query
}

Note: Build.VERSION_CODES.CUPCAKE corresponds to API 3 (Android 1.5). The example above is for illustrative purposes of version-check patterns.

3. User-Facing Feature Comparison#

4. Development Toolchain Evolution#

Best Practice: Developers began using minSdkVersion in manifests:

<uses-sdk android:minSdkVersion="2" /> <!-- 1.1 = API Level 2 -->

5. Best Practices for Targeting Early Android#

Compatibility Patterns#

1. Runtime Version Checks

if (Integer.parseInt(Build.VERSION.SDK) >= 2) { 
    // Use 1.1 APIs
}

2. Abstract New Functionality

public interface LocationWrapper {
    Location getLastLocation();
}
 
// Implement version-specific implementation

Performance Tips#

• Memory Management: Explicitly recycle bitmaps (critical under 16MB heap)
• Threading: Prefer AsyncTask over raw threads (backported via support libs)
• Storage: Always use Context.getFilesDir() vs hardcoded paths

6. Real-World Code Comparison#

Map Location Handling (1.0 vs 1.1)#

Android 1.0 (Basic Implementation)

MapController mc = mapView.getController();
mc.animateTo(geoPoint); // No position tracking

Android 1.1 (Added Features)

// MyLocationOverlay available since 1.0
MyLocationOverlay myLocOverlay = new MyLocationOverlay(context, mapView);
myLocOverlay.enableMyLocation(); // Requires new permission
mapView.getOverlays().add(myLocOverlay);

7. Conclusion#

While Android 1.0 established core mobile paradigms, 1.1 played a critical role in:

1. Stabilizing foundational systems
2. Expanding hardware compatibility
3. Introducing subtle but impactful API refinements
4. Setting precedent for rapid iteration cycles

These early versions remind us that backward compatibility and incremental improvements remain central to Android's philosophy. Modern Android development still employs patterns established during this era—especially runtime version checks and abstraction layers.

8. References#

1. Android 1.0 Release Notes (2008)
2. Android 1.1 API Diff Report
3. Android Source Code Tags: android-1.0_r1 / android-1.1_r1
4. Professional Android Application Development (Wrox, 2009)