page.title=Support and Release Notes
meta.keywords="preview", "android"
page.tags="preview", "developer preview"
page.image=images/cards/card-n-support_2x.png

@jd:body


<div id="qv-wrapper">
<div id="qv">

<h2>In this document</h2>

<ul>
  <li><a href="#dp4">Developer Preview 4</a>
    <ul>
      <li><a href="#general">General advisories</a></li>
      <li><a href="#new">New in DP4</a></li>
      <li><a href="#ki">Known issues</a></li>
    </ul>
  </li>
  <li><a href="#dp3">Developer Preview 3</a></li>
  <li><a href="#dp2">Developer Preview 2</a></li>
  <li><a href="#dp1">Developer Preview 1</a></li>
</ul>

<!--
<h2>See Also</h2>
<ol>
  <li></li>
</ol>
-->

</div>
</div>

<p>
  Two primary support channels are available to you when developing and testing
  with the Android N Developer Preview: Please file bugs at <a href=
  "https://developer.android.com/preview/bug"
  >https://developer.android.com/preview/bug</a> for
  device-specific, system, and Google App bugs. For issues in other apps,
  please contact the developer directly.
</p>

<p>
  To discuss issues or ideas with other developers working with Android N, join
  the <a href="{@docRoot}preview/dev-community">Developer Preview Google+
  community</a>.
</p>

<h2 id="dp4">Developer Preview 4</h2>

<div class="wrap">
  <div class="cols">
    <div class="col-6of12">
      <p>
        <em>Date: June 2016<br>
        Build: NPD56N<br>
        Emulator support: x86 &amp; ARM (32/64-bit)<br>
        Google Play services: 8.4</em>
      </p>
    </div>
  </div>
</div>

<h3 id="general">General advisories</h3>

<p>
  This Developer Preview release is for <strong>app developers and other early
  adopters</strong> and is available for daily use, development, or
  compatibility testing. Please be aware of these general notes about the
  release:
</p>

<ul>
  <li>This release may have various <strong>stability issues</strong> on
  supported devices.
  </li>

  <li>Some apps <strong>may not function as expected</strong> on the new
  platform version. This includes Google’s apps as well as other apps.
  </li>

  <li>Developer Preview 4 is <strong>Compatibility Test Suite (CTS)
  approved</strong> on these devices: Nexus 5X, Nexus 6, Nexus 6P, and
  Pixel C. Apps that depend on CTS approved builds should work normally
  on these devices (Android Pay for example).
  </li>

  <li>Developer Preview 4 is <strong>available on all supported
  devices:</strong> Nexus 5X, Nexus 6, Nexus 6P, Nexus 9, Nexus Player,
  Pixel C, General Mobile 4G (Android One), as well as Sony Xperia Z3
  (D6603 and D6653 models).
  </li>
</ul>


<h3 id="new">New in DP4</h3>

<h4>Android N final APIs</h4>

<p>
  Developer Preview 4 includes the <strong>final APIs</strong> for the upcoming
  Android N platform. The new API level is 24.
</p>

<h4>Play publishing</h4>

<p>
  You can now publish apps that use <strong>API level 24</strong> to Google
  Play, in alpha, beta, and production release channels.
</p>

<h4>Android Studio and tools updates</h4>

<p>
  Along with Developer Preview 4 we’re providing the <strong>final API 24
  SDK</strong> to be used with Android Studio 2.1.2 and higher. In addition,
  we’re releasing updated Developer Preview 4 system images for the emulator to
  help test your apps.
</p>

<p>
  As new updates roll out for Android Studio, you should see minor improvements in
  the new project wizards and AVD manager as we add enhanced support for API 24.
  These are primarily cosmetic changes and should not stop you from getting
  your app ready for an update in the Play store.
</p>

<h4 id="api-changes">Feature and API changes</h4>

<ul>
  <li>In previous versions of Android, an app activates with all of its locale
  resources loaded before locale negotiation begins. Starting in Android N DP4,
  the system negotiates resource locales individually for each resource object
  before the app activates.
  </li>

  <li>As announced at Developer Preview 3, we’ve deferred the Launcher
  Shortcuts feature to a later release of Android. In Developer Preview 4,
  we’ve removed the Launcher Shortcuts APIs.
  </li>

  <li>We’ve changed the BLE Scanning behavior starting in DP4. We’ll prevent
  applications from starting and stopping scans more than 5 times in 30
  seconds. For long running scans, we’ll convert them into opportunistic scans.
  </li>

  <li>The <a href=
  "{@docRoot}preview/features/multi-window.html">Multi-Window</a>
  <code>android:minimalHeight</code> and <code>android:minimalWidth</code>
  attributes have been renamed to <code>android:minHeight</code> and
  <code>android:minWidth</code>.
  </li>
</ul>

<h3 id="ki">Known Issues</h3>

<h4>Stability</h4>

<ul>
  <li>Users may encounter system instability (such as kernel panics and
  crashes).
  </li>
</ul>

<h4>Launcher</h4>

<ul>
  <li>The default launcher’s <strong>All Apps</strong> tray may become
  unresponsive after cycling the screen off and on. Returning to the
  homescreen and relaunching the <strong>All Apps</strong> tray may resolve
  this issue.
  </li>
</ul>

<h4>Setup Wizard</h4>

<ul>
  <li>Crash on selecting "Not now" in "Set up email" screen.
  </li>
</ul>

<h4>Media</h4>

