October 13, 2015 10:22 am

Windows 10 SDK Preview Build 10563 Released

Today, we released a new Windows 10 SDK Preview and the associated Windows 10 Mobile emulators (Build 10563), to be used in conjunction with Windows 10 Insider Preview (Build 10565). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 10563 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview. The Preview SDK can be downloaded from the Windows 10 Developer Tools page.

We do recommend any uninstalling any preview SDK and emulators if you have it installed. This will prevent UI clutter in Visual Studio when choosing what emulator to target.

Start developing and @WindowsDev would love to see what you create. If you find bugs or issues, please leverage the Windows Feedback tool or MSDN forums.

What is new in SDK 10563

Emulator:

  • Updated the OS image included with the Windows 10 Mobile Emulator

SDK:

  • Corrected the signing of the Microsoft General MIDI DLS for Universal Windows Apps Extension SDK
  • Corrected the “No .natvis files found” error when you run Debugging Tools For Windows (WinDbg)” issue with WinDbg. See https://support.microsoft.com/en-us/kb/3091112 for more details.
  • Corrected the Windows Performance Analyzer crashes when ResidentSet graph is used
  • Corrected problem that prevented trace capture on pre-Windows 8 OS releases using xperf.exe and wpr.exe.
  • Corrected Windows Performance Analyzer crash when trying to modify the symbols inclusion/exclusion list in the Load Settings tab of the Configure Symbols dialog.
  • Improved Intellisense documentation for a large number of APIs.

Updated tests in the Windows App Certification Kit:

  • The “App prelaunch” test was enabled. This test proactively prelaunches and keeps apps in the background, verifying that the app handles the prelaunch scenario correctly.
  • The “App resources” test now runs correctly against UWA apps. This could result in failures not previously seen but for which the apps were always expected to pass.
  • The “Supported APIs” test no longer fails the app if the app invokes approved APIs by ordinals.

Changes in the Universal Windows Platform – Added

namespace Windows.ApplicationModel.Calls {
  public sealed class CallAnswerEventArgs
  public sealed class CallRejectEventArgs
  public sealed class CallStateChangeEventArgs
  public struct CallsVoipContract
  public sealed class MuteChangeEventArgs
  public sealed class VoipCallCoordinator
  public sealed class VoipPhoneCall
  public enum VoipPhoneCallMedia : uint
  public enum VoipPhoneCallRejectReason
  public enum VoipPhoneCallResourceReservationStatus
  public enum VoipPhoneCallState
}

namespace Windows.Devices.Printers {
  public sealed class Print3DDevice
  public struct PrintersContract
  public sealed class PrintSchema
}

namespace Windows.Foundation.Metadata {
  public sealed class PreviousContractVersionAttribute : Attribute {
    public PreviousContractVersionAttribute(string contract, uint versionLow, uint versionHigh);
    public PreviousContractVersionAttribute(string contract, uint versionLow, uint versionHigh, string newContract);
  }
}

namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    DevicePairing = 1013,
    Print3DWorkflow = 1011,
  }
  public sealed class DevicePairingActivatedEventArgs : IActivatedEventArgs, IDevicePairingActivatedEventArgs
  public interface IDevicePairingActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public sealed class SensorDataThresholdTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Chat {
  public sealed class ChatConversation {
    bool CanModifyParticipants { get; set; }
  }
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactCardOptions {
    IVector<string> ServerSearchContactListIds { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackageView {
    void SetAcceptedFormatId(string formatId);
  }
  public sealed class OperationCompletedEventArgs {
    string AcceptedFormatId { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public enum EmailCertificateValidationStatus
  public sealed class EmailMailbox {
    IAsyncOperation<IVectorView<EmailRecipientResolutionResult>> ResolveRecipientsAsync(IIterable<string> recipients);
    IAsyncOperation<EmailMailboxCreateFolderResult> TryCreateFolderAsync(string parentFolderId, string name);
    IAsyncOperation<EmailMailboxDeleteFolderStatus> TryDeleteFolderAsync(string folderId);
    IAsyncOperation<EmailMailboxEmptyFolderStatus> TryEmptyFolderAsync(string folderId);
    IAsyncOperation<IVectorView<EmailCertificateValidationStatus>> ValidateCertificatesAsync(IIterable<Certificate> certificates);
  }
  public sealed class EmailMailboxCapabilities {
    bool CanCreateFolder { get; }
    bool CanDeleteFolder { get; }
    bool CanEmptyFolder { get; }
    bool CanMoveFolder { get; }
    bool CanResolveRecipients { get; }
    bool CanValidateCertificates { get; }
  }
  public sealed class EmailMailboxCreateFolderResult
  public enum EmailMailboxCreateFolderStatus
  public enum EmailMailboxDeleteFolderStatus
  public enum EmailMailboxEmptyFolderStatus
  public sealed class EmailMailboxPolicies {
    bool MustEncryptSmimeMessages { get; }
    bool MustSignSmimeMessages { get; }
  }
  public sealed class EmailMeetingInfo {
    bool IsReportedOutOfDateByServer { get; }
  }
  public sealed class EmailMessage {
    IRandomAccessStreamReference SmimeData { get; set; }
    EmailMessageSmimeKind SmimeKind { get; set; }
  }
  public enum EmailMessageSmimeKind
  public sealed class EmailRecipientResolutionResult
  public enum EmailRecipientResolutionStatus
}
namespace Windows.ApplicationModel.Store {
  public static class CurrentApp {
    public static IAsyncOperation<string> GetCustomerCollectionsIdAsync(string serviceTicket, string publisherUserId);
    public static IAsyncOperation<string> GetCustomerPurchaseIdAsync(string serviceTicket, string publisherUserId);
  }
  public sealed class ListingInformation {
    string CurrencyCode { get; }
    string FormattedBasePrice { get; }
    bool IsOnSale { get; }
    DateTime SaleEndDate { get; }
  }
  public sealed class ProductListing {
    string CurrencyCode { get; }
    string FormattedBasePrice { get; }
    bool IsOnSale { get; }
    DateTime SaleEndDate { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    void Cancel(string correlationVector);
    void Pause(string correlationVector);
    void Restart(string correlationVector);
  }
  public sealed class AppInstallManager {
    void Cancel(string productId, string correlationVector);
    IAsyncOperation<bool> GetIsAppAllowedToInstallAsync(string productId, string skuId, string catalogId, string correlationVector);
    void Pause(string productId, string correlationVector);
    void Restart(string productId, string correlationVector);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector);
    IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string catalogId, string correlationVector);
    IAsyncOperation<AppInstallItem> StartAppInstallAsync(string productId, string skuId, bool repair, bool forceUseOfNonRemovableStorage, string catalogId, string bundleId, string correlationVector);
    IAsyncOperation<AppInstallItem> UpdateAppByPackageFamilyNameAsync(string packageFamilyName, string correlationVector);
  }
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    string EnterpriseDataIdentity { get; }
    bool IsDataEncryptedUnderLock { get; }
  }
}
namespace Windows.Data.Json {
  public static class JsonError {
    public static JsonErrorStatus GetStatus(int hresult);
  }
}
namespace Windows.Devices.Bluetooth {
  public enum BluetoothAddressType
  public sealed class BluetoothDevice : IClosable {
    DeviceInformation DeviceInformation { get; }
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress);
    public static string GetDeviceSelectorFromClassOfDevice(BluetoothClassOfDevice classOfDevice);
    public static string GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus);
    public static string GetDeviceSelectorFromDeviceName(string deviceName);
    public static string GetDeviceSelectorFromPairingState(bool pairingState);
  }
  public enum BluetoothError {
    DisabledByUser = 7,
  }
  public sealed class BluetoothLEAppearance
  public static class BluetoothLEAppearanceCategories
  public static class BluetoothLEAppearanceSubcategories
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothLEAppearance Appearance { get; }
    BluetoothAddressType BluetoothAddressType { get; }
    DeviceInformation DeviceInformation { get; }
    public static IAsyncOperation<BluetoothLEDevice> FromBluetoothAddressAsync(ulong bluetoothAddress, BluetoothAddressType bluetoothAddressType);
    public static string GetDeviceSelectorFromAppearance(BluetoothLEAppearance appearance);
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress);
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress, BluetoothAddressType bluetoothAddressType);
    public static string GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus);
    public static string GetDeviceSelectorFromDeviceName(string deviceName);
    public static string GetDeviceSelectorFromPairingState(bool pairingState);
  }
}
namespace Windows.Devices.Bluetooth.Rfcomm {
  public sealed class RfcommServiceProvider {
    void StartAdvertising(StreamSocketListener listener, bool radioDiscoverable);
  }
}
namespace Windows.Devices.Enumeration {
  public sealed class DeviceInformationCustomPairing
  public sealed class DeviceInformationPairing {
    DeviceInformationCustomPairing Custom { get; }
    DevicePairingProtectionLevel ProtectionLevel { get; }
    IAsyncOperation<DevicePairingResult> PairAsync(DevicePairingProtectionLevel minProtectionLevel, IDevicePairingSettings devicePairingSettings);
    public static bool TryRegisterForAllInboundPairingRequests(DevicePairingKinds pairingKindsSupported);
    IAsyncOperation<DeviceUnpairingResult> UnpairAsync();
  }
  public enum DevicePairingKinds : uint
  public sealed class DevicePairingRequestedEventArgs
  public enum DevicePairingResultStatus {
    Failed = 19,
    OperationAlreadyInProgress = 15,
    PairingCanceled = 14,
    RejectedByHandler = 17,
    RemoteDeviceHasAssociation = 18,
    RequiredHandlerNotRegistered = 16,
  }
  public sealed class DeviceUnpairingResult
  public enum DeviceUnpairingResultStatus
  public interface IDevicePairingSettings
}
namespace Windows.Devices.Perception {
  public static class KnownPerceptionFrameSourceProperties {
    public static string DeviceId { get; }
  }
  public sealed class PerceptionColorFrameSource {
    string DeviceId { get; }
  }
  public sealed class PerceptionDepthFrameSource {
    string DeviceId { get; }
  }
  public sealed class PerceptionInfraredFrameSource {
    string DeviceId { get; }
  }
}
namespace Windows.Devices.Printers.Extensions {
  public sealed class Print3DWorkflow
  public enum Print3DWorkflowDetail
  public sealed class Print3DWorkflowPrintRequestedEventArgs
  public enum Print3DWorkflowStatus
}
namespace Windows.Devices.Sensors {
  public interface ISensorDataThreshold
  public sealed class Pedometer {
    IMapView<PedometerStepKind, PedometerReading> GetCurrentReadings();
    public static IVectorView<PedometerReading> GetReadingsFromTriggerDetails(SensorDataThresholdTriggerDetails triggerDetails);
  }
  public sealed class PedometerDataThreshold : ISensorDataThreshold
  public sealed class ProximitySensorDataThreshold : ISensorDataThreshold
  public sealed class SensorDataThresholdTriggerDetails
  public enum SensorType
}
namespace Windows.Devices.WiFiDirect {
  public sealed class WiFiDirectAdvertisement {
    IVector<WiFiDirectConfigurationMethod> SupportedConfigurationMethods { get; }
  }
  public enum WiFiDirectConfigurationMethod
  public sealed class WiFiDirectConnectionParameters : IDevicePairingSettings {
    IVector<WiFiDirectConfigurationMethod> PreferenceOrderedConfigurationMethods { get; }
    WiFiDirectPairingProcedure PreferredPairingProcedure { get; set; }
    public static DevicePairingKinds GetDevicePairingKinds(WiFiDirectConfigurationMethod configurationMethod);
  }
  public enum WiFiDirectPairingProcedure
}
namespace Windows.Gaming.UI {
  public static class GameBar
}
namespace Windows.Graphics.Display {
  public sealed class DisplayInformation {
    IReference<double> DiagonalSizeInInches { get; }
  }
}
namespace Windows.Graphics.Holographic {
  public struct HolographicAdapterId
  public sealed class HolographicCamera
  public sealed class HolographicCameraPose
  public sealed class HolographicCameraRenderingParameters
  public sealed class HolographicFrame
  public sealed class HolographicFramePrediction
  public enum HolographicFramePresentResult
  public enum HolographicFramePresentWaitBehavior
  public sealed class HolographicSpace
  public sealed class HolographicSpaceCameraAddedEventArgs
  public sealed class HolographicSpaceCameraRemovedEventArgs
  public struct HolographicStereoTransform
}
namespace Windows.Management.Orchestration {
  public sealed class CurrentAppOrchestration
  public sealed class SingleAppModeContext : IClosable
}
namespace Windows.Media.Capture {
  public sealed class AppCapture
}
namespace Windows.Media.Core {
  public sealed class MediaBinder
  public sealed class MediaBindingEventArgs
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    MediaSourceState State { get; }
    event TypedEventHandler<MediaSource, MediaSourceStateChangedEventArgs> StateChanged;
    public static MediaSource CreateFromMediaBinder(MediaBinder binder);
    void Reset();
  }
  public enum MediaSourceState
  public sealed class MediaSourceStateChangedEventArgs
}
namespace Windows.Media.DialProtocol {
  public sealed class DialDevice {
    string FriendlyName { get; }
    IRandomAccessStreamReference Thumbnail { get; }
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    public static MediaPlaybackItem FindFromMediaSource(MediaSource source);
  }
  public sealed class MediaPlaybackList : IMediaPlaybackSource {
    IReference<TimeSpan> MaxPrefetchTime { get; set; }
    IVectorView<MediaPlaybackItem> ShuffledItems { get; }
    MediaPlaybackItem StartingItem { get; set; }
    void SetShuffledItems(IIterable<MediaPlaybackItem> value);
  }
  public sealed class MediaPlayer {
    void AddAudioEffect(string activatableClassId, bool effectOptional, IPropertySet configuration);
    void RemoveAllEffects();
  }
}
namespace Windows.Media.Protection {
  public sealed class ProtectionCapabilities
  public enum ProtectionCapabilityResult
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSource : IMediaSource {
    AdaptiveMediaSourceAdvancedSettings AdvancedSettings { get; }
  }
  public sealed class AdaptiveMediaSourceAdvancedSettings
}
namespace Windows.Perception {
  public sealed class PerceptionTimestamp
  public static class PerceptionTimestampHelper
}
namespace Windows.Perception.People {
  public sealed class HeadPose
}
namespace Windows.Perception.Spatial {
  public sealed class SpatialAnchor
  public static class SpatialAnchorManager
  public sealed class SpatialAnchorRawCoordinateSystemAdjustedEventArgs
  public sealed class SpatialAnchorStore
  public struct SpatialBoundingBox
  public struct SpatialBoundingFrustum
  public struct SpatialBoundingOrientedBox
  public struct SpatialBoundingSphere
  public sealed class SpatialBoundingVolume
  public sealed class SpatialCoordinateSystem
  public enum SpatialLocatability
  public sealed class SpatialLocation
  public sealed class SpatialLocator
  public sealed class SpatialLocatorAttachedFrameOfReference
  public sealed class SpatialLocatorPositionalTrackingDeactivatingEventArgs
  public sealed class SpatialStationaryFrameOfReference
}
namespace Windows.Perception.Spatial.Surfaces {
  public sealed class SpatialSurface
  public sealed class SpatialSurfaceMesh
  public sealed class SpatialSurfaceMeshBuffer
  public sealed class SpatialSurfaceMeshIntersection
  public sealed class SpatialSurfaceMeshOptions
  public sealed class SpatialSurfaceObserver
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class WebTokenRequest {
    IMap<string, string> AppProperties { get; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction PullCookiesAsync(string uriString, string callerPFN);
  }
}
namespace Windows.Security.Credentials {
  public sealed class KeyCredential {
    IBuffer RetrievePublicKey(CryptographicPublicKeyBlobType blobType);
  }
}
namespace Windows.Services.Maps {
  public static class MapService {
    public static string DataAttributions { get; }
  }
}
namespace Windows.Storage {
  public static class DownloadsFolder {
    public static IAsyncOperation<StorageFile> CreateFileForUserAsync(User user, string desiredName);
    public static IAsyncOperation<StorageFile> CreateFileForUserAsync(User user, string desiredName, CreationCollisionOption option);
    public static IAsyncOperation<StorageFolder> CreateFolderForUserAsync(User user, string desiredName);
    public static IAsyncOperation<StorageFolder> CreateFolderForUserAsync(User user, string desiredName, CreationCollisionOption option);
  }
  public enum KnownFolderId
  public static class KnownFolders {
    public static IAsyncOperation<StorageFolder> GetFolderForUserAsync(User user, KnownFolderId folderId);
  }
  public sealed class StorageLibrary {
    public static IAsyncOperation<StorageLibrary> GetLibraryForUserAsync(User user, KnownLibraryId libraryId);
  }
}
namespace Windows.System {
  public static class MemoryManager {
    public static bool TrySetAppMemoryUsageLimit(ulong value);
  }
}
namespace Windows.System.Profile {
  public enum PlatformDataCollectionLevel
  public static class PlatformDiagnosticsAndUsageDataSettings
}
namespace Windows.UI.Composition {
  public sealed class ColorKeyFrameAnimation : KeyFrameAnimation
  public enum CompositionAlphaMode
  public class CompositionAnimation : CompositionObject {
    void SetColorParameter(string key, Color value);
    void SetQuaternionParameter(string key, Quaternion value);
  }
  public enum CompositionBackfaceVisibility
  public sealed class CompositionBatch : CompositionObject
  public sealed class CompositionBatchCompletedEventArgs : CompositionObject
  public enum CompositionBatchTypes : uint
  public enum CompositionBitmapInterpolationMode
  public enum CompositionBorderMode
  public class CompositionBrush : CompositionObject
  public sealed class CompositionColorBrush : CompositionBrush
  public enum CompositionColorSpace
  public enum CompositionCompositeMode
  public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface
  public sealed class CompositionEffectBrush : CompositionBrush
  public sealed class CompositionEffectFactory : CompositionObject {
    HResult ExtendedError { get; }
    CompositionEffectFactoryLoadStatus LoadStatus { get; }
    CompositionEffectBrush CreateBrush();
  }
  public sealed class CompositionEffectFactoryLoadResult
  public enum CompositionEffectFactoryLoadStatus {
    Other = -1, // used to be 2
    Pending = 2,
  }
  public sealed class CompositionGraphicsDevice {
    event TypedEventHandler<CompositionGraphicsDevice, RenderingDeviceReplacedEventArgs> RenderingDeviceReplaced;
    CompositionDrawingSurface CreateDrawingSurface(Size sizePixels, DirectXPixelFormat pixelFormat, CompositionAlphaMode alphaMode);
  }
  public class CompositionObject : IClosable {
    void ConnectAnimation(string propertyName, CompositionAnimation animation);
  }
  public sealed class CompositionPropertySet : CompositionObject {
    void InsertColor(string propertyName, Color value);
    void InsertQuaternion(string propertyName, Quaternion value);
    CompositionGetValueStatus TryGetColor(string propertyName, out Color value);
    CompositionGetValueStatus TryGetQuaternion(string propertyName, out Quaternion value);
  }
  public sealed class CompositionSurfaceBrush : CompositionBrush
  public sealed class Compositor : IClosable {

