//==============================================================================================
/// <summary>
/// Initialize the _controller table.
/// </summary>
/// <returns></returns>
//==============================================================================================
private async Task InitializeAsync()
{
if (_controller == null)
{
_controller = _dataStore.CloudService.GetSyncTable<Organization>();
}
}
protected override async void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Activity_To_Do);
CurrentPlatform.Init ();
// Create the Mobile Service Client instance, using the provided
// Mobile Service URL
client = new MobileServiceClient(applicationURL);
await InitLocalStoreAsync();
// Set the current instance of TodoActivity.
instance = this;
// Make sure the GCM client is set up correctly.
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);
// Get the Mobile Service sync table instance to use
toDoTable = client.GetSyncTable <ToDoItem> ();
textNewToDo = FindViewById<EditText> (Resource.Id.textNewToDo);
// Create an adapter to bind the items with the view
adapter = new ToDoItemAdapter (this, Resource.Layout.Row_List_To_Do);
var listViewToDo = FindViewById<ListView> (Resource.Id.listViewToDo);
listViewToDo.Adapter = adapter;
//// Load the items from the Mobile App backend.
//OnRefreshItemsSelected ();
}
public async Task Initialize()
{
if (isInitialized)
return;
var time = Xamarin.Insights.TrackTime("InitializeTime");
time.Start();
//Create our client
MobileService = new MobileServiceClient("https://mycoffeeapp.azurewebsites.net");
const string path = "syncstore.db";
//setup our local sqlite store and intialize our table
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<CupOfCoffee>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
//Get our sync table that will call out to azure
coffeeTable = MobileService.GetSyncTable<CupOfCoffee>();
isInitialized = true;
time.Stop();
}
protected override async void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Activity_To_Do);
CurrentPlatform.Init ();
// Create the Mobile Service Client instance, using the provided
// Mobile Service URL and key
client = new MobileServiceClient (applicationURL, applicationKey);
await InitLocalStoreAsync();
// Get the Mobile Service sync table instance to use
toDoTable = client.GetSyncTable <ToDoItem> ();
textNewToDo = FindViewById<EditText> (Resource.Id.textNewToDo);
// Create an adapter to bind the items with the view
adapter = new ToDoItemAdapter (this, Resource.Layout.Row_List_To_Do);
var listViewToDo = FindViewById<ListView> (Resource.Id.listViewToDo);
listViewToDo.Adapter = adapter;
// Load the items from the Mobile Service
OnRefreshItemsSelected ();
}
public async Task Initialize()
{
if (isInitialized)
return;
var time = Xamarin.Insights.TrackTime("InitializeTime");
time.Start();
var handler = new AuthHandler();
//Create our client
MobileService = new MobileServiceClient("https://mycoffeeapp.azurewebsites.net", handler);
handler.Client = MobileService;
if (!string.IsNullOrWhiteSpace (Settings.AuthToken) && !string.IsNullOrWhiteSpace (Settings.UserId)) {
MobileService.CurrentUser = new MobileServiceUser (Settings.UserId);
MobileService.CurrentUser.MobileServiceAuthenticationToken = Settings.AuthToken;
}
const string path = "syncstore.db";
//setup our local sqlite store and intialize our table
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<CupOfCoffee>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
//Get our sync table that will call out to azure
coffeeTable = MobileService.GetSyncTable<CupOfCoffee>();
isInitialized = true;
time.Stop();
}
public async Task Init()
{
if (MobileService.SyncContext.IsInitialized)
return;
var path = "syncstore.db";
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<Order>();
store.DefineTable<Account>();
store.DefineTable<Contact>();
try
{
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
}
catch(Exception ex)
{
Debug.WriteLine(@"Sync Failed: {0}", ex.Message);
}
orderTable = MobileService.GetSyncTable<Order>();
accountTable = MobileService.GetSyncTable<Account>();
contactTable = MobileService.GetSyncTable<Contact>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ToDo.TodoItemManager"/> class.
/// </summary>
public TodoItemManager ()
{
// Create the service client and make sure to use the native network stack via ModernHttpClient's NativeMessageHandler.
this.client = new MobileServiceClient (Constants.ApplicationURL, Constants.GatewayURL, new CustomMessageHandler ());
// This is where we want to store our local data.
this.store = new MobileServiceSQLiteStore (((App)App.Current).databaseFolderAndName);
// Create the tables.
this.store.DefineTable<TodoItem> ();
// Initializes the SyncContext using a specific IMobileServiceSyncHandler which handles sync errors.
this.client.SyncContext.InitializeAsync (store, new SyncHandler ());
// The ToDo items should be synced.
this.todoTable = client.GetSyncTable<TodoItem> ();
// Uncomment to clear all local data to have a fresh start. Then comment out again.
//this.todoTable.PurgeAsync();
// Create a Sqlite-Net connection to the SAME DB that is also used for syncing.
// Everything that gets inserted via this connection will not be synced.
// Azure Mobile always syncs everything, so we have to either use an alternative database or use another API to acces the same DB.
this.sqliteNetConn = new SQLiteAsyncConnection (((App)App.Current).databaseFolderAndName);
this.sqliteNetConn.CreateTableAsync<ConfigItem> ();
}
public async Task InitializeAsync()
{
var store = new MobileServiceSQLiteStore("localdata.db");
store.DefineTable<PolicyHistory> ();
await this.MobileService.SyncContext.InitializeAsync(store);
phTable = this.MobileService.GetSyncTable<PolicyHistory>();
}
public async Task InitializeAsync()
{
var store = new MobileServiceSQLiteStoreWithLogging("localdata.db");
store.DefineTable<Job> ();
await this.MobileService.SyncContext.InitializeAsync(store);
jobTable = this.MobileService.GetSyncTable<Job>();
}
private TodoItemManager()
{
this.client = new MobileServiceClient(Constants.ApplicationURL);
var store = new MobileServiceSQLiteStore("localstore.db");
store.DefineTable<TodoItem>();
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable<TodoItem>();
}
protected override async void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Activity_To_Do);
progressBar = FindViewById<ProgressBar> (Resource.Id.loadingProgressBar);
// Initialize the progress bar
progressBar.Visibility = ViewStates.Gone;
// Create ProgressFilter to handle busy state
var progressHandler = new ProgressHandler ();
progressHandler.BusyStateChange += (busy) => {
if (progressBar != null)
progressBar.Visibility = busy ? ViewStates.Visible : ViewStates.Gone;
};
try {
CurrentPlatform.Init ();
// Create the Mobile Service Client instance, using the provided
// Mobile Service URL and key
client = new MobileServiceClient (
applicationURL,
applicationKey, progressHandler);
string path =
Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "localstore.db");
if (!File.Exists(path))
{
File.Create(path).Dispose();
}
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<ToDoItem>();
await client.SyncContext.InitializeAsync(store, new SyncHandler(this));
// Get the Mobile Service Table instance to use
toDoTable = client.GetSyncTable <ToDoItem> ();
textNewToDo = FindViewById<EditText> (Resource.Id.textNewToDo);
// Create an adapter to bind the items with the view
adapter = new ToDoItemAdapter (this, Resource.Layout.Row_List_To_Do);
var listViewToDo = FindViewById<ListView> (Resource.Id.listViewToDo);
listViewToDo.Adapter = adapter;
// Load the items from the Mobile Service
await RefreshItemsFromTableAsync ();
} catch (Java.Net.MalformedURLException) {
CreateAndShowDialog (new Exception ("There was an error creating the Mobile Service. Verify the URL"), "Error");
} catch (Exception e) {
CreateAndShowDialog (e, "Error");
}
}
//private IMobileServiceTable<TodoItem> todoTable = App.MobileService.GetTable<TodoItem>();
public MainPageViewModel()
{
_mobileService = new MobileServiceClient(
"https://isvacceleratoreumar.azurewebsites.net",
"https://default-web-eastus744386286bdd4ad5816e8100d15de451.azurewebsites.net",
"");
_todoTable = _mobileService.GetSyncTable<TodoItem>();
}
public ServicesRepository()
{
_mobileService = new MobileServiceClient("YOUR URL HERE", "YOUR APP SECRET HERE");
_categoryTable = _mobileService.GetSyncTable<Category>();
_serviceTypeTable = _mobileService.GetSyncTable<ServiceType>();
_productTable = _mobileService.GetSyncTable<Product>();
_productInfoTable = _mobileService.GetSyncTable<ProductInformation>();
InitLocalStore();
}
public async Task Init()
{
initialized = true;
string path = "syncstore.db";
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<TripExpense>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
expenseTable = MobileService.GetSyncTable<TripExpense>();
}
// currently only tests that a single file has been added
private async Task TestFiles(IMobileServiceSyncTable<DataEntity> table, string name, string content)
{
var files = await table.GetFilesAsync(item);
Assert.Equal(1, files.Count());
Assert.Equal(name, files.ElementAt(0).Name);
using (var stream = await table.GetFileAsync(item, name))
{
Assert.Equal(content, new StreamReader(stream).ReadToEnd());
}
}
public async Task InitializeAsync()
{
this.MobileService =
new MobileServiceClient(MobileUrl, new LoggingHandler());
var store = new MobileServiceSQLiteStore("local.db");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store, StoreTrackingOptions.NotifyLocalAndServerOperations);
jobTable = MobileService.GetSyncTable<Job>();
}
private QSTodoService ()
{
CurrentPlatform.Init ();
SQLitePCL.CurrentPlatform.Init();
// Initialize the Mobile Service client with the Mobile App URL, Gateway URL and key
client = new MobileServiceClient (applicationURL);
// Create an MSTable instance to allow us to work with the TodoItem table
todoTable = client.GetSyncTable <ToDoItem> ();
}
private QSTodoService ()
{
CurrentPlatform.Init ();
SQLitePCL.Batteries.Init();
// Initialize the client with the mobile app backend URL.
client = new MobileServiceClient (applicationURL);
// Create an MSTable instance to allow us to work with the TodoItem table
todoTable = client.GetSyncTable <ToDoItem> ();
}
public async Task InitLocalDBSyncTables()
{
await InitLocalStoreAsync();
// Get the Mobile Service sync table instance to use
employeeSyncTable = client.GetSyncTable<EmployeeItem>();
eventSyncTable = client.GetSyncTable<EventItem>();
recipientListSyncTable = client.GetSyncTable<RecipientListItem>();
// Load the items from the Mobile Service
await SyncAsync(pullData: true);
}
public AzureDataService()
{
this.client = new MobileServiceClient(App.ApplicationURL);
var store = new MobileServiceSQLiteStore("gomonkeystore.db");
store.DefineTable<Monkey>();
this.monkeyTable = this.client.GetSyncTable<Monkey>();
this.client.InitializeFileSyncContext(new ImagesFileSyncHandler<Monkey>(monkeyTable), store);
this.client.SyncContext.InitializeAsync(store, StoreTrackingOptions.AllNotifications);
var dispose = this.client.EventManager.Subscribe<Microsoft.WindowsAzure.MobileServices.Eventing.IMobileServiceEvent>((e) => {
System.Diagnostics.Debug.WriteLine("Event Handled: " + e.Name);
});
}
public async Task Init()
{
initialized = true;
const string path = "syncstore.db";
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<Store>();
store.DefineTable<Feedback> ();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
storeTable = MobileService.GetSyncTable<Store>();
feedbackTable = MobileService.GetSyncTable<Feedback> ();
}
public SensorModel()
{
// initialize mobile services and SQLLite store
Microsoft.WindowsAzure.MobileServices.CurrentPlatform.Init();
#if __IOS__
SQLitePCL.CurrentPlatform.Init();
#endif
// initialize the client with your app url and key
client = new MobileServiceClient(applicationURL, applicationKey);
// create sync table instance
sensorDataTable = client.GetSyncTable<SensorDataItem>();
}
public async Task InitializeAsync()
{
this.MobileService = AppService.CreateMobileServiceClient(
"https://fetechnician-code.azurewebsites.net/",
"OtFsjAFDBBMENsPCBQFJmItwjvAfaX77");
// 3. initialize local store
var store = new MobileServiceSQLiteStore("local-db-fabrikam80");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store);
jobTable = MobileService.GetSyncTable<Job>();
}
public async Task InitializeAsync()
{
this.MobileService =
new MobileServiceClient(MobileUrl, new LoggingHandler());
var store = new MobileServiceSQLiteStore("local.db");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store, StoreTrackingOptions.NotifyLocalAndServerOperations);
jobTable = MobileService.GetSyncTable<Job>();
// This sample doesn't do any authentication. To add it, see
// https://azure.microsoft.com/en-us/documentation/articles/app-service-mobile-xamarin-forms-get-started-users/
}
public async Task InitializeAsync()
{
this.MobileService = AppService.CreateMobileServiceClient(
MobileAppURL,
"");
// 3. initialize local store
var store = new MobileServiceSQLiteStore("local-db-" + MobileAppName);
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store);
jobTable = MobileService.GetSyncTable<Job>();
}
private LocationMeasurementManager()
{
this._client = new MobileServiceClient(ConstantsRt.ApplicationUrl);
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore(offlineDbPath);
store.DefineTable <LocationMeasurement>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.locationMeasurementTable = client.GetSyncTable <LocationMeasurement>();
#else
this._locationMeasurementTable = _client.GetTable <LocationMeasurement>();
#endif
}
public async Task Initialize()
{
//Create our client
MobileService = new MobileServiceClient("http://empleadomobile.azurewebsites.net");
const string path = "syncstore.db";
//setup our local sqlite store and intialize our table
var store = new MobileServiceSQLiteStore(path);
store.DefineTable <Job>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
//Get our sync table that will call out to azure
JobsTable = MobileService.GetSyncTable <Job>();
}
//Nuevo Constructor
public App(string db)
{
InitializeComponent();
MainPage = new NavigationPage(new MainPage());
//asignamos la dirección que recibe el constructor
DbLocation = db;
//el data store necesita la dirección de la bdd en el celular
var store = new MobileServiceSQLiteStore(db);
//definición de la tabla en el mobile Service
store.DefineTable <Post>();
//Contexto de la tabla
MobileService.SyncContext.InitializeAsync(store);
//Metodo que permite leer a tabla de local y si se puede de la nube
postsTable = MobileService.GetSyncTable <Post>();
}
private SBAManager()
{
this.client = new MobileServiceClient("https://sbat1.azurewebsites.net");
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore("localstore.db");
store.DefineTable <TodoItem>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable <TodoItem>();
#else
this.todoTable = client.GetTable <String>();
#endif
}
public bool CheckServiceAccess()
{
try
{
this.itemTable = this.client.GetSyncTable <Item>();
this.statusTable = this.client.GetSyncTable <Status>();
return(this.itemTable is IMobileServiceSyncTable <Item>);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
return(false);
}
public App(string databaseLocation)
{
InitializeComponent();
MainPage = new NavigationPage(new MainPage());
DatabaseLocation = databaseLocation;
var store = new MobileServiceSQLiteStore(databaseLocation);
store.DefineTable <Post>();
MobileService.SyncContext.InitializeAsync(store);
postsTable = MobileService.GetSyncTable <Post>();
}
public async Task Initialize()
{
DefaultManager = new MobileServiceClient(BaseUrl);
var path = "baches.db";
path = Path.Combine(MobileServiceClient.DefaultDatabasePath, path);
var store = new MobileServiceSQLiteStore(path);
store.DefineTable <Bache>();
await DefaultManager.SyncContext.InitializeAsync(store);
bacheTable = DefaultManager.GetSyncTable <Bache>();
}
private TodoItemManager()
{
this.client = new MobileServiceClient(Constants.ApplicationURL);
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore(offlineDbPath);
store.DefineTable <TodoItem>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable <TodoItem>();
#else
this.todoTable = client.GetTable <TodoItem>();
#endif
}
protected override async void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
//TODO show IOC vs Dependency injection
// SimpleIoc.Default.Register<ISqlite> (new SqliteDroid ());
SimpleIoc.Default.Register<Data.ISqlite>(() => new SqliteDroid());
activityTable = client.GetSyncTable<CaAPA.Data.Activities> ();
await InitLocalStoreAsync();
LoadApplication(new App());
}
public async Task PullAsync_TriggersPush_WhenPushOtherTablesIsTrue_AndThereIsOperationTable()
{
ResetDatabase(TestTable);
TestUtilities.DropTestTable(TestDbName, "relatedTable");
TestUtilities.DropTestTable(TestDbName, "StringIdType");
var hijack = new TestHttpHandler();
hijack.AddResponseContent("{\"id\":\"abc\",\"String\":\"Hey\"}");
hijack.AddResponseContent("{\"id\":\"abc\",\"String\":\"Hi\"}");
hijack.AddResponseContent("[{\"id\":\"abc\",\"String\":\"Hey\"},{\"id\":\"def\",\"String\":\"World\"}]"); // for pull
hijack.AddResponseContent("[]"); // last page
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable("relatedTable", new JObject()
{
{ "id", String.Empty }
});
store.DefineTable <StringIdType>();
IMobileServiceClient client = await CreateClient(hijack, store);
// insert item in pull table
IMobileServiceSyncTable unrelatedTable = client.GetSyncTable("relatedTable");
await unrelatedTable.InsertAsync(new JObject()
{
{ "id", "abc" }
});
// then insert item in other table
MobileServiceSyncTable <StringIdType> mainTable = client.GetSyncTable <StringIdType>() as MobileServiceSyncTable <StringIdType>;
var item = new StringIdType()
{
Id = "abc", String = "what?"
};
await mainTable.InsertAsync(item);
await mainTable.PullAsync(null, null, null, true, CancellationToken.None);
Assert.Equal(4, hijack.Requests.Count); // 2 for push and 2 for pull
QueryEquals(hijack.Requests[0].RequestUri.AbsolutePath, "/tables/relatedTable");
QueryEquals(hijack.Requests[1].RequestUri.AbsolutePath, "/tables/StringIdType");
QueryEquals(hijack.Requests[1].RequestUri.AbsolutePath, "/tables/StringIdType");
QueryEquals(hijack.Requests[1].RequestUri.AbsolutePath, "/tables/StringIdType");
Assert.Equal(0L, client.SyncContext.PendingOperations);
}
public async Task PushAsync_DiscardsOperationAndDeletesTheItem_WhenCancelAndDiscardItemAsync()
{
ResetDatabase(TestTable);
var hijack = new TestHttpHandler();
string conflictResult = "{\"id\":\"b\",\"String\":\"Wow\",\"version\":\"def\"}";
hijack.Responses.Add(new HttpResponseMessage(HttpStatusCode.PreconditionFailed)
{
Content = new StringContent(conflictResult)
}); // first push
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable <ToDoWithSystemPropertiesType>();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable <ToDoWithSystemPropertiesType> table = service.GetSyncTable <ToDoWithSystemPropertiesType>();
// first insert an item
var updatedItem = new ToDoWithSystemPropertiesType()
{
Id = "b", String = "Hey", Version = "abc"
};
await table.UpdateAsync(updatedItem);
// then push it to server
var ex = await Assert.ThrowsAsync <MobileServicePushFailedException>(service.SyncContext.PushAsync);
Assert.NotNull(ex.PushResult);
MobileServiceTableOperationError error = ex.PushResult.Errors.FirstOrDefault();
Assert.NotNull(error);
Assert.Equal(1L, service.SyncContext.PendingOperations); // operation is not removed
updatedItem = await table.LookupAsync("b");
Assert.Equal("Hey", updatedItem.String); // item is not updated
await error.CancelAndDiscardItemAsync();
Assert.Equal(0L, service.SyncContext.PendingOperations); // operation is removed
updatedItem = await table.LookupAsync("b");
Assert.Null(updatedItem); // item is deleted
}
protected override async void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Activity_To_Do);
CurrentPlatform.Init();
// Create the client instance, using the mobile app backend URL.
client = new MobileServiceClient(applicationURL);
Microsoft.WindowsAzure.MobileServices.CurrentPlatform.Init();
manager = ItemManager.DefaultManager;
// Set the current instance of TodoActivity.
instance = this;
// Make sure the GCM client is set up correctly.
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);
// Register the app for push notifications.
GcmClient.Register(this, ToDoBroadcastReceiver.senderIDs);
#if OFFLINE_SYNC_ENABLED
await InitLocalStoreAsync();
// Get the sync table instance to use to store TodoItem rows.
todoTable = client.GetSyncTable <ToDoItem>();
#else
todoTable = client.GetTable <ToDoItem>();
#endif
textNewToDo = FindViewById <EditText>(Resource.Id.textNewToDo);
// Create an adapter to bind the items with the view
adapter = new ToDoItemAdapter(this, Resource.Layout.Row_List_To_Do);
var listViewToDo = FindViewById <ListView>(Resource.Id.listViewToDo);
listViewToDo.Adapter = adapter;
Button btnRegistrar = FindViewById <Button>(Resource.Id.btnRegistrar);
btnRegistrar.Click += btnRegistrar_ClickAsync;
// Load the items from the mobile app backend.
OnRefreshItemsSelected();
}
protected async void LocalInsertReportableFocusEvent(ReportableFocusEvent rfe)
{
Assert.IsNotNull <ReportableFocusEvent>(rfe);
IMobileServiceSyncTable <ReportableFocusEvent> localTable = Client.GetSyncTable <ReportableFocusEvent>();
try
{
await localTable.InsertAsync(rfe);
Debug.Log($"Recording: {rfe.EventType} on {rfe.EntityName} at {rfe.LocalPosition}");
}
catch (Exception e)
{
Debug.LogError(e.ToString());
}
}
private QSTodoService()
{
CurrentPlatform.Init();
// Initialize the client with the mobile app backend URL.
client = PinnacleApp.Client;
#if OFFLINE_SYNC_ENABLED
// Initialize the store
//Task.Run(async() => await InitStoreAsync());
// Create an MSTable instance to allow us to work with the TodoItem table
//todoTable = client.GetSyncTable<ToDoItem>();
#else
todoTable = client.GetTable <ToDoItem>();
#endif
}
private AzureDataStore()
{
this.client = new MobileServiceClient(
"https://ourtaskstemp.azurewebsites.net");
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore(offlineDbPath);
store.DefineTable <ToDoItem>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.itemTable = client.GetSyncTable <ToDoItem>();
#else
this.itemTable = client.GetTable <ToDoItem>();
#endif
}
private BudgetCategoryManager()
{
this.client = new MobileServiceClient(
Constants.ApplicationURL);
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore("localstore.db");
store.DefineTable <BudgetItem>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable <BudgetCategory>();
#else
this.budgetCategoryTable = client.GetTable <BudgetCategory>();
#endif
}
public async Task Initialize()
{
if (_mobileServiceClient?.SyncContext?.IsInitialized ?? false)
{
return;
}
const string path = "syncstore.db";
//setup our local sqlite store and intialize our table
var store = new MobileServiceSQLiteStore(path);
store.DefineTable <Message>();
await _mobileServiceClient.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
//Get our sync table that will call out to azure
_messageTable = _mobileServiceClient.GetSyncTable <Message>();
}
async Task InitializeDataStore()
{
if (azureClient.SyncContext.IsInitialized)
{
return;
}
var store = new MobileServiceSQLiteStore("foodie.db");
store.DefineTable <Recipe>();
await azureClient.SyncContext.InitializeAsync(store);
recipeTable = azureClient.GetSyncTable <Recipe>();
await SyncOfflineCache();
}
public async Task InitAsync()
{
// Setup local database
var path = Path.Combine(MobileServiceClient.DefaultDatabasePath, "syncstore.db");
var store = new MobileServiceSQLiteStore(path);
// Define local tables to sync with
store.DefineTable <Session>();
store.DefineTable <Speaker>();
// Initialize SyncContext
await client.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
// Get our sync table that will call out to azure
sessionTable = client.GetSyncTable <Session>();
speakerTable = client.GetSyncTable <Speaker>();
}
private void Initialize()
{
this.client = new MobileServiceClient(
Constants.ApplicationURL);
var store = new MobileServiceSQLiteStore("localstore.db");
if (!client.SyncContext.IsInitialized)
{
store.DefineTable <Sessions>();
store.DefineTable <Speakers>();
client.SyncContext.InitializeAsync(store);
}
tablaSesion = client.GetSyncTable <Sessions>();
tablaSpeaker = client.GetSyncTable <Speakers>();
}
private AzureCouponManager()
{
this.client = new MobileServiceClient(Constants.AzureMobileService);
#if OFFLINE_SYNC_ENABLED
var store = new MobileServiceSQLiteStore(offlineDbPath);
store.DefineTable <TodoItem>();
//Initializes the SyncContext using the default IMobileServiceSyncHandler.
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable <TodoItem>();
Console.WriteLine("inside constructor");
#else
this.couponTable = client.GetTable <CouponSchedule>();
#endif
}
public void Init()
{
if (_startedIniting)
{
return;
}
_startedIniting = true;
CurrentPlatform.Init();
SQLitePCL.CurrentPlatform.Init();
// Initialize the Mobile Service client with your URL and key
_client = new MobileServiceClient(ApplicationUrl, ApplicationKey, _instance);
// Create an MSTable instance to allow us to work with the TodoItem table
_table = _instance._client.GetSyncTable <EventItem>();
}
public async Task DownloadFileAsync <T>(IMobileServiceSyncTable <T> table, MobileServiceFile file, string targetPath, int attempt = 0)
{
try
{
await table.DownloadFileAsync(file, targetPath);
}
catch (UnauthorizedAccessException)
{
DeleteLocalFile(file);
if (attempt < 3)
{
await Task.Delay(300)
.ContinueWith(async t => await DownloadFileAsync(table, file, targetPath, attempt++));
}
}
}
private FavoritesManager()
{
this.client = new MobileServiceClient(CoreConstants.ApplicationURL);
#if OFFLINE_SYNC_ENABLED
MobileServiceSQLiteStore store = new MobileServiceSQLiteStore("localfavorites.db");
store.DefineTable <Favorite>();
store.DefineTable <Registration>();
this.client.SyncContext.InitializeAsync(store);
this.favoritesTable = client.GetSyncTable <Favorite>();
this.registrationsTable = client.GetSyncTable <Registration>();
#else
this.favoritesTable = client.GetTable <Favorite>();
this.registrationsTable = client.GetTable <Registration>();
#endif
}
public async Task InitializeAsync()
{
if (MobileService?.SyncContext?.IsInitialized ?? false)
{
return;
}
MobileService = new MobileServiceClient(PCL_AppConstants.sCurrentServiceURL);
string path = "appX007.db";
var store = new MobileServiceSQLiteStoreWithLogging(path, PCL_AppConstants.bLogSqlLite);
store.DefineTable <TodoItem>();
await MobileService.SyncContext.InitializeAsync(store);
itemsTable = MobileService.GetSyncTable <T>();
}
private QSTodoService()
{
CurrentPlatform.Init();
// Initialize the client with the mobile app backend URL.
client = new MobileServiceClient(applicationURL);
#if OFFLINE_SYNC_ENABLED
// Initialize the store
InitializeStoreAsync().Wait();
// Create an MSTable instance to allow us to work with the TodoItem table
todoTable = client.GetSyncTable <ToDoItem>();
#else
todoTable = client.GetTable <ToDoItem>();
#endif
}
/// <summary>
/// Resets the local store.
/// </summary>
async Task ResetLocalStoreAsync()
{
_AcquaintanceTable = null;
// On UWP, it's necessary to Dispose() and nullify the MobileServiceSQLiteStore before
// trying to delete the database file, otherwise an access exception will occur
// because of an open file handle. It's okay to do for iOS and Android as well, but not necessary.
_MobileServiceSQLiteStore?.Dispose();
_MobileServiceSQLiteStore = null;
await DeleteOldLocalDatabase().ConfigureAwait(false);
_IsInitialized = false;
Settings.LocalDataResetIsRequested = false;
Settings.DataIsSeeded = false;
}
public async Task InitializeAsync()
{
if (isInitialized)
{
return;
}
var store = new MobileServiceSQLiteStore(_dbPath);
store.DefineTable <ToDoItem>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
itemsTable = MobileService.GetSyncTable <ToDoItem>();
isInitialized = true;
}
public async Task Initialize()
{
if (MobileService?.SyncContext?.IsInitialized ?? false)
{
return;
}
MobileService = new MobileServiceClient("http://projectservermobile.azurewebsites.net");
const string path = "offlinetimesheetstore.db";
storez = new MobileServiceSQLiteStore(path);
storez.DefineTable <OfflineTimesheetModel>();
await MobileService.SyncContext.InitializeAsync(storez);
offlineTimesheet = MobileService.GetSyncTable <OfflineTimesheetModel>();
}
public async Task Init()
{
initialized = true;
const string path = "syncstore.db";
var store = new MobileServiceSQLiteStore(path);
store.DefineTable <Store>();
store.DefineTable <Feedback> ();
//store.DefineTable<Region>();
store.DefineTable <Favourites>();
await MobileService.SyncContext.InitializeAsync(store, new MobileServiceSyncHandler());
storeTable = MobileService.GetSyncTable <Store>();
feedbackTable = MobileService.GetSyncTable <Feedback> ();
//regionTable = MobileService.GetSyncTable<Region>();
favouriteTable = MobileService.GetSyncTable <Favourites>();
}
protected async override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
SetContentView(Resource.Layout.Main);
// Create the Mobile Service Client instance, using the provided
// Mobile Service URL
client = new MobileServiceClient(applicationURL);
// Get the Mobile Service sync table instance to use
torneoItemTable = client.GetSyncTable <TorneoItem>();
// Obtener una referencia al botón Siguiente
btnRegistro = FindViewById <Button>(Resource.Id.BtnRegistro);
// Registrar el manejador de evento click del botón Siguiente
btnRegistro.Click += BtnSiguienteClick;
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
Xamarin.Forms.Forms.Init (this, bundle);
#region Azure stuff
CurrentPlatform.Init ();
Client = new MobileServiceClient (
Constants.Url,
Constants.Key);
#region Azure Sync stuff
// http://azure.microsoft.com/en-us/documentation/articles/mobile-services-xamarin-android-get-started-offline-data/
// new code to initialize the SQLite store
string path = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "test1.db");
if (!File.Exists(path))
{
File.Create(path).Dispose();
}
var store = new MobileServiceSQLiteStore(path);
store.DefineTable<TodoItem>();
Client.SyncContext.InitializeAsync(store).Wait();
#endregion
todoTable = Client.GetSyncTable<TodoItem>();
todoItemManager = new TodoItemManager(Client, todoTable);
App.SetTodoItemManager (todoItemManager);
#endregion region
#region Text to Speech stuff
App.SetTextToSpeech (new Speech ());
#endregion
SetPage (App.GetMainPage ());
}
/// <summary>
/// Initializes the backend service and connects with Azure
/// </summary>
/// <returns></returns>
public static async Task InitAsync()
{
if (_IsInitialized)
return;
// Create the mobile client
_MobileService = new MobileServiceClient("http://YOUR-MOBILE-SERVICE-URL");
// Setup the local SQLite database
var store = new MobileServiceSQLiteStore("mynotestore.db");
store.DefineTable<Note>();
await _MobileService.SyncContext.InitializeAsync(store);
// Get tables for local database
_NoteTable = _MobileService.GetSyncTable<Note>();
// Set initialized flag to avoid double initialisation
_IsInitialized = true;
}
protected override async void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
// Set our view from the "main" layout resource
SetContentView (Resource.Layout.Activity_To_Do);
CurrentPlatform.Init ();
// Create the Mobile Service Client instance, using the provided
// Mobile Service URL and key
client = new MobileServiceClient (AppConstant.applicationURL, AppConstant.applicationKey);
await InitLocalStoreAsync();
user = new MobileServiceUser(Intent.GetStringExtra("UserID"));
user.MobileServiceAuthenticationToken = Intent.GetStringExtra("UserToken");
client.CurrentUser = user;
// Set the current instance of TodoActivity.
instance = this;
// Make sure the GCM client is set up correctly.
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);
// Register the app for push notifications.
GcmClient.Register(this, ToDoBroadcastReceiver.senderIDs);
// Get the Mobile Service sync table instance to use
toDoTable = client.GetSyncTable <ToDoItem> ();
textNewToDo = FindViewById<EditText> (Resource.Id.textNewToDo);
// Create an adapter to bind the items with the view
adapter = new ToDoItemAdapter (this, Resource.Layout.Row_List_To_Do);
var listViewToDo = FindViewById<ListView> (Resource.Id.listViewToDo);
listViewToDo.Adapter = adapter;
// Load the items from the Mobile Service
OnRefreshItemsSelected ();
}
public async Task Initialize()
{
if (Client?.SyncContext?.IsInitialized ?? false)
return;
var appUrl = "https://ilovecoffee.azurewebsites.net";
#if AUTH
Client = new MobileServiceClient(appUrl, new AuthHandler());
if (!string.IsNullOrWhiteSpace (Settings.AuthToken) && !string.IsNullOrWhiteSpace (Settings.UserId)) {
Client.CurrentUser = new MobileServiceUser (Settings.UserId);
Client.CurrentUser.MobileServiceAuthenticationToken = Settings.AuthToken;
}
#else
//Create our client
Client = new MobileServiceClient(appUrl);
#endif
//InitialzeDatabase for path
var path = "syncstore.db";
path = Path.Combine(MobileServiceClient.DefaultDatabasePath, path);
//setup our local sqlite store and intialize our table
var store = new MobileServiceSQLiteStore(path);
//Define table
store.DefineTable<CupOfCoffee>();
//Initialize SyncContext
await Client.SyncContext.InitializeAsync(store);
//Get our sync table that will call out to azure
coffeeTable = Client.GetSyncTable<CupOfCoffee>();
}
