am dacbf67a: Merge changes I1df85b6a,I7c6a68b6 into ics-mr1

* commit 'dacbf67ab915fa8b987f6fb9f044160af92652cd':
  docs: second set of diagram updates
  docs: Update lifecycle diagrams to use new omnigraffle designs; add corresponding graffle files update discussion of activity state restore for clarification

docs/html/guide/topics/fundamentals/activities.jd

@@ -19,9 +19,10 @@ page.title=Activities
   </li>
   <li><a href="#StartingAnActivity">Starting an Activity</a>
     <ol>
-      <li><a href="#StartingAnActivityForResult">Starting an Activity for a Result</a></li>
+      <li><a href="#StartingAnActivityForResult">Starting an activity for a result</a></li>
     </ol>
   </li>
+  <li><a href="#ShuttingDown">Shutting Down an Activity</a></li>
   <li><a href="#Lifecycle">Managing the Activity Lifecycle</a>
     <ol>
       <li><a href="#ImplementingLifecycleCallbacks">Implementing the lifecycle callbacks</a></li>
@@ -612,17 +613,9 @@ that
 when an activity is paused or stopped, the state of the activity is retained. This is true because
 the {@link android.app.Activity} object is still held in memory when it is paused or
 stopped&mdash;all information about its members and current state is still alive. Thus, any changes
-the user made within the activity are retained in memory, so that when the activity returns to the
+the user made within the activity are retained so that when the activity returns to the
 foreground (when it "resumes"), those changes are still there.</p>
 
-<div class="figure" style="width:615px">
-<img src="{@docRoot}images/fundamentals/restore_instance.png" alt="" />
-<p class="img-caption"><strong>Figure 2.</strong> The two ways in which an activity returns to user
-focus with its state intact: either the activity is stopped, then resumed and the activity state
-remains intact (left), or the activity is destroyed, then recreated and the activity must restore
-the previous activity state (right).</p>
-</div>
-
 <p>However, when the system destroys an activity in order to recover memory, the {@link
 android.app.Activity} object is destroyed, so the system cannot simply resume it with its state
 intact. Instead, the system must recreate the {@link android.app.Activity} object if the user
@@ -630,26 +623,35 @@ navigates back to it. Yet, the user is unaware
 that the system destroyed the activity and recreated it and, thus, probably
 expects the activity to be exactly as it was. In this situation, you can ensure that
 important information about the activity state is preserved by implementing an additional
