20 Dec 2017

Dev Center’s Year in Review: 2017

Author: Dev Center Team
Go to Source

In 2017, the Dev Center Team has been hard at work bringing new features and programs to the Windows developer community. Our goal is to deliver features that will help you, as a developer, attract new customers, engage with your current Windows 10 customers and monetize your apps and games on Windows.  Today, we want to share all the new and exciting things we’ve brought to the community within the past year. Below are just some of the improvements we’ve made:

The Dev Center experience:

Monetization opportunities:

Customer engagement:

  • Create more engaging Store listings with video trailers that could drive more acquisitions

  • Offer personalized content to specific segments of your customer using targeted offers
  • Use search terms to help optimize how your app shows up in customer searches

App & game analytics:

Microsoft Ads Platform:

We would like to thank all the Windows developers, publishers and partners for continuing to invest in the Windows 10 ecosystem. We look forward to continuing our work to help make you successful in 2018!

Go to Source

Share this
20 Dec 2017
19 Dec 2017

Announcing Project Honolulu Technical Preview 1712 Build 05002

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

Today we are releasing Project Honolulu Technical Preview 1712 Build 05002 to Windows Server Insiders.

Project Honolulu is a flexible, lightweight browser-based customer-deployed platform and solution for Windows Server management scenarios for troubleshooting, configuration and maintenance. Project Honolulu Technical Preview 1712 Build 05002 is now available to Insiders before the public.

What’s New in Project Honolulu Technical Preview 1712 Build 05002

We’ve added a couple top requested features in Virtual Machines and continued with the performance enhancements that lead to faster load times and page rendering.

Virtual Machines

Based on high customer request, we now support viewing and changing VM settings while a VM is running, similar to how you can in Hyper-V Manager. On Generation 2 VMs, you can change general settings, memory setting, checkpoint setting and add disks and network adapters.

You can also enable nested virtualization when creating a VM, or from the processor settings of an existing (stopped) VM. This is functionality that was previously only accessible from the command line.

Events

Administrative events are now displayed.

Performance improvements

The new data grid control has been added to all tools except the HCI solution and Storage Replica.

We have started rolling out a new tree control with the same scale and performance improvements as the new data grid. The new tree control is implemented in the Files and Registry tools.

How to Download 

To obtain the Insider software downloads, registered Insiders may navigate directly to the Windows Server Insider Preview download page.  If you have not yet registered as an Insider, see GETTING STARTED WITH SERVER on the Windows Insiders for Business portal.

Known Issues with Project Honolulu Technical Preview 1712 Build 05002

There are no new known issues specific to this release. You can find the complete list of known issues in Project Honolulu here.

If you encounter bugs please post on the Project Honolulu space on Windows Server Tech Community.

Terms of Use

All pre-release software made available to you via the Windows Server Insider program are governed by the Insider Terms of Use, which takes precedence over any license agreement that may be in the product.

No downtime for Hustle-As-A-Service,
Dona <3

Go to Source

Share this
19 Dec 2017

Windows 10 SDK Preview Build 17061 now available

Author: Clint Rutkas
Go to Source

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17061 or greater). The Preview SDK Build 17061 contains bug fixes and under development changes to the API surface area.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 Creators build or earlier to the store.
  • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.

Known Issues

  • Installation on an operating system that is not a Windows 10 Insider Preview build is not supported and may fail.
  • Cannot deploy to a device: When attempting to deploy to a mobile device, it fails with the following error:  DEP0001: Unexpected Error: SmartDeviceException – Class not registered [0x80131500]

Please follow this posting for updates.  https://developercommunity.visualstudio.com/content/problem/122425/dep0001-unexpected-error-smartdeviceexception-the.html

  • XAML Designer fails to load: When attempting to load the XAML designer, an Unhandled exception occurs “The XAML Designer has excited unexpectedly.

What’s New:

  • C++/WinRT Now Available: The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler. Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.

 Breaking Changes

  • New MIDL key words.

As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.

The new keywords are:

  • event
  • set
  • get
  • partial
  • unsealed
  • overridable
  • protected
  • importwinmd

If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.

The error will be similar to:

1 >d:ossrconecorecomcombaseunittestastatestserverstestserver6idlremreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”

To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.

API Updates and Additions

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

The following APIs have been added to the platform since the release of 16299.


