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 AzureService()
{
//comment back in to enable Azure Mobile Services.
MobileService = new MobileServiceClient("https://javusdemands.azurewebsites.net/");
expenseTable = MobileService.GetTable<Expense>();
}
private async Task PrepareTableAsync(MobileServiceClient client)
{
// Make sure the table is empty
IMobileServiceTable<Product> table = client.GetTable<Product>();
IEnumerable<Product> results = await table.ReadAsync();
foreach (Product item in results)
{
await table.DeleteAsync(item);
}
products = new Product[50];
for (int i = 0; i < 50; i++)
{
string id = Guid.NewGuid().ToString();
Product p = new Product()
{
AvailableTime = TimeSpan.FromHours(i),
Id = id,
DisplayAisle = (short)(i + 10),
InStock = i % 2 == 0,
Name = "Product" + i,
OptionFlags = (byte)i,
OtherId = i,
Price = 30.09M,
Type = i % 2 == 0 ? ProductType.Food : ProductType.Furniture,
Weight = i % 2 == 0 ? 35.7f : (float?)null,
};
products[i] = p;
await table.InsertAsync(p);
}
}
public AzureDataStore()
{
// This is a sample read-only azure site for demo
// Follow the readme.md in the GitHub repo on how to setup your own.
MobileService = new MobileServiceClient(
"http://myshoppe-demo.azurewebsites.net");
}
public void Construction()
{
string appUrl = "http://www.test.com/";
string appKey = "secret...";
MobileServiceClient service = new MobileServiceClient(new Uri(appUrl), appKey);
Assert.AreEqual(appUrl, service.ApplicationUri.ToString());
Assert.AreEqual(appKey, service.ApplicationKey);
service = new MobileServiceClient(appUrl, appKey);
Assert.AreEqual(appUrl, service.ApplicationUri.ToString());
Assert.AreEqual(appKey, service.ApplicationKey);
service = new MobileServiceClient(new Uri(appUrl));
Assert.AreEqual(appUrl, service.ApplicationUri.ToString());
Assert.AreEqual(null, service.ApplicationKey);
service = new MobileServiceClient(appUrl);
Assert.AreEqual(appUrl, service.ApplicationUri.ToString());
Assert.AreEqual(null, service.ApplicationKey);
Uri none = null;
Throws<ArgumentNullException>(() => new MobileServiceClient(none));
Throws<FormatException>(() => new MobileServiceClient("not a valid uri!!!@#!@#"));
}
private async void Login(MobileServiceAuthenticationProvider provider)
{
var client = new MobileServiceClient(this.uriEntry.Value, this.keyEntry.Value);
var user = await client.LoginAsync(this, provider);
var alert = new UIAlertView("Welcome", "Your userId is: " + user.UserId, null, "OK");
alert.Show();
}
public MainViewModel(IPopupService popupService, SynchronizationContext synchonizationContext)
{
var client = new MobileServiceClient(
_mobileServiceUrl,
_mobileServiceKey);
_liveAuthClient = new LiveAuthClient(_mobileServiceUrl);
// Apply a ServiceFilter to the mobile client to help with our busy indication
_mobileServiceClient = client.WithFilter(new DotoServiceFilter(
busy =>
{
IsBusy = busy;
}));
_popupService = popupService;
_synchronizationContext = synchonizationContext;
_invitesTable = _mobileServiceClient.GetTable<Invite>();
_itemsTable = _mobileServiceClient.GetTable<Item>();
_profilesTable = _mobileServiceClient.GetTable<Profile>();
_listMembersTable = _mobileServiceClient.GetTable<ListMembership>();
_devicesTable = _mobileServiceClient.GetTable<Device>();
_settingsTable = _mobileServiceClient.GetTable<Setting>();
SetupCommands();
LoadSettings();
}
/// <summary>
/// Initializes a new instance of the ViewModelLocator class.
/// </summary>
public ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
ToggableNetworkInformation networkInfo = new ToggableNetworkInformation();
SimpleIoc.Default.Register<INetworkInformation>(() => networkInfo);
SimpleIoc.Default.Register<ICacheProvider, TimestampCacheProvider>();
SimpleIoc.Default.Register<IStructuredStorage, SQLiteStructuredStorage>();
SimpleIoc.Default.Register<NetworkInformationDelegate>(() =>
{
return new NetworkInformationDelegate(() => networkInfo.IsOnline, b => networkInfo.IsOnline = b);
});
SimpleIoc.Default.Register<MainViewModel>();
DelegatingHandler handler = new CacheHandler(SimpleIoc.Default.GetInstance<ICacheProvider>());
// This MobileServiceClient has been configured to communicate with your Mobile Service's url
// and application key. You're all set to start working with your Mobile Service!
MobileServiceClient MobileService = new MobileServiceClient(
"https://YOURAPP.azure-mobile.net/",
"YOURKEY",
handler
);
SimpleIoc.Default.Register<IMobileServiceClient>(() => MobileService);
}
public static ZumoTestGroup CreateTests()
{
ZumoTestGroup result = new ZumoTestGroup("Misc tests");
result.AddTest(CreateFilterTestWithMultipleRequests(true));
result.AddTest(CreateFilterTestWithMultipleRequests(false));
result.AddTest(new ZumoTest("Validate that filter can bypass service", async delegate(ZumoTest test)
{
string json = "{'id':1,'name':'John Doe','age':33}".Replace('\'', '\"');
var client = new MobileServiceClient(
ZumoTestGlobals.Instance.Client.ApplicationUri,
ZumoTestGlobals.Instance.Client.ApplicationKey,
new HandlerToBypassService(201, "application/json", json));
var table = client.GetTable("TableWhichDoesNotExist");
var item = new JObject();
var inserted = await table.InsertAsync(item);
List<string> errors = new List<string>();
if (!Util.CompareJson(JObject.Parse(json), inserted, errors))
{
foreach (var error in errors)
{
test.AddLog(error);
}
test.AddLog("Error comparing object returned by the filter");
return false;
}
else
{
return true;
}
}));
result.AddTest(CreateUserAgentValidationTest());
result.AddTest(CreateParameterPassingTest(true));
result.AddTest(CreateParameterPassingTest(false));
result.AddTest(CreateOptimisticConcurrencyTest("Conflicts - client wins", (clientItem, serverItem) =>
{
var mergeResult = clientItem.Clone();
mergeResult.Version = serverItem.Version;
return mergeResult;
}));
result.AddTest(CreateOptimisticConcurrencyTest("Conflicts - server wins", (clientItem, serverItem) =>
{
return serverItem;
}));
result.AddTest(CreateOptimisticConcurrencyTest("Conflicts - Name from client, Number from server", (clientItem, serverItem) =>
{
var mergeResult = serverItem.Clone();
mergeResult.Name = clientItem.Name;
return mergeResult;
}));
result.AddTest(CreateSystemPropertiesTest(true));
result.AddTest(CreateSystemPropertiesTest(false));
return result;
}
public override bool FinishedLaunching (UIApplication app, NSDictionary options)
{
Forms.Init ();
// create a new window instance based on the screen size
window = new UIWindow (UIScreen.MainScreen.Bounds);
#region Azure stuff
CurrentPlatform.Init ();
Client = new MobileServiceClient (
Constants.Url,
Constants.Key);
todoTable = Client.GetTable<TodoItem>();
todoItemManager = new TodoItemManager(todoTable);
App.SetTodoItemManager (todoItemManager);
#endregion region
#region Text to Speech stuff
App.SetTextToSpeech (new Speech ());
#endregion region
// If you have defined a view, add it here:
// window.RootViewController = navigationController;
window.RootViewController = App.GetMainPage ().CreateViewController ();
// make the window visible
window.MakeKeyAndVisible ();
return true;
}
/// <summary>
/// Initializes a new instance of the ViewModelLocator class.
/// </summary>
public ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
ToggableNetworkInformation networkInfo = new ToggableNetworkInformation();
SimpleIoc.Default.Register<INetworkInformation>(() => networkInfo);
SimpleIoc.Default.Register<IStructuredStorage>(() => new SQLiteStructuredStorage("cache"));
SimpleIoc.Default.Register<ISynchronizer, TimestampSynchronizer>();
SimpleIoc.Default.Register<Func<Uri, bool>>(() => (u => true));
//SimpleIoc.Default.Register<ICacheProvider, DisabledCacheProvider>();
SimpleIoc.Default.Register<ICacheProvider, TimestampCacheProvider>();
SimpleIoc.Default.Register<NetworkInformationDelegate>(() =>
{
return new NetworkInformationDelegate(() => networkInfo.IsOnline, b => networkInfo.IsOnline = b);
});
SimpleIoc.Default.Register<MainViewModel>();
DelegatingHandler handler = new CacheHandler(SimpleIoc.Default.GetInstance<ICacheProvider>());
// Configure your mobile service here
MobileServiceClient MobileService = new MobileServiceClient(
Constants.MobileServiceUrl,
Constants.MobileServiceKey,
handler
);
SimpleIoc.Default.Register<IMobileServiceClient>(() => MobileService);
}
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
mobileServiceClient = new MobileServiceClient("AZURE_URL_GOES_HERE", "AZURE_API_KEY_GOES_HERE");
}
public async Task<MobileServiceUser> LoginAsync(MobileServiceClient client, MobileServiceAuthenticationProvider provider)
{
try
{
var window = UIKit.UIApplication.SharedApplication.KeyWindow;
var root = window.RootViewController;
if(root != null)
{
var current = root;
while(current.PresentedViewController != null)
{
current = current.PresentedViewController;
}
Settings.LoginAttempts++;
var user = await client.LoginAsync(current, provider);
Settings.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty;
Settings.UserId = user?.UserId ?? string.Empty;
return user;
}
}
catch(Exception e)
{
e.Data["method"] = "LoginAsync";
Xamarin.Insights.Report(e);
}
return null;
}
private async Task PrepareTableAsync(MobileServiceClient client)
{
// Make sure the table is empty
IMobileServiceTable<Product> table = client.GetTable<Product>();
IEnumerable<Product> results = await table.ReadAsync();
foreach (Product item in results)
{
await table.DeleteAsync(item);
}
for (int i = 0; i < 50; i++)
{
await table.InsertAsync(new Product()
{
AvailableTime = TimeSpan.FromHours(i),
Id = Guid.NewGuid().ToString(),
DisplayAisle = (short)(i + 10),
InStock = i % 2 == 0,
Name = "Product" + i,
OptionFlags = (byte)i,
OtherId = i,
Price = 30.09M,
Type = i % 2 == 0 ? ProductType.Food : ProductType.Furniture,
Weight = i % 2 == 0 ? 35.7f : (float?)null,
});
}
//make sure we do not have any timestamps saved for requests
await this.CacheProvider.Purge();
}
/// <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 App()
{
TelemetryConfiguration.Active.InstrumentationKey = "5afcb70e-e5b7-41c5-9e57-aa6fb9f08c2a";
Microsoft.ApplicationInsights.WindowsAppInitializer.InitializeAsync(
Microsoft.ApplicationInsights.WindowsCollectors.Metadata |
Microsoft.ApplicationInsights.WindowsCollectors.Session |
Microsoft.ApplicationInsights.WindowsCollectors.PageView |
Microsoft.ApplicationInsights.WindowsCollectors.UnhandledException
);
InitializeComponent();
SplashFactory = (e) => new Views.Splash(e);
#region TelemetryClient Init
Telemetry = new TelemetryClient();
#endregion
MobileService =
new MobileServiceClient(
"https://petrolheadappuwp.azurewebsites.net"
);
#region App settings
var _settings = SettingsService.Instance;
RequestedTheme = _settings.AppTheme;
CacheMaxDuration = _settings.CacheMaxDuration;
ShowShellBackButton = _settings.UseShellBackButton;
#endregion
}
public MainPage()
{
this.InitializeComponent();
_mobileService = new MobileServiceClient( PixelPrinterPlugin.GetServiceUrl( _environment ) );
_mobileService.AlternateLoginHost = new Uri( PixelPrinterPlugin.GetServiceUrl( PixelPrinterPlugin.TargetEnvironment.Live ) );
}
public void RegisterForRemotePushNotifications(MobileServiceClient client, string channelName)
{
// Register for push with Mobile Services
IEnumerable<string> tag = new List<string>() { channelName };
var push = client.GetPush();
push.RegisterNativeAsync(DeviceToken, tag);
}
/// <summary>
/// Singleton 응용 프로그램 개체를 초기화합니다. 이것은 실행되는 작성 코드의 첫 번째
/// 줄이며 따라서 main() 또는 WinMain()과 논리적으로 동일합니다.
/// </summary>
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
/*** Injecting objects to public static instances ***/
// App
MobileService = new MobileServiceClient(
"https://pinthecloud.azure-mobile.net/",
"yvulzHAGRgNsGnPLHKcEFCPJcuyzKj23"
);
ApplicationSessions = new WSApplicationSessions();
ApplicationSettings = new WSApplicationSettings();
// Manager
SpotManager = new SpotManager();
Geolocator = new Geolocator();
BlobStorageManager = new BlobStorageManager();
LocalStorageManager = new LocalStorageManager();
OneDriveManager = new OneDriveManager();
DropBoxManager = new DropboxManager();
GoogleDriveManger = new GoogleDriveManager();
/////////////////////////////////////////////////////
// This order will be displayed at every App Pages
/////////////////////////////////////////////////////
StorageHelper.AddStorageManager(OneDriveManager.GetStorageName(), OneDriveManager);
StorageHelper.AddStorageManager(DropBoxManager.GetStorageName(), DropBoxManager);
StorageHelper.AddStorageManager(GoogleDriveManger.GetStorageName(), GoogleDriveManger);
Switcher.SetStorageToMainPlatform();
AccountManager = new AccountManager();
}
/// <summary>
/// Initializes a new instance of the MobileServiceTables class.
/// </summary>
/// <param name="tableName">The name of the table.</param>
/// <param name="client">
/// Reference to the MobileServiceClient associated with this table.
/// </param>
public MobileServiceTable(string tableName, MobileServiceClient client)
{
Debug.Assert(tableName != null, "tableName cannot be null!");
Debug.Assert(client != null, "client cannot be null!");
this.TableName = tableName;
this.MobileServiceClient = client;
}
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();
//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 void OnCreate(Bundle bundle)
{
FormsAppCompatActivity.TabLayoutResource = Resource.Layout.Tabbar;
FormsAppCompatActivity.ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
// This MobileServiceClient has been configured to communicate with the Azure Mobile App and
// Azure Gateway using the application url. You're all set to start working with your Mobile App!
Microsoft.WindowsAzure.MobileServices.MobileServiceClient ProjectPandaClient = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
"https://projectpanda.azurewebsites.net");
//auth code for android
global::Xamarin.Auth.Presenters.XamarinAndroid.AuthenticationConfiguration.Init(this, bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
//Calender view code
XamForms.Controls.Droid.Calendar.Init();
//Lottie Animation android code
AnimationViewRenderer.Init();
#region Local database for android devices
string dbName = "userSettingsdb.sqlite";
string folderPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
string fullPath = Path.Combine(folderPath, dbName);
#endregion
LoadApplication(new ProjectPanda.App(fullPath));
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
ClearTextbox();
try
{
SelLoginIDDupeCheck selLoginIDDupeCheck = new SelLoginIDDupeCheck();
//selLoginIDDupeCheck.memberID = crypto
var client = new MobileServiceClient(serverURL.Text, serverKey.Password);
string j = @"{""memberID"": ""aaa"" }";
//토큰 = body 텍스트 - 으로 바로 로드
inputTextbox.Text = j;
JToken token = JObject.Parse(j);
var orderResult = await client.InvokeApiAsync("CBSelLoginIDDupeCheck", token);
outputTextbox.Text = orderResult.ToString();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
public ServicioDatosImpl()
{
client=new MobileServiceClient(Cadenas.UrlServicio,
Cadenas.TokenServicio);
}
/// <summary>
/// Versucht Login, ohne einen entsprechenden Dialog zu zu zeigen.
/// </summary>
/// <returns>Ein MobileServiceUser, der awaited werden kann oder null bei Misserfolg.</returns>
internal static async Task<MobileServiceUser> AuthenticateSilent(MobileServiceClient mobileService)
{
LiveAuthClient liveAuthClient = new LiveAuthClient(APIKeys.LiveClientId);
session = (await liveAuthClient.InitializeAsync()).Session;
return await mobileService.LoginWithMicrosoftAccountAsync(session.AuthenticationToken);
}
private async void PerformUserLogin(object sender, System.Windows.Input.GestureEventArgs e)
{
username = userName.Text;
phoneNo = userPhone.Text;
if (MainPage.online == true)
{
Users user = new Users();
user.Name = username;
user.Phone_no = phoneNo;
user.uri = "uri here";
MobileService = new MobileServiceClient(
"https://shopappdata.azure-mobile.net/",
"dkwwuiuHYYQwbozjKaWRJYYpEiTjFt73"
);
userTable = MobileService.GetTable<Users>();
await userTable.InsertAsync(user);
user_id = user.Id;
MainPage.settings.Add("id", user_id);
MainPage.settings.Add("Pnumber", phoneNo);
MainPage.settings.Add("name", username);
}
else
{
// Prompt
}
// TODO: send this username and phoneno. to be added into the database
NavigationService.GoBack();
}
public ImagesListViewModel(MobileServiceClient client)
{
_client = client;
//_UserName = "******";
//_AlbumName = "Demo Album";
}
/// <summary>
/// Utility method that can be used to execute a test. It will capture any exceptions throw
/// during the execution of the test and return a message with details of the exception thrown.
/// </summary>
/// <param name="testName">The name of the test being executed.
/// </param>
/// <param name="test">A test to execute.
/// </param>
/// <returns>
/// Either the result of the test if the test passed, or a message with the exception
/// that was thrown.
/// </returns>
public static async Task<string> ExecuteTest(string testName, Func<Task<string>> test)
{
string resultText = null;
bool didPass = false;
if (client == null)
{
string appUrl = null;
App.Harness.Settings.Custom.TryGetValue("MobileServiceRuntimeUrl", out appUrl);
client = new MobileServiceClient(appUrl);
}
try
{
resultText = await test();
didPass = true;
}
catch (Exception exception)
{
resultText = string.Format("ExceptionType: {0} Message: {1} StackTrace: {2}",
exception.GetType().ToString(),
exception.Message,
exception.StackTrace);
}
return string.Format("Test '{0}' {1}.\n{2}",
testName,
didPass ? "PASSED" : "FAILED",
resultText);
}
static AzureDB ()
{
CurrentPlatform.Init ();
MobileService = new MobileServiceClient (ApplicationURL, ApplicationKey);
GetScoreTable ();
GetUserAuthenticationTable ();
}
partial void AddClientSecrets(ref MobileServiceClient client)
{
client = new MobileServiceClient(
"{ Mobile Service URL }",
"{ Mobile Service key }"
);
}
public static void Connect(string applicationUri, string applicationKey)
{
// the initialization should be done only once really, so locking the whole initial connection effort
lock (syncLock)
{
if (mobileServiceClientInitialized != true)
{
mobileServiceClient = new MobileServiceClient(applicationUri, applicationKey);
mobileServiceClientInitialized = true;
}
}
}
protected override async void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
// This MobileServiceClient has been configured to communicate with the Azure Mobile App and
// Azure Gateway using the application url. You're all set to start working with your Mobile App!
Microsoft.WindowsAzure.MobileServices.MobileServiceClient Mercury2Client = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
"https://mercury2.azurewebsites.net");
global::Xamarin.Forms.Forms.Init(this, bundle);
LoadApplication(new App());
await CrossMedia.Current.Initialize();
//Initialize the azure mobile client
Microsoft.WindowsAzure.MobileServices.CurrentPlatform.Init();
}
public List <Users> RetrieveUserData()
{
Task.Run(async() =>
{
// Initialization for Azure Mobile Apps
Microsoft.WindowsAzure.MobileServices.CurrentPlatform.Init();
// This MobileServiceClient has been configured to communicate with the Azure Mobile App and
// Azure Gateway using the application url. You're all set to start working with your Mobile App!
Microsoft.WindowsAzure.MobileServices.MobileServiceClient BopAppClient = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
"https://bopapp.azurewebsites.net");
Console.WriteLine("MOBILE SERVICE CLIENT CONNECTED");
//Mobile stored version of database.
IMobileServiceTable <Users> table = BopAppClient.GetTable <Users>();
Console.WriteLine("MOBILE SERVICE TABLE CONNECTED");
try
{
users = await table.ToListAsync();
Console.WriteLine("LOCATL TABLE CONNECTED. Size of array is == " + users.Count);
}
catch (System.Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
}
Console.WriteLine($"Are we on the UI thread? {Looper.MainLooper.Thread == Looper.MyLooper()?.Thread}");
Console.WriteLine("Done fetching/calculating data");
}).Wait();
Console.WriteLine("retrievedUserData");
return(users);
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="provider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The uri scheme.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, MobileServiceAuthenticationProvider provider, string uriScheme, IDictionary <string, string> parameters)
{
return(LoginAsync(client, provider.ToString(), uriScheme, parameters));
}
/// <summary>
/// Extension method to get a <see cref="Push"/> object made from an existing <see cref="MobileServiceClient"/>.
/// </summary>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> to create with.
/// </param>
/// <returns>
/// The <see cref="Push"/> object used for registering for notifications.
/// </returns>
public static Push GetPush(this MobileServiceClient client)
{
return(new Push(client));
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="provider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The uri scheme.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, string provider, string uriScheme)
{
return(LoginAsync(client, provider, uriScheme, null));
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="provider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The uri scheme.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, string provider, string uriScheme, IDictionary <string, string> parameters)
{
MobileServiceUIAuthentication auth = new MobileServiceUIAuthentication(client, provider, uriScheme, parameters);
return(auth.LoginAsync());
}
/// <summary>
/// Initializes a new instance of the MobileServiceTables class.
/// </summary>
/// <param name="tableName">The name of the table.</param>
/// <param name="client">
/// Reference to the MobileServiceClient associated with this table.
/// </param>
public MobileServiceTable(string tableName, MobileServiceClient client)
: base(tableName, client)
{
}
/// <summary>
/// Resume login process with the specified URL.
/// </summary>
public static void ResumeWithURL(this MobileServiceClient client, Uri uri)
{
MobileServiceUIAuthentication.CurrentAuthenticator?.OnResponseReceived(uri);
}
internal Push(MobileServiceClient client)
: this(client, string.Empty, null)
{
}
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client">The MobileServiceClient instance to login with</param> /// <param name="rectangle">The area in <paramref name="view"/> to anchor to.</param> /// <param name="view">UIView used to display a popover from on iPad.</param> /// <param name="provider">Authentication provider to use.</param> /// <param name="uriScheme">The URL scheme of the application.</param> /// <param name="parameters"> /// Provider specific extra parameters that are sent as query string parameters to login endpoint. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, RectangleF rectangle, UIView view, string provider, string uriScheme, IDictionary <string, string> parameters) => LoginAsync(client, rectangle, (object)view, provider, uriScheme, parameters);
public MobileServiceUIAuthentication(Context context, MobileServiceClient client, string providerName, string uriScheme, IDictionary <string, string> parameters)
: base(client, providerName, uriScheme, parameters)
{
this.context = context;
}
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client">The MobileServiceClient instance to login with</param> /// <param name="viewController">UIViewController used to display modal login UI on iPhone/iPods.</param> /// <param name="provider">Authentication provider to use.</param> /// <param name="uriScheme">The URL scheme of the application.</param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, UIViewController viewController, string provider, string uriScheme) => LoginAsync(client, viewController, provider, uriScheme, parameters: null);
/// <summary>
/// Resume login process with the specified URL.
/// </summary>
#pragma warning disable IDE0060 // Remove unused parameter
public static bool ResumeWithURL(this MobileServiceClient client,
#pragma warning restore IDE0060 // Remove unused parameter
UIApplication app, NSUrl url, NSDictionary options)
{
return(Xamarin.Essentials.Platform.OpenUrl(app, url, options));
}
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client">The MobileServiceClient instance to login with</param> /// <param name="viewController">UIViewController used to display modal login UI on iPhone/iPods.</param> /// <param name="provider">Authentication provider to use.</param> /// <param name="uriScheme">The URL scheme of the application.</param> /// <param name="parameters"> /// Provider specific extra parameters that are sent as query string parameters to login endpoint. /// </param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, UIViewController viewController, string provider, string uriScheme, IDictionary <string, string> parameters) => LoginAsync(client, default, viewController, provider, uriScheme, parameters);
/// <summary>
/// Initializes a new instance of the MobileServiceLogin class.
/// </summary>
/// <param name="client">
/// Reference to the MobileServiceClient associated with this table.
/// </param>
/// <param name="ignoreFilters">
/// Optional parameter to indicate if the client filters should be ignored
/// and requests should be sent directly. Is <c>true</c> by default. This should
/// only be set to false for testing purposes when filters are needed to intercept
/// and validate requests and responses.
/// </param>
public MobileServiceLogin(MobileServiceClient client, bool ignoreFilters = true)
{
Debug.Assert(client != null, "client should not be null.");
this.Client = client;
this.IgnoreFilters = ignoreFilters;
}
/// <summary> /// Log a user into a Mobile Services application given a provider name. /// </summary> /// <param name="client">The MobileServiceClient instance to login with</param> /// <param name="rectangle">The area in <paramref name="view"/> to anchor to.</param> /// <param name="view">UIView used to display a popover from on iPad.</param> /// <param name="provider">Authentication provider to use.</param> /// <param name="uriScheme">The URL scheme of the application.</param> /// <returns> /// Task that will complete when the user has finished authentication. /// </returns> public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, RectangleF rectangle, UIView view, MobileServiceAuthenticationProvider provider, string uriScheme) => LoginAsync(client, rectangle, view, provider, uriScheme, parameters: null);
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="provider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The uri scheme.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, MobileServiceAuthenticationProvider provider, string uriScheme)
{
return(LoginAsync(client, provider, uriScheme, parameters: null));
}
/// <summary>
/// Instantiates a new instance of <see cref="MobileServiceUIAuthentication"/>.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
/// <param name="provider">
/// The authentication provider.
/// </param>
/// <param name="uriScheme">
/// The uri scheme.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
public MobileServiceUIAuthentication(MobileServiceClient client, string provider, string uriScheme, IDictionary <string, string> parameters)
: base(client, provider, uriScheme, parameters)
{
}
/// <summary>
/// Initializes a new instance of the MobileServiceTables class.
/// </summary>
/// <param name="tableName">
/// The name of the table.
/// </param>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> associated with this table.
/// </param>
public MobileServiceTable(string tableName, MobileServiceClient client)
: base(tableName, client)
{
this.queryProvider = new MobileServiceTableQueryProvider();
}
public MobileServiceUIAuthentication(RectangleF rect, object view, MobileServiceClient client, string providerName, string uriScheme, IDictionary <string, string> parameters)
: base(client, providerName, uriScheme, parameters)
{
this.rect = rect;
this.view = view;
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="viewController" type="MonoTouch.UIKit.UIViewController">
/// UIViewController used to display modal login UI on iPhone/iPods.
/// </param>
/// <param name="provider" type="MobileServiceAuthenticationProvider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, UIViewController viewController, MobileServiceAuthenticationProvider provider, string uriScheme, IDictionary <string, string> parameters)
{
return(LoginAsync(client, default(RectangleF), viewController, provider.ToString(), uriScheme, parameters));
}
internal PushHttpClient(MobileServiceClient client)
{
this.client = client;
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="barButtonItem" type="MonoTouch.UIKit.UIBarButtonItem">
/// UIBarButtonItem used to display a popover from on iPad.
/// </param>
/// <param name="provider" type="string">
/// The name of the authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, UIBarButtonItem barButtonItem, string provider, string uriScheme, IDictionary <string, string> parameters)
{
return(LoginAsync(client, default(RectangleF), barButtonItem, provider, uriScheme, parameters));
}
internal static Task <MobileServiceUser> LoginAsync(MobileServiceClient client, RectangleF rect, object view, string provider, string uriScheme, IDictionary <string, string> parameters)
{
var auth = new MobileServiceUIAuthentication(rect, view, client, provider, uriScheme, parameters);
return(auth.LoginAsync());
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="rectangle" type="System.Drawing.RectangleF">
/// The area in <paramref name="view"/> to anchor to.
/// </param>
/// <param name="view" type="MonoTouch.UIKit.UIView">
/// UIView used to display a popover from on iPad.
/// </param>
/// <param name="provider" type="string">
/// The name of the authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, RectangleF rectangle, UIView view, string provider, string uriScheme)
{
return(LoginAsync(client, rectangle, view, provider, uriScheme, parameters: null));
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="barButtonItem" type="MonoTouch.UIKit.UIBarButtonItem">
/// UIBarButtonItem used to display a popover from on iPad.
/// </param>
/// <param name="provider" type="string">
/// The name of the authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, UIBarButtonItem barButtonItem, string provider, string uriScheme)
{
return(LoginAsync(client, barButtonItem, provider, uriScheme, parameters: null));
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="context" type="Android.Content.Context">
/// The Context to display the Login UI in.
/// </param>
/// <param name="provider" type="string">
/// The name of the authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, Context context, string provider, string uriScheme)
{
return(LoginAsync(client, context, provider, uriScheme, parameters: null));
}
/// <summary>
/// Log a user into a Mobile Services application given a provider name.
/// </summary>
/// <param name="client" type="Microsoft.WindowsAzure.MobileServices.MobileServiceClient">
/// The MobileServiceClient instance to login with
/// </param>
/// <param name="rectangle" type="System.Drawing.RectangleF">
/// The area in <paramref name="view"/> to anchor to.
/// </param>
/// <param name="view" type="MonoTouch.UIKit.UIView">
/// UIView used to display a popover from on iPad.
/// </param>
/// <param name="provider" type="MobileServiceAuthenticationProvider">
/// Authentication provider to use.
/// </param>
/// <param name="uriScheme">
/// The URL scheme of the application.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
/// <returns>
/// Task that will complete when the user has finished authentication.
/// </returns>
public static Task <MobileServiceUser> LoginAsync(this MobileServiceClient client, RectangleF rectangle, UIView view, MobileServiceAuthenticationProvider provider, string uriScheme, IDictionary <string, string> parameters)
{
return(LoginAsync(client, rectangle, (object)view, provider.ToString(), uriScheme, parameters));
}
