forked from FlairWork/Quran360WindowsPhone
/
App.xaml.cs
282 lines (240 loc) · 10.8 KB
/
App.xaml.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Shell;
using Telerik.Windows.Controls;
using System.Reflection;
using Microsoft.Phone.Marketplace;
using System.IO.IsolatedStorage;
using System.IO;
namespace Quran360
{
public partial class App : Application
{
// Declare a private variable to store application state.
private string _applicationDataObject;
// Declare an event for when the application data changes.
public event EventHandler ApplicationDataObjectChanged;
// Declare a public property to access the application data variable.
public string ApplicationDataObject
{
get { return _applicationDataObject; }
set
{
if (value != _applicationDataObject)
{
_applicationDataObject = value;
OnApplicationDataObjectChanged(EventArgs.Empty);
}
}
}
// Create a method to raise the ApplicationDataObjectChanged event.
protected void OnApplicationDataObjectChanged(EventArgs e)
{
EventHandler handler = ApplicationDataObjectChanged;
if (handler != null)
{
handler(this, e);
}
}
// Declare a public property to store the status of the application data.
public string ApplicationDataStatus { get; set; }
private static MainViewModel viewModel = null;
/// <summary>
/// A static ViewModel used by the views to bind against.
/// </summary>
/// <returns>The MainViewModel object.</returns>
public static MainViewModel ViewModel
{
get
{
// Delay creation of the view model until necessary
if (viewModel == null)
viewModel = new MainViewModel();
return viewModel;
}
}
/// <summary>
/// Provides easy access to the root frame of the Phone Application.
/// </summary>
/// <returns>The root frame of the Phone Application.</returns>
public PhoneApplicationFrame RootFrame { get; private set; }
private Quran360DataContext _db;
public Quran360DataContext db
{
get
{
if (_db == null)
_db = new Quran360DataContext(Quran360DataContext.DBConnectionString);
return _db;
}
}
/// <summary>
/// Constructor for the Application object.
/// </summary>
public App()
{
// Global handler for uncaught exceptions.
UnhandledException += Application_UnhandledException;
// Show graphics profiling information while debugging.
if (System.Diagnostics.Debugger.IsAttached)
{
// Display the current frame rate counters.
Application.Current.Host.Settings.EnableFrameRateCounter = true;
// Show the areas of the app that are being redrawn in each frame.
//Application.Current.Host.Settings.EnableRedrawRegions = true;
// Enable non-production analysis visualization mode,
// which shows areas of a page that are being GPU accelerated with a colored overlay.
//Application.Current.Host.Settings.EnableCacheVisualization = true;
}
// Standard Silverlight initialization
InitializeComponent();
// Phone-specific initialization
InitializePhoneApplication();
// Create the database if it does not exist.
using (Quran360DataContext db = new Quran360DataContext(Quran360DataContext.DBConnectionString))
{
if (db.DatabaseExists() == false)
{
//Create the database
//db.CreateDatabase();
db.MoveReferenceDatabase();
}
}
}
// Code to execute when the application is launching (eg, from Start)
// This code will not execute when the application is reactivated
private void Application_Launching(object sender, LaunchingEventArgs e)
{
var nameHelper = new AssemblyName(Assembly.GetExecutingAssembly().FullName);
var version = nameHelper.Version;
var full = nameHelper.FullName;
var name = nameHelper.Name;
ApplicationUsageHelper.Init(version.ToString());
RadRateApplicationReminder radRateApplicationReminder = new RadRateApplicationReminder();
radRateApplicationReminder.AllowUsersToSkipFurtherReminders = true;
//radRateApplicationReminder.AreFurtherRemindersSkipped = false;
radRateApplicationReminder.RecurrencePerUsageCount = 5;
radRateApplicationReminder.Notify();
RadTrialApplicationReminder applicationReminder = new RadTrialApplicationReminder();
//applicationReminder.SimulateTrialForTests = true;
//applicationReminder.OccurrencePeriod = new TimeSpan(15, 0, 0, 0);
//applicationReminder.AllowedTrialPeriod = new TimeSpan(30, 0, 0, 0);
//applicationReminder.OccurrencePeriod = new TimeSpan(0, 0, 5, 0);
//applicationReminder.AllowedTrialPeriod = new TimeSpan(0, 0, 15, 0);
applicationReminder.AllowedTrialUsageCount = 30;
applicationReminder.FreeUsageCount = 15;
//applicationReminder.OccurrenceUsageCount = 1;
applicationReminder.Notify();
}
// Code to execute when the application is activated (brought to foreground)
// This code will not execute when the application is first launched
private void Application_Activated(object sender, ActivatedEventArgs e)
{
// Ensure that application state is restored appropriately
///if (!App.ViewModel.IsDataLoaded)
//{
// App.ViewModel.LoadMainData();
//}
if (e.IsApplicationInstancePreserved)
{
ApplicationDataStatus = "application instance preserved.";
return;
}
// Check to see if the key for the application state data is in the State dictionary.
if (PhoneApplicationService.Current.State.ContainsKey("ApplicationDataObject"))
{
// If it exists, assign the data to the application member variable.
ApplicationDataStatus = "data from preserved state.";
ApplicationDataObject = PhoneApplicationService.Current.State["ApplicationDataObject"] as string;
}
}
// Code to execute when the application is deactivated (sent to background)
// This code will not execute when the application is closing
private void Application_Deactivated(object sender, DeactivatedEventArgs e)
{
// Ensure that required application state is persisted here.
// If there is data in the application member variable...
if (!string.IsNullOrEmpty(ApplicationDataObject))
{
// Store it in the State dictionary.
PhoneApplicationService.Current.State["ApplicationDataObject"] = ApplicationDataObject;
// Also store it in isolated storage, in case the application is never reactivated.
SaveDataToIsolatedStorage("Quran360DataFile.txt", ApplicationDataObject);
}
}
// Code to execute when the application is closing (eg, user hit Back)
// This code will not execute when the application is deactivated
private void Application_Closing(object sender, ClosingEventArgs e)
{
// The application will not be tombstoned, so save only to isolated storage.
if (!string.IsNullOrEmpty(ApplicationDataObject))
{
SaveDataToIsolatedStorage("Quran360DataFile.txt", ApplicationDataObject);
}
}
private void SaveDataToIsolatedStorage(string isoFileName, string value)
{
IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication();
StreamWriter sw = new StreamWriter(isoStore.OpenFile(isoFileName, FileMode.OpenOrCreate));
sw.Write(value);
sw.Close();
IsolatedStorageSettings.ApplicationSettings["DataLastSaveTime"] = DateTime.Now;
}
// Code to execute if a navigation fails
private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
{
if (System.Diagnostics.Debugger.IsAttached)
{
// A navigation has failed; break into the debugger
System.Diagnostics.Debugger.Break();
}
}
// Code to execute on Unhandled Exceptions
private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
{
if (System.Diagnostics.Debugger.IsAttached)
{
// An unhandled exception has occurred; break into the debugger
System.Diagnostics.Debugger.Break();
}
}
#region Phone application initialization
// Avoid double-initialization
private bool phoneApplicationInitialized = false;
// Do not add any additional code to this method
private void InitializePhoneApplication()
{
if (phoneApplicationInitialized)
return;
// Create the frame but don't set it as RootVisual yet; this allows the splash
// screen to remain active until the application is ready to render.
RootFrame = new PhoneApplicationFrame();
RootFrame.Navigated += CompleteInitializePhoneApplication;
// Handle navigation failures
RootFrame.NavigationFailed += RootFrame_NavigationFailed;
// Ensure we don't initialize again
phoneApplicationInitialized = true;
}
// Do not add any additional code to this method
private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
{
// Set the root visual to allow the application to render
if (RootVisual != RootFrame)
RootVisual = RootFrame;
// Remove this handler since it is no longer needed
RootFrame.Navigated -= CompleteInitializePhoneApplication;
}
#endregion
}
}