diff --git a/src/devices/graphics/arch-st.jd b/src/devices/graphics/arch-st.jd
index 573ec66..5bdcb92 100644
--- a/src/devices/graphics/arch-st.jd
+++ b/src/devices/graphics/arch-st.jd
@@ -144,7 +144,7 @@
 from MediaCodec and stashes it in memory.</p>
 
 <h2 id=st_vid_play>Secure texture video playback</h2>
-<p>Android N supports GPU post-processing of protected video content. This
+<p>Android 7.0 supports GPU post-processing of protected video content. This
 allows using the GPU for complex non-linear video effects (such as warps),
 mapping protected video content onto textures for use in general graphics scenes
 (e.g., using OpenGL ES), and virtual reality (VR).</p>
@@ -164,7 +164,7 @@
 attachments.</li>
 </ul>
 
-<p>Android N also updates SurfaceTexture and ACodec
+<p>Android 7.0 also updates SurfaceTexture and ACodec
 (<code>libstagefright.so</code>) to allow protected content to be sent even if
 the windows surface does not queue to the window composer (i.e., SurfaceFlinger)
 and provide a protected video surface for use within a protected context. This
diff --git a/src/devices/graphics/implement-hwc.jd b/src/devices/graphics/implement-hwc.jd
index ecf6cfb..77b425a 100644
--- a/src/devices/graphics/implement-hwc.jd
+++ b/src/devices/graphics/implement-hwc.jd
@@ -232,10 +232,10 @@
 This is the HWC device's cue to complete the composition process and display the
 final result.</p>
 
-<h2 id="multiple_displays">Multiple displays in Android N</h2>
+<h2 id="multiple_displays">Multiple displays in Android 7.0</h2>
 <p>While the HWC2 interface is quite flexible when it comes to the number of
 displays in the system, the rest of the Android framework is not yet as
-flexible. When designing a HWC2 implementation intended for use on Android N,
+flexible. When designing a HWC2 implementation intended for use on Android 7.0,
 there are some additional restrictions not present in the HWC definition itself:
 </p>
 
diff --git a/src/devices/tech/admin/implement.jd b/src/devices/tech/admin/implement.jd
index 9c1d1b4..8c4580c 100644
--- a/src/devices/tech/admin/implement.jd
+++ b/src/devices/tech/admin/implement.jd
@@ -36,7 +36,7 @@
 general requirements.</p>
 
 <h3 id=HAL_values>Thermal HAL values</h3>
-<p>Android N includes support for HardwarePropertiesManager API, a new device
+<p>Android 7.0 includes support for HardwarePropertiesManager API, a new device
 monitoring and health reporting API that enables applications to query the state
 of device hardware. This API is exposed via
 <code>android.os.HardwarePropertiesManager</code> and makes calls through
diff --git a/src/devices/tech/admin/multi-user.jd b/src/devices/tech/admin/multi-user.jd
index 24b4da8..24f4fec 100644
--- a/src/devices/tech/admin/multi-user.jd
+++ b/src/devices/tech/admin/multi-user.jd
@@ -172,7 +172,7 @@
   by secondary users.</li>
 </ul>
 
-<p>Android N includes several enhancements, including:</p>
+<p>Android 7.0 includes several enhancements, including:</p>
 
 <ul>
   <li><em>Toggle work profile</em>. Users can disable their managed profile
@@ -187,6 +187,6 @@
   <code>device_admin</code> must implement always-on VPN.</li>
 </ul>
 
-<p>For more details on Android N device administration features, refer to
+<p>For more details on Android 7.0 device administration features, refer to
 <a href="https://developer.android.com/preview/features/afw.html">Android
 for Work Updates</a>.</p>
diff --git a/src/devices/tech/admin/testing-setup.jd b/src/devices/tech/admin/testing-setup.jd
index ea7a015..727f685 100644
--- a/src/devices/tech/admin/testing-setup.jd
+++ b/src/devices/tech/admin/testing-setup.jd
@@ -79,7 +79,7 @@
 Provisioning</a>.</p>
 
 <h2 id="troubleshooting">Bug reports and logs</h2>
