Windows 10 SDK Preview Build 10563 Released

News

Extraordinary Robot
News Feed
#1
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.

Continue reading...
 


This website is not affiliated, owned, or endorsed by Microsoft Corporation. It is a member of the Microsoft Partner Program.