    CompositionColorBrush CreateColorBrush();
    CompositionColorBrush CreateColorBrush(Color color);
    ColorKeyFrameAnimation CreateColorKeyFrameAnimation();
    QuaternionKeyFrameAnimation CreateQuaternionKeyFrameAnimation();
    CompositionBatch CreateScopedBatch(CompositionBatchTypes batchType);
    SpriteVisual CreateSpriteVisual();
    CompositionSurfaceBrush CreateSurfaceBrush();
    CompositionSurfaceBrush CreateSurfaceBrush(ICompositionSurface surface);
    CompositionBatch GetCommitBatch(CompositionBatchTypes batchType);
  }
  public sealed class QuaternionKeyFrameAnimation : KeyFrameAnimation
  public sealed class RenderingDeviceReplacedEventArgs
  public sealed class SpriteVisual : ContainerVisual
  public class Visual : CompositionObject {
    Vector2 AnchorPoint { get; set; }
    CompositionBackfaceVisibility BackfaceVisibility { get; set; }
    CompositionBorderMode BorderMode { get; set; }
    CompositionCompositeMode CompositeMode { get; set; }
    bool IsVisible { get; set; }
  }
}

namespace Windows.UI.Core {
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    event TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerRoutedAway;
    event TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerRoutedReleased;
    event TypedEventHandler<ICorePointerRedirector, PointerEventArgs> PointerRoutedTo;
  }
  public interface ICorePointerRedirector
}
namespace Windows.UI.Input {
  public sealed class KeyboardDeliveryInterceptor
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialGestureRecognizer
  public enum SpatialGestureSettings : uint
  public sealed class SpatialHoldCanceledEventArgs
  public sealed class SpatialHoldCompletedEventArgs
  public sealed class SpatialHoldStartedEventArgs
  public sealed class SpatialInputSource
  public sealed class SpatialInteraction
  public sealed class SpatialInteractionEventArgs
  public sealed class SpatialNavigationCanceledEventArgs
  public sealed class SpatialNavigationCompletedEventArgs
  public sealed class SpatialNavigationStartedEventArgs
  public sealed class SpatialNavigationUpdatedEventArgs
  public sealed class SpatialPathCanceledEventArgs
  public sealed class SpatialPathCompletedEventArgs
  public sealed class SpatialPathDelta
  public sealed class SpatialPathStartedEventArgs
  public sealed class SpatialPathUpdatedEventArgs
  public sealed class SpatialPointerDevice
  public enum SpatialPointerKind
  public sealed class SpatialPointerLocation
  public sealed class SpatialPointerPose
  public sealed class SpatialPointerProperties
  public sealed class SpatialPointerState
  public sealed class SpatialPointerStateEventArgs
  public sealed class SpatialRecognitionEndedEventArgs
  public sealed class SpatialRecognitionStartedEventArgs
  public sealed class SpatialTappedEventArgs
}
namespace Windows.UI.StartScreen {
  public sealed class JumpList
  public sealed class JumpListItem
  public enum JumpListItemKind
  public enum JumpListSystemGroupKind
}
namespace Windows.UI.Text.Core {
  public sealed class CoreTextEditContext {
    event TypedEventHandler<CoreTextEditContext, object> NotifyFocusLeaveCompleted;
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationViewTransferContext
}
namespace Windows.UI.WebUI {
  public sealed class WebUIDevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IDevicePairingActivatedEventArgs
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty LandmarkTypeProperty { get; }
    public static AutomationProperty LocalizedLandmarkTypeProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty LandmarkTypeProperty { get; }
    public static DependencyProperty LocalizedLandmarkTypeProperty { get; }
    public static AutomationLandmarkType GetLandmarkType(DependencyObject element);
    public static string GetLocalizedLandmarkType(DependencyObject element);
    public static void SetLandmarkType(DependencyObject element, AutomationLandmarkType value);
    public static void SetLocalizedLandmarkType(DependencyObject element, string value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationLandmarkType
  public class AutomationPeer : DependencyObject {
    AutomationLandmarkType GetLandmarkType();
    virtual AutomationLandmarkType GetLandmarkTypeCore();
    string GetLocalizedLandmarkType();
    virtual string GetLocalizedLandmarkTypeCore();
  }
}
namespace Windows.UI.Xaml.Controls {
  public class MenuFlyoutPresenter : ItemsControl {
    MenuFlyoutPresenterTemplateSettings TemplateSettings { get; }
  }
  public class RichEditBox : Control {
    RichEditClipboardFormat ClipboardCopyFormat { get; set; }
    public static DependencyProperty ClipboardCopyFormatProperty { get; }
    IAsyncOperation<IVectorView<string>> GetLinguisticAlternativesAsync();
  }
  public enum RichEditClipboardFormat
  public class TextBox : Control {
    IAsyncOperation<IVectorView<string>> GetLinguisticAlternativesAsync();
  }
  public enum WebViewPermissionType {
    PointerLock = 3,
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapActualCameraChangedEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
  public sealed class MapActualCameraChangingEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
  public enum MapCameraChangeReason
  public sealed class MapControl : Control {
    event TypedEventHandler<MapControl, MapRightTappedEventArgs> MapRightTapped;
  }
  public enum MapLoadingStatus {
    DataUnavailable = 2,
  }
  public sealed class MapPolygon : MapElement {
    IVector<Geopath> Paths { get; }
  }
  public sealed class MapRightTappedEventArgs
  public sealed class MapTargetCameraChangedEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class ComboBoxTemplateSettings : DependencyObject {
    double DropDownContentMinWidth { get; }
  }
  public sealed class CommandBarTemplateSettings : DependencyObject {
    double OverflowContentMaxWidth { get; }
  }
  public sealed class MenuFlyoutPresenterTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class ElementCompositionPreview {
    public static Visual GetElementChildVisual(UIElement element);
    public static Visual GetElementVisual(UIElement element);
    public static CompositionPropertySet GetScrollViewerManipulationPropertySet(ScrollViewer scrollViewer);
    public static void SetElementChildVisual(UIElement element, Visual visual);
  }
}
namespace Windows.UI.Xaml.Media {
  public class FontFamily {
    public static FontFamily XamlAutoFontFamily { get; }
  }
  public sealed class PartialMediaFailureDetectedEventArgs {
    HResult ExtendedError { get; }
  }
}
namespace Windows.Web.Http.Filters {
  public sealed class HttpBaseProtocolFilter : IClosable, IHttpFilter {
    HttpCookieUsageBehavior CookieUsageBehavior { get; set; }
  }
  public enum HttpCookieUsageBehavior
}

