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

<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="dp3">Developer Preview 3</h2>

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

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


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

<dl>
  <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="dp2-fixes">Fixes for issues reported by developers</h4>

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

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

<h3 id="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>TODO</li>
</ul>

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

<p>TODO</p>

<h4>Device-specific issues</h4>

<p>TODO</p>

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

  <dd>
    Issue 1
  </dd>

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

<!-- 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>