namespace Windows.ApplicationModel {
  public enum AddResourcePackageOptions : uint
  public sealed class AppInstance
  public sealed class PackageCatalog {
    IAsyncOperationWithProgress&lt;PackageCatalogAddResourcePackageResult, PackageInstallProgress&gt; AddResourcePackageAsync(string resourcePackageFamilyName, string resourceID, AddResourcePackageOptions options);
    IAsyncOperation&lt;PackageCatalogRemoveResourcePackagesResult&gt; RemoveResourcePackagesAsync(IIterable&lt;Package&gt; resourcePackages);
  }
  public sealed class PackageCatalogAddResourcePackageResult
  public sealed class PackageCatalogRemoveResourcePackagesResult
  public struct PackageInstallProgress
  public enum StartupTaskState {
    EnabledByPolicy = 4,
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    BarcodeScannerProvider = 1022,
  }
  public sealed class BarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public interface IBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public enum BackgroundAccessRequestKind
  public static class BackgroundExecutionManager {
    public static IAsyncOperation&lt;bool&gt; RequestAccessKindAsync(BackgroundAccessRequestKind requestedAccess, string reason);
  }
  public sealed class CustomSystemEventTrigger : IBackgroundTrigger
  public enum CustomSystemEventTriggerRecurrence
  public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
  public sealed class NetworkOperatorDataUsageTrigger : IBackgroundTrigger
  public sealed class StorageLibraryChangeTrackerTrigger : IBackgroundTrigger
  public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public enum PhoneCallMedia {
    AudioAndRealTimeText = 2,
  }
  public sealed class VoipCallCoordinator {
    VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
    VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
  }
  public sealed class VoipPhoneCall {
    void NotifyCallAccepted(VoipPhoneCallMedia media);
  }
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    IAsyncOperation&lt;bool&gt; LaunchForUserAsync(User user);
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackagePropertySet : IIterable&lt;IKeyValuePair&lt;string, object&gt;&gt;, IMap&lt;string, object&gt; {
    string ContentSourceUserActivityJson { get; set; }
  }
  public sealed class DataPackagePropertySetView : IIterable&lt;IKeyValuePair&lt;string, object&gt;&gt;, IMapView&lt;string, object&gt; {
    string ContentSourceUserActivityJson { get; }
  }
  public static class StandardDataFormats {
    public static string UserActivityJsonArray { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview {
  public enum StoreSystemFeature {
    ArchitectureArm64 = 34,
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    bool LaunchAfterInstall { get; set; }
  }
  public sealed class AppInstallManager {
    IAsyncOperation&lt;bool&gt; GetIsPackageIdentityAllowedToInstallAsync(string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation&lt;bool&gt; GetIsPackageIdentityAllowedToInstallForUserAsync(User user, string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation&lt;IVectorView&lt;AppInstallItem&gt;&gt; SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation&lt;IVectorView&lt;AppInstallItem&gt;&gt; SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation&lt;AppInstallItem&gt; SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation&lt;AppInstallItem&gt; SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation&lt;IVectorView&lt;AppInstallItem&gt;&gt; StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
    IAsyncOperation&lt;IVectorView&lt;AppInstallItem&gt;&gt; StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
  }
  public sealed class AppInstallOptions
  public sealed class AppInstallStatus {
    bool IsStaged { get; }
  }
  public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    public UserActivity(string activityId);
    string ToJson();
    public static string ToJsonArray(IIterable&lt;UserActivity&gt; activities);
    public static UserActivity TryParseFromJson(string json);
    public static IVector&lt;UserActivity&gt; TryParseFromJsonArray(string json);
  }
  public sealed class UserActivityChannel {
    public static void DisableAutoSessionCreation();
    IAsyncOperation&lt;IVector&lt;UserActivitySessionHistoryItem&gt;&gt; GetRecentUserActivitiesAsync(int maxUniqueActivities);
    IAsyncOperation&lt;IVector&lt;UserActivitySessionHistoryItem&gt;&gt; GetSessionHistoryItemsForUserActivityAsync(string activityId, DateTime startTime);
    public static UserActivityChannel TryGetForWebAccount(WebAccount account);
  }
  public sealed class UserActivityRequest
  public sealed class UserActivityRequestedEventArgs
  public sealed class UserActivityRequestManager
  public sealed class UserActivitySessionHistoryItem
  public sealed class UserActivityVisualElements {
    string AttributionDisplayText { get; set; }
  }
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter {
    bool AreClassicSecureConnectionsSupported { get; }
    bool AreLowEnergySecureConnectionsSupported { get; }
  }
  public sealed class BluetoothDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
  public sealed class BluetoothLEDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
}
namespace Windows.Devices.Display {
  public sealed class DisplayMonitor
  public enum DisplayMonitorConnectionKind
  public enum DisplayMonitorDescriptorKind
  public enum DisplayMonitorPhysicalConnectorKind
  public enum DisplayMonitorUsageKind
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerReport {
    public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    bool IsVideoPreviewShownOnEnable { get; set; }
    void HideVideoPreview();
    IAsyncOperation&lt;bool&gt; ShowVideoPreviewAsync();
  }
  public sealed class UnifiedPosErrorData {
    public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
  }
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest
  public sealed class BarcodeScannerDisableScannerRequestEventArgs
  public sealed class BarcodeScannerEnableScannerRequest
  public sealed class BarcodeScannerEnableScannerRequestEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest
  public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerHideVideoPreviewRequest
  public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
  public sealed class BarcodeScannerProviderConnection : IClosable
  public sealed class BarcodeScannerProviderTriggerDetails
  public sealed class BarcodeScannerSetActiveSymbologiesRequest
  public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
  public sealed class BarcodeScannerSetSymbologyAttributesRequest
  public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerStartSoftwareTriggerRequest
  public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
  public sealed class BarcodeScannerStopSoftwareTriggerRequest
  public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
  public enum BarcodeScannerTriggerState
  public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Foundation.Numerics {
  public struct Rational
}
namespace Windows.Globalization {
  public static class ApplicationLanguages {
    public static IVectorView&lt;string&gt; GetLanguagesForUser(User user);
  }
  public sealed class Language {
    LanguageLayoutDirection LayoutDirection { get; }
  }
  public enum LanguageLayoutDirection
}
namespace Windows.Graphics {
  public struct DisplayAdapterId
  public interface IGeometrySource2D
}
namespace Windows.Graphics.Capture {
  public sealed class Direct3D11CaptureFrame : IClosable
  public sealed class Direct3D11CaptureFramePool : IClosable
  public sealed class GraphicsCaptureItem
  public sealed class GraphicsCapturePicker
  public sealed class GraphicsCaptureSession : IClosable
}
namespace Windows.Graphics.DirectX {
  public enum DirectXColorSpace
}
namespace Windows.Graphics.Display {
  public sealed class AdvancedColorInfo
  public enum AdvancedColorKind
  public sealed class BrightnessOverrideSettings
  public sealed class ColorOverrideSettings
  public enum DisplayBrightnessOverrideScenario
  public enum DisplayColorOverrideScenario
  public sealed class DisplayEnhancementOverride
  public sealed class DisplayEnhancementOverrideCapabilities
  public sealed class DisplayEnhancementOverrideCapabilitiesChangedEventArgs
  public sealed class DisplayInformation {
    event TypedEventHandler&lt;DisplayInformation, object&gt; AdvancedColorInfoChanged;
    AdvancedColorInfo GetAdvancedColorInfo();
  }
  public enum HdrMetadataFormat
  public struct NitRange
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool CanOverrideViewport { get; }
  }
  public sealed class HolographicCameraPose {
    void OverrideProjectionTransform(HolographicStereoTransform projectionTransform);
    void OverrideViewport(Rect leftViewport, Rect rightViewport);
    void OverrideViewTransform(SpatialCoordinateSystem coordinateSystem, HolographicStereoTransform coordinateSystemToViewTransform);
  }
  public sealed class HolographicFramePresentationMonitor : IClosable
  public sealed class HolographicFramePresentationReport
  public sealed class HolographicSpace {
    HolographicSpaceUserPresence UserPresence { get; }
    event TypedEventHandler&lt;HolographicSpace, object&gt; UserPresenceChanged;
    HolographicFramePresentationMonitor CreateFramePresentationMonitor(uint maxQueuedReports);
    void WaitForNextFrameReady();
    void WaitForNextFrameReadyWithHeadStart(TimeSpan requestedHeadStartDuration);
  }
  public enum HolographicSpaceUserPresence
}
namespace Windows.Graphics.Imaging {
  public enum BitmapPixelFormat {
    P010 = 104,
  }
}
namespace Windows.Graphics.Printing {
  public sealed class PrintPageRange
  public sealed class PrintPageRangeOptions
  public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
    IVector&lt;PrintPageRange&gt; CustomPageRanges { get; }
    PrintPageRangeOptions PageRangeOptions { get; }
  }
  public static class StandardPrintTaskOptions {
    public static string CustomPageRanges { get; }
  }
}
namespace Windows.Graphics.Printing.OptionDetails {
  public sealed class PrintBindingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintBorderingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCollationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintColorModeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCopiesOptionDetails : IPrintNumberOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomItemListOptionDetails : IPrintCustomOptionDetails, IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
    void AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon);
  }
  public sealed class PrintCustomTextOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomToggleOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails
  public sealed class PrintDuplexOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintHolePunchOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaSizeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaTypeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public enum PrintOptionType {
    Toggle = 4,
  }
  public sealed class PrintOrientationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintPageRangeOptionDetails : IPrintOptionDetails
  public sealed class PrintQualityOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintStapleOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintTaskOptionDetails : IPrintTaskOptionsCore, IPrintTaskOptionsCoreUIConfiguration {
    PrintCustomToggleOptionDetails CreateToggleOption(string optionId, string displayName);
  }
}
namespace Windows.Management.Deployment {
  public sealed class PackageManager {
    IAsyncOperationWithProgress&lt;DeploymentResult, DeploymentProgress&gt; RequestAddPackageAsync(Uri packageUri, IIterable&lt;Uri&gt; dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable&lt;string&gt; optionalPackageFamilyNames, IIterable&lt;Uri&gt; relatedPackageUris, IIterable&lt;Uri&gt; packageUrisToInstall);
  }
}
namespace Windows.Management.Update {
  public sealed class PreviewBuildsManager
  public sealed class PreviewBuildsState
}
namespace Windows.Media {
  public sealed class VideoFrame : IClosable, IMediaFrame {
    IAsyncAction CopyToAsync(VideoFrame frame, IReference&lt;BitmapBounds&gt; sourceBounds, IReference&lt;BitmapBounds&gt; destinationBounds);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height, IDirect3DDevice device);
    public static VideoFrame CreateWithDirect3D11Surface(IDirect3DSurface surface);
    public static VideoFrame CreateWithSoftwareBitmap(SoftwareBitmap bitmap);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioGraph : IClosable {
    IAsyncOperation&lt;CreateMediaSourceAudioInputNodeResult&gt; CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
    IAsyncOperation&lt;CreateMediaSourceAudioInputNodeResult&gt; CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
  }
  public sealed class AudioGraphSettings {
    double MaxPlaybackSpeedFactor { get; set; }
  }
  public sealed class AudioStateMonitor
  public sealed class CreateMediaSourceAudioInputNodeResult
  public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
  public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
  public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
    BitmapPropertySet BitmapProperties { get; }
    CapturedFrameControlValues ControlValues { get; }
  }
  public enum KnownVideoProfile {
    HdrWithWcgPhoto = 8,
    HdrWithWcgVideo = 7,
    HighFrameRate = 5,
    VariablePhotoSequence = 6,
    VideoHdr8 = 9,
  }
  public sealed class MediaCaptureSettings {
    IDirect3DDevice Direct3D11Device { get; }
  }
  public sealed class MediaCaptureVideoProfile {
    IVectorView&lt;MediaFrameSourceInfo&gt; FrameSourceInfos { get; }
    IMapView&lt;Guid, object&gt; Properties { get; }
  }
  public sealed class MediaCaptureVideoProfileMediaDescription {
    IMapView&lt;Guid, object&gt; Properties { get; }
    string Subtype { get; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class AudioMediaFrame
  public sealed class MediaFrameFormat {
    AudioEncodingProperties AudioEncodingProperties { get; }
  }
  public sealed class MediaFrameReference : IClosable {
    AudioMediaFrame AudioMediaFrame { get; }
  }
  public sealed class MediaFrameSourceController {
    AudioDeviceController AudioDeviceController { get; }
  }
  public sealed class MediaFrameSourceInfo {
    string ProfileId { get; }
    IVectorView&lt;MediaCaptureVideoProfileMediaDescription&gt; VideoProfileMediaDescription { get; }
  }
  public enum MediaFrameSourceKind {
    Audio = 4,
    Image = 5,
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    AudioStreamDescriptor Copy();
  }
  public sealed class MediaBindingEventArgs {
    void SetDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    DownloadOperation DownloadOperation { get; }
    public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class TimedMetadataStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    VideoStreamDescriptor Copy();
  }
}
namespace Windows.Media.Devices {
  public sealed class VideoDeviceController : IMediaDeviceController {
    VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
  }
  public sealed class VideoTemporalDenoisingControl
  public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp {
    IAsyncOperation&lt;string&gt; GetUniqueDeviceNameAsync();
  }
}
namespace Windows.Media.Effects {
  public sealed class VideoTransformEffectDefinition : IVideoEffectDefinition {
    VideoTransformSphericalProjection SphericalProjection { get; }
  }
  public sealed class VideoTransformSphericalProjection
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    AudioEncodingProperties Copy();
  }
  public sealed class ContainerEncodingProperties : IMediaEncodingProperties {
    ContainerEncodingProperties Copy();
  }
  public sealed class ImageEncodingProperties : IMediaEncodingProperties {
    ImageEncodingProperties Copy();
  }
  public sealed class MediaEncodingProfile {
    IVector&lt;TimedMetadataStreamDescriptor&gt; GetTimedMetadataTracks();
    void SetTimedMetadataTracks(IIterable&lt;TimedMetadataStreamDescriptor&gt; value);
  }
  public static class MediaEncodingSubtypes {
    public static string P010 { get; }
  }
  public enum MediaPixelFormat {
    P010 = 2,
  }
  public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    VideoEncodingProperties Copy();
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSession {
    MediaRotation PlaybackRotation { get; set; }
    MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
  }
  public sealed class MediaPlaybackSessionOutputDegradationPolicyState
  public enum MediaPlaybackSessionVideoConstrictionReason
  public sealed class MediaPlayer : IClosable {
    AudioStateMonitor AudioStateMonitor { get; }
  }
}
namespace Windows.Media.SpeechSynthesis {
  public enum SpeechAppendedSilence
  public enum SpeechPunctuationSilence
  public sealed class SpeechSynthesizerOptions {
    SpeechAppendedSilence AppendedSilence { get; set; }
    SpeechPunctuationSilence PunctuationSilence { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    string ResourceContentType { get; }
    IReference&lt;TimeSpan&gt; ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    string ResourceContentType { get; }
    IReference&lt;TimeSpan&gt; ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    string ResourceContentType { get; }
    IReference&lt;TimeSpan&gt; ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    string ResourceContentType { get; }
    IReference&lt;TimeSpan&gt; ResourceDuration { get; }
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
  public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class CellularApnContext {
    string ProfileName { get; set; }
  }
  public sealed class ConnectionProfileFilter {
    IReference&lt;Guid&gt; PurposeGuid { get; set; }
  }
  public sealed class WwanConnectionProfileDetails {
    WwanNetworkIPKind IPKind { get; }
    IVectorView&lt;Guid&gt; PurposeGuids { get; }
  }
  public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
  public sealed class ESim
  public sealed class ESimAddedEventArgs
  public enum ESimAuthenticationPreference
  public sealed class ESimDownloadProfileMetadataResult
  public static class ESimManager
  public sealed class ESimOperationResult
  public enum ESimOperationStatus
  public sealed class ESimPolicy
  public sealed class ESimProfile
  public enum ESimProfileClass
  public struct ESimProfileInstallProgress
  public sealed class ESimProfileMetadata
  public enum ESimProfileMetadataState
  public sealed class ESimProfilePolicy
  public enum ESimProfileState
  public sealed class ESimRemovedEventArgs
  public sealed class ESimServiceInfo
  public enum ESimState
  public sealed class ESimUpdatedEventArgs
  public sealed class ESimWatcher
  public enum ESimWatcherStatus
  public sealed class MobileBroadbandAntennaSar {
    public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
  }
  public sealed class MobileBroadbandModem {
    bool IsInEmergencyCallMode { get; }
    event TypedEventHandler&lt;MobileBroadbandModem, object&gt; IsInEmergencyCallModeChanged;
    IAsyncOperation&lt;MobileBroadbandPco&gt; TryGetPcoAsync();
  }
  public sealed class MobileBroadbandModemIsolation
  public sealed class MobileBroadbandPco
  public sealed class MobileBroadbandPcoDataChangeTriggerDetails
  public enum NetworkOperatorDataUsageNotificationKind
  public sealed class NetworkOperatorDataUsageTriggerDetails
  public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocket : IClosable, IWebSocket {
    IAsyncOperationWithProgress&lt;uint, uint&gt; SendFinalFrameAsync(IBuffer data);
    IAsyncOperationWithProgress&lt;uint, uint&gt; SendNonfinalFrameAsync(IBuffer data);
  }
  public sealed class ServerMessageWebSocket : IClosable
  public sealed class ServerMessageWebSocketControl
  public sealed class ServerMessageWebSocketInformation
  public sealed class ServerStreamWebSocket : IClosable
  public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
  public sealed class VpnChannel {
    object CurrentRequestTransportContext { get; }
    void AddAndAssociateTransport(object transport, object context);
    ControlChannelTriggerStatus GetSlotTypeForTransportContext(object context);
    void ReplaceAndAssociateTransport(object transport, object context);
    void StartReconnectingTransport(object transport, object context);
    void StartWithTrafficFilter(IIterable&lt;HostName&gt; assignedClientIpv4Addresses, IIterable&lt;HostName&gt; assignedClientIpv6Addresses, VpnInterfaceId vpninterfaceId, VpnRouteAssignment assignedRoutes, VpnDomainNameAssignment assignedNamespace, uint mtuSize, uint maxFrameSize, bool reserved, IIterable&lt;object&gt; transports, VpnTrafficFilterAssignment assignedTrafficFilters);
  }
  public sealed class VpnPacketBuffer {
    object TransportContext { get; set; }
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationMessage {
    CanceledByUser = 22,
    CenterHand = 23,
    ConnectionRequired = 20,
    DeviceUnavailable = 28,
    MoveHandCloser = 24,
    MoveHandFarther = 25,
    PlaceHandAbove = 26,
    RecognitionFailed = 27,
    TimeLimitExceeded = 21,
  }
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class FindAllAccountsResult
  public enum FindAllWebAccountsStatus
  public static class WebAuthenticationCoreManager {
    public static IAsyncOperation&lt;FindAllAccountsResult&gt; FindAllAccountsAsync(WebAccountProvider provider);
    public static IAsyncOperation&lt;FindAllAccountsResult&gt; FindAllAccountsAsync(WebAccountProvider provider, string clientId);
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public sealed class WebProviderTokenRequest {
    string ApplicationPackageFamilyName { get; }
    string ApplicationProcessName { get; }
    IAsyncOperation&lt;bool&gt; CheckApplicationForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRouteDrivingOptions {
    IReference&lt;DateTime&gt; DepartureTime { get; set; }
  }
  public sealed class PlaceInfo {
    public static PlaceInfo CreateFromAddress(string displayAddress);
    public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreCanAcquireLicenseResult
  public enum StoreCanLicenseStatus
  public sealed class StoreContext {
    bool CanSilentlyDownloadStorePackageUpdates { get; }
    IAsyncOperation&lt;StoreCanAcquireLicenseResult&gt; CanAcquireStoreLicenseAsync(string productStoreId);
    IAsyncOperation&lt;StoreCanAcquireLicenseResult&gt; CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
    IAsyncOperationWithProgress&lt;StorePackageUpdateResult, StorePackageUpdateStatus&gt; DownloadAndInstallStorePackagesAsync(IIterable&lt;string&gt; storeIds);
    IAsyncOperation&lt;IVectorView&lt;StoreQueueItem&gt;&gt; GetAssociatedStoreQueueItemsAsync();
    IAsyncOperation&lt;StoreProductQueryResult&gt; GetStoreProductsAsync(IIterable&lt;string&gt; productKinds, IIterable&lt;string&gt; storeIds, StoreProductOptions storeProductOptions);
    IAsyncOperation&lt;IVectorView&lt;StoreQueueItem&gt;&gt; GetStoreQueueItemsAsync(IIterable&lt;string&gt; storeIds);
    IAsyncOperationWithProgress&lt;StorePackageUpdateResult, StorePackageUpdateStatus&gt; RequestDownloadAndInstallStorePackagesAsync(IIterable&lt;string&gt; storeIds, StorePackageInstallOptions storePackageInstallOptions);
    IAsyncOperation&lt;StoreUninstallStorePackageResult&gt; RequestUninstallStorePackageAsync(Package package);
    IAsyncOperation&lt;StoreUninstallStorePackageResult&gt; RequestUninstallStorePackageByStoreIdAsync(string storeId);
    IAsyncOperationWithProgress&lt;StorePackageUpdateResult, StorePackageUpdateStatus&gt; TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable&lt;StorePackageUpdate&gt; storePackageUpdates);
    IAsyncOperationWithProgress&lt;StorePackageUpdateResult, StorePackageUpdateStatus&gt; TrySilentDownloadStorePackageUpdatesAsync(IIterable&lt;StorePackageUpdate&gt; storePackageUpdates);
    IAsyncOperation&lt;StoreUninstallStorePackageResult&gt; UninstallStorePackageAsync(Package package);
    IAsyncOperation&lt;StoreUninstallStorePackageResult&gt; UninstallStorePackageByStoreIdAsync(string storeId);
  }
  public sealed class StorePackageInstallOptions
  public sealed class StorePackageUpdateResult {
    IVectorView&lt;StoreQueueItem&gt; StoreQueueItems { get; }
  }
  public sealed class StoreProductOptions
  public sealed class StoreQueueItem
  public sealed class StoreQueueItemCompletedEventArgs
  public enum StoreQueueItemExtendedState
  public enum StoreQueueItemKind
  public enum StoreQueueItemState
  public sealed class StoreQueueItemStatus
  public sealed class StoreUninstallStorePackageResult
  public enum StoreUninstallStorePackageStatus
}
namespace Windows.Storage {
  public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
    StorageLibraryChangeTracker TryGetChangeTracker();
  }
}
namespace Windows.Storage.Provider {
  public interface IStorageProviderUriSource
  public sealed class StorageProviderGetContentInfoForPathResult
  public sealed class StorageProviderGetPathForContentUriResult
  public enum StorageProviderUriSourceStatus
}
namespace Windows.Storage.Search {
  public sealed class StorageLibraryChangeTrackerTriggerDetails
}
namespace Windows.System {
  public sealed class AppActivationResult
  public sealed class AppDiagnosticInfo {
    IAsyncOperation&lt;AppActivationResult&gt; LaunchAsync();
  }
  public sealed class AppExecutionStateChangeResult
  public sealed class AppResourceGroupInfo {
    IAsyncOperation&lt;AppExecutionStateChangeResult&gt; StartResumeAsync();
    IAsyncOperation&lt;AppExecutionStateChangeResult&gt; StartSuspendAsync();
    IAsyncOperation&lt;AppExecutionStateChangeResult&gt; StartTerminateAsync();
  }
  public enum AutoUpdateTimeZoneStatus
  public static class TimeZoneSettings {
    public static IAsyncOperation&lt;AutoUpdateTimeZoneStatus&gt; AutoUpdateTimeZoneAsync(TimeSpan timeout);
  }
  public sealed class User {
    public static User GetDefault();
  }
  public enum UserType {
    SystemManaged = 4,
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticInvoker {
    IAsyncOperationWithProgress&lt;DiagnosticActionResult, DiagnosticActionState&gt; RunDiagnosticActionFromStringAsync(string context);
  }
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection {
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
  }
  public sealed class DevicePortalConnectionRequestReceivedEventArgs {
    bool IsWebSocketUpgradeRequest { get; }
    IVectorView&lt;string&gt; WebSocketProtocolsRequested { get; }
    Deferral GetDeferral();
  }
}
namespace Windows.System.Inventory {
  public sealed class InstalledDesktopApp : IStringable
}
namespace Windows.System.Profile {
  public static class AnalyticsInfo {
    public static IAsyncOperation&lt;IMapView&lt;string, string&gt;&gt; GetClientPropertiesAsync(IIterable&lt;string&gt; attributeNames);
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    RemoteSystemPlatform Platform { get; }
  }
  public sealed class RemoteSystemEnumerationCompletedEventArgs
  public enum RemoteSystemPlatform
  public sealed class RemoteSystemWatcher {
    event TypedEventHandler&lt;RemoteSystemWatcher, RemoteSystemEnumerationCompletedEventArgs&gt; EnumerationCompleted;
    event TypedEventHandler&lt;RemoteSystemWatcher, RemoteSystemWatcherErrorOcurredEventArgs&gt; ErrorOcurred;
  }
  public enum RemoteSystemWatcherError
  public sealed class RemoteSystemWatcherErrorOcurredEventArgs
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static GlobalizationPreferencesForUser GetForUser(User user);
  }
  public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountForUserAsync(User user);
    public static IAsyncAction ShowManageAccountsForUserAsync(User user);
  }
  public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Composition {
  public sealed class AnimationController : CompositionObject
  public enum AnimationControllerProgressBehavior
  public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public sealed class CompositionContainerShape : CompositionShape
  public sealed class CompositionEllipseGeometry : CompositionGeometry
  public class CompositionGeometry : CompositionObject
  public class CompositionLight : CompositionObject {
    bool IsEnabled { get; set; }
  }
  public sealed class CompositionLineGeometry : CompositionGeometry
  public class CompositionObject : IClosable {
    AnimationController TryGetAnimationController(string propertyName);
  }
  public sealed class CompositionPath : IGeometrySource2D
  public sealed class CompositionPathGeometry : CompositionGeometry
  public sealed class CompositionRectangleGeometry : CompositionGeometry
  public sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
  public class CompositionShape : CompositionObject
  public sealed class CompositionShapeCollection : CompositionObject, IIterable&lt;CompositionShape&gt;, IVector&lt;CompositionShape&gt;
  public sealed class CompositionSpriteShape : CompositionShape
  public enum CompositionStrokeCap
  public sealed class CompositionStrokeDashArray : CompositionObject, IIterable&lt;float&gt;, IVector&lt;float&gt;
  public enum CompositionStrokeLineJoin
  public sealed class CompositionViewBox : CompositionObject
  public sealed class Compositor : IClosable {
    string Comment { get; set; }
    float GlobalPlaybackRate { get; set; }
    public static float MaxGlobalPlaybackRate { get; }
    public static float MinGlobalPlaybackRate { get; }
    BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
    BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
    BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
    CompositionContainerShape CreateContainerShape();
    CompositionEllipseGeometry CreateEllipseGeometry();
    CompositionLineGeometry CreateLineGeometry();
    CompositionPathGeometry CreatePathGeometry();
    CompositionPathGeometry CreatePathGeometry(CompositionPath path);
    PathKeyFrameAnimation CreatePathKeyFrameAnimation();
    CompositionRectangleGeometry CreateRectangleGeometry();
    CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry();
    ShapeVisual CreateShapeVisual();
    CompositionSpriteShape CreateSpriteShape();
    CompositionSpriteShape CreateSpriteShape(CompositionGeometry geometry);
    CompositionViewBox CreateViewBox();
    IAsyncAction RequestCommitAsync();
  }
  public sealed class PathKeyFrameAnimation : KeyFrameAnimation
  public sealed class PointLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
  public sealed class ShapeVisual : ContainerVisual
  public sealed class SpotLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
}
namespace Windows.UI.Composition.Core {
  public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
  public sealed class DesktopWindowTarget : CompositionTarget
}
namespace Windows.UI.Composition.Diagnostics {
  public sealed class CompositionDebugHeatMaps
  public enum CompositionDebugOverdrawContentKinds : uint
  public sealed class CompositionDebugSettings
}
namespace Windows.UI.Composition.Interactions {
  public enum VisualInteractionSourceRedirectionMode {
    CapableTouchpadAndPointerWheel = 3,
    PointerWheelOnly = 2,
  }
}
namespace Windows.UI.Core {
  public enum AppViewBackButtonVisibility {
    Disabled = 2,
  }
  public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CoreIndependentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public interface ICorePointerInputSource2 : ICorePointerInputSource
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    InkModelerAttributes ModelerAttributes { get; }
  }
  public sealed class InkInputConfiguration
  public sealed class InkModelerAttributes
  public sealed class InkPresenter {
    InkInputConfiguration InputConfiguration { get; }
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotification {
    IReference&lt;DateTime&gt; ExpirationTime { get; set; }
  }
}
namespace Windows.UI.StartScreen {
  public sealed class TileMixedRealityModel {
    TileMixedRealityModelActivationBehavior ActivationBehavior { get; set; }
  }
  public enum TileMixedRealityModelActivationBehavior
}
namespace Windows.UI.Text {
  public sealed class ContentLinkInfo
  public sealed class RichEditTextRange : ITextRange
  public enum TextRangeUnit {
    ContentLink = 32,
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationViewTab
  public sealed class ApplicationViewTabBadge
  public sealed class ApplicationViewTabIcon
  public sealed class ApplicationViewTabManager
  public sealed class ApplicationViewTabManagerTabClosedEventArgs
  public sealed class ApplicationViewTabManagerTabCloseRequestedEventArgs
  public sealed class ApplicationViewTabManagerTabDraggedOutEventArgs
  public sealed class ApplicationViewTabManagerTabDroppedInEventArgs
  public sealed class ApplicationViewTabManagerTabRearrangedEventArgs
  public static class ApplicationViewTabPolicy
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView {
    event TypedEventHandler&lt;CoreInputView, object&gt; XYFocusTransferredToPrimaryView;
    event TypedEventHandler&lt;CoreInputView, CoreInputViewTransferringXYFocusEventArgs&gt; XYFocusTransferringFromPrimaryView;
    bool TryTransferXYFocusToPrimaryView(Rect origin, CoreInputViewXYFocusTransferDirection direction);
  }
  public sealed class CoreInputViewTransferringXYFocusEventArgs
  public enum CoreInputViewXYFocusTransferDirection
}
namespace Windows.UI.WebUI {
  public sealed class WebUIBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs {
    TileActivatedInfo TileActivatedInfo { get; }
  }
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions {
    double HorizontalAlignmentRatio { get; set; }
    double HorizontalOffset { get; set; }
    double VerticalAlignmentRatio { get; set; }
    double VerticalOffset { get; set; }
  }
  public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
  public sealed class ElementSoundPlayer {
    public static ElementSpatialAudioMode SpatialAudioMode { get; set; }
  }
  public enum ElementSpatialAudioMode
  public enum FocusVisualKind {
    Reveal = 2,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent BringIntoViewRequestedEvent { get; }
    public static RoutedEvent ContextRequestedEvent { get; }
    KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
    DependencyObject KeyboardAcceleratorPlacementTarget { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementTargetProperty { get; }
    DependencyObject KeyTipTarget { get; set; }
    public static DependencyProperty KeyTipTargetProperty { get; }
    event TypedEventHandler&lt;UIElement, BringIntoViewRequestedEventArgs&gt; BringIntoViewRequested;
    virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
    virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
    public static void RegisterAsScrollPort(UIElement element);
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty HeadingLevelProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty HeadingLevelProperty { get; }
    public static AutomationHeadingLevel GetHeadingLevel(DependencyObject element);
    public static void SetHeadingLevel(DependencyObject element, AutomationHeadingLevel value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationHeadingLevel
  public class AutomationPeer : DependencyObject {
    AutomationHeadingLevel GetHeadingLevel();
    virtual AutomationHeadingLevel GetHeadingLevelCore();
  }
  public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
    void Invoke();
  }
  public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer, IExpandCollapseProvider
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarButtonTemplateSettings TemplateSettings { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarToggleButtonTemplateSettings TemplateSettings { get; }
  }
  public sealed class ContentLinkChangedEventArgs
  public enum ContentLinkChangeKind
  public sealed class HandwritingPanelClosedEventArgs
  public sealed class HandwritingPanelOpenedEventArgs
  public enum HandwritingPanelPlacementAlignment
  public class HandwritingView : Control
  public class MediaTransportControls : Control {
    bool IsCompactOverlayButtonVisible { get; set; }
    public static DependencyProperty IsCompactOverlayButtonVisibleProperty { get; }
    bool IsCompactOverlayEnabled { get; set; }
    public static DependencyProperty IsCompactOverlayEnabledProperty { get; }
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    MenuFlyoutItemTemplateSettings TemplateSettings { get; }
  }
  public class NavigationView : ContentControl {
    string PaneTitle { get; set; }
    public static DependencyProperty PaneTitleProperty { get; }
    event TypedEventHandler&lt;NavigationView, object&gt; PaneClosed;
    event TypedEventHandler&lt;NavigationView, NavigationViewPaneClosingEventArgs&gt; PaneClosing;
    event TypedEventHandler&lt;NavigationView, object&gt; PaneOpened;
    event TypedEventHandler&lt;NavigationView, object&gt; PaneOpening;
  }
  public sealed class NavigationViewPaneClosingEventArgs
  public class RefreshContainer : ContentControl
  public sealed class RefreshInteractionRatioChangedEventArgs
  public enum RefreshPullDirection
  public sealed class RefreshRequestedEventArgs
  public sealed class RefreshStateChangedEventArgs
  public class RefreshVisualizer : Control
  public enum RefreshVisualizerOrientation
  public enum RefreshVisualizerState
  public class RichEditBox : Control {
    SolidColorBrush ContentLinkBackgroundColor { get; set; }
    public static DependencyProperty ContentLinkBackgroundColorProperty { get; }
    SolidColorBrush ContentLinkForegroundColor { get; set; }
    public static DependencyProperty ContentLinkForegroundColorProperty { get; }
    ContentLinkProviderCollection ContentLinkProviders { get; set; }
    public static DependencyProperty ContentLinkProvidersProperty { get; }
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
    event TypedEventHandler&lt;RichEditBox, ContentLinkChangedEventArgs&gt; ContentLinkChanged;
    event TypedEventHandler&lt;RichEditBox, ContentLinkInvokedEventArgs&gt; ContentLinkInvoked;
  }
  public class TextBox : Control {
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
  }
  public class TreeView : Control
  public sealed class TreeViewCollapsedEventArgs
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemInvokedEventArgs
  public class TreeViewItemTemplateSettings : DependencyObject
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject
  public enum TreeViewSelectionMode
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler&lt;WebView, WebViewSeparateProcessLostEventArgs&gt; SeparateProcessLost;
  }
  public enum WebViewExecutionMode {
    SeparateProcess = 2,
  }
  public enum WebViewPermissionType {
    Screen = 5,
    WebVR = 6,
  }
  public sealed class WebViewSeparateProcessLostEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    string Region { get; set; }
    public static DependencyProperty RegionProperty { get; }
  }
  public class MapElement : DependencyObject {
    bool IsEnabled { get; set; }
    public static DependencyProperty IsEnabledProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class AppBarButtonTemplateSettings : DependencyObject
  public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
  public class ListViewItemPresenter : ContentPresenter {
    bool DisableTilt { get; set; }
    public static DependencyProperty DisableTiltProperty { get; }
  }
  public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Documents {
  public sealed class ContactContentLinkProvider : ContentLinkProvider
  public sealed class ContentLink : Inline
  public sealed class ContentLinkInvokedEventArgs
  public class ContentLinkProvider : DependencyObject
  public sealed class ContentLinkProviderCollection : IIterable&lt;ContentLinkProvider&gt;, IVector&lt;ContentLinkProvider&gt;
  public sealed class PlaceContentLinkProvider : ContentLinkProvider
}
namespace Windows.UI.Xaml.Input {
  public sealed class FocusManager {
    public static IAsyncOperation&lt;FocusMovementResult&gt; TryFocusAsync(DependencyObject element, FocusState value);
    public static IAsyncOperation&lt;FocusMovementResult&gt; TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection);
    public static IAsyncOperation&lt;FocusMovementResult&gt; TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class FocusMovementResult
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
  public sealed class KeyboardAcceleratorInvokedEventArgs {
    KeyboardAccelerator KeyboardAccelerator { get; }
  }
  public enum KeyboardAcceleratorPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
}
namespace Windows.UI.Xaml.Media {
  public sealed class CompositionTarget {
    public static event EventHandler&lt;RenderedEventArgs&gt; Rendered;
  }
  public sealed class RenderedEventArgs
}
namespace Windows.Web.UI {
  public interface IWebViewControl
  public sealed class WebViewControlContentLoadingEventArgs
  public sealed class WebViewControlDeferredPermissionRequest
  public sealed class WebViewControlDOMContentLoadedEventArgs
  public sealed class WebViewControlLongRunningScriptDetectedEventArgs
  public sealed class WebViewControlNavigationCompletedEventArgs
  public sealed class WebViewControlNavigationStartingEventArgs
  public sealed class WebViewControlNewWindowRequestedEventArgs
  public sealed class WebViewControlPermissionRequest
  public sealed class WebViewControlPermissionRequestedEventArgs
  public enum WebViewControlPermissionState
  public enum WebViewControlPermissionType
  public sealed class WebViewControlScriptNotifyEventArgs
  public sealed class WebViewControlSettings
  public sealed class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs
  public sealed class WebViewControlUnviewableContentIdentifiedEventArgs
  public sealed class WebViewControlWebResourceRequestedEventArgs
}
namespace Windows.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl
  public sealed class WebViewControlAcceleratorKeyPressedEventArgs
  public enum WebViewControlAcceleratorKeyRoutingStage
  public enum WebViewControlMoveFocusReason
  public sealed class WebViewControlMoveFocusRequestedEventArgs
  public sealed class WebViewControlProcess
  public enum WebViewControlProcessCapabilityState
  public sealed class WebViewControlProcessOptions
}

Go to Source

Share this
19 Dec 2017

Application Engagement in Windows Timeline with User Activities

Author: Shawn Henry
Go to Source

Great applications help users do great things — enabling a wide range of creative, productivity and entertainment scenarios. Returning to activities can be a challenge, especially when a person wants to continue those activities across multiple devices. By writing User Activities, application developers have a new tool to get users back into their application.

In this article, you’ll learn how to drive application re-engagement by writing great User Activities into the Microsoft Graph with their UWP applications. This article is also a companion to the Microsoft Connect(); session: Engaging with your customers on any platform using the Microsoft Graph, Activity Feed, and Adaptive Cards.

User Activities and Timeline

Starting in Windows Insider Preview build 17056 or higher, User Activities generated by your application appear in Timeline. By writing User Activities into the Microsoft Graph, you can express specific content within your application as a destination which is showcased in Windows, and accessible on your iOS and Android devices.

Each User Activity represents a single destination within your app: such as a TV show, document or your current campaign in a game. When you engage with that activity (by creating an Activity Session), the system creates a history record indicating the start and end time for that activity. As you re-engage with that User Activity over time, multiple History Records will be recorded for a single User Activity. Here’s how to get started:

Adding UserActivities to your app

UserActivities are the unit of user engagement in Windows, and they consist of three components: a deep-link, visuals and content metadata.

  1. The Activation Deep Link is a URI that can be passed back to an application or experience in order to resume the application with specific context. Typically, these links take the form of protocol handler for a scheme (e.g. “my-app://page2?action=edit”) or an AppUriHandlers (e.g. http://constoso.com/page2?action=edit).
  2. Visuals are a set of properties that allow users to visually identify an activity, for example: title, description, or Adaptive Card elements.
  3. Finally, Content Metadata is metadata for the content of the of activity that can be used to group and retrieve activities under a specific context. Often, this takes the form of http://schema.org data.

In order to integrate UserActivities with your application, you need to:

  1. Generate UserActivity objects when your user’s context changes within an application (page navigation, new game, etc.)
  2. Populate UserActivity objects with the minimum set of required fields: ActivityId, ActivationUri, DisplayText
  3. Add a custom scheme handler to your application so it can be re-activated by your UserActivities

UserActivities can be integrated into an application with just a few lines of code:


UserActivitySession _currentActivity;

private async Task GenerateActivityAsync()
{
    //Get the default UserActivityChannel and query it for our UserActivity. If the activity doesn't exist, one is created.
    UserActivityChannel channel = UserActivityChannel.GetDefault();
    UserActivity userActivity = await channel.GetOrCreateUserActivityAsync(&quot;MainPage&quot;);

    //Populate required properties
    userActivity.VisualElements.DisplayText = &quot;Hello Activities&quot;;
    userActivity.ActivationUri = new Uri(&quot;my-app://page2?action=edit&quot;);
    
    //Save
    await userActivity.SaveAsync(); //save the new metadata

    //Dispose of any current UserActivitySession, and create a new one.
    _currentActivity?.Dispose();
    _currentActivity = userActivity.CreateSession();
}

The first line in the GenerateActivityAsync() method gets a user’s UserActivityChannel. This is the feed that this app’s activities will be published to. The next line queries that channel of an activity called “MainPage”

  • Your application should name activities in such a way that same ID is generated each time the user is in a particular location in the app. For example, if your application is page-based, use an identifier for the page, if it’s document based, use the name of the doc (or a hash of the name).
  • If there is an existing activity in the feed with the same ID, that activity will be return from the channel (with the UserActivity object State property set to Published). If there is no activity with that name, and new activity with State set to New.
  • Activities are scoped to your app, there is no need to worry about your activity ID colliding with IDs from other applications

After getting or creating the activity the next lines of code specify the other two required fields: the DisplayText and the ActivationUri.

Next, save the UserActivity metadata, by calling SaveAsync(), and finally CreateSession(). That last method returns a UserActivitySession object that we can use to manage when the user is actually engaged with the UserActivity. For example, we should call Dispose() on the UserActivitySession when the user leaves the page. In the example above, we also call Dispose() on _currentActivity right before we call CreateSession(). This is because we made _currentActivity a member field of our page, and we want to stop any existing activity before we start the new one (the ‘?’ is an inline null-check).

Since, in this case, our ActivationUri is a custom scheme, we also need to register the Protocol in the application manifest. This can be done in the Package.appmanifest XML file, or using the designer, as shown below. Double-click the Package.appmanifest file to launch the designer, select the Declarations tab and add a Protocol definition. The only property that needs to be filled out, for now, is Name. It should match the URI we specified above hello-activities.

Now we need to write some code to tell the application what to do when it’s been activated via a protocol. In this case, we’ll override the OnActivated method in App.xaml.cs to pass the URI on to our MainPage:


protected override void OnActivated(IActivatedEventArgs e)
{
    LoadFrame(e);
    if (e.Kind == ActivationKind.Protocol)
    {
        var uriArgs = e as ProtocolActivatedEventArgs;
        if (uriArgs != null)
        {
            Frame rootFrame = Window.Current.Content as Frame;
	    if (uriArgs.Host == &quot;page2”)
            {
                rootFrame.Navigate(typeof(SecondaryPage), uriArgs)
            }
        }
    }
    Window.Current.Activate();
}

Use Adaptive Cards to Improve the Timeline Experience

User Activities will appear in Cortana and Timeline experiences. When activities appear in Timeline, we display them using the Adaptive Card framework. If you do not provide an adaptive card for each activity, Timeline will automatically create a simple activity card based on your application name and icon, the required Title field and optional Description field. Below is an example Adaptive Card payload and the card it produces.


{
  &quot;$schema&quot;: &quot;http://adaptivecards.io/schemas/adaptive-card.json&quot;,
  &quot;type&quot;: &quot;AdaptiveCard&quot;,
  &quot;backgroundImage&quot;: &quot;https://winblogs.azureedge.net/win/2017/11/eb5d872c743f8f54b957ff3f5ef3066b.jpg&quot;,
  &quot;body&quot;: [
    {
      &quot;type&quot;: &quot;Container&quot;,
      &quot;items&quot;: [
        {
          &quot;type&quot;: &quot;TextBlock&quot;,
          &quot;text&quot;: &quot;Windows Blog&quot;,
          &quot;weight&quot;: &quot;bolder&quot;,
          &quot;size&quot;: &quot;large&quot;,
          &quot;wrap&quot;: true,
          &quot;maxLines&quot;: 3
        },
        {
          &quot;type&quot;: &quot;TextBlock&quot;,
          &quot;text&quot;: &quot;Training Haiti’s radiologists: St. Louis doctor takes her teaching global&quot;,
          &quot;size&quot;: &quot;default&quot;,
          &quot;wrap&quot;: true,
          &quot;maxLines&quot;: 3
        }
      ]
    }
  ]
}

Adaptive Cards can be added to the UserActivity object by passing a JSON string to the AdaptiveCardBuilder and setting the UserActivity.VisualElements.Content property:


activity.VisualElements.Content = 
AdaptiveCardBuilder.CreateAdaptiveCardFromJson(cardText);

Cross-platform and Service-to-service integration

If your application has a cross-platform presence (for example on Android and iOS), or maintains user state in the cloud, you can publish UserActivities via integration with Microsoft Graph.

Once your application or service is authenticated with a Microsoft Account, it is two simple REST calls to generate Activity and History objects, using the same data as described above.

Summary

In this blog post, we learned how to use the UserActivity API to make your application show up in Timeline and Cortana, but there is much more you can do:

Go to Source

Share this
19 Dec 2017

Service Workers: Going beyond the page

Author: Ali Alabbas
Go to Source

We’re thrilled to announce that today’s Windows Insider build enables Service Workers by default in Microsoft Edge for the first time.

This is an exciting milestone for us and for the web! These new APIs allow the web to offer better experiences when devices are offline or have limited connectivity, and to send push notifications even when the page or browser isn’t open.

This milestone also establishes the foundation for full-featured Progressive Web App experiences in Microsoft Edge and the Microsoft Store. We’ve carefully tailored our implementation together with Windows and are excited to be the only browser on Windows 10 to provide push handling in the background to optimize for better battery usage. We’ll have more to share about PWAs on Windows in the weeks ahead, so be sure to stay tuned!

We believe Service Workers are a foundational new tool for the web with the potential to usher in a new golden age of web apps. You can try out web experiences powered by Service Workers in Microsoft Edge on starting with today’s Windows Insider release, 17063.

Before we walk through how Service Workers work, let’s start with some context on how the web has tried to handle offline capabilities before Service Workers came along.

The state of the web

Not too long ago, the web’s capabilities were lagging behind what native apps could do. Browser vendors, standards bodies, and the web community have relentlessly attacked this gap over the last decade, with the goal of enabling richer web experiences.

A particularly egregious sore spot for the web has always been how it handled—or failed to handle—the lack of an internet connection, or a poor-quality connection. Offline and the web never really went well together—in most cases, we were given a frustrating error page that only made it clearer that the web’s greatest asset was also its greatest weakness: the internet. In contrast, native apps are typically designed to provide a good experience even while offline or experiencing spotty service.

On top of that, native apps can re-engage their users with push notifications. On the web, after the browser or the app disappears, so does your ability to deliver relevant information or updates to your users.

In the rearview: Application Cache

By 2012, we were able to do offline on the web by introducing a new standard: Application Cache (or App Cache for short). Developers could list URLs for the browser to keep in a special cache called the App Cache, so that when users visited the page they would see something other than an infuriating error page.

Unfortunately, this wasn’t the silver bullet we were looking for in terms of bringing offline to the web. There are more than a few well-documented limitations for App Cache that made it confusing and error prone for many users and web developers. The sum of it all was that there was little control in how the App Cache would work since most of the logic occurred behind-the-scenes in the browser.

That meant if you ran into an issue, it would be exceedingly difficult to understand how to resolve it. There was an obvious need for something that gave greater control to developers by offering the capabilities of App Cache but made it more programmatic and dynamic while doing away with many of its limitations that made it difficult to debug.

Hit Rewind

App Cache left a lot to be desired. For the next swing at enabling offline scenarios, it was clear that browsers needed to provide web developers true control over what would happen when a page and its sub-resources were downloaded, rather than having it automatically and transparently handled in the browser.

With the ability to intercept network requests from a page and to prescribe what to do with each, site authors would be able to respond back to the page with a resource that it could use. Before we get there, it seems that we would need to revisit one of the most fundamental aspects of the web: fetching a resource.

How fetching!

As you may recall from my last post on Fetch, we now have the fetch() method as well as the Request and Response primitives. As a refresher, here’s how you might retrieve some JSON data using the fetch API:

https://gist.github.com/kypflug/20cfe09274331571b545f08f273d3e7d

Every request that happens on a page (including the initial navigation, CSS, images, scripts and XHR) is defined as a fetch. The fetch() method (as shown in the code sample) is just a way to explicitly initiate a fetch, while implicit fetches occur when loading a page and all of its sub-resources.

Since we’ve unified the concepts of fetching resources across the web platform, we can provide site authors the chance to define their own behavior via a centralized algorithm. So, how do we pass that control over to you?

Service worker: the worker that serves

Web workers have long been a great tool to offload intensive JavaScript to a separate execution context that doesn’t block the UI nor interaction with the page. Given the right conditions, we can repurpose the concept of a web worker to allow a developer to write logic in response to a fetch occurring on a page. This worker wouldn’t just be a web worker, though. It deserves a new name: Service worker.

A service worker, like a web worker, is written in a JavaScript file. In the script, you can define an event listener for the fetch event. This event is special, in that it gets fired every time the page makes a request for a resource. In the handler for the fetch event, a developer will have access to the actual Request being made.

https://gist.github.com/kypflug/e39fd8caf4b5c5bff92af9478a2778f2

You can choose to respond with a fetch for the provided Request using the JavaScript APIs which returns a Response back to the page. Doing this essentially follows the typical browser behavior for that request—it’s not intrinsically useful to just do a fetch for the request, ideally it would be more useful if we save previous Response objects for later.

Cache it!

The Cache API allows us to look up a specific Request and get its associated Response object. The APIs give access to a new underlying key/value storage mechanism, where the key is a Request object and the value is a Response object. The underlying caches are separate from the browser’s HTTP cache and are origin-bound (meaning that they are isolated based on scheme://hostname:port) so that you cannot access caches outside of your origin. Each origin can define multiple different caches with different names. The APIs allow you asynchronously open and manipulate the caches by making use of Promises:

https://gist.github.com/kypflug/b45c38e3aab068e2ed73f5b6a2fcf592

These caches are completely managed by the developer, including updating the entries and purging them when they’re no longer needed – this allows you to rely on what will be there when you may not necessarily be connected to the internet.

Although the Caches API is defined as part of the Service Worker spec, it can also be accessed from the main page.

So now you have two asynchronous storage APIs to choose from: Indexed DB and the Caches API. In general, if what you’re trying to store is URL-addressable, use the Caches API; for everything else, use Indexed DB.

Now that we have a way to save those Response objects for later use, we’re in business!

Back to the worker

With a service worker, we can intercept the request and respond from cache. This gives us the ability to improve page load performance and reliability, as well as to offer an offline experience. You can choose to let the fetch go through to the internet as is, or to get something from the cache using the Cache API.

The first step to using a service worker is to register it on the page. You can do this by first feature-detecting and then calling the necessary APIs:

https://gist.github.com/kypflug/5c8946ab14d63ae1220674e973d9275f

As part of the registration, you’ll need to specify the location of the service worker script file and define the scope. The scope is used to define the range of URLs that you want the service worker to control. After a service worker is registered, the browser will keep track of the service worker and the scope it is registered to.

Upon navigating to a page, the browser will check if a service worker is registered for that page based on the scope. If so, the page will go on to use that service worker until it is navigated away or closed. In such a case, the page is said to be controlled by that service worker. Otherwise, the page will instead use the network as usual, and will not be controlled by a service worker.

Upon registration, the service worker won’t control the page that registered it. It will take control if you refresh the page or you open a new page that’s within its scope.

After initiating the registration of a service worker, it will go through the registration process. That will involve going through the different phases of its lifecycle.

The service worker lifecycle

Let’s unpack the different phases of the service worker’s lifecycle, starting with what happens once you try to register it.

Installing

This is the first step that any service worker goes through. After the JavaScript file has been downloaded and parsed by the browser, it will run the install event of your script. That’s when you’ll want to get everything ready such as priming your caches.

In the following example, the oninstall event handler in the service worker will create a cache called “static-v1” and add all the static resources of the page to the cache for later use by the fetch handler.

https://gist.github.com/kypflug/25727eb1dc9338e58b199ced638ebaa2

Installed

Once the service worker is installed, the setup is complete, and the service worker is awaiting all pages/iframes (clients) that are controlled by this service worker registration to be closed so that it can be activated. It could be potentially problematic to change the service worker for pages that are still actively using a previous version of the service worker, so the browser will instead wait until they’ve been navigated away or closed.

Activating

Once no clients are controlled by the service worker registration (or if you called the skipWaiting API), the service worker goes to the activating phase. This will run the activate event in the service worker which will give you the opportunity to clean up after the previous workers that may have left things behind, such as stale caches.

In this example, the onactivate event handler in the service worker will remove all caches that are not named “static-v1.”

https://gist.github.com/kypflug/247156862fe818bd9f66e0b5812f0502

Activated

Once it’s been activated, the service worker can now handle fetch and other events as well!

In this example, the onfetch event handler in the service worker will respond back to the page with a match from the cache if it exists and if there isn’t an entry in the cache, it will defer to making a fetch to the internet instead. If that fetch fails, it will resort to returning a fallback.

https://gist.github.com/kypflug/547194a4e5f80eb34720541e77b31d6f

Redundant

The final phase of the service worker is when it is being replaced by another service worker because there’s a new one available that is going to take its place.

There’s more to it: the big picture

So far, we’ve explored the following service worker events: install, activate, and fetch. Install and activate are considered lifetime events while fetch is considered a functional event. What if we could expand on the service worker’s programming model and introduce other functional events that could plug in to it? Given that service workers are event-driven and are not tied down to the lifetime of a page, we could add other events such as push and notificationclick which would present the necessary APIs to enable push notifications on the web.

Push it to the limit

Push notifications provide a mechanism for developers to inform their users in a timely, power-efficient and dependable way, that re-engages them with customized and relevant content. Compared to current web notifications, a push notification can be delivered to a user without needing the browser/app or page to be opened.

The W3C Push API and Notification API go hand-in-hand to enable push notifications in modern browsers. The Push API is used to set up a push subscription and is invoked when a message is pushed to the corresponding service worker. The service worker then is responsible for showing a notification to the user using the Notification API and reacting to user interaction with the notification.

A standardized method of message delivery is also important for the W3C Push API to work consistently across all major browsers where application servers will need to use multiple push services. For instance, Google Chrome and Mozilla Firefox use Firebase Cloud Messaging (FCM) and Mozilla Cloud Services (MCS), respectively while Microsoft Edge relies on the Windows Push Notification Service (WNS) to deliver push messages.

To reach reasonable interoperability with other browsers’ messaging services, WNS has now deployed support for the Web Push protocols being finalized within IETF, as well as the Message Encryption spec and the Voluntary Application Server Identification (VAPID) spec for web push. Web developers can now use the Web Push APIs and service workers to provide an interoperable push service on the web.

To start, you’ll first need to make sure your web server is setup to send pushes. The Web-Push open-source library is a great reference for anyone new to web push. The contributors have done a reasonable job in keeping up with the IETF specs. After starting up a node.js server based on the web-push library, you’ll need to setup the VAPID keys. Keep in mind that you’ll need to use HTTPS as it is required for service workers and push. You only need to set up the VAPID keys once which can be generated easily using the corresponding function in the web-push library.

https://gist.github.com/kypflug/d431c41f3b39e0e4e89e05aa59ecbaa4

Once that’s all sorted out, it’s time to take advantage of push in your site or app. Once the page loads, the first thing you’ll want to do is get the public key from the application server so that you can set up the push subscription.

https://gist.github.com/kypflug/8020af4245f5afe3ddd95cbe3527011e

With the public key in hand, as before, we’ll need to install the service worker, but this time, we’ll also create a push subscription.

https://gist.github.com/kypflug/154e8984cfc20d8820cecaa7536154a1

Before a new push subscription is created, Microsoft Edge will check whether a user granted permission to receive notifications. If not, the user will be prompted by the browser for permission. You can read more about permission management in an earlier post about Web Notifications in Microsoft Edge. From a user’s perspective, notifications from the page or from a push service appear identical, so we are using the same permission for both types of notifications.

To create a push subscription, you’ll need to set the userVisibleOnly option to “true” – meaning a notification must be shown as a result of a push – and provide a valid applicationServerKey. If there is already a push subscription, there is no need to subscribe again.

At any point when a push is received by the client, a corresponding service worker is run to handle the event. As part of this push handling, a notification must be shown so that the user understands that something is potentially happening in the background.

https://gist.github.com/kypflug/6aa49c671ce351cf6d3b67cdaecda316

Of course, after a notification is shown, there is still the matter of dealing with when its been clicked. As such, we need to have another event listener in the service worker that would handle this case.

https://gist.github.com/kypflug/bc17aa590c18753df9ca07e4c0d7b157

In this case, we first dismiss the notification and then we can choose to open a window to the intended destination. You’re also able to sort through the already open windows and focus one of those, or perhaps even navigate an existing window.

Push: The Next Generation

As part of our ongoing commitment to expanding the possibilities of the web, Microsoft Edge and PWAs in Windows will handle these service worker push event handlers in the background—there’s no need for Microsoft Edge or your PWA to be running for the push to be handled. That’s because we’ve integrated with Windows to allow for a more holistic approach to push notifications.

By leveraging Windows’ time-tested process lifetime management, we’re able to offer a system that reacts appropriately to system pressures such as low battery or high CPU and memory usage. For users, that means better resource management and battery life expectations. For developers, it means a push event handler that will get to run to completion, without interruption from user actions such as closing the browser window or app. Note that a service worker instance that is running in the foreground for the fetch event will not be the same as the one in the background handling the push event.

Notifications in Microsoft Edge and PWAs will be integrated in the Windows Action Center. If a user receives a notification and didn’t get the chance to act on it, it will get tucked away into Action Center for later, so notifications never get left unseen. Action Center will also group multiple notifications coming from the same domain, so that users have an easier time sorting through them.

Service worker: properties

I’d like to take a moment to go over some things you should keep in mind when using service workers in your web app or site. In no particular order, here they are:

  • HTTPS-only. Service workers will not work in HTTP; you will need to use HTTPS. Fortunately, if you’re testing locally, you’re allowed to register service workers on localhost.
  • No DOM access is allowed. As with web workers, you don’t get access to the page’s object model. This means that if you need to change something about the page, you’ll need to use postMessage from the service worker to the page so that you can handle it DOM changes from the page.
  • Executes separate from page. Because these scripts are not tied to the lifetime of a page, it’s important to understand that they do not share the same context as the page. Aside from not having access to the DOM (as stated earlier), they won’t have access to the same variables available on the page.
  • Trumps App Cache. Service workers and App Cache don’t play well together. App Cache will be ignored when service workers are in use. Service workers were meant to give more control to the web developer—imagine if you had to deal with the magic of App Cache while you’re trying to step through the logic of your service worker!
  • Script can’t be on CDN. The JavaScript file for the service worker can’t be hosted on a Content Distribution Network (CDN), it must be on the same domain as the page. However, if you like, you can import scripts from your CDN.
  • Can be terminated any time. Remember that service workers are meant to be short-lived and their lifetime is tied to events. In particular, service workers have a time limit in which they must finish executing their event handlers. In other cases, the browser or the operating system may choose to terminate a service worker that impacts the battery, CPU, or memory consumption. In either case, it would be prudent to not rely on global variables in the service worker in case a different service worker instance is used on a subsequent event that’s being handled.
  • Only asynchronous requests allowed. Synchronous XHR is not allowed here! Neither is localStorage, so it’s best to make use of Indexed DB and the new Caches API described earlier.
  • Service worker to scope is 1:1. You’ll only be able to have one service worker per scope. That means if you try to register a different service worker for a scope that already has a service worker, that service worker will be updated.

Recap

Service workers are so much more than an HTTP proxy! They are the foundation of a web app model that enables event-driven JavaScript to run, independent of web pages. Service workers were brought in to the web platform as a necessity to enable offline use cases, but it’s clear that they can do so much more, as we continue to extend their capabilities to other scenarios. Today we have push, but in the future, there will be other exciting capabilities that will bring the web that much closer to offering the captivating and reliable experiences we’ve always wanted.

Go put a worker to work!

So, what are you waiting for? You can get started testing service workers in Microsoft Edge today by installing the Windows Insider Preview build 17063 or higher. We’d love to hear your feedback, so please share any bugs you encounter or reach out to us on Twitter to get in touch!

— Ali Alabbas, Program Manager, Microsoft Edge
— Jatinder Mann, Program Manager, Microsoft Edge

Go to Source

Share this
19 Dec 2017

Announcing Windows 10 Insider Preview Build 17063 for PC

Author: Dona Sarkar
Go to Source

Hello Windows Insiders!

Today, we are releasing Windows 10 Insider Preview Build 17063 for PC to Windows Insiders in the Fast ring and for those who opted in to Skip Ahead.

What’s new in Build 17063

Introducing Timeline

Timeline is here! We know that it can be difficult to get back to stuff you were working on in the past. If you’re like us, you might sometimes forget which site or app you were using or where you saved a file. Now you can finally close apps without worrying—with Timeline, you can get right back to where you left off.

Timeline introduces a new way to resume past activities you started on this PC, other Windows PCs, and iOS/Android devices. Timeline enhances Task View, allowing you to switch between currently running apps and past activities.

The default view of Timeline shows snapshots of the most relevant activities from earlier in the day or a specific past date. A new annotated scrollbar makes it easy to get back to past activities.

Task view has been enhanced to include a Timeline of past activities.

Figure 1. Task view has been enhanced to include a Timeline of past activities.

There’s also a way to see all the activities that happened in a single day—just select See all next to the date header. Your activities will be organized into groups by hour to help you find tasks you know you worked on that morning, or whenever.

Browse all your activities for a single day.

Figure 2. Browse all your activities for a single day.

And if you can’t find the activity you’re looking for in the default view, search for it.

Search Timeline to find exactly what you are looking for.

Figure 3. Search Timeline to find exactly what you are looking for.

Activities

In Timeline, a user activity is the combination of a specific app and a specific piece of content you were working on at a specific time. Each activity links right back to a webpage, document, article, playlist, or task, saving you time when you want to resume that activity later.

App developers are working hard to enhance their apps by creating high-quality activity cards to appear in Timeline. In this Preview release, you can see and resume web-browsing activities in Microsoft Edge, files you opened in apps like Microsoft Office including Word, Excel, PowerPoint, and OneNote, and updated UWP versions of Maps, News, Money, Sports, and Weather.

We encourage app developers to update their apps to support timeline.

The new activity history settings page allows you to control which accounts appear in Timeline. This is most relevant for users with multiple accounts, such as a personal Microsoft account, and a work or school account. Settings here also let you disable activity collection and clear your activity history.

The activity history settings page lets you choose which accounts you want to appear in your timeline.

Figure 4. The activity history settings page lets you choose which accounts you want to appear in your timeline.

Cortana

In addition to resuming past activities through Timeline, your personal digital assistant Cortana will suggest activities you might want to resume to help you stay productive as you switch between your phone, laptop, and other Cortana-enabled devices. This experience is powered by the same activities that appear in Timeline.

Cortana helps you resume activities when switching between devices.

Figure 5. Cortana helps you resume activities when switching between devices.

Getting started

Use your PC normally. After a while, select the new Task view icon in the task bar. (You can also open Task view by pressing Windows logo key + Tab.) Below your running apps, you’ll see past activities in Timeline.

The Task view icon has been updated to reflect new timeline capabilities.

Figure 6. The Task view icon has been updated to reflect new timeline capabilities.

If you have more than one PC, try using Timeline on all of them—you’ll see the same activities no matter which PC you’re using. And if an activity from one PC used a modern app that you don’t have installed on another PC, Windows will help you install that app.

We’d love to hear your feedback, so please press the feedback button in the upper-right corner of Timeline if you have any problems or suggestions.

Microsoft Edge Improvements

Fluent updates in Microsoft Edge: Microsoft Edge now supports an updated Dark theme, with darker blacks, and much better contrast with all colors, text, and icons. This addresses many accessibility contrast issues, making the Microsoft Edge UI easy to navigate and more visually pleasing. As well, Microsoft Edge now supports Reveal on our navigation buttons, action buttons, buttons in the tab bar, as well as on lists throughout Microsoft Edge (such as in the HUB: Favorites, Reading, History, Downloads), making navigating Edge UI even easier. We’ve heard your feedback and have also updated the Acrylic in the tab bar and in-active tabs, allowing more color to show through.

Bookmark button and flyout become one: With this build, Microsoft Edge has also simplified adding and managing bookmarks for EPUB and PDF books. Based on your feedback we now allow you to add bookmarks and manage your list of bookmarks from the same location. This provides a very consistent experience across the different book formats and makes it really easy for users to manage their bookmarks from one location.

Offline web sites and push notifications: Microsoft Edge now supports Service Workers and the Push and Cache APIs. These new web standards allow web pages to send push notifications to your Action Center or refresh data in the background, even when the browser is closed. In addition, certain web pages can now work offline or improve performance, by using locally cached data when the cache is up to date, or when your device has a poor connection. You can learn more about these features in our post Service Workers: Going beyond the page. These features lay the technical foundation for Progressive Web Apps on Windows 10 – we’ll have lots more to share about this topic soon on the Microsoft Edge Dev Blog!

Web Media Extensions Package: This build installs the Web Media Extensions package for Microsoft Edge, which extends Microsoft Edge and Windows 10 to support open-source formats (OGG Vorbis and Theora) commonly found on the web. Try out your favorite OGG content (such as Wikipedia videos or audio)! We will be monitoring feedback from this feature in Insider flights to eventually expand to broader availability to Microsoft Edge customers in the Current Branch.

Gesture Improvements for Precision Touch Pads: This build introduces a new gesture experience for Precision Touch Pads (found on Surface and other modern Windows 10 devices). You can now use gestures like pinch and zoom, or two-finger panning, to achieve the same interactions on web sites that you can do with a touch screen today. For example, you can now pinch-to-zoom on a map in Bing Maps to zoom in the map without zooming the entire page. Developers can learn more about how this change is implemented and how to make sure your sites are ready for modern input experiences over at our blog post, Building a great touchpad experience for the web with Pointer Events.

Sets

A few weeks ago, we announced a new Windows 10 feature called “Sets” (we may end up calling it something else by the time it ships) which would be coming to Windows Insiders as a controlled study. The concept behind Sets is to make sure that everything related to your task: relevant webpages, research documents, necessary files and applications, is connected and available to you in one click. Office (starting with Mail & Calendar and OneNote), Windows, and Edge become more integrated to create a seamless experience, so you can get back to what’s important and be productive, recapturing that moment, saving time – we believe that’s the true value of Sets. Starting with today’s build, Sets will be available to Insiders however because it is being introduced as a controlled study, not all Insiders will see Sets. For more on this – see my blog post here.

Cortana Improvements

Cortana’s Notebook has a new look: Notebook has undergone a UX transformation to be more responsive to Cortana’s evolving capabilities and allow users to easily complete their tasks.

  • Your content has a new home called Organizer that lets you access your lists and reminders with ease. And all Skills are together, so you can easily configure Cortana to suit your needs. Configuration experience has also been significantly simplified.
  • Tabbed view to cleanly segregate your content and configuration and single page to manage Cortana’s Skills and easy way to discover more.
  • Simplified configuration experience page with easy interest management.
  • This is a server side change currently rolling out for those using English (United States) and will be rolled out to other markets with time.

Account entry point in the navigation menu: To improve discoverability and consistency, we’re moving the account entry point out of Cortana’s Notebook and into the navigation menu (that’s the side bar that contains elements like Home, Notebook, and Collections).

Lists and Collections – better together! Cortana Collections have been merged with Lists, so you get personalized suggestions and help with List creation – all in a rich, attractive interface. Cortana helps you track your To-Do’s and manage Grocery lists. She also suggests items of interest –  restaurants to try out, recipes to make, books to read, movies & shows to watch, things to shop for – and makes it easy to add them to your lists.  See and use your Lists and suggestions in the List home:

You can access it from Notebook:

For now, this feature is only available for Insiders using English (United States), who are logged into both Windows and Cortana with their Microsoft Account.

A note about Collections: We’ve made an underlying breaking change to how Cortana’s Collection works – if you’ve been using this feature in previous builds we need to migrate your data to our new collection APIs. Because of this, once you upgrade to this build you’ll notice all of your existing saved list items have moved under suggestions. If you want to keep these suggestions, please drag and drop them back into the list. Thank you everyone who’s given us feedback so far about the Collections experience – please continue doing so!

Cortana loves music: You can now use Cortana to control music playback on more of your favorite music apps (EN-US only). Starting with this build, we are enabling natural language compatibility for Spotify just like the Harman Kardon Invoke! This will work on both, above the lock screen (PC is locked) as well as below! You can try queries like…

  • Play Christmas music on Spotify
  • Play my discover weekly playlist on Spotify
  • Play on
  • Play some Drake
  • Play focus music
  • Play rock music
  • Play my tracks

Once music is playing you can ask Cortana what’s playing like this:

  • Hey Cortana, what’s playing?

Cortana will keep you posted on your tracks.

To start rocking to your favorite tracks just get the latest app update and sign into Spotify in the notebook under the music section.

NOTE: For the above to work, you need to have a Spotify account (free or premium).

Windows Shell Improvements

Bring on the Fluent! Today, Start and Action Center support acrylic to align with Fluent design principles. And now we’re bringing the next wave of Shell UI to the party by applying acrylic to the taskbar, Share UI, Clock & Calendar flyout, Network flyout, Volume flyout, and Input flyout. Try it out and let us know what you think!

Note: The acrylic background is disabled if you enter battery saver mode. We’re also investigating an issue where if you have scaling > 100% the blurred background may appear distorted.

Save notification drafts: Notifications are inherently transient – one thing we’ve heard from you is how it can be frustrating to have started writing a response into a notification (such as one from Skype), only to have the response disappear if you didn’t submit it before the notification went away. Well, no more! If a toast gets dismissed with unsubmitted text, we will now save the draft; open the action center and your text will now be saved with the notification.

Simplified letter grouping in Start for East Asian languages: One of the top feedback items from our users is that it’s too hard and takes too long to find apps in the all apps list because of the way the apps are grouped when using East Asian languages. We hear you, and we’re happy to announce that with this build we’ve simplified the grouping of apps in the all apps list for Chinese (Simplified), Japanese, and Korean. This change is most noticeable for Chinese (Simplified) and Japanese, where we’ve reduced the number of groups by 29 and 36, respectively. If you use Windows in these languages, please take a moment to check it out once you get the build and let us know how it feels.

Chinese (Simplified) previous and new all apps list sections

Japanese previous and new all apps list sections

Cloud states for the Navigation Pane: In an effort to further keep you informed about the state of your OneDrive files and folders on demand, we’re looking at adding a state icon to use in File Explorer’s Navigation Pane. If you’d like to turn this off, there’s an option in the File Explorer ribbon View tab – click the Options button, then in the dialog that appears go to the Navigation Pane section of the View tab and uncheck “Always show availability status”.

A consistent Network flyout on the login screen: Continuing our work to modernize all the elements of Windows 10, we’ve now updated the network flyout on the login screen to use the same familiar network flyout you’ve grown to love in the taskbar.

Improving your update experience: In an effort to keep you informed about the state of your PC, if Windows Update Settings shows a warning or alert, we will now echo that via a new Windows Update system tray icon. If you right click the icon, you will see options relevant to the current state, such as restart, schedule the restart, or go to Windows Update settings. If visible, this icon can be turned off from within Taskbar Settings.

An improved My People experience

Based on your feedback we’ve been working on evolving the My People experience and taking it to the next level. This build brings with it a number of requested features, improvements and changes including:

  • Drag and drop rearrange: Checking off one of our top feedback requests – you can now drag and drop contacts to rearrange them in the taskbar! You can also drop contacts into and out of the People flyout. Note: as part of this feature change, when you upgrade, if you have multiple contacts pinned to taskbar you will notice that their order will reverse direction on the taskbar

  • You decide how many contacts to show in the taskbar: With the Fall Creators Update you could have a maximum of 3 people pinned to the taskbar, with any additional pins appearing in the People flyout. We’ve heard your feedback and today’s build brings a new setting so you can decide how many you’d like to show – from one to ten, or you can choose to show them all in the overflow. You can find the setting with the other People settings under Settings > Personalization > Taskbar.
  • Animations for people in overflow: To improve discoverability you’ll now see an animation across the People icon to let you know when someone is pinned to the overflow list in the flyout. In addition, previously you could only receive emotive notifications from contacts that were directly on your taskbar – with today’s flight this experience is now available for people pinned within the People flyout as well! Here’s a glimpse of how it looks (showcased using our favorite “windows10” Skype emoji). Want to try it? Get one of your pinned contacts to send you a “(poke)”, or add, pin, and ping our emoji bot.

  • Fluent in the flyout: As part of our larger ongoing effort to reach our Fluent Design goals, you’ll notice that the People flyout now makes use of acrylic, reveal, and light effects.
  • Improving app discoverability: As developers work to integrate My People support into their apps, we’ll now suggest apps that you might be interested in. There’s an option to turn this on or off in the People settings under Settings > Personalization > Taskbar.

Add a new dimension to what you capture in Snipping tool

This build brings a new “edit in Paint 3D” button to the Snipping Tool so you can take your snip to the next level via Paint 3D.  Move (or remove) objects with Magic select, augment and annotate with a variety of options, bring in 3D objects from Remix 3D, and more!

Windows Settings Improvements

Settings gets a new look: You’ve already seen we say “bring on the Fluent!” in other areas of Shell, and Settings is no different. With today’s build you’ll find not only have we refreshed the Settings UI leveraging Fluent Design principles, but we’ve also taken a look at the Settings homepage and redesigned it with an eye for visual acuity. As you explore the plethora of new and improved settings below, take a moment to get a feel for the updated design as a whole and let us know what you think.

Security questions for local accounts: With the Fall Creators Update, we started working on self help solutions for password recovery from the Lock screen. Today, we’re adding this functionality to local accounts as well, through the newly available use of security questions for local accounts. If you already have a local account, you can add security questions by going to Settings > Accounts > Sign-in Options > “Update your security questions”. If you’re installing a new PC using a local account, setup will walk you through adding these questions and answers right there in the workflow. Once your security questions are set up, if you find yourself unable to remember your password on the lock screen, you will see a link to reset your password, whereupon clicking you’ll be prompted to enter the answers to your security questions.

View your display info in one convenient location: Beginning with Build 17060, you can now view detailed information about your display by visiting the new “Advanced display settings” page linked at the bottom of Settings > System > Display.

Most of the information should be self-explanatory, but here are a couple of pieces that you might want more detail on:

  • Desktop resolution vs active signal resolution. Typically, your desktop resolution and your active signal resolution will be identical. To provide a smoother experience, Windows prefers to keep your display running at its native signal resolution. If you change your display resolution under Settings > System > Display > Scale and layout > Resolution, you may see a difference between your desktop resolution and your active signal resolution.
  • The mysterious 59 Hz refresh rate. Display enthusiasts may remember this conversation from the Windows 7 days. You may see 59 Hz listed as your refresh rate even though you have set it to 60 Hz, but rest assured that this is by design for monitors and TVs that report only 59.94 Hz but not 60 Hz. Learn more about it here.

Stay tuned for more improvements to display settings! Your feedback is important to us – if there are new features you would like to see in display settings in the coming releases, please let us know through the Feedback Hub. Search for and upvote your favorite features, or file your suggestion under the Desktop Environment > Settings.

Improving your scaling experience: In this flight we’ve made it easier for you to fix apps that become blurry if you dock/undock, RDP, or change display settings. Some desktop apps can become blurry in these scenarios. When this happens, you have to log out and back in to Windows to have these apps render properly. In this flight, you can turn on a feature that will enable these apps to be fixed simply by re-launching them. There are three components to this feature:

  • A new setting in the Display Settings page: Under Settings > System > Display > Advanced scaling, you’ll find a new section called “Fix scaling for apps” where you can enable a setting to let Windows try and fix apps so they’re not blurry.

  • A toast that pops up when we detect that you might have blurry apps on your main display.

  • A per-app override of the global setting. By right clicking on the exe for a desktop apps and choosing properties, you can select “Change High DPI Settings”, then “Override System DPI”, then configure the behavior.

NOTE: This won’t work for all desktop apps and it only improves blurry desktop apps while they’re on the main display. If you’re using multiple displays with different scale factors and running in “Extend” display mode, these apps might still be blurry on secondary displays.

A new Keyboard Settings page: We’re introducing a new Keyboard Settings experience on PC! Now found under the Time & Language Settings, you’ll be able to easily add new keyboard layouts, switch between Japanese 106/109 and English 101/102 keyboard layouts, turn on and off settings like key sounds and autocorrect, and other advanced keyboard-related settings. Additionally you can now change the default keyboard independently of the display language, for example using the French display language and having English as the default keyboard (this option was previously available in Control Panel, but has now been moved to Settings). Duplicate settings from Control Panel have been removed.

A new and improved Region & Language Settings page: As part of our ongoing effort to converge Settings and Control Panel, as well as improve Settings usability, you’ll find with today’s build that we have reimagined the Region & Language Settings. We’ve added icons to each language entry to indicate when language support is installed for display language, text-to-speech, speech recognition, and/or handwriting. We’ve also added an entirely new language selection experience – enabling you to quickly identify available language features per language. This also marks the initial integration of Local Experience Packs, native AppX packages, that with Microsoft Store to enable us to regularly update language resources with translation improvements collected from Windows Insiders and other feedback channels. We’re still fine-tuning the UI, so expect some small changes over the next few flights.

Set data settings to prefer cellular usage: In Cellular Settings you can now choose to use cellular instead of Wi-Fi always or when Wi-Fi is poor. This updated Windows feature allows people with fast LTE connections and large/unlimited data plans to favor cellular whenever available and avoid being stuck on poor Wi-Fi connections.

NOTE: The Cellular Settings page will only be visible for people using PCs with cellular connections.

Improved Data Usage Management: You can now configure data limits and/or place background data restrictions to Wi-Fi and Ethernet connections, in addition to cellular connections, in the Data usage page. The updated settings page aims to support a diverse set of devices and users. Whether you have a PC with cellular connectivity or a metered ethernet network connection, tailor your data usage to your budget and needs. Want to see your data usage at a glance? Right click on the Data usage tab in Settings and pin it to the Start menu to see a data usage live tile.

Reset your Game Mode Settings: Under Settings > Gaming > Game Mode there is a new option called ”Reset Game Mode Settings” that allows you to restore Game Mode settings for their PC back to the default values for the feature.

Improved Per-app Settings: When we added a new context menu option to go straight from the app in Start to the per-app settings in Settings, we mentioned turning this page into a one stop shop for settings related to each app. In today’s build you’ll notice that we now bubble up any permissions the app has asked for, along with an easy option for you to toggle them. We’ve also added links to check background usage, lock screen notifications, and defaults, and options to terminate and/or uninstall the app.

Windows Defender Improvements

Windows Defender Application Guard (WDAG) update: You spoke, and we listened. Microsoft is bringing Windows Defender Application Guard to Windows 10 Professional in the next feature update of Windows 10. Now, like Windows 10 Enterprise users, Windows 10 Pro Users can navigate the Internet in Application Guard knowing their systems are protected from even the most sophisticated browser attacks.

Windows Defender Application Guard provides unprecedented protection against targeted threats using Microsoft’s industry leading Hyper-V virtualization technology. Check out this recent RSA talk on Window Defender Application Guard if you’d like to understand this feature in some more detail.

It is available now to our awesome Windows Insider community to give it a try and we would like to hear your feedback.

For more details please see our tech community page.

Quick access from the context menu: You can now right-click on the Windows Defender icon in the notification area and get an updated context menu that lets you quickly do a quick scan, update your Defender definitions, change the notifications and open Windows Defender Security Center.

Windows Subsystem for Linux (WSL)

WSL can run background tasks: Processes that set themselves up to run in the background such as sshd, tmux/screen, etc. will now continue running after the last console window has been closed. Read this blog for more information and a demo.

Elevated and non-elevated WSL instances can run simultaneously:  Previously WSL instances all had to all run as elevated or all unelevated.  Now you can run some elevated and some non-elevated instances.  You can also use Scheduled Tasks to run WSL.

WSL runs in remote connections: WSL is now supported when connected via OpenSSH, VPN, Enter-PSSession, and/or other similar Windows remoting tools. Previously this would only work in cases where the user logged in interactively and started a WSL instance before connecting remotely. to the remote host and then launch WSL. With background processes you can background sshd in WSL so it persists in the background without having any open windows.

Tool to convert Linux paths to Windows-friendly paths: Wslpath is a tool that allows you to convert Linux paths to their Windows equivalent. Here is a quick reference for how you can use the wslpath tool:

-a    force result to absolute path format
-u    translate from a Windows path to a WSL path (default)
-w    translate from a WSL path to a Windows path
-m    translate from a WSL path to a Windows path, with ‘/’ instead of ‘’

New tools available to developers on Windows

Windows Command line Toolchain includes bsdtar (tar) and curl.
bsdtar and curl, two popular command line tools from the Unix shell, are now available in Windows and Windows Server.  bsdtar provides handy extraction/creation of compressed files and curl offers data transfer capabilities so you can download files from a remote location.  Read this blog to learn more about the addition of these two new tools and see how they’re shaping the developer experience on Windows.

Unix style sockets (AF_UNIX) are available on Windows
AF_UNIX is an address family which has enabled inter-process communication on Unix for countless years. The windows equivalent is named pipes, which offers similar facilities. Based on user feedback, we heard that you’d like an easier path when porting tools relying on AF_UNIX to Windows. As a result, two Win32 processes can now use the AF_UNIX address family over Winsock API to communicate with each other.  Read this blog for more details.

Control Windows legacy apps access to your camera

Camera privacy settings under Settings > Privacy > Camera give you fine control over the apps that have access to your camera. Prior to this update, the toggle marked ‘Let apps use my camera hardware’ only applied to apps installed from the Windows Store (think Skype from Store). This meant that you could have the toggle set to off, but still have legacy apps use the camera (think Skype for Desktop). With this update, we are changing the toggle’s behavior to include all legacy apps. Note that each legacy app will not appear individually in the list today like Store apps do, but they will respect the toggle.

Another related change that is also part of this update will include the Windows Camera app in the list of apps that can use your camera; it was previously exempt from this list.

If your legacy camera application stops working after taking this update, please check your camera privacy settings and ensure that the toggle is enabled. Please try the new camera privacy features & remember to file all feedback via the Feedback Hub.

Input Improvements

Personalize the handwriting panel: In this release you can now change the font that your handwriting converts to in the handwriting panel! Go to Settings > Devices > Pen & Windows Ink > “Change the font of the handwriting experience”, select your preferred font from the dropdown, then write in the handwriting panel to see your chosen font.

You can now use the Emoji Panel in more languages! Based on your feedback, we’ve been working diligently on more added support for more languages and as of today’s build you can now use the emoji over 190 locals – 152 of which have tooltip support when you hover over each emoji. This includes English (Great Britain), French (France), German (Germany), Spanish (Spain), and more! You can open the Emoji Panel by pressing Windows logo key + period(.). Currently you can only browse and use mouse/touch/keyboard to pick an emoji in these languages, however we’re working on adding search. Stay tuned!

Single or multiple emoji at a time – you choose: With the previous flight we added support for inputting multiple emoji at a time. Today we’re adding a setting so that you can decide which behavior is best for you. Simply check or uncheck the new “Don’t close panel automatically after an emoji has been entered” setting under Settings > Time & Language > Keyboard > Advanced Keyboard Settings.

Emoji data update: Last flight we shared our initial emoji data update across multiple languages for this release – as promised with today’s flight we have the second bulk of the payload. We’ve added a number of additional words you can use to find the emoji you’re looking for in your language – use the touch keyboard and search for things like hedgehog, vampire, and pretzel.

Hardware keyboard suggestions update: Since our first flight with this new feature, we have two updates to share with you:

  • Firstly: We now support dark theme! Use Color Settings to switch between light and dark and see how your text suggestions will now follow suit.
  • Secondly: We’ve moved the settings for how to enable this feature, you can now find it under Keyboard Settings > English (United States) > Options > Hardware keyboard > “Show text suggestions as I type”.

Split layout comes to the touch keyboard: As many of you know we redesigned the touch keyboard to be XAML-based for the Fall Creators Update. We’ve been hard at work addressing your feedback, and are happy to announce that with this build the touch keyboard now supports the split layout – an ergonomic layout designed to be used with both hands, one on each side of your tablet.

Note: Korean, Japanese and Simplified Chinese languages aren’t yet supported for this layout, but we’re working on it.

The standard touch keyboard layout for Japanese, Korean, Quick and ChangJie for Traditional Chinese: Now the standard keyboard layout for East Asian languages are available except Simplified Chinese and Bopomofo for Traditional Chinese (which we’re still working on). Japanese Kana layout is also supported. If you want to switch between wide, one-handed, and the standard touch keyboard layouts, just tap the button in the top left of the keyboard.

New features for IT Pros in Delivery Optimization

We’ve added multiple policies in this release (both Group Policies and MDM Policies) that provide Admins with means to throttle bandwidth at certain times of day (for both foreground and background traffic), restrict peer selection to the same subnet, automatically join devices into peer groups by using a DHCP server’s User option or the connection’s DNS suffix as well as the ability to increase the usage of peers by delaying the use of the HTTP source.

To view the list of new configs, open the GP Editor and checkout the new policies under Administrative Templates > Windows Components > Delivery Optimization:

These features were added based on feedback from IT Pros who rely on Delivery Optimization to reduce the bandwidth consumption on their network. The throttling policies can be useful to you if you are looking to throttle Internet bandwidth during critical business hours while allowing update traffic to flow faster at other times. The new peer selection policies address feedback we’ve received from customers who are using AAD and Modern Management (Intune, WUfB) and needed more options to automatically group peers in each site they manage.

Registry Process

In recent Insider Preview builds, you may have noticed a new process labelled “Registry” in Task Manager. The purpose of this process is similar to that of the memory compression store process in that it is a minimal process whose address space is used to hold data on behalf of the kernel. However, while the memory compression process is used to hold compressed pages, the registry process is used to hold registry hive data (e.g. HKEY_LOCAL_MACHINESOFTWARE, HKEY_CURRENT_USER).

Storing registry hive data in the registry process gives the registry access to more powerful memory management capabilities which will allow us to reduce the registry’s memory usage in the future.

Today’s Insider Preview build is the first to store hive data in the registry process and this is visible in Task Manager as increased memory usage by that process. Since this data was previously in kernel paged pool there is also a corresponding decrease in paged pool usage so overall there is no net change in hive data memory usage.

 
Figure 1: Example increase in Registry process memory usage (before/after).

 
Figure 2: Example decrease in Paged Pool (before/after).

Other notable changes

A note about HomeGroup: Easily connecting to and sharing the important pieces of your digital life with those who matter most has never been easier with today’s Modern PCs and the cloud. Whether it’s connecting PCs and printers on your home network via the Share functionality in Windows or using OneDrive to share a photo album of your last vacation, Windows 10 makes connecting multiple devices and sharing content streamlined and simple. And it’s because of that evolution that with today’s build you’ll start to see us retire the HomeGroup service. HomeGroup was terrific for the pre-cloud and pre-mobile era, but today this functionality is built right into Windows 10 and apps. Starting with this build, the HomeGroup service is no longer operational in Windows 10. The user profile used for sharing and the file/folder/printer shares will continue to work.

Here are recommended alternatives to HomeGroup for you to get the best file-sharing experience in Windows 10 going forward:

  • File Storage:
    • OneDrive is a cloud-first, cross-device storage and collaboration platform for all of the pieces of data that matter most in your life – like your files, your photos, your videos, and more.
    • OneDrive Files On-Demand takes cloud file storage a step further, allowing you to access all your files in the cloud without having to download them and use storage space on your device.
  • Share Functionality: For those who prefer not to use the Cloud to connect their devices, the Share functionality for folders and printers allows you to see the available devices and connect them to and from other PCs on your home network.
  • Easier Connection: No more remembering cryptic HomeGroup passwords in order to connect to another PC. You can now simply connect through your Microsoft Account email address across devices.

General changes, improvements, and fixes for PC

  • We fixed an issue where all types of dynamic volumes listed here wouldn’t mount properly or be accessible from Windows (the data remained intact but inaccessible on the volume on impacted builds).
  • We fixed an issue where after opening and closing the People flyout notification toasts might stop appearing until the computer had been rebooted.
  • We fixed an issue where Cortana’s notification settings were unexpectedly missing in Settings after upgrading to recent builds.
  • We fixed an issue where when there was a problem with Cortana’s speech resources not being available, she could end up blocking Start.
  • We fixed an issue resulting in potentially not receiving all of your notifications from Cortana in the last first flights. We fixed an issue where when using Windows in Hebrew no search results were shown in Search until a space was entered.
  • We fixed an issue such that Recycle Bin will now show up in the search results when typing in Cortana. This was a server-side change so you will see it outside the bounds of this flight.
  • We fixed an issue where opening the Action Center while there was a notification toast visible could result in the Action Center unexpectedly animating in from the bottom corner rather than the side.
  • We fixed an issue where if you reinstalled or reset your PC without internet in the last few flights the default tiles in Start could get stuck as downward arrows.
  • We fixed an issue where if the system was low on memory context menus might display in a narrow width missing all text.
  • We fixed an issue with the File Picker dialog from recent builds where saving file names that included an additional period in the name (like A.ver2.exe) would result in the file extension not being included with the saved file (A.ver2).
  • We fixed an issue where certain videos when watching in Microsoft Edge would stop playing and become unresponsive upon altering play speed to 4x or 8x.
  • We fixed an issue resulting the expected tooltip not appearing when hovering the mouse over images on certain sites in Microsoft Edge.
  • We fixed an issue where no search suggestions were displayed while typing in the Microsoft Edge address bar if the PC was set to a region not currently supported by Cortana.
  • We fixed an issue that could result in an error message saying “device does not respond” when attempting to use Near Share.
  • We fixed an issue where nearby devices that had near share enabled might not be listed in Share.
  • We fixed an issue resulting in cursor lags on some devices when night light was transitioning.
  • When you use the split gesture to add more space between two words in the handwriting panel (a caret, as showcased here) that space will now close back up after a pause.
  • We’ve added a top level link to Storage Settings to “free up space” now, so you can get at it faster if you need it, rather than having to open Storage Sense first.
  • We’ve made some small tweaks to the design of the Windows Update Settings page and subpages.
  • To improve discoverability, when you have an update pending reboot in Windows Update Settings, beside the restart now button you will now also see a button for selecting other restart options.
  • We fixed an issue resulting in some Insiders finding that Outlook 2016 crashed frequently on the previous flight.
  • We fixed an issue where the group policy to set a custom lock screen image wouldn’t work if you had also set a policy that disabled the image on the login screen.
  • We fixed an issue resulting in docker not working in the last few flights.
  • We fixed an issue from recently flights where the Emoji Panel’s most frequently used page wasn’t updating.
  • We fixed an issue where the touch keyboard showed a very small size on large monitors.
  • We’ve updated the touch keyboard to now have an animation when invoking and dismissing.
  • We fixed an issue where keys on the full touch keyboard might become stuck in a visually pressed state.
  • We’ve updated the wide touch keyboard such that if you double tap the Shift key to turn on caps lock the key will now stay in a visual pressed state so you can see that caps lock is engaged.
  • We’ve updated the full touch keyboard so that you can now use keyboard shortcuts that contain 3 keys (for example, WIN + Alt + D).
  • We’ve made some small design changes to the dictation UI that appears when you press WIN+H.
  • We fixed an issue where the Chinese (Simplified) Pinyin IME might hang when typing quickly into Cortana.
  • We fixed the issue where VPNs that used custom pop-up windows during connection were failing with error 720 when attempting to connect.
  • We fixed the issue causing users that have enabled the legacy console to be unable to launch any command line application.

Known issues

  • Popular Tencent games like League of Legends and NBA2k Online may cause 64-bit PCs to bugcheck (GSOD).
  • [DEVELOPERS] Deploying an x86 app to a x64 PC remotely result in “FileNotFound” deployment failures if the target PC is running Build 17040. Deploying an x64 app to a x64 PC remotely or a x86 app to a x86 PC will work fine.
  • Microsoft Edge may not receive Push Notifications from websites in this flight, due to an issue saving permissions on a per-site basis. We expect this issue to be resolved in the next preview build.
  • Launching an immersive 360 degree video from the Movies and TV app within Windows Mixed Reality will result in the video facing the wrong way. Subsequent launches of 360 degree videos will work correctly.
  • When users try to create a Microsoft Edge InPrivate window from inside a Mixed Reality headset, a regular window will get created instead. Users won’t be able to use InPrivate inside Mixed Reality in this build. InPrivate on desktop is not affected.
  • We’re preparing for the inclusion of OpenSSH Server as a deployment mechanism in Developer Mode. However the UI code got checked in ahead of the components, and so while there is a “Use OpenSSH (Beta) for remote deployment” switch in the UI under Settings, it won’t work, and turning it on will break remote deployment to that device until the switch is turned off.
  • If you’re using any EUDC fonts Microsoft Edge, Cortana, and other apps that use a webview won’t launch. You can resolve this issue by deleting the HKCUEUDC key in Registry Editor. Note, if you do this, you won’t be able to see EUDC characters. We recommend you export this regkey before deleting it, so it’s easy to reapply the key in a future flight once the issue has been fixed.
  • After upgrading to this build you may find touch and pen to not work on the non-primary display. Related to this, mouse, touch, and pen input might not happen in the right place after an orientation change or if you’re using a non-native aspect ratio. We’re working on a fix.

Update about symbols for debugging

With the cadence that we make Windows Insider Preview builds available, the Windows debugging symbol we publish via an installer on the Microsoft Download Center for Slow flights is quickly made out of date. We have made significant improvements to the online Microsoft Symbols Server by moving this to be an Azure-based symbol store and now include symbols for ALL Windows Insider flights to the Fast and Slow rings. You can find more about this in this MSDN blog entry. Going forward we will no longer publish the offline symbol installer for Insider Slow flights and would love to hear your feedback on how we can make developer debugging experience even better!

Giving feedback on Office products

We know that there is a large proportion of our Windows Insiders who are also Office Insiders as well. And if you’re not –  sign-up to be an Office Insider here! Within the Feedback Hub, you can provide feedback on the Office suite of products as well. This is a great place to capture feedback, share ideas, or just tell us about your experiences and feed them directly back to the Office engineering teams. Simply tell us which app you are using from the drop down menu, tell us about the issue or idea, and click submit. It’s that easy to send feedback to the team to influence product development and new features and functionality that we roll out.

No downtime for Hustle-As-A-Service,
Dona <3

Go to Source

Share this
19 Dec 2017

Last Chance holiday savings at Microsoft Store begin today

Author: Elana Pidgeon
Go to Source

Words on a white background that read, last second gifts

Still scrambling to find those final few gifts? Microsoft Store has the perfect last-minute gifts with major savings on the season’s hottest products like Surface, Xbox, Windows Mixed Reality headsets and PC bundles, accessories and more to get you through the final shopping push. You can still get your gifts in time for the holidays by picking up your online purchase at your local Microsoft Store open through Dec. 24.

Keep reading for the final holiday deals of the season from Microsoft Store kicking off today!

Surface, Xbox one S and an Xbox controller pictured together

Last-minute deals at the best price for those left on your list:

Xbox and Gaming:

  • Save up to $80 on select Xbox One S 500GB bundles, now starting at $199, plus a free select game (through Jan. 6, 2018) **
  • Get PlayerUnknown’s Battlegrounds (PUBG) for a limited time with an Xbox One X purchase (through Jan. 6, 2018)
  • Save up to $100 on select Xbox One S 1TB bundles, now for $299 (through Jan. 6, 2018)
  • Save $20 on select Xbox Wireless Controllers including the Minecraft Creeper and Minecraft Pig editions with purchase of the Minecraft Explorers Pack (through Dec. 30)
  • Get $10 off Super Lucky’s Tale, Disneyland Adventures, Zoo Tycoon: Ultimate Animal Collection or Pixar’s Rush: A Disney Pixar Adventure
  • Get $20 off Halo Wars 2, Gears of War 4, Forza Motorsport 7 and Forza Horizon 3
  • Plus! Get a Limited-Edition Xbox Holiday Ornament with any purchase at your local Microsoft Store. For terms and conditions click here.

Surface:

  • Save $200 on select Surface Pro and Laptop i5 devices, starting at $799 (through Dec. 31)
  • Buy a select Surface device and get the new Harman Kardon Invoke speaker, $199 value (through Dec. 24) ***

Windows Mixed Reality:

  • Save up to $650 on Windows Mixed Reality headsets and select gaming PC bundles (through Dec. 31)

Windows 10 PCs:

  • Save up to $500 on select PCs, starting at $329 (through Jan. 2, 2018)

Hot accessories:

  • Save up to $50 on select Fitbit devices (through Dec. 24)
  • Save $10 on the Bose SoundLink Micro Speaker (through Dec. 30)
  • Save $60 on Beats Solo3 Wireless Headphones (through Dec. 26)
  • Save $50 on select EERO home WiFi products (through Dec. 24)
  • Save $30 on select JBL Speakers (through Dec. 30)
  • Save $20 on Circle Media with Disney (through Dec. 24)

Countdown to 2018 sale kicks off Dec. 22

Words on a white background that read, countdown to 2018

Here’s a sneak peek into digital deals starting on Dec. 22 through Jan. 4, including this year’s hottest games, movies and TV. For those who are truly hard to shop for, let them choose their perfect gift with a digital gift card to Microsoft Store online, on Windows 10, and on Xbox. Limitations apply.

  • Xbox Digital Games: Save up to 65 percent on Middle Earth: Shadow of War and Forza Motorsport 7 and more. Plus, Xbox Live Gold members save up to 10 percent more.
  • PC Games: Save up to 50 percent on popular PC games, including Cuphead, World of Warships and others.
  • Books: Save up to 80 percent on Robert Ludlum’s The Bourne Objective, Don’t Sweat the Small Stuff and It’s All Small Stuff, Etiquette and Espionage and others.
  • Movies & TV: Save up to 60 percent on Star Wars: The Force Awakens, Kingsman: The Golden Circle, Spider-Man: Homecoming and others.
  • Apps: Save up to 75 percent on Affinity Photo, Dolby Access, djay Pro, Adobe Photoshop Elements 2018, Drawboard PDF and others.

Don’t forget to share your most inspiring wish through the Microsoft Wish Machine at any Microsoft Store across the U.S.Canada and Sydney, Australia. Wishes are already being granted so get yours in today through Dec. 31! For official rules, including prize descriptions, click here.

For more information on Xbox deals at Microsoft Store and other participating retailers head to Xbox Wire.

Happy shopping!

*Offer valid while supplies last. Promo period varies for each deal. Deal availability varies in select markets. Not valid on prior orders or purchases; cannot be transferred or otherwise redeemed for cash or coupon code(s). May not be combinable with other offers. Refunds will take into account the discount. Price discount does not include taxes, shipping or other fees Void where prohibited or restricted by law. Microsoft reserves the right to modify or discontinue offers at any time. Other exclusions and limits may apply. 

**Offer valid from 9:00 PM PST on November 16, 2017 to 11:59 PM PST on December 31, 2017, while supplies last. Available only in Microsoft retail and online store in the United States (including Puerto Rico). Offer valid only on select Xbox One S consoles. Excludes Xbox One X, refurbished and pre-order consoles. Not valid on prior orders or purchases; cannot be transferred or otherwise redeemed for cash or promo code(s). May not be combinable with other offers. Refunds will take into account the discount. Price discount does not include taxes, shipping or other fees. Void where prohibited or restricted by law. Microsoft reserves the right to modify or discontinue offers at any time. Limit of 3 offers per customer. Other exclusions and limits may apply.

***Offer valid from December 2, 2017 to December 24, 2017, while supplies last. Available only in Microsoft retail and online store in United States. Offer valid only on select Surface i7 laptop, Surface i7 Pro, Surface Studio, and Harmon Kardon Invoke when purchased together in same transaction. Not valid on prior orders or purchases; cannot be transferred or otherwise redeemed for cash or promo code(s). May not be combinable with other offers. Refunds will take into account the discount. Price discount does not include taxes, shipping or other fees. Void where prohibited or restricted by law. Microsoft reserves the right to modify or discontinue offers at any time. Limit of 1 offer per customer. Other exclusions and limits may apply. 

Go to Source

Share this
18 Dec 2017

Windows 10 Tip: How to recover your pin and password from the lock screen

Author: Elana Pidgeon
Go to Source

Did you know with the Windows 10 Fall Creators Update, you can now easily reset your pin or password, right from your device’s lock screen?

Here’s how to get started:

On your PC’s lock screen, click I forgot my password and sign in with your MSA account. From there, you’ll be asked to prove you’re not a robot by typing the code shown on the screen – once that’s done, click next.

Windows 10 lockscreen shown to reset your password from the lockscreen

Select a recovery email address or phone from the drop-down menu where you want the code to recover your password to be sent. Fill out the hidden part of the email address or phone number and click Send code.

Animation showing how to reset your password from the Windows 10 lockscreen

Log into the account you chose for recovery from a phone or another device, fill in the code you were sent on the screen, enter a new password – and you’re done! You can also reset your pin from the lock screen using these same steps.

Visit this blog post to learn more about what’s new in the Windows 10 Fall Creators Update, and if you don’t have the Fall Creators Update yet you can visit this post to learn how to get it.

Windows 10 Tip: How to recover your pin and password from the lock screen

Tweet This

Have a great week!

Go to Source

Share this
15 Dec 2017

© 2015-2017 Alt-Tech Inc. All rights reserved.

Click Me