 namespace Windows.Graphics.Printing3D {
  public sealed class Print3DManager
  public sealed class Print3DTask
  public sealed class Print3DTaskCompletedEventArgs
  public enum Print3DTaskCompletion
  public enum Print3DTaskDetail
  public sealed class Print3DTaskRequest
  public sealed class Print3DTaskRequestedEventArgs
  public sealed class Print3DTaskSourceChangedEventArgs
  public sealed class Print3DTaskSourceRequestedArgs
  public delegate void Print3DTaskSourceRequestedHandler(Print3DTaskSourceRequestedArgs args);
  public sealed class Printing3D3MFPackage
  public sealed class Printing3DBaseMaterial
  public sealed class Printing3DBaseMaterialGroup
  public struct Printing3DBufferDescription
  public enum Printing3DBufferFormat
  public sealed class Printing3DColorMaterial
  public sealed class Printing3DColorMaterialGroup
  public sealed class Printing3DComponent
  public sealed class Printing3DComponentWithMatrix
  public sealed class Printing3DCompositeMaterial
  public sealed class Printing3DCompositeMaterialGroup
  public struct Printing3DContract
  public sealed class Printing3DMaterial
  public sealed class Printing3DMesh
  public enum Printing3DMeshVerificationMode
  public sealed class Printing3DMeshVerificationResult
  public sealed class Printing3DModel
  public sealed class Printing3DModelTexture
  public enum Printing3DModelUnit
  public sealed class Printing3DMultiplePropertyMaterial
  public sealed class Printing3DMultiplePropertyMaterialGroup
  public enum Printing3DObjectType
  public sealed class Printing3DTexture2CoordMaterial
  public sealed class Printing3DTexture2CoordMaterialGroup
  public enum Printing3DTextureEdgeBehavior
  public sealed class Printing3DTextureResource
}

Changes in the Universal Windows Platform – Removed

namespace Windows.Foundation.Metadata {
  public sealed class PreviousContractVersionAttribute : Attribute {
    public PreviousContractVersionAttribute(Type contract, uint versionLow, uint versionHigh);
    public PreviousContractVersionAttribute(Type contract, uint versionLow, uint versionHigh, Type newContract);
  }
}

namespace Windows.Data.Json {
  public static class JsonError {
    public static JsonErrorStatus GetStatus(int hresult);
  }
}

namespace Windows.Management.Orchestration {
  public sealed class CurrentAppOrchestration
  public sealed class SingleAppModeContext : IClosable
}

namespace Windows.UI.Composition {
  public sealed class AnimationEndedEventArgs : CompositionObject
  public enum AnimationEndReason
  public sealed class CompositionEffect : CompositionObject
  public sealed class CompositionEffectFactory : CompositionObject {
    IAsyncOperation<CompositionEffectFactoryLoadResult> CompleteLoadAsync();
    CompositionEffect CreateEffect();
  }
  public sealed class CompositionEffectFactoryLoadResult
  public enum CompositionEffectFactoryLoadStatus {
    Other = 2, // now -1
  }
  public sealed class CompositionGraphicsDevice {
    CompositionImage CreateImageFromUri(Uri uri);
    CompositionImage CreateImageFromUri(Uri uri, CompositionImageOptions options);
  }
  public sealed class CompositionImage : CompositionObject, ICompositionSurface
  public sealed class CompositionImageLoadResult
  public enum CompositionImageLoadStatus
  public sealed class CompositionImageOptions
  public enum CompositionImageProgressStage
  public class CompositionObject : IClosable {
    CompositionPropertyAnimator ConnectAnimation(string propertyName, CompositionAnimation animation);
  }
  public sealed class CompositionPropertyAnimator : CompositionObject
  public sealed class Compositor : IClosable {
    CompositionGraphicsDevice DefaultGraphicsDevice { get; }
    EffectVisual CreateEffectVisual();
    ImageVisual CreateImageVisual();
    SolidColorVisual CreateSolidColorVisual();
  }
  public sealed class EffectVisual : ContainerVisual
  public sealed class ImageVisual : ContainerVisual
  public sealed class SolidColorVisual : ContainerVisual
}

Changes in the Windows Desktop Extension – Added

namespace Windows.Media.Capture {
  public sealed class AppCaptureAlternateShortcutKeys {
    VirtualKey ToggleMicrophoneCaptureKey { get; set; }
    VirtualKeyModifiers ToggleMicrophoneCaptureKeyModifiers { get; set; }
  }
  public sealed class AppCaptureSettings {
    bool IsMicrophoneCaptureEnabled { get; set; }
  }
}

 
namespace Windows.Security.EnterpriseData {
  public enum DataProtectionStatus {
    AccessSuspended = 5,
    LicenseExpired = 4,
  }
  public enum EnforcementLevel
  public static class FileProtectionManager {
    public static IAsyncOperation<bool> IsContainerAsync(IStorageFile file);
    public static IAsyncOperation<ProtectedContainerImportResult> LoadFileFromContainerAsync(IStorageFile containerFile, IStorageItem target, NameCollisionOption collisionOption);
    public static IAsyncOperation<ProtectedContainerExportResult> SaveFileAsContainerAsync(IStorageFile protectedFile, IIterable<string> sharedWithIdentities);
  }
  public enum FileProtectionStatus {
    AccessSuspended = 9,
    LicenseExpired = 8,
  }
  public enum ProtectedImportExportStatus {
    AccessSuspended = 7,
    LicenseExpired = 6,
  }
  public sealed class ProtectionPolicyManager {
    public static bool IsProtectionEnabled { get; }
    public static event EventHandler<object> PolicyChanged;
    public static ProtectionPolicyEvaluationResult CheckAccessForApp(string sourceIdentity, string appPackageFamilyName);
    public static EnforcementLevel GetEnforcementLevel(string identity);
    public static bool HasContentBeenRevokedSince(string identity, DateTime since);
    public static bool IsProtectionUnderLockRequired(string identity);
    public static bool IsUserDecryptionAllowed(string identity);
    public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync(string sourceIdentity, string appPackageFamilyName);
  }
}