-callback method that allows you to save information about the state of your activity and then
+callback method that allows you to save information about the state of your activity: {@link
-restore it when the the system recreates the activity.</p>
+android.app.Activity#onSaveInstanceState onSaveInstanceState()}.</p>
 
-<p>The callback method in which you can save information about the current state of your activity is
+<p>The system calls {@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}
-{@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}. The system calls this method
+before making the activity vulnerable to destruction. The system passes this method
-before making the activity vulnerable to being destroyed and passes it
+a {@link android.os.Bundle} in which you can save 
-a {@link android.os.Bundle} object. The {@link android.os.Bundle} is where you can store 
 state information about the activity as name-value pairs, using methods such as {@link
-android.os.Bundle#putString putString()}. Then, if the system kills your activity's
+android.os.Bundle#putString putString()} and {@link
-process and the user navigates back to your activity, the system passes the {@link
+android.os.Bundle#putInt putInt()}. Then, if the system kills your application
-android.os.Bundle} to {@link android.app.Activity#onCreate onCreate()} so you can restore the
+process and the user navigates back to your activity, the system recreates the activity and passes
-activity state you saved during {@link android.app.Activity#onSaveInstanceState
+the {@link android.os.Bundle} to both {@link android.app.Activity#onCreate onCreate()} and {@link
-onSaveInstanceState()}. If there is no state information to restore, then the {@link
+android.app.Activity#onRestoreInstanceState onRestoreInstanceState()}. Using either of these
-android.os.Bundle} passed to {@link android.app.Activity#onCreate onCreate()} is null.</p>
+methods, you can extract your saved state from the {@link android.os.Bundle} and restore the
+activity state. If there is no state information to restore, then the {@link
+android.os.Bundle} passed to you is null (which is the case when the activity is created for
+the first time).</p>
+
+<img src="{@docRoot}images/fundamentals/restore_instance.png" alt="" />
+<p class="img-caption"><strong>Figure 2.</strong> The two ways in which an activity returns to user
+focus with its state intact: either the activity is destroyed, then recreated and the activity must restore
+the previously saved state, or the activity is stopped, then resumed and the activity state
+remains intact.</p>
 
 <p class="note"><strong>Note:</strong> There's no guarantee that {@link
 android.app.Activity#onSaveInstanceState onSaveInstanceState()} will be called before your
 activity is destroyed, because there are cases in which it won't be necessary to save the state
 (such as when the user leaves your activity using the BACK key, because the user is explicitly
-closing the activity). If the method is called, it is always called before {@link
+closing the activity). If the system calls {@link android.app.Activity#onSaveInstanceState
+onSaveInstanceState()}, it does so before {@link
 android.app.Activity#onStop onStop()} and possibly before {@link android.app.Activity#onPause
 onPause()}.</p>
 
@@ -657,17 +659,17 @@ onPause()}.</p>
 android.app.Activity#onSaveInstanceState onSaveInstanceState()}, some of the activity state is
 restored by the {@link android.app.Activity} class's default implementation of {@link
 android.app.Activity#onSaveInstanceState onSaveInstanceState()}. Specifically, the default
-implementation calls {@link
+implementation calls the corresponding {@link
-android.view.View#onSaveInstanceState onSaveInstanceState()} for every {@link android.view.View}
+android.view.View#onSaveInstanceState onSaveInstanceState()} method for every {@link
-in the layout, which allows each view to provide information about itself
+android.view.View} in the layout, which allows each view to provide information about itself
 that should be saved. Almost every widget in the Android framework implements this method as
 appropriate, such that any visible changes to the UI are automatically saved and restored when your
 activity is recreated. For example, the {@link android.widget.EditText} widget saves any text
 entered by the user and the {@link android.widget.CheckBox} widget saves whether it's checked or
 not. The only work required by you is to provide a unique ID (with the <a
 href="{@docRoot}guide/topics/resources/layout-resource.html#idvalue">{@code android:id}</a>
-attribute) for each widget you want to save its state. If a widget does not have an ID, then it
+attribute) for each widget you want to save its state. If a widget does not have an ID, then the
-cannot save its state.</p>
+system cannot save its state.</p>
 
 <div class="sidebox-wrapper">
 <div class="sidebox">
@@ -689,7 +691,9 @@ restored, by default).</p>
 android.app.Activity#onSaveInstanceState onSaveInstanceState()} helps save the state of the UI, if
 you override the method in order to save additional state information, you should always call the
 superclass implementation of {@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}
-before doing any work.</p>
+before doing any work. Likewise, you should also call the supercall implementation of {@link
+android.app.Activity#onRestoreInstanceState onRestoreInstanceState()} if you override it, so the
+default implementation can restore view states.</p>
 
 <p class="note"><strong>Note:</strong> Because {@link android.app.Activity#onSaveInstanceState
 onSaveInstanceState()} is not guaranteed
@@ -701,7 +705,7 @@ to a database) when the user leaves the activity.</p>
 <p>A good way to test your application's ability to restore its state is to simply rotate the
 device so that the screen orientation changes. When the screen orientation changes, the system
 destroys and recreates the activity in order to apply alternative resources that might be available
-for the new orientation. For this reason alone, it's very important that your activity
+for the new screen configuration. For this reason alone, it's very important that your activity
 completely restores its state when it is recreated, because users regularly rotate the screen while
 using applications.</p>
 
@@ -709,22 +713,25 @@ using applications.</p>
 <h3 id="ConfigurationChanges">Handling configuration changes</h3>
 
 <p>Some device configurations can change during runtime (such as screen orientation, keyboard
-availability, and language). When such a change occurs, Android restarts the running Activity
+availability, and language). When such a change occurs, Android recreates the running activity
-({@link android.app.Activity#onDestroy} is called, followed immediately by {@link
+(the system calls {@link android.app.Activity#onDestroy}, then immediately calls {@link
-android.app.Activity#onCreate onCreate()}). The restart behavior is
+android.app.Activity#onCreate onCreate()}). This behavior is
 designed to help your application adapt to new configurations by automatically reloading your
-application with alternative resources that you've provided. If you design your activity to
+application with alternative resources that you've provided (such as different layouts for
-properly handle this event, it will be more resilient to unexpected events in the activity
+different screen orientations and sizes).</p>
-lifecycle.</p>
 
-<p>The best way to handle a configuration change, such as a change in the screen orientation, is
+<p>If you properly design your activity to handle a restart due to a screen orientation change and
-  to simply preserve the state of your application using {@link
+restore the activity state as described above, your application will be more resilient to other
+unexpected events in the activity lifecycle.</p>
+
+<p>The best way to handle such a restart is
+  to save and restore the state of your activity using {@link
   android.app.Activity#onSaveInstanceState onSaveInstanceState()} and {@link
 android.app.Activity#onRestoreInstanceState onRestoreInstanceState()} (or {@link
 android.app.Activity#onCreate onCreate()}), as discussed in the previous section.</p>
 
-<p>For a detailed discussion about configuration changes that happen at runtime and how you should
+<p>For more information about configuration changes that happen at runtime and how you can handle
-handle them, read <a href="{@docRoot}guide/topics/resources/runtime-changes.html">Handling
+them, read the guide to <a href="{@docRoot}guide/topics/resources/runtime-changes.html">Handling
 Runtime Changes</a>.</p>
 
 

docs/html/guide/topics/fundamentals/fragments.jd

@@ -33,7 +33,7 @@ parent.link=activities.html
     </li>
     <li><a href="#Lifecycle">Handling the Fragment Lifecycle</a>
       <ol>
-        <li><a href="#CoordinadingWithActivity">Coordinating with the activity lifecycle</a></li>
+        <li><a href="#CoordinatingWithActivity">Coordinating with the activity lifecycle</a></li>
       </ol>
     </li>
     <li><a href="#Example">Example</a></li>
@@ -143,7 +143,7 @@ href="{@docRoot}guide/practices/tablets-and-handsets.html">Supporting Tablets an
 
 <h2 id="Creating">Creating a Fragment</h2>
 
-<div class="figure" style="width:314px">
+<div class="figure" style="width:327px">
 <img src="{@docRoot}images/fragment_lifecycle.png" alt="" />
 <p class="img-caption"><strong>Figure 2.</strong> The lifecycle of a fragment (while its
 activity is running).</p>
@@ -657,7 +657,7 @@ href="{@docRoot}guide/topics/ui/actionbar.html">Action Bar</a> developer guides.
 
 <h2 id="Lifecycle">Handling the Fragment Lifecycle</h2>
 
-<div class="figure" style="width:403px">
+<div class="figure" style="width:350px">
 <img src="{@docRoot}images/activity_fragment_lifecycle.png" alt=""/>
 <p class="img-caption"><strong>Figure 3.</strong> The activity lifecycle's affect on the fragment
 lifecycle.</p>

docs/html/guide/topics/fundamentals/tasks-and-back-stack.jd

@@ -72,7 +72,7 @@ order in which each activity is opened.</p>
 suppose you have a two-pane layout using fragments, one of which is a list view (fragment A) and the
 other being a layout to display an item from the list (fragment B). When the user selects an item
 from the list, fragment B is replaced by a new fragment (fragment C). In this case, it might be
-desireable for the user to navigate back to reveal fragment B, using the BACK key.</p>
+desireable for the user to navigate back to reveal fragment B, using the BACK button.</p>
 <p>In order to add fragment B to the back stack so that this is possible, you must call {@link
 android.app.FragmentTransaction#addToBackStack addToBackStack()} before you {@link
 android.app.FragmentTransaction#commit()} the transaction that replaces fragment B with fragment
@@ -93,17 +93,17 @@ is created and the "main" activity for that application opens as the root activi
 <p>When the current activity starts another, the new activity is pushed on the top of the stack and
 takes focus. The previous activity remains in the stack, but is stopped. When an activity
 stops, the system retains the current state of its user interface. When the user presses the BACK
-key, the current activity is popped from the top of the stack (the activity is destroyed) and the
+button, the current activity is popped from the top of the stack (the activity is destroyed) and the
 previous activity resumes (the previous state of its UI is restored). Activities in the stack are
 never rearranged, only pushed and popped from the stack&mdash;pushed onto the stack when started by
-the current activity and popped off when the user leaves it using the BACK key. As such, the back
+the current activity and popped off when the user leaves it using the BACK button. As such, the back
 stack operates as a "last in, first out" object structure. Figure 1 visualizes
 this behavior with a timeline showing the progress between activities along with the current back
 stack at each point in time.</p>
 
 <img src="{@docRoot}images/fundamentals/diagram_backstack.png" alt="" />
 <p class="img-caption"><strong>Figure 1.</strong> A representation of how each new activity in a
-task adds an item to the back stack. When the user presses the BACK key, the current activity is
+task adds an item to the back stack. When the user presses the BACK button, the current activity is
 destroyed and the previous activity resumes.</p>
 
 
@@ -111,22 +111,22 @@ destroyed and the previous activity resumes.</p>
 previous one, until the user returns to the Home screen (or to whichever activity was running when
 the task began). When all activities are removed from the stack, the task no longer exists.</p>
 
-<div class="figure" style="width:369px">
+<div class="figure" style="width:287px">
 <img src="{@docRoot}images/fundamentals/diagram_multitasking.png" alt="" /> <p
-class="img-caption"><strong>Figure 2.</strong> Two tasks: Task A is in the background, waiting
+class="img-caption"><strong>Figure 2.</strong> Two tasks: Task B receives user interaction
-to be resumed, while Task B receives user interaction in the foreground.</p>
+in the foreground, while Task A is in the background, waiting to be resumed.</p>
 </div>
-<div class="figure" style="width:178px">
+<div class="figure" style="width:215px">
   <img src="{@docRoot}images/fundamentals/diagram_multiple_instances.png" alt="" /> <p
 class="img-caption"><strong>Figure 3.</strong> A single activity is instantiated multiple times.</p>
 </div>
 
 <p>A task is a cohesive unit that can move to the "background" when users begin a new task or go
-to the Home screen, via the HOME key. While in the background, all the activities in the task are
+to the Home screen, via the HOME button. While in the background, all the activities in the task are
 stopped, but the back stack for the task remains intact&mdash;the task has simply lost focus while
 another task takes place, as shown in figure 2. A task can then return to the "foreground" so users
 can pick up where they left off. Suppose, for example, that the current task (Task A) has three
-activities in its stack&mdash;two under the current activity. The user presses the HOME key, then
+activities in its stack&mdash;two under the current activity. The user presses the HOME button, then
 starts a new application from the application launcher. When the Home screen appears, Task A goes
 into the background. When the new application starts, the system starts a task for that application
 (Task B) with its own stack of activities. After interacting with
@@ -135,7 +135,7 @@ started Task A. Now, Task A comes to the
 foreground&mdash;all three activities in its stack are intact and the activity at the top of the
 stack resumes. At
 this point, the user can also switch back to Task B by going Home and selecting the application icon
-that started that task (or by touching and holding the HOME key to reveal recent tasks and selecting
+that started that task (or by touching and holding the HOME button to reveal recent tasks and selecting
 one). This is an example of multitasking on Android.</p>
 
 <p class="note"><strong>Note:</strong> Multiple tasks can be held in the background at once.
@@ -148,7 +148,7 @@ users to start a particular activity from more than one activity, a new instance
 that activity is created and popped onto the stack (rather than bringing any previous instance of
 the activity to the top). As such, one activity in your application might be instantiated multiple
 times (even from different tasks), as shown in figure 3. As such, if the user navigates backward
-using the BACK key, each instance of the activity is revealed in the order they were opened (each
+using the BACK button, each instance of the activity is revealed in the order they were opened (each
 with their own UI state). However, you can modify this behavior if you do not want an activity to be
 instantiated more than once. How to do so is discussed in the later section about <a
 href="#ManagingTasks">Managing Tasks</a>.</p>
@@ -159,13 +159,13 @@ href="#ManagingTasks">Managing Tasks</a>.</p>
 <ul>
   <li>When Activity A starts Activity B, Activity A is stopped, but the system retains its state
 (such as scroll position and text entered into forms).
-If the user presses the BACK key while in Activity B, Activity A resumes with its state
+If the user presses the BACK button while in Activity B, Activity A resumes with its state
 restored.</li>
-  <li>When the user leaves a task by pressing the HOME key, the current activity is stopped and
+  <li>When the user leaves a task by pressing the HOME button, the current activity is stopped and
 its task goes into the background. The system retains the state of every activity in the task. If
 the user later resumes the task by selecting the launcher icon that began the task, the task comes
 to the foreground and resumes the activity at the top of the stack.</li>
-  <li>If the user presses the BACK key, the current activity is popped from the stack and
+  <li>If the user presses the BACK button, the current activity is popped from the stack and
 destroyed. The previous activity in the stack is resumed. When an activity is destroyed, the system
 <em>does not</em> retain the activity's state.</li>
   <li>Activities can be instantiated multiple times, even from other tasks.</li>
@@ -247,7 +247,7 @@ flags to define how activities are associated with tasks and how the behave in t
 <p class="caution"><strong>Caution:</strong> Most applications should not interrupt the default
 behavior for activities and tasks. If you determine that it's necessary for your activity to modify
 the default behaviors, use caution and be sure to test the usability of the activity during
-launch and when navigating back to it from other activities and tasks with the BACK key. Be sure 
+launch and when navigating back to it from other activities and tasks with the BACK button. Be sure 
 to test for navigation behaviors that might conflict with the user's expected behavior.</p>
 
 
@@ -311,8 +311,8 @@ android.app.Activity#onNewIntent onNewIntent()}, because it's at the top of the
 stack remains A-B-C-D. However, if an intent arrives for an activity of type B, then a new
 instance of B is added to the stack, even if its launch mode is {@code "singleTop"}.</p>
   <p class="note"><strong>Note:</strong> When a new instance of an activity is created,
-the user can press the BACK key to return to the previous activity. But when an existing instance of
+the user can press the BACK button to return to the previous activity. But when an existing instance of
-an activity handles a new intent, the user cannot press the BACK key to return to the state of
+an activity handles a new intent, the user cannot press the BACK button to return to the state of
 the activity before the new intent arrived in {@link android.app.Activity#onNewIntent
 onNewIntent()}.</p>
 </dd>
@@ -324,7 +324,7 @@ intent to the existing instance through a call to its {@link
 android.app.Activity#onNewIntent onNewIntent()} method, rather than creating a new instance. Only
 one instance of the activity can exist at a time.
   <p class="note"><strong>Note:</strong> Although the activity starts in a new task, the
-BACK key still returns the user to the previous activity.</p></dd>
+BACK button still returns the user to the previous activity.</p></dd>
 <dt>{@code "singleInstance"}.</dt>
   <dd>Same as {@code "singleTask"}, except that the system doesn't launch any other activities into
 the task holding the instance. The activity is always the single and only member of its task;
@@ -342,19 +342,17 @@ already has a task running in the background, that task is brought forward to ha
 intent.</p>
 
 <p>Regardless of whether an activity starts in a new task or in the same task as the activity that
-started it, the BACK key always takes the user to the previous activity. However, if you
+started it, the BACK button always takes the user to the previous activity. However, if you
-start an activity from your task (Task A) that specifies the {@code singleTask} launch mode, then
+start an activity that specifies the {@code singleTask} launch mode, then if an instance of
-that activity might have an instance in the background that belongs to a task with its own back
+that activity exists in a background task, that whole task is brought to the foreground. At this
-stack (Task B). In this
+point, the back stack now includes all activities from the task brought forward, at the top of the
-case, when Task B is brought forward to handle a new intent, the BACK key first navigates
+stack. Figure 4 illustrates this type of scenario.</p>
-backward through the activities in Task B before returning to
-the top-most activity in Task A. Figure 4 visualizes this type of scenario.</p>
 
 <img src="{@docRoot}images/fundamentals/diagram_backstack_singletask_multiactivity.png" alt="" />
 <p class="img-caption"><strong>Figure 4.</strong> A representation of how an activity with
 launch mode "singleTask" is added to the back stack. If the activity is already a part of a
-background task with its own back stack (Task B), then the entire back stack also comes
+background task with its own back stack, then the entire back stack also comes
-forward, on top of the current task (Task A).</p>
+forward, on top of the current task.</p>
 
 <p>For more information about using launch modes in the manifest file, see the
 <code><a href="{@docRoot}guide/topics/manifest/activity-element.html">&lt;activity&gt;</a></code>
@@ -447,7 +445,7 @@ flag, the system looks for a different task to house the new activity. Often, it
 However, it doesn't have to be.  If there's already an existing task with the same affinity as the
 new activity, the activity is launched into that task.  If not, it begins a new task.</p>
 
-<p>If this flag causes an activity to begin a new task and the user presses the HOME key to leave
+<p>If this flag causes an activity to begin a new task and the user presses the HOME button to leave
 it, there must be some way for the user to navigate back to the task. Some entities (such as the
 notification manager) always start activities in an external task, never as part of their own, so
 they always put {@code FLAG_ACTIVITY_NEW_TASK} in the intents they pass to {@link
@@ -549,9 +547,9 @@ android.content.Intent#ACTION_MAIN}
 and a {@link android.content.Intent#CATEGORY_LAUNCHER}
 filter. Imagine, for example, what could happen if the filter is missing: An intent launches a
 {@code "singleTask"} activity, initiating a new task, and the user spends some time working in
-that task.  The user then presses the HOME key. The task is now sent to the background and not
+that task.  The user then presses the HOME button. The task is now sent to the background and is
-visible. Because it is not represented in the application launcher, the user has no way to return to
+not visible. Now the user has no way to return to the task, because it is not represented in the
-the task.
+application launcher.
 </p>
 
 <p>For those cases where you don't want the user to be able to return to an activity, set the

docs/html/guide/topics/resources/index.jd

@@ -28,18 +28,18 @@ to provide compatibility with different configurations, you must organize resour
 project's {@code res/} directory, using various sub-directories that group resources by type and
 configuration.</p>
 
-<div class="figure" style="width:421px">
+<div class="figure" style="width:429px">
-<img src="{@docRoot}images/resources/resource_devices_diagram1.png" height="137" alt="" />
+<img src="{@docRoot}images/resources/resource_devices_diagram1.png" height="167" alt="" />
 <p class="img-caption">
-<strong>Figure 1.</strong> Two different devices, both using default
+<strong>Figure 1.</strong> Two different devices, each using the default layout
-resources.</p>
+(the app provides no alternative layouts).</p>
 </div>
 
-<div class="figure" style="width:421px">
+<div class="figure" style="width:429px">
-<img src="{@docRoot}images/resources/resource_devices_diagram2.png" height="137" alt="" />
+<img src="{@docRoot}images/resources/resource_devices_diagram2.png" height="167" alt="" />
 <p class="img-caption">
-<strong>Figure 2.</strong> Two different devices, one using alternative
+<strong>Figure 2.</strong> Two different devices, each using a different layout provided
-resources.</p>
+for different screen sizes.</p>
 </div>
 
 <p>For any type of resource, you can specify <em>default</em> and multiple
@@ -54,18 +54,16 @@ append an appropriate configuration qualifier to the directory name.</li>
 </ul>
 
 <p>For example, while your default UI
-layout is saved in the {@code res/layout/} directory, you might specify a different UI layout to
+layout is saved in the {@code res/layout/} directory, you might specify a different layout to
 be used when the screen is in landscape orientation, by saving it in the {@code res/layout-land/}
 directory. Android automatically applies the appropriate resources by matching the
 device's current configuration to your resource directory names.</p>
 
-<p>Figure 1 demonstrates how a collection of default resources from an application are applied
+<p>Figure 1 illustrates how the system applies the same layout for
-to two different devices when there are no alternative resources available. Figure 2 shows
+two different devices when there are no alternative resources available. Figure 2 shows
-the same application with a set of alternative resources that qualify for one of the device
+the same application when it adds an alternative layout resource for larger screens.</p>
-configurations, thus, the two devices uses different resources.</p>
 
-<p>The information above is just an introduction to how application resources work on Android.
+<p>The following documents provide a complete guide to how you can organize your application resources,
-The following documents provide a complete guide to how you can organize your application resources,
 specify alternative resources, access them in your application, and more:</p>
 
 <dl>

docs/html/guide/topics/resources/providing-resources.jd

@@ -207,10 +207,10 @@ resources.</p>
 <h2 id="AlternativeResources">Providing Alternative Resources</h2>
 
 
-<div class="figure" style="width:421px">
+<div class="figure" style="width:429px">
-<img src="{@docRoot}images/resources/resource_devices_diagram2.png" height="137" alt="" />
+<img src="{@docRoot}images/resources/resource_devices_diagram2.png" height="167" alt="" />
 <p class="img-caption">
-<strong>Figure 1.</strong> Two different devices, one using alternative resources.</p>
+<strong>Figure 1.</strong> Two different devices, each using different layout resources.</p>
 </div>
 
 <p>Almost every application should provide alternative resources to support specific device
@@ -1021,8 +1021,8 @@ drawables from {@code drawable-en-port}.</p>
 logic:</p>
 
 
-<div class="figure" style="width:280px">
+<div class="figure" style="width:371px">
-<img src="{@docRoot}images/resources/res-selection-flowchart.png" alt="" height="590" />
+<img src="{@docRoot}images/resources/res-selection-flowchart.png" alt="" height="471" />
 <p class="img-caption"><strong>Figure 2.</strong> Flowchart of how Android finds the
 best-matching resource.</p>
 </div>