<ul>
  <li>Media playback may be unreliable on Nexus 9 and Nexus Player, including
  issues playing HD video.
  </li>

  <li>Occasional freeze when running the YouTube app with other apps in
  multi-window mode on Pixel C devices. In some cases hard reboot is required.
  </li>

  <li>Apps may have issues playing some Widevine DRM-protected content on Nexus
  9 devices.
  </li>

  <li>Issues handling VP8 video on Nexus 9 devices.
  </li>
</ul>

<h4>External storage</h4>

<ul>
  <li>Apps may become unstable when the user moves them from internal storage
  to adoptable external storage (this can include SD card or devices attached
  over USB).
  </li>
</ul>

<h4>Screen zoom and multiple APKs in Google Play</h4>

<ul>
  <li>On devices running Android N, Google Play services 9.0.83 incorrectly
  reports the current screen density rather than the stable screen density.
  When screen zoom is enabled on these devices, this can cause Google Play to
  select a version of a multi-APK app that’s designed for smaller screens. This
  issue is fixed in the next version of Google Play services and will be
  included in a later Developer Preview release.
  </li>
</ul>

<h4>Vulkan support and multiple APKs in Google Play</h4>

<ul>
  <li>On devices running Android N, Google Play services 9.0.83 currently
  reports Vulkan support but not Vulkan version. This can cause Google Play to
  select a version of a multi-APK app that’s designed for lower Vulkan support
  on devices with higher version support. Currently, the Google Play Store does
  not accept uploads of apps which use Vulkan version targeting. This support
  will be added to the Google Play Store in the future and fixed in the next
  version of Google Play services (to be included in a later Developer Preview
  release). Any N devices using the version of Google Play services 9.0.83 will
  continue to receive versions of apps targeting basic Vulkan support.
  </li>
</ul>

<h4>Accessibility</h4>
<ul>
  <li>Switch access doesn't allow user to navigate web pages in Chrome.
  </li>

  <li>Accessibility issues for talkback users with notification dismissal, and
  wifi selection screen.
  </li>
</ul>

<h4>Android for Work</h4>