-<p>In Android N, device owner Device Policy Client (DPCs) can get bug reports
+<p>In Android 7.0, device owner Device Policy Client (DPCs) can get bug reports
 and view logs for enterprise processes on a managed device.</p>
 
 <p>To trigger a bug report (i.e., the equivalent data collected by <code>adb
diff --git a/src/devices/tech/config/namespaces_libraries.jd b/src/devices/tech/config/namespaces_libraries.jd
index 49c74e4..1839d71 100644
--- a/src/devices/tech/config/namespaces_libraries.jd
+++ b/src/devices/tech/config/namespaces_libraries.jd
@@ -26,11 +26,11 @@
 </div>
 
 <p>
-Android N introduces namespaces for native libraries to limit internal API
+Android 7.0 introduces namespaces for native libraries to limit internal API
 visibility and resolve situations when apps accidentally end up using platform
 libraries instead of their own. See the <a
 href="http://android-developers.blogspot.com/2016/06/improving-stability-with-private-cc.html">Improving
-Stability with Private C/C++ Symbol Restrictions in Android N</a> Android
+Stability with Private C/C++ Symbol Restrictions in Android 7.0</a> Android
 Developers blog post</a> for application-specific changes.
 </p>
 
diff --git a/src/devices/tech/connect/block-numbers.jd b/src/devices/tech/connect/block-numbers.jd
index d9c96c1..aa20729 100644
--- a/src/devices/tech/connect/block-numbers.jd
+++ b/src/devices/tech/connect/block-numbers.jd
@@ -50,11 +50,11 @@
 <h2 id="features">Features</h2>
 
 <p>
-The Android N release introduces a <code>BlockedNumberProvider</code> content
+The Android 7.0 release introduces a <code>BlockedNumberProvider</code> content
 provider that stores a list of phone numbers the user has specified should not
 be able to contact them via telephony communications (calls, SMS, MMS). The
 system will respect the numbers in the blocked list by restricting calls and
-texts from those numbers. Android N displays the list of blocked numbers and
+texts from those numbers. Android 7.0 displays the list of blocked numbers and
 allows the user to add and remove numbers.
 </p>
 
diff --git a/src/devices/tech/dalvik/dex-format.jd b/src/devices/tech/dalvik/dex-format.jd
index aa11792..9230cc0 100644
--- a/src/devices/tech/dalvik/dex-format.jd
+++ b/src/devices/tech/dalvik/dex-format.jd
@@ -285,7 +285,7 @@
 document.</p>
 
 <p class="note"><strong>Note:</strong> Support for version <code>037</code> of
-the format was added in the Android N release. Prior to this release most
+the format was added in the Android 7.0 release. Prior to this release most
 versions of Android have used version <code>035</code> of the format. The only
 difference between versions <code>035</code> and <code>037</code> is the
 addition of default methods and the adjustment of the <code>invoke</code>
diff --git a/src/devices/tech/dalvik/jit-compiler.jd b/src/devices/tech/dalvik/jit-compiler.jd
index 00f26e4..d341450 100644
--- a/src/devices/tech/dalvik/jit-compiler.jd
+++ b/src/devices/tech/dalvik/jit-compiler.jd
@@ -27,7 +27,7 @@
 </div>
 
 <p>
-Android N adds a just-in-time (JIT) compiler with code profiling to Android
+Android 7.0 adds a just-in-time (JIT) compiler with code profiling to Android
 runtime (ART) that constantly improves the performance of Android apps as they
 run. The JIT compiler complements ART's current ahead-of-time (AOT) compiler and
 improves runtime performance, saves storage space, and speeds app updates and
@@ -178,7 +178,7 @@
 </p>
 
 <p>
-In Android N, there's a generic way to specify the level of
+In Android 7.0, there's a generic way to specify the level of
 compilation/verification based on the different use cases. For example, the
 default option for install time is to do only verification (and postpone
 compilation to a later stage). The compilation levels can be configured via
diff --git a/src/devices/tech/power/batterystats.jd b/src/devices/tech/power/batterystats.jd
index cc4716b..9a56d25 100644
--- a/src/devices/tech/power/batterystats.jd
+++ b/src/devices/tech/power/batterystats.jd
@@ -564,7 +564,7 @@
 
 <p>Additionally, OEMs must continue to configure and submit the power profile
 for their devices. However, when the platform detects that Bluetooth, cellular
-(as of Android N), or Wi-Fi radio power data is available from the chipset, it
+(as of Android 7.0), or Wi-Fi radio power data is available from the chipset, it
 uses chipset data instead of power profile data. For details, see
 <a href="{@docRoot}devices/tech/power/values.html#values">Power values</a>.</p>
 
diff --git a/src/devices/tech/power/values.jd b/src/devices/tech/power/values.jd
index 5878896..11eda5b 100644
--- a/src/devices/tech/power/values.jd
+++ b/src/devices/tech/power/values.jd
@@ -39,7 +39,7 @@
 computes the mAh value, which is then used to estimate the amount of battery
 drained by the application/subsystem.</p>
 
-<p>Devices with Bluetooth, modem, and Wi-Fi controllers running Android N and
+<p>Devices with Bluetooth, modem, and Wi-Fi controllers running Android 7.0 and
 higher can provide additional power values obtained from chipset data.</p>
 
 
@@ -346,7 +346,7 @@
 </table>
 
 <h2 id="le-bt-scans">Low Energy (LE) and Bluetooth scans</h2>
-<p>For devices running Android N, the system collects data for Low Energy (LE)
+<p>For devices running Android 7.0, the system collects data for Low Energy (LE)
 scans and Bluetooth network traffic (such as RFCOMM and L2CAP) and associates
 these activities with the initiating application. Bluetooth scans are associated
 with the application that initiated the scan, but batch scans are not (and
