Windows 10 SDK Preview Build 10563 Released

Discussion in 'Live RSS Feeds' started by News, Oct 13, 2015.

  1. News

    News Extraordinary Robot
    News Feed

    Joined:
    Jun 27, 2006
    Messages:
    26,189
    Likes Received:
    20
    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...
     

Share This Page

Loading...