<ul>
  <li>Currently, CA certificates provisioned through {@link
  android.app.admin.DevicePolicyManager} are not
  available to profiles other than the primary user/profile due to a preload
  issue. For example, this could prevent a user from connecting to a trusted
  server when in a Work profile. This issue will be resolved in the next
  Developer Preview.
  </li>

  <li>After reboot with work mode off, solving work challenge does not switch
  on work mode.
  </li>

  <li>Users receiving a video call in Hangouts have to unlock work challenge
    first.
  </li>

  <li>Accessing Settings &gt; Security &gt; Device Security crash observed when
  separating primary and work challenge.
  </li>

  <li>If {@link android.os.UserManager#DISALLOW_CONFIG_VPN} is set before
  calling {@link android.app.admin.DevicePolicyManager#setAlwaysOnVpnPackage
  DevicePolicyManager.setAlwaysOnVpnPackage()}, then setting always on VPN does
  not work. That is, after rebooting the device with the {@link
  android.os.UserManager#DISALLOW_CONFIG_VPN} restriction set, VPN is not
  autostarted.
  </li>
</ul>

<!-- TBA, if any
<h4>Device-specific issues</h4>

<dl>
  <dt>
    <strong>Device Name</strong>
  </dt>

  <dd>
    Issue 1
  </dd>

  <dd>
    Issue 2
  </dd>
</dl>

-->


<h4 id="dp4-fixes">Fixes for issues reported by developers</h4>

<p>
  A number of issues reported by developers have been fixed, including:
</p>

<ul>
  <li>The active network state ({@link android.net.NetworkInfo#getState
  NetworkInfo.getState()} and {@link android.net.NetworkInfo#getDetailedState
  NetworkInfo.getDetailedState()}) might return incorrect values during some
  restricted background scenarios
  </li>

  <li>Data Saver restricts the foreground MMS mobile network request
    (<a href="https://code.google.com/p/android/issues/detail?id=208478">bug
    208478</a>)
  </li>

  <li>Quick settings tiles and notifications sometimes unresponsive
  </li>

  <li>Unable to dismiss Clock notifications
  </li>

  <li>Duplication of bluetooth icon and other status icons
  </li>

  <li>Additional bluetooth connectivity fixes
  </li>
</ul>

<p>For the full list of fixed issues, see <a href="https://goo.gl/6uCKtf">the
issue tracker</a>.</p>




<!-- DP3 Release Notes Archive -->

<h2 id="dp3">Developer Preview 3</h2>

<div class="wrap">
  <div class="cols">
    <div class="col-6of12">
      <p>
        <em>Date: May 2016<br>
        Build: NPD35K<br>
        Emulator support: x86 &amp; ARM (32/64-bit)<br>
        Google Play services: 8.4</em>
      </p>
    </div>
  </div>
</div>

<h3 id="dp3-general">General advisories</h3>

<p>
  This Developer Preview release is for <strong>app developers and other early
  adopters</strong> and is available for daily use, development, or
  compatibility testing. Please be aware of these general notes about the
  release:
</p>

<ul>
  <li>This release may have various <strong>stability issues</strong> on
    supported devices. Users may encounter system instability, such as kernel
    panics and crashes.
  </li>

  <li>Some apps <strong>may not function as expected</strong> on the new
  platform version. This includes Google’s apps as well as other apps.
  </li>

  <li>Developer Preview 3 is <strong>Compatibility Test Suite (CTS)
  approved</strong> on these devices: Nexus 5X, Nexus 6, Nexus 6P, and Pixel
  C. Apps that depend on CTS approved builds should
  work normally on these devices (Android Pay for example).
  </li>

  <li>Developer Preview 3 is <strong>available on all supported
  devices:</strong> Nexus 5X, Nexus 6, Nexus 6P, Nexus 9, Nexus Player, Pixel
  C, General Mobile 4G (Android One), as well as Sony Xperia Z3 (D6603 and
  D6653 models).

  </li>
</ul>


<h3 id="dp3-new">New in DP3</h3>

<h4>VR Mode for Android</h4>

<p>
  Android N adds platform support and optimizations for a new VR Mode to let
  developers build high quality mobile VR experiences for users. There are a
  number of performance enhancements, including access to an exclusive CPU core
  for VR apps. Within your apps, you can take advantage of intelligent
  head-tracking, and stereo notifications that work for VR. Most importantly,
  Android N provides for very low latency graphics.
</p>

<p>
  For more information, see the <a href=
  "https://developers.google.com/vr/android/">Google VR SDK for Android</a>.
</p>

<h4>Sustained performance mode</h4>

<p>
  Android N includes optional support for <a href=
  "{@docRoot}preview/api-overview.html#sustained_performance_api">sustained
  performance mode</a>, enabling OEMs to provide hints on device performance
  capabilities for long running applications. App developers can then use these
  hints to tune applications for a predictable, consistent level of device
  performance over long periods of time. App developers can try out this new
  API in the developer preview on Nexus 6P devices only.
</p>

<h4>Multiprocess WebView</h4>

<p>
  Starting with version 51 in Android N, WebView will run web content in a
  separate sandboxed process when the developer option "Multiprocess WebView"
  is enabled. The WebView team is looking for feedback on compatibility and
  runtime performance in N before enabling multiprocess WebView in a future
  version of Android. In this version, regressions in startup time, total
  memory usage and software rendering performance are expected.
</p>

<p>
  If you find unexpected issues in multiprocess mode we’d like to hear about
  them. Please get in touch with the WebView team by <a href=
  "https://bugs.chromium.org/p/chromium/issues/entry?template=Webview%20Bugs">
  filing a bug</a>.
</p>

<h4>Keyboard Shortcuts helper</h4>

<p>
  Android N lets users press <code>Meta+/</code> to trigger a <strong>Keyboard
  Shortcuts</strong> screen that displays all shortcuts available both from the
  system and from the app in focus. Developers can add their own shortcuts or
  trigger the Shortcuts screen from their apps. See <a href=
  "{@docRoot}preview/api-overview.html#keyboard_shortcuts_helper">Keyboard
  Shortcuts helper</a> for details.
</p>

<h4>FrameMetrics API</h4>

<p>
  DP3 introduces a new <a href=
  "{@docRoot}preview/api-overview.html#framemetrics_api">FrameMetrics API</a>
  that allows an app to monitor its UI rendering performance by exposing a
  streaming pubsub API to transfer frame timing info for the application’s
  current window. <code>FrameMetricsListener</code> can be used to measure
  interaction-level UI performance in production with higher granularity and
  without the need for a USB connection.
</p>

<h4 id="dp3-api-changes">Feature and API changes</h4>

<dl>
  <dt>
    Launcher Shortcuts and the Launcher Shortcuts API
  </dt>

  <dd>
    We’ve decided to defer this feature to a future release of Android. We plan
    to remove the Launcher Shortcuts APIs (ShortcutManager and others) from the
    public Android N API starting in the next developer preview.
  </dd>

  <dt>
    WebView Javascript run before page load
  </dt>

  <dd>
    Starting with apps targeting Android N, the Javascript context is reset
    when a new page is loaded. Currently, the context is carried over for the
    first page loaded in a new {@link android.webkit.WebView} instance.
    Developers looking to inject Javascript into the {@link
    android.webkit.WebView} should execute the script after the page has
    started to load.
  </dd>

  <dt>
    WebView Geolocation on insecure origins
  </dt>

  <dd>
    Starting with apps targeting Android N, the geolocation API will only be
    allowed on secure origins (over HTTPS.) This policy is designed to protect
    users' private information when they're using an insecure connection.
  </dd>

  <dt>
    Data Saver
  </dt>

  <dd>
    Starting in Developer Preview 3, apps can use use an intent to display a
    system dialog that lets the user directly add the app to the Data Saver
    exemption whitelist. See the <a href=
    "{@docRoot}preview/api-overview.html#data_saver">Data Saver
    documentation</a> for details.
  </dd>

  <dt>
    <a href=
    "{@docRoot}preview/api-overview.html#number-blocking">Number-blocking</a>
  </dt>

  <dd>
    If an unauthorized user attempts to block or unblock a number, the
    operation now fails with {@link java.lang.SecurityException}. (Previously,
    the operation threw {@link java.lang.UnsupportedOperationException}.)
  </dd>

  <dt>
    <a href="{@docRoot}preview/api-overview.html#tile_api">Quick Settings Tile
    API</a>
  </dt>

  <dd>
    The system now uses the activity's metadata to decide on the tile mode.
    (Previously, tile mode was determined by the return value of
    <code>TileService.onTileAdded()</code>.) For more information, see
    <code>TileService.META_DATA_ACTIVE_TILE</code> in the downloadable <a href=
    "{@docRoot}preview/setup-sdk.html#docs-dl">API Reference</a>.
  </dd>
</dl>

<h4 id="dp3-fixes">Fixes for issues reported by developers</h4>

<p>
  A number of issues reported by developers have been fixed, including:
</p>

<ul>
  <li>Bluetooth Audio playback interrupted after 1 song (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=206889">206889</a>)
  </li>

  <li>Pixel C Consistently Crashes (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=206962">206962</a>)
  </li>

  <li>Clock and Toast notification issues (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=203094">203094</a>)
  </li>

  <li>Pixel C reboots when connected to MacBook Pro via USB C Cable (bug
  <a href=
  "https://code.google.com/p/android/issues/detail?id=205432">205432</a>)
  </li>

  <li>Calandar offset by one day (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=203002">203002</a>)
  </li>

  <li>TelephonyManager.getAllCellInfo returning invalid data (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=203022">203022</a>)
  </li>

  <li>Nexus 6p, Bluetooth keeps disconnecting (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=208062">208062</a>)
  </li>
</ul>

<p>For the full list of fixed issues, see <a href="https://goo.gl/6uCKtf">the
issue tracker</a>.</p>

<h3 id="dp3-ki">Known Issues</h3>

<h4>Accessibility</h4>

<ul>
  <li>Unable to listen to TTS output when pitch is set near maximum level.
  </li>

  <li>Accessibility features and settings may be disrupted with the user adds a
  Work profile, including magnification gesture and setting. Accessibility
  state is restored when the user next touches the associated settings.
  </li>
</ul>

<h4>Camera</h4>

<ul>
  <li>The Camera app has exhibited instability; it may crash in various
    circumstances, such as when launched in multi-window mode.
  </li>

  <li>Pressing the shutter continuously in panorama mode may cause the Camera
  app to crash.
  </li>
</ul>

<h4>Audio</h4>
<ul>
  <li>A platform audio player issue prevents some apps from functioning
  normally. For example, Skype and other apps are affected by this issue.
  </li>
</ul>

<h4>Connectivity</h4>


<ul>
  <li>When a Bluetooth Low Energy (BLE) peripheral role device advertises a
  service and a BLE central role device connects, the peripheral role device
  disconnects very quickly.
  </li>

  <li>Wi-Fi connection may be dropped when the screen is off.
  </li>

  <li>RFCOMM connections are unstable and may result in data corruption and
  dangling connections.
  </li>

  <li>The active network state ({@link android.net.NetworkInfo#getState
  NetworkInfo.getState()} and {@link android.net.NetworkInfo#getDetailedState
  NetworkInfo.getDetailedState()}) might return incorrect values during some
  restricted background scenarios.
  </li>
</ul>


<h4>
  Launcher
</h4>

<ul>
  <li>The default launcher’s All Apps tray may become unresponsive after
  cycling screen off / screen on. Returning to the homescreen and relaunching
  the All Apps tray may resolve this issue.
  </li>
</ul>

<h4>
  Keyboard
</h4>

<ul>
  <li>When updating a device running Android 6.0 or earlier to the N Developer
  Preview, Google Keyboard does not preserve preferences data such as recent
  emoji and sound settings.
  </li>

  <li>Google Indic Managed Keyboard may be unstable.
  </li>

  <li>When entering text in a password field, the user can select Russian as
  the input language but the keyboard remains in English. This prevents the
  user from entering Russian-language passwords.
  </li>
</ul>

<h4>
  Locale and languages
</h4>

<ul>
  <li>When using a right-to-left (RTL) locale, the system may unexpectedly
  switch to left-to-right (LTR) presentation after restarting the device.
  </li>
</ul>

<h4>Media</h4>

<ul>
  <li>Media playback be be unreliable on Nexus 9 and Nexus Player, including
  issues playing HD video.
  </li>
</ul>

<h4>
  Multi-window mode
</h4>

<ul>
  <li>Device may freeze when changing orientation in multi-window mode.
  </li>

  <li>Several apps currently have issues with multi-window mode:
    <ul>
      <li>The system UI may crash when docking Settings &gt; Display &gt;
      Screen brightness to multi-window.
      </li>

      <li>The Camera app may crash when launched in multi-window mode.
      </li>

      <li>YouTube may crash when launched into multi-window mode. To fix the
      issue, you can clear the YouTube app’s data at Storage &gt; Apps &gt;
      YouTube.
      </li>
    </ul>
  </li>
</ul>

<h4>
  Google Play services
</h4>

<ul>
  <li>Apps using Google Cast through Google Play services may be unstable when
  the user selects a system locale that uses letters and numbers outside of the
  ASCII range.
  </li>
</ul>

<h4>
  Android for Work and Google Apps Device Policy
</h4>

<ul>
  <li>The Device Policy app may crash when the user unlocks the device with the
  "device policy status" screen pinned.
  </li>

  <li>After setting up a work profile with file-based encryption enabled and
  then turning off Work, users must unlock primary profile screen lock to once
  again access Work apps.
  </li>

  <li>Device reboots when removing the security pattern lock and opening work
  app/personal app in the multi-window.
  </li>

  <li>Setting DISALLOW_VPN_CONFIG is causing the consent dialog to appear in
  always-on-vpn set by Device Policy Client.
  </li>

  <li>Traffic is not locked down until VPN is connected in always-on-vpn mode.
  </li>
</ul>

<h4>
  External storage
</h4>

<ul>
  <li>Apps may become unstable when the user moves them from internal storage
  to adoptable external storage (this can include SD card or devices attached
  over USB).
  </li>
</ul>

<h4>
  Screen zoom and multiple APKs in Google Play
</h4>

<ul>
  <li>On devices running Android N, Google Play services 9.0.83 incorrectly reports
  the current screen density rather than the stable screen density. When screen
  zoom is enabled on these devices, this can cause Google Play to select a
  version of a multi-APK app that’s designed for smaller screens. This issue is
  fixed in the next version of Google Play services and will be included in a
  later Developer Preview release.
  </li>

  <li>On devices running Android N, Google Play services 9.0.83 currently reports
  Vulkan support but not Vulkan version. This can cause Google Play to select a
  version of a multi-APK app that’s designed for lower Vulkan support on
  devices with higher version support. Currently, the Google Play Store does
  not accept uploads of Apps which use Vulkan version targeting. This support
  will be added to the Google Play Store in the future and fixed in the next
  version of Google Play services (to be included in a later Developer Preview
  release) any N devices using the version of Google Play services 9.0.83 will
  continue to receive versions of Apps targeting basic Vulkan support.
  </li>
</ul>

<h4>Notifications</h4>

<ul>
  <li>MessagingStyle does not show notifications with "null" (self) sender.
  </li>
</ul>

<h4>Developer Tools</h4>

<ul>
  <li>
    <code>adb</code> may sometimes disconnect while using JDWP debugging.
  </li>
</ul>


<!-- DP2 Release Notes Archive -->

<h2 id="dp2">Developer Preview 2</h2>

<div class="wrap">
  <div class="cols">
    <div class="col-6of12">
      <p>
        <em>Date: April 2016<br>
        Builds: NPC91K, NPC91O<br>
        Emulator support: x86 &amp; ARM (32/64-bit)<br>
        Google Play services: 8.4</em>
      </p>
    </div>
  </div>
</div>

<h3 id="dp2-new">New in DP2</h3>

<ul>
  <li>Platform support for Vulkan, a new 3D rendering API that provides
  explicit, low-overhead GPU (Graphics Processor Unit) control and offers
  improved performance for draw-call heavy applications. For details, see the
  <a href="{@docRoot}ndk/guides/graphics/index.html">documentation</a>.
  </li>

  <li>New people emoji with support for skin tones, and new Unicode 9 glyphs.
  Skin tone and new emoji will not show up until keyboards build support for
  them in the palette. Apps should not need to take any action to take
  advantage of these new emoji, unless the apps use a non-system font. IME
  developers need to incorporate support for the new emoji.
  </li>

  <li>
    <a href="{@docRoot}preview/api-overview.html#launcher_shortcuts">Launcher
    Shortcuts API</a>: Apps can use <code>ShortcutManager</code> to send
    shortcuts to starting points within themselves to the launcher.
  </li>

  <li>
    <a href="{@docRoot}preview/features/multi-window.html">Multi-Window</a>:
    You can now specify a separate minimum height and minimum width for an
    activity. In addition, several API names have been slightly changed.
  </li>
</ul>

<h4 id="dp2-fixes">Fixes for issues reported by developers</h4>

<p>
  A number of issues reported by developers have been fixed, including:
</p>

<ul>
  <li>Can’t connect to hidden SSID or non-broadcast Wi-Fi. (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=203116">203116</a>)
  </li>

  <li>Microphone mute state persists across activities. (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=205922">205922</a>)
  </li>

  <li>Changing multi-window focus pauses YouTube. (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=203424">203424</a>)
  </li>

  <li>Direct Reply may close open activity. (bug <a href=
  "https://code.google.com/p/android/issues/detail?id=204411">204411</a>)
  </li>

  <li>Various stability fixes.
  </li>
</ul>

<h3 id="dp2-general">General advisories</h3>

<p>
  This Developer Preview release is for <strong>app developers only</strong>
  and is designed for use in compatibility testing and early development only.
  Please be aware of these general notes about the release:
</p>

<ul>

  <li>The development tool components and support libraries have been updated
  for the DP2 release. Make sure to update your preview development environment
  before developing for DP2. For instructions on setting up your development
  environment, see
  <a href="{@docRoot}preview/setup-sdk.html">Set Up the Preview</a>.
  </li>

  <li>This release has various stability and performance issues on all devices
  that make it <strong>not suitable for daily use on phone or tablet</strong>,
  especially for non-developers.
  </li>

  <li>Battery life and performance have not yet been optimized with this
  release:

    <ul>
      <li>System and app <strong>performance is known to be periodically slow /
      janky</strong>, and devices may become occasionally unresponsive. These
      problems may become more acute with prolonged use.
      </li>

      <li>Battery life may be regressed in this release for screen-on and
      screen-off use cases.
      </li>
    </ul>
  </li>

  <li>Some <strong>apps may not function normally</strong> on Developer Preview
  2. This includes Google’s apps as well as other apps.
  </li>

  <li>This early build is not <strong>Compatibility Test Suite (CTS)
  approved</strong>. Apps that depend on CTS approved builds won’t work
  (Android Pay for example).
  </li>

  <li>This preview release supports the following devices: Nexus 5X, Nexus 6,
  Nexus 6P, Nexus 9, and Pixel C, as well as General Mobile 4G
  (Android One). Support for Nexus Player is coming soon.
  </li>


  <li><a href=
  "https://github.com/googlesamples/android-testdpc/releases">TestDPC</a> has
  been updated to handle API changes between DP1 and DP2.
  </li>
</ul>

<h3 id="dp2-ki">Known Issues</h3>

<h4>Performance and battery</h4>

<ul>
  <li>System and app performance is known to be <strong>periodically slow /
  janky</strong>, and device may become occasionally unresponsive. These
  problems may become more acute with prolonged use.
  </li>
</ul>

<h4>Google accounts</h4>

<ul>
  <li>In some circumstances, there can be issues with
  <code>AccountManagerService</code> that prevent logging in to Google accounts
  </li>
</ul>

<h4>System update</h4>

<ul>
  <li>Device may restart immediately after updating to DP2.
  </li>
</ul>

<h4>Accessibility</h4>

<ul>
  <li>Problem with listening to text-to-speech (TTS) output when pitch is set
  near maximum level.
  </li>
</ul>

<h4>Bluetooth</h4>

<ul>
  <li>Bluetooth Low Energy (LE) GATT characteristics are using the wrong write
  type and will not be sent to a remote device. Thus, for example, some fitness
  devices will not work.
  </li>
</ul>

<h4>Setup wizard</h4>

<ul>
  <li>The option to restore data on a new device (or newly reset device) from
  "Your Google Account" is not actionable in the setup wizard. You must restore
  data from an existing device by selecting "another Android device" in the
  setup wizard, or else set it up as a new device.
  </li>
</ul>

<h4>OEM unlock</h4>

<ul>
  <li>On some devices, <strong>Enable OEM unlock</strong> is grayed out in
  "Developer Options" while running DP2.<br>
  <strong>Workaround:</strong> Opt in to
  the Android Beta Program (if you are not already opted in) by visiting
  <a href="https://www.google.com/android/beta" class=
  "external-link">www.google.com/android/beta</a>. Then, opt out and accept the
  downgrade OTA. Opting out causes the device to downgrade to Android 6.0. You
  should now be able to choose <strong>Enable OEM unlock</strong> in
  "Developer Options". Personal data is erased when you downgrade the
  device; however, unlocking the bootloader would have erased this data anyway.
  </li>
</ul>

<h4>Android for Work</h4>

<ul>
  <li>Work Security Challenge
    <ul>
      <li>After migration to N, or after the user creates work profiles, work
      profiles can't create keys in the keystore until the user changes their
      pattern, PIN, or password, or sets up a Work Challenge.
      </li>

      <li>In Direct boot mode, applying the passcode restrictions to the device
      causes the work profile to be unlocked, even though the device is locked.
      This makes the work profile accessible even though it should be protected
      by the device lock screen.
      </li>
    </ul>
  </li>

  <li>Always On VPN
    <ul>
      <li>If Always On VPN mode is turned on, but VPN is not available, apps
      connect over the ordinary network. Apps should be offline if they have no
      VPN connection available.
      </li>

      <li>When Always On mode is on, a VPN connection is not established after
      a device reboots into Direct boot mode, even after the user unlocks the
      secure lock screen.
      </li>
    </ul>
  </li>

  <li>Suspend Packages
    <ul>
      <li>Device admins can suspend critical system packages, which may lead to
      unexpected behavior, such as placing calls despite the "Telephone
      disabled" dialog being displayed.
      </li>
    </ul>
  </li>

  <li>Other
    <ul>
      <li>The Settings app crashes on launch if {@link
      android.os.UserManager#DISALLOW_MOUNT_PHYSICAL_MEDIA} is set to true when
      the user inserts physical media such as an SD card.
      </li>

      <li>The first check-in in a Work Profile takes several minutes to
      complete.
      </li>
    </ul>
  </li>
</ul>

<h4 id="vulkan">Vulkan</h4>

<ul>
   <li>Nexus 5X/6P</li>
   <ul>
      <li>Gaps between binding numbers and non-zero
      as the first binding number causes {@code vkCreateGraphicsPipeline()} to fail.</li>
      <li>Vulkan exhibits incorrect sampling behavior on projected texture coordinates.</li>
      <li>in the multithreadCmdBuffer sample, {@code vkCmdClearColorImage()} crashes when
      running with the N-DP2 driver.</li>
      <li>Return values from {@code vkGetPhysicalDeviceFormatProperties()} do not set a value
      for {@code VkFormatProperties::linearTilingFeatures}, which takes a value of 0 as
      a result.</li>
      <li>Vulkan floating point frame buffer attachments are not handled correctly.</li>
    </ul>
   <li>Nexus Player</li>
   <ul>
      <li>SPIR-V shaders may trigger driver asserts.</li>
      <li>Some pipeline configurations may cause {@code vkCreateGraphicsPipeline()}
      to crash.</li>
  </ul>
</ul>

<h4>Device-specific issues</h4>

<dl>
  <dt>
    <strong>Android One</strong>
  </dt>

  <dd>
    Data connection fails when device is switched from slot 1 to slot 2 SIM.
  </dd>

  <dt>
    <strong>Pixel C</strong>
  </dt>

  <dd>
    Unable to toggle Voice Search "Always On" option.
  </dd>

  <dt>
    <strong>Nexus 6</strong>
  </dt>

  <dd>
    Camera pictures in portrait orientation are corrupted, except for HDR+
    photos.
  </dd>

  <dt>
    <strong>Nexus Player</strong>
  </dt>

  <dd>
    Playback of Netflix HD content may fail on Nexus Player.
  </dd>

  <dd>
    Any application that relies on dynamic video resolution changes may fail on
    Nexus Player.
  </dd>

  <dd>
    Any application that use the VP9 video codec may fail on Nexus Player.
  </dd>
</dl>

<!-- DP 1 release notes archive -->

<h2 id="dp1">Developer Preview 1</h2>

<div class="wrap">
  <div class="cols">
    <div class="col-6of12">
      <p>
        <em>Date: March 2016<br>
        Builds: NPC56P, NPC56R, updated: NPC56W, NPC56X<br>
        Emulator support: x86 &amp; ARM (32/64-bit)<br>
        Google Play services: 8.4</em>
      </p>
    </div>
  </div>
</div>

<h3 id="dp1-general">General advisories</h3>

<p>
  This Developer Preview release is for app developers only and is designed for
  use in compatibility testing and early development only. Please be aware of
  these general notes about the release:
</p>
<ul>
  <li>This release has various stability and performance issues on all devices
  that make it <em>not suitable for daily use on phone or tablet</em>,
  especially for non-developers.
  </li>

  <li>System and app performance is known to be <strong>periodically slow /
  janky</strong>, and device may become occasionally unresponsive. These
  problems may become more acute with prolonged use.
  </li>

  <li>Battery life may be regressed in this release for screen-on and
  screen-off use cases.
  </li>

  <li>Some apps may not function normally on Developer Preview 1. This includes
  Google’s apps as well as other apps.
  </li>

  <li>This early build is not Compatibility Test Suite (CTS) approved. Apps
  that depend on CTS approved builds (Android Pay for example) won’t work.
  </li>

  <li>This preview release supports the following devices: Nexus 5X, Nexus 6,
  Nexus 6P, Nexus 9, Nexus Player, and Pixel C, as well as General Mobile 4G
  (Android One).
  </li>
</ul>

<h3 id="dp1-platform">Platform Issues</h3>

<h4>Performance and battery</h4>

<ul>
  <li>System and app performance is known to be <strong>periodically slow /
  janky</strong>, and device may become occasionally unresponsive. These
  problems may become more acute with prolonged use.
  </li>

  <li>Battery life may be regressed in this release for screen-on and
  screen-off use cases.
  </li>
</ul>
<h4 id="dialer">Dialer</h4>

<ul>
  <li>Dialer app does not support Direct boot. This will be addressed later in
  N Developer Preview.
  </li>

  <li>Voicemail playback does not work.
  </li>
</ul>

<h4>Microphone</h4>

<ul>
   <li>The system may incorrect persists the microphone mute state across apps and reboots. If you mute the microphone in an app and the state is persisted, open any app that has microphone mute controls and unmute the microphone.</li>
</ul>

<h4 id="ui">System UI</h4>

<ul>
  <li>Some new or modified strings in the system UI are not translated to all
  languages.
  </li>

  <li>Overview UI is still in development, and subject to change. For example,
  we intend to remove the timer that appears when the user switches between
  apps.
  </li>

  <li>Settings controls and toggles may be slow or appear to be unresponsive.
  </li>

  <li>Visual design of notifications is subject to change.
  </li>

  <li>In the Gmail app, direct archiving of emails included in a notification
  bundle does not work properly.
  </li>
</ul>

<h4>Android for Work</h4>

<ul>
  <li>Work Security Challenge
    <ul>
      <li>After migration to N, or after the user creates work profiles, work
      profiles can't create keys in the keystore until the user changes their
      pattern, PIN, or password, or sets up a Work Challenge.
      </li>

      <li>In Direct boot mode, applying the passcode restrictions to the device
      causes the work profile to be unlocked, even though the device is locked.
      This makes the work profile accessible even though it should be protected
      by the device lock screen.
      </li>

      <li>When the user enters a wrong password and pin, the system does not
      display any informational message; instead, it only clears the input
      field. This issue does not affect pattern or fingerprint input.
      </li>

      <li>On a tablet, the background displayed with the work challenge is
      disproportionately small.
      </li>

      <li>The version of <a href=
      "https://play.google.com/store/apps/details?id=com.google.android.apps.enterprise.dmagent">
        Google Apps Device Policy</a> that is bundled with N Developer Preview
        does not yet support the Work Profile Security Challenge feature.
        Developers should instead use <a href=
        "https://github.com/googlesamples/android-testdpc/releases">TestDPC</a>
        to test this feature.
      </li>
    </ul>
  </li>

  <li>Always On VPN
    <ul>
      <li>If Always On VPN mode is turned on, but VPN is not available, apps
      not specified as exceptions to the Always On policy connect over the
      ordinary network. Unless specified as exceptions to Always On VPN policy,
      apps should be offline if they have no VPN connection available.
        <ul>
          <li>When Always On mode is on, a VPN connection is not established
          after a device reboots into Direct boot mode, even after the user
          unlocks the secure lock screen.
          </li>
        </ul>
      </li>
    </ul>
  </li>

  <li>Improved Contacts
    <ul>
      <li>Bluetooth PBAP/MAP devices do not display Caller ID for work
      contacts. The next release of Preview resolves this issue.
      </li>
    </ul>
  </li>

  <li>Work Mode
    <ul>
      <li>The Google Now Launcher does not display whether Work Mode is on or
      off. The Launcher also does not show app suspension state.
      </li>

      <li>After the user turns Work Mode off and on, the system no longer shows
      Work profile app widgets, such as Calendar.
      </li>
    </ul>
  </li>

  <li>Suspend Packages
  </li>

  <li>Device admins can suspend critical system packages, which may lead to
  unexpected behavior, such as placing calls despite the Telephone disabled
  dialog’s being displayed.
  </li>

  <li>Other
    <ul>
      <li>The Settings app crashes on launch if {@link
      android.os.UserManager#DISALLOW_MOUNT_PHYSICAL_MEDIA} is set to true when
      the user inserts physical media such as an SD card.
      </li>

      <li>The {@code DPM.setPackagesSuspended} state does not persist when the
      user uninstalls and then reinstalls an app. Either the app should remain
      suspended after uninstall/reinstall, or suspended apps should not be
      uninstallable
      </li>

      <li>The first check-in in a Work Profile takes several minutes to
      complete. This may cause the device to take longer than normal to be
      visible in the Play EMM API.
      </li>

      <li>Notifications from Work Profile apps are not visible to notification
      listeners installed in the personal profile. As a result, the system does
      not display Notifications as expected.
      </li>

    </ul>
  </li>
</ul>

<h4 >Keyboard</h4>

<ul>
  <li>Bluetooth pairing between keyboards and Android devices may be unstable.
  </li>
</ul>

<h4 >Video</h4>

<ul>
<li>Video playback may lag and show interruptions.</li>
</ul>

<h4>Wi-Fi</h4>

<ul>
  <li>Wi-Fi has undergone some refactoring which may change API corner case
  behavior. Specifically, applications which attempt to connect to specific
  networks, or attempt to reconnect to networks should retest.
  </li>

  <li>The legacy DHCP client has been removed from the platform. The only DHCP
  client that the platform supports is the DHCP client introduced in M.
  </li>
</ul>

<h4>Direct boot</h4>

<ul>
  <li>NFC doesn't function until first unlock.
    <ul>
      <li>When a phone with Bluetooth enabled is restarted, Bluetooth does not
      turn on automatically. You must manually re-enable Bluetooth.
      </li>

      <li>Under some circumstances, the default ringtone may not sound for
      phone calls and messages. This behavior is fixed in the next N Preview
      release, with one exception (and workaround):
      </li>

      <li>On a device that is not freshly wiped--one that has been booted at
      least once since being set to direct boot mode--the default notification
      ringtone does not sound. The user can work around this issue by manually
      selecting a ringtone from Settings.
      </li>

      <li>Direct boot is not enabled by default on devices running an N
      Developer Preview build. To enable direct boot for testing and
      development, go to Developer Options and tap Convert to File Encryption.
      In this dev preview, this requires a factory reset to repartition and
      reformat your device for File-based Encryption.
      </li>
    </ul>
  </li>
</ul>

<h4>Picture-in-picture for Android TV</h4>

<ul>
  <li>The PIP integration in the Recents UI is not finalized, and is subject to
  change.
    <ul>
      <li>The animation of the PIP window is not smooth. Future releases of the
      Preview will improve this.
      </li>
    </ul>
  </li>

  <li style="list-style: none">Future releases of the Preview will improve upon
  the visual design and layout alignment of PIP.
  </li>
</ul>

<h4>Bug reports</h4>

<ul>
  <li>Bug reports do not always complete successfully (as a workaround,
  sometimes they can still be accessed through the bug report document provider
  in internal storage).
  </li>
</ul>

<h4>Split-screen Multi-window</h4>

<ul>
  <li>Apps may experience crashes and unexpected UI behavior when put into
  split-screen mode. These are app issues that must be fixed by the app
  developer.
  </li>

  <li>When an app targets a version of the Android platform earlier than N, the
  App may not work with split-screen toast may appear multiple times.
  </li>

  <li>Long-pressing the Overview button while using an app with a fixed
  orientation may produce unexpected app behavior.
  </li>

  <li>Apps may flicker while resizing.
  </li>

  <li>Animations are not yet final.
  </li>
</ul>

<h4>Input method</h4>

<ul>
  <li>Google Keyboard unexpectedly falls back to the generic Google keyboard
  when <b>Use system language</b>, but Google Keyboard doesn’t support any of
  the languages selected in the system-language preferences. It should fall
  back to American English.
    <p>
      You can work around this problem by adding at least one language that
      Google Keyboard supports.
    </p>
  </li>
</ul>

<h4>Accessibility</h4>

<ul>
  <li>TalkBack exhibits issues with features including Notifications, Quick
  Settings Tiles and Multi-window display that may cause system crashing or
  lack of spoken feedback from TalkBack. Future releases of the preview will
  address these issues.
  </li>
</ul>

<h3 id="dp1-device-sp">Device-Specific Notes and Issues</h3>

<h4>Nexus Player</h4>
<ul>
  <li>Video playback, app compatibility and stability issues are expected on
  Nexus Player in this release of the Preview.
  </li>
</ul>

<h4>Pixel C</h4>
<ul>
<li>Multi-window resizing may cause crashing.</li>
</ul>

<h4>Nexus 9</h4>
<ul>
<li>Nexus 9 devices may not start after receiving an over-the-air (OTA) update
  via the Android Beta Program. To recover from this issue, you can try
  to manually install the OTA image. For more information, see
  <a href="{@docRoot}preview/download-ota.html">Applying a Device OTA Image</a>.
</li>
</ul>