 namespace Windows.Services.Maps.Guidance {
  public enum GuidanceAudioNotificationKind
  public sealed class GuidanceAudioNotificationRequestedEventArgs
  public sealed class GuidanceNavigator {
    bool IsGuidanceAudioMuted { get; set; }
    public static bool UseAppProvidedVoice { get; }
    event TypedEventHandler<GuidanceNavigator, GuidanceAudioNotificationRequestedEventArgs> AudioNotificationRequested;
  }
}

 namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControlBusinessLandmarkClickEventArgs
  public sealed class MapControlBusinessLandmarkRightTappedEventArgs
  public sealed class MapControlDataHelper : DependencyObject
  public sealed class MapControlTransitFeatureClickEventArgs
  public sealed class MapControlTransitFeatureRightTappedEventArgs
}

Changes in the Windows Desktop Extension – Removed

namespace Windows.Devices.Printers.Extensions {
  public sealed class Print3DWorkflow
  public enum Print3DWorkflowDetail
  public sealed class Print3DWorkflowPrintRequestedEventArgs
  public enum Print3DWorkflowStatus
}

namespace Windows.Devices.Printers {
  public sealed class Print3DDevice
  public struct PrintersContract
  public sealed class PrintSchema
}

namespace Windows.Graphics.Printing3D {
  public sealed class Print3DManager
  public sealed class Print3DTask
  public sealed class Print3DTaskCompletedEventArgs
  public enum Print3DTaskCompletion
  public enum Print3DTaskDetail
  public sealed class Print3DTaskRequest
  public sealed class Print3DTaskRequestedEventArgs
  public sealed class Print3DTaskSourceChangedEventArgs
  public sealed class Print3DTaskSourceRequestedArgs
  public delegate void Print3DTaskSourceRequestedHandler(Print3DTaskSourceRequestedArgs args);
  public sealed class Printing3D3MFPackage
  public sealed class Printing3DBaseMaterial
  public sealed class Printing3DBaseMaterialGroup
  public struct Printing3DBufferDescription
  public enum Printing3DBufferFormat
  public sealed class Printing3DColorMaterial
  public sealed class Printing3DColorMaterialGroup
  public sealed class Printing3DComponent
  public sealed class Printing3DComponentWithMatrix
  public sealed class Printing3DCompositeMaterial
  public sealed class Printing3DCompositeMaterialGroup
  public struct Printing3DContract
  public sealed class Printing3DMaterial
  public sealed class Printing3DMesh
  public enum Printing3DMeshVerificationMode
  public sealed class Printing3DMeshVerificationResult
  public sealed class Printing3DModel
  public sealed class Printing3DModelTexture
  public enum Printing3DModelUnit
  public sealed class Printing3DMultiplePropertyMaterial
  public sealed class Printing3DMultiplePropertyMaterialGroup
  public enum Printing3DObjectType
  public sealed class Printing3DTexture2CoordMaterial
  public sealed class Printing3DTexture2CoordMaterialGroup
  public enum Printing3DTextureEdgeBehavior
  public sealed class Printing3DTextureResource
}

Changes in the Windows Mobile Extension – Added

namespace Windows.ApplicationModel.Calls.Provider {
  public sealed class PhoneCallOrigin {
    string DisplayName { get; set; }
  }
}

Changes in the Windows IOT Extension – Added

namespace Windows.Devices {
  public interface ILowLevelDevicesAggregateProvider
  public sealed class LowLevelDevicesAggregateProvider : ILowLevelDevicesAggregateProvider
  public sealed class LowLevelDevicesController
}
namespace Windows.Devices.Adc {
  public sealed class AdcController {
    public static IAsyncOperation<AdcController> GetDefaultAsync();
  }
}
namespace Windows.Devices.Gpio {
  public sealed class GpioController {
    public static IAsyncOperation<IVectorView<GpioController>> GetControllersAsync(IGpioProvider provider);
    public static IAsyncOperation<GpioController> GetDefaultAsync();
  }
}
namespace Windows.Devices.Gpio.Provider {
  public sealed class GpioPinProviderValueChangedEventArgs
  public interface IGpioControllerProvider
  public interface IGpioPinProvider
  public interface IGpioProvider
  public enum ProviderGpioPinDriveMode
  public enum ProviderGpioPinEdge
  public enum ProviderGpioPinValue
  public enum ProviderGpioSharingMode
}
namespace Windows.Devices.I2c {
  public sealed class I2cController
}
namespace Windows.Devices.I2c.Provider {
  public interface II2cControllerProvider
  public interface II2cDeviceProvider : IClosable
  public interface II2cProvider
  public enum ProviderI2cBusSpeed
  public sealed class ProviderI2cConnectionSettings
  public enum ProviderI2cSharingMode
  public struct ProviderI2cTransferResult
  public enum ProviderI2cTransferStatus
}
namespace Windows.Devices.Pwm {
  public sealed class PwmController {
    public static IAsyncOperation<PwmController> GetDefaultAsync();
  }
}
namespace Windows.Devices.Spi {
  public sealed class SpiController
}
namespace Windows.Devices.Spi.Provider {
  public interface ISpiControllerProvider
  public interface ISpiDeviceProvider : IClosable
  public interface ISpiProvider
  public sealed class ProviderSpiConnectionSettings
  public enum ProviderSpiMode
  public enum ProviderSpiSharingMode
}

namespace Windows.System {
  public static class ProcessLauncher
  public sealed class ProcessLauncherOptions
  public sealed class ProcessLauncherResult
}

Moving your projects forward

After installing the new Windows 10 SDK, update your projects with the Visual Studio Release Candidate to use the new SDK.

First, update the Project file (.csproj, .jsproj, .vcxproj) by:

