Given the pains Apple has taken to ease the porting effort for developers, this claim is not just a little bit exaggerated. Let's compare the significant sources of platform fragmentation from an app developer's perspective; we've got 1) input interface and capabilities, 2) output capabilities, 3) OS capabilities, and 4) performance capabilities.

1) The fragmentation of input capabilities for the iPhone is manifested by a regular addition of input sensors to the iPhone. The actual physical text and interaction input on the iPhone has stayed unchanged since the first generation, with the same virtual keyboard, home button and touchscreen size and shape. Since the original iPhone shipped with an accelerometer, the 3G added a GPS receiver, the 3GS added a magnetometer and video camera, and the iPhone 4 adds a gyroscope and front-facing camera. The input capabilities of the iPhone platform are on a steady path forward, never losing any previous abilities. This makes it so a currently written app will always work as expected on a future device, as it will have at least the same set of input capabilities.

Android, on the other hand, has a vastly different situation. Some devices have hardware keyboards of varying design, some have only a virtual one. Various devices also have different shape, aspect ratio and size touchscreens. Accelerometers are present on all Android devices, but anything beyond that is a bit of a crap shoot, appearing in some models, disappearing in later ones. Flagship devices will typically mirror or exceed the input capabilities of the latest iPhone, for example, but other models will leave some out. There is no expectation that any given input capability beyond accelerometers will be present in future devices.

2) The output capabilities of the iPhone platform so far have gone from a 3.5" display at 480x320 resolution to a 3.5" display at 960x640, exactly pixel-doubled with the same physical size. This means that your app written with a resolution of 480x320 in mind will display perfectly without distortion on the new devices.

The Android platform, however, is host to a plethora of screen configurations of varying size, aspect ratio, resolution, etc., essentially making you redesign your interface for each different screen in the market.

3) The OS situation is vastly different on the iPhone and Android. iPhone OS updates are made available to the entire installed base at the same time for free, and the installed base of iPhone OS users is very quick to upgrade to the latest firmware, with ~90% running the latest major OS version, and most of the remaining ones only one version behind, with only a couple percentage points of stragglers. This means that you can count on your entire target audience being running at least the previous major firmware version. This makes the developer's job much easier by eliminating the need to test against older, often bug-ridden firmware versions.

http://metrics.admob.com/2009/12/updated-iphone-os-stats/

On Android, we still have vendors shipping devices with the one-year-old Android 1.6 firmware, long after the major releases of 2.0, 2.1 and now 2.2. People who bought devices with older firmware often are not even offered updates to the latest version. Due to this, the portion of users running the latest firmware is a minority, and there are large populations stuck at various versions of the firmware. Since your target market is stuck running older versions of the firmware, you have no choice but to support ancient firmware revisions, with messy work-arounds for various bugs.

http://developer.android.com/resources/dashboard/platform-ve...

4) Performance capabilities are mostly a wash, the only difference being that the iPhone is on a steady path towards increasing capabilities, while Android has a more scattered path, with high and low-end devices with different performance capabilities on the market at any given time.

As a developer, it becomes obvious that the fragmentation taking place on the iPhone is not of the same order of magnitude as that taking place in the Android platform. This is to be expected when comparing a single-vendor platform to a commodity platform, but that doesn't make it any easier to deal with for those targeting the latter.