/// <summary>
 /// Invoked when there is a change in the display orientation.
 /// </summary>
 /// <param name="sender">
 /// DisplayInformation object from which the new Orientation can be determined
 /// </param>
 /// <param name="e"></param>
 void displayInformation_OrientationChanged(DisplayInformation sender, object args)
 {
     if (null != accelerometerReadingTransform)
     {
         accelerometerReadingTransform.ReadingTransform = sender.CurrentOrientation;
     }
 }

		public WindowsDeviceInfo()
		{
			// TODO: Screen size and DPI can change at any time
			_information = DisplayInformation.GetForCurrentView();
			_information.OrientationChanged += OnOrientationChanged;
			CurrentOrientation = GetDeviceOrientation(_information.CurrentOrientation);
		}

 private void OnDisplayContentsInvalidated(DisplayInformation sender, object args)
 {
     Debug.WriteLine("CompositionImageLoader - Display Contents Invalidated");
     //
     // This will trigger the device lost event
     //
     CanvasDevice.GetSharedDevice();
 }

 private void DisplayInformation_OrientationChanged(DisplayInformation sender, Object args)
 {
     displayOrientation = sender.CurrentOrientation;
     if (capturing)
     {
         setPreviewRotation();
     }
 }

 private void UpdateDpi(DisplayInformation displayInformation)
 {
     if (displayInformation != null)
     {
         LogicalDpi = displayInformation.LogicalDpi.ToString();
         Scale = (displayInformation.RawPixelsPerViewPixel * 100.0).ToString();
     }
 }

        private void DisplayInformation_OrientationChanged(DisplayInformation sender, object args)
        {
            var strategy = GetHighlightStrategyForOrientation(DisplayInformation.GetForCurrentView().CurrentOrientation);

            if (_viewModel.ChangeHighlightStrategyCommand.CanExecute(strategy))
            {
                _viewModel.ChangeHighlightStrategyCommand.Execute(strategy);
            }
        }

 private async void MainPage_OrientationChanged(DisplayInformation sender, object args) {
     if (Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar")) {
         var flag = sender.CurrentOrientation != DisplayOrientations.Portrait;
         StatusBar statusBar = StatusBar.GetForCurrentView();
         if (flag)
             await statusBar.HideAsync();
         else
             await statusBar.ShowAsync();
     }
 }

 private void OrientationChanged(DisplayInformation sender, object args)
 {
     if (sender.CurrentOrientation == DisplayOrientations.Landscape || sender.CurrentOrientation == DisplayOrientations.LandscapeFlipped)
     {
         ShellViewModel.SetHamburguerButtonProperties(Visibility.Collapsed);
     }
     else
     {
         ShellViewModel.SetHamburguerButtonProperties(Visibility.Visible);
     }
 }

 private void DisplayInfo_OrientationChanged(DisplayInformation sender, object args)
 {
     if (mediaCapture != null)
     {
         mediaCapture.SetPreviewRotation(frontCam
         ? VideoRotationLookup(sender.CurrentOrientation, true)
         : VideoRotationLookup(sender.CurrentOrientation, false));
         var rotation = VideoRotationLookup(sender.CurrentOrientation, false);
         mediaCapture.SetRecordRotation(rotation);
     }
 }

 private void OnOrientationChanged(DisplayInformation sender, object args)
 {
     if (sender.CurrentOrientation == DisplayOrientations.Portrait)
     {
         this.SetDisplayForWidth(this.currentViewHeight);
     }
     else
     {
         this.SetDisplayForWidth(this.currentViewWidth);
     }
     
 }

        private void DisplayInfoOrientationChanged(DisplayInformation sender, object args)
        {
            var orientation = sender.CurrentOrientation;
            if (orientation == DisplayOrientations.Landscape || orientation == DisplayOrientations.LandscapeFlipped)
            {
                var res = VisualStateManager.GoToState(this, "Landscape", true);

            }
            if (orientation == DisplayOrientations.Portrait || orientation == DisplayOrientations.PortraitFlipped)
            {
                var res = VisualStateManager.GoToState(this, "Portrait", false);
            }
        }

        public Scenario4_OrientationChanged()
        {
            this.InitializeComponent();

            // Get two instances of the accelerometer:
            // One that returns the raw accelerometer data
            accelerometerOriginal = Accelerometer.GetDefault();
            // Other on which the 'ReadingTransform' is updated so that data returned aligns with the request transformation.
            accelerometerReadingTransform = Accelerometer.GetDefault();

            if(accelerometerOriginal == null || accelerometerReadingTransform == null)
            {
                rootPage.NotifyUser("No accelerometer found", NotifyType.ErrorMessage);
            }
            displayInformation = DisplayInformation.GetForCurrentView();
        }

 private static async void AppViewHelper_OrientationChanged(DisplayInformation sender, object args)
 {
     if (Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
     {
         var statusBar = StatusBar.GetForCurrentView();
         if (sender.CurrentOrientation == DisplayOrientations.Landscape ||
             sender.CurrentOrientation == DisplayOrientations.LandscapeFlipped)
         {
             await statusBar.HideAsync();
         }
         else
         {
             await statusBar.ShowAsync();
         }
     }
 }

partial         void OrientationChanged(DisplayInformation info, object sender)
        {
            switch (info.CurrentOrientation)
            {
                case DisplayOrientations.Landscape:
                case DisplayOrientations.LandscapeFlipped:
                    PivotGrid(X, Y);

                    break;

                case DisplayOrientations.Portrait:
                case DisplayOrientations.PortraitFlipped:
                    PivotGrid(Y, X);

                    break;
            }
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            // Get two instances of the accelerometer:
            // One that returns the raw accelerometer data
            accelerometerOriginal = Accelerometer.GetDefault();
            // Other on which the 'ReadingTransform' is updated so that data returned aligns with the request transformation.
            accelerometerReadingTransform = Accelerometer.GetDefault();

            if(accelerometerOriginal == null || accelerometerReadingTransform == null)
            {
                rootPage.NotifyUser("No accelerometer found", NotifyType.ErrorMessage);
            }
            else
            {
                ScenarioEnableButton.IsEnabled = true;
            }

            // Register for orientation change
            displayInformation = DisplayInformation.GetForCurrentView();
            displayInformation.OrientationChanged += displayInformation_OrientationChanged;
        }

        public static double GetMaxImageWidth(DisplayInformation display)
        {
            var maxImageWidth = Window.Current.Bounds.Width;

            if (display.CurrentOrientation == DisplayOrientations.Landscape
                || display.CurrentOrientation == DisplayOrientations.LandscapeFlipped)
            {
                var frame = Window.Current.Content as Frame;
                if (frame != null)
                {
                    var page = frame.Content as Page;
                    if (page != null)
                    {
                        var bottomAppBar = page.BottomAppBar;

                        if (bottomAppBar != null)
                            maxImageWidth -= bottomAppBar.ActualHeight;
                    }
                }
            }
            return maxImageWidth;
        }

 private void PageBaseOrientationChanged(DisplayInformation sender, object args)
 {
     CheckOrientationForPage();
 }

 private void OnOrientationChanged(DisplayInformation sender, object args)
 {
     this.TransitionStoryboardState();
 }

 /// <summary>
 /// Event handler for the DpiChanged event. 
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="args"></param>
 private void OnDpiChanged(DisplayInformation sender, object args)
 {
     // If the DpiChanged event is raised then the DPI of the current view has changed. Since the image was generated
     // at the old DPI, it should be re-rendered if possible to ensure the content does not display rendering artifacts due
     // to scaling.  Note the resulting content may be different than before if the tree has changed.
     RenderImageSource();
 }

        private void DisplayProperties_OrientationChanged(DisplayInformation dinfo, object sender)
        {
            lock(_eventLocker)
            {
                // Set the new orientation.
                _orientation = ToOrientation(dinfo.CurrentOrientation);

                // Call the user callback.
                OnOrientationChanged();

                // If we have a valid client bounds then update the graphics device.
                if (_viewBounds.Width > 0 && _viewBounds.Height > 0)
                    Game.graphicsDeviceManager.ApplyChanges();
            }
        }