      1. Opening the project in Visual Studio
      2. Right clicking on the project in the Visual Studio Solution Explorer, and choose “Properties”
      3. Depending on your project type, the UI will look a little different but click on the dropdown that says “Target Version”. The below screenshot is from a C# Project. Note: If you’re using a Javascript project, open the .jsproj and find a replace the TargetPlatformVersion with 10.0. 10563.0.
      4. Select Windows 10 Insider Preview (10.0; Build 10563).

Now that you have updated the project file, find the application’s Package.appxmanifest and do the following:

      1. Open that file (it should present you with an XML Editor)
      2. Find the Element, Dependencies and its child element, TargetDeviceFamily
      3. Modify the MaxVersion Tested Attribute from “10.0.10240.0” to “10.0.10563.0.”
      4. Save and close the file.

Known Issues

SDK Backwards compatibility: Do not install this preview SDK on your production machine. If you do so, any applications you submit to the Store after installing this SDK will fail validation because this SDK will update some of the build tools used to preview versions of those tools.

If you have other issues, please post to the forums and include the following [UWP][SDK] in the title if it is a Windows 10 SDK install or uninstall issue.

Now you’re ready to use the new SDK. Start developing and @WindowsDev would love to see what you create. If you find bugs or issues, please leverage the Windows Feedback tool or MSDN forums.

Updated October 13, 2015 1:37 pm

Join the conversation

  1. Is there any chance that UWP apps will be able to communicate hardware and OS information? I may be deploying UWP apps in an environment where devices will need to communicate their configurations to an administrator.

  2. Too bad – I read the “Known Issues” after I found out that I can no longer submitt my apps to the store now, since it reports the error: The package file … uses the following files: [MakePri.exe, 10.0.10563.0], which are above the maximum version allowed: [MakePri.exe, 10.0.10499.0]. Please update your Visual Studio build tools and try again.
    Problem is: After uninstalling the SDK, the build target 10563 can no longer be selected in Visual Studio 2015 BUT when submitting the app to the store the same error as mentioned is still shown. :( How can this SDK be completely removed and all Settings of VS be reverted to the previous Build?

  3. So I installed the new SDK and now every time I try to open Visual Studio 2015 (Enterprise Edition) it crashes…

  4. I have to design and develop a new WP app that will be released in january. The client needs a smartphone app to be available both for windows8.1 and windows10 devices. Which design guidelines and sdk are better to follow/use?

    • My advice here would be to use the Windows Phone 8.1 SDK using a Universal app. This will allow a Windows 10 Mobile and Windows Phone 8.1 device to install the app.

  5. So, just to clarify …

    In order to deploy from visual studio to Windows 10 mobile builds greater than 10581 we need to at least have the preview SDKs emulators installed, which for some reason are necessary to deploy to devices, and which also seem to install the updated WACK for the as yet undocumented prelaunch capabilities. Yet if we do that so we can test on W10 mobile devices, even if we don’t have the actual SDK installed, we can’t push the app to the store? Even for beta testing?

    • if you want to target the new APIs, yes, you would. Per the warning on this preview SDK drop, installing *this* preview would break your ability to submit to the store on that machine. You should be able to deploy to a later mobile build (10581+) from a 10240 desktop build, VS tooling and Windows tooling.