What is a widget?

If you ever worked with a web framework like React, you should know the concept of components. Flutter widgets are directly inspired by this idea. Widget is a reusable piece of code, which describes how your application’s UI looks like. Widgets define the user interface by their state. In some cases, the state can be static and not change over time – see the section below about Flutter widget types for details.

As soon as a widget’s state changes, Flutter rebuilds its outlook and in effect re-renders the GUI. The framework is said to do it efficiently by measuring what has changed in the widgets tree since the last rendering and re-paints only what’s necessary.

The most basic Flutter app might look as follows:

The runApp() method takes a Widget as its argument. In our case, it takes a Center widget, which has one child – a Text widget. As expected, such a simple Flutter app shows a “Hello Flutter!” text at the center of the screen.

This simple example shows us a few interesting facts:

• there are many built-in widgets, like Center and Text
• widgets can have a child or children – this is widgets nesting and it happens all the time and can be very deep
• Flutter widgets can have their own properties, like textDirection.

Widgets nesting sometimes makes simple Flutter apps having a lot of source code inside a single file. However, as I mentioned in the previous post, don’t get discouraged by that Actually, having a lot of nested widgets in Flutter is a good practice. If you have a few huge widgets without much nesting instead, it means that there’s something wrong with your implementation. Flutter widgets – as all reusable pieces of code – should not have too many responsibilities. SOLID also applies here

Viewing Flutter widgets with Flutter Inspector

As widgets tree may get big and quite heavily nested, there’s a very useful tool to easily view and explore it. This tool is called Flutter Inspector.

While in debug mode in Visual Studio Code, you can launch it by clicking the blue magnifier icon:

It opens in a web browser and allows you to see the whole widgets tree in your app:

There’s a very handy feature “Select Widget Mode” which, when enabled, lets you select the widgets directly in your emulator or phone. After doing this, you can see the selected widget’s properties in the inspector.

Types of Flutter widgets

In Flutter, you can – and will – create your own widgets. Widget is just a Dart class which extends a proper base class. Depending on whether your widget actually manages any state and changes over time, you have two types of base classes to inherit from – StatelessWidget or StatefulWidget.

The main purpose of each type of widget is to provide an implementation of a build() method which returns a Widget object. However, each widget type does it a bit differently. Let’s see this in action.

StatelessWidgets

The simplest widget you can create is a stateless widget. You create it by simply creating a class extending StatelessWidget. Here’s the sample source code and a view it generates:

	import 'package:flutter/material.dart';
	void main() => runApp(
	MaterialApp(
	title: "My CodeJourney Flutter app",
	home: Scaffold(
	appBar: AppBar(
	title: Text("My First App"),
	),
	body: MyFirstWidget(),
	),
	),
	);
	class MyFirstWidget extends StatelessWidget {
	@override
	Widget build(BuildContext context) {
	return Container(
	padding: EdgeInsets.all(8.0),
	child: Text(
	"Hello MyFirstWidget!",
	style: TextStyle(color: Colors.green),
	),
	);
	}
	}

view raw main_stateless_widget.dart hosted with ❤ by GitHub

You can play with it yourself in the DartPad.

There are quite a few new things in the source code. Let’s point them out:

• as our main widget, we used MaterialApp and provided it to runApp() method. MaterialApp widget gives us material design for our app out of the box. As soon as you use it, you can nest more material widgets from the widgets library. There’s a similar widget for Apple-oriented widgets called CupertinoApp, which allows using Cupertino widgets
• we used another material widget – a Scaffold. It provides us with an appBar and body properties – setting them we’re getting this nice-looking application’s skeleton with entitled app bar and home for our widget. Scaffold also gives us many things “for free”, e.g. FloatingActionButton
• body of our Scaffold is our first own stateless widget – MyFirstWidget. As mentioned before, it overrides the build() method, which simply returns another widget tree. Notice the usage of a Container widget, which is very useful for grouping other widgets.

StatelessWidget is simple, works and is just there Let’s see something more interesting now – StatefulWidgets.

StatefulWidgets

When you want your widget to change over time and maintain its state (in most cases you do), you can create a stateful widget. You do it by creating a Dart class extending StatefulWidget. Unlike StatelessWidgets, StatefulWidget doesn’t override the build() method. Instead, it implements a createState() method, which creates the initial widget’s state (see below).

Apart from the main widget class, which itself is still “final” (or better said – immutable), you create a class extending State. This class maintains the actual state and it is now who provides the build() method’s implementation.

Let’s see the sample code and produced GUI:

	class MySecondWidget extends StatefulWidget {
	MySecondWidget({Key key}) : super(key: key);
	@override
	_MySecondWidgetState createState() =>
	_MySecondWidgetState();
	}
	class _MySecondWidgetState extends State<MySecondWidget> {
	int _clickCount = 0;
	void incrementClickCount() {
	setState(() {
	this._clickCount++;
	});
	}
	@override
	Widget build(BuildContext context) {
	return Scaffold(
	appBar: AppBar(
	title: Text("My First App"),
	),
	body: Container(
	padding: EdgeInsets.all(8.0),
	child: Text(
	"Hello! Times clicked: "
	+ this._clickCount.toString(),
	style: TextStyle(
	color: Colors.green,
	fontSize: 20.0),
	),
	),
	floatingActionButton: FloatingActionButton(
	child: Icon(Icons.add),
	onPressed: this.incrementClickCount,
	),
	);
	}
	}

view raw main_stateful_widget.dart hosted with ❤ by GitHub

The full code you can play with is available in the DartPad.

Now some comments about the StatefulWidget code:

• notice how MySecondWidget class passes a key to its superclass. Concept of Flutter widgets keys is interesting and we’ll dig into it in a separate post. For now, just treat it as a convention to always accept a key as a named argument and pass it to the base class
• as said before, in this simple example, MySecondWidget only creates the initial state by instantiating _MySecondWidgetState
• you’re already familiar with most of the code in _MySecondWidgetState, but notice the usage of setState() in incrementClickCount() function. It tells Flutter that the state has changed, so the framework can re-render the UI. If you directly change the value of this._clickCount without calling setState(), GUI will not be updated until setState() is called in some other place. We’ll talk more about state management techniques in Flutter in the future articles
• note how easy it is to add a FloatingActionButton thanks to using Scaffold material widget.

That was easy and works nicely! You now know how to use both Flutter widget types

Flutter quick actions in VS Code

I’d like to share with you two easy tips for working with Flutter in Visual Studio Code. Both speed up the development nicely. It assumes that you configured VS Code properly (if not read this article) and have Flutter extension installed.

Ctrl + .

First important keyboard shortcut is Ctrl+. (Cmd+. on Mac). It allows you to perform many element-contextual actions. For me it’s most useful for removing widgets or wrapping widgets with other ones:

Snippets for widgets creation

Another useful feature are code snippets for creating widgets. You use them by starting to type their acronym in your .dart file. There are two acronyms for widgets creation – stless for StatelessWidget and stful for StatefulWidget scaffolding. The usage looks as follows:

Most popular Flutter widgets

I wanted to list you here some most popular Flutter widgets, but they are quite well described here. You can also search through the widgets library. We’ve also used quite few of them in our examples above

Community widgets

Many more people are starting to use Flutter and they also create a lot of community widgets. You can find the Dart packages for Flutter on pub.dev. I also recommend checking the Flutter Awesome website where the best Flutter widgets, libraries and other extensions are listed.

Summary

That’s it! You’ve just learned how to use stateless and stateful widgets in Flutter. We’ve also seen what’s the difference between them and what are some basic conventions in creating them. There’s a lot more to Flutter widgets and related topics, but these are topics for separate posts. I hope to publish more of them soon

In my opinion, bringing components into the mobile world in the form of widgets is a very nice idea. They give quite a good separation of logic and GUI management. For sure it’s a fresh start, totally changing the way in which we think about mobile apps development. Components have done their job in the web world, so why would widgets not succeed in mobile apps? We’ll see!

What do you think? If you are interested in some particular topics related to Flutter – let me know!

The post Basics of Flutter Widgets appeared first on CodeJourney.net.

What is Flutter?

Flutter is an open-source platform and development kit created by Google. You can use it to create mobile (Android, iOS), desktop (Windows, Mac, Linux) and recently also web applications.

Flutter is quite new, as it’s first official version 1.0 was released in December 2018. Before, it was developed and used internally by Google for a few years.

Since this time, countless Flutter apps have been published. You can find their list for instance here. One of the most well-known Flutter apps is Xianyu app created by Alibaba and used by 50M+ people.

The main purposes of Flutter are claimed to be fast development, beautiful and consistent UIs and native performance on each platform.

Dart as a programming language

Flutter uses Dart as a programming language. Why is that? Well, of course, Dart is also developed by Google However, one of the real reasons is believed to be performance.

As you probably know, Flutter is not the first (and not the last) cross-platform mobile development platform. Its main competitor is React Native, which uses JavaScript. Dart compiles to the given platform’s native machine code. Thanks to that, it doesn’t have to use a JavaScript bridge to interact with native components that React Native apps have to do. I don’t know how true this is in real life and how it helps with performance, but that is one of the reasons for using Dart as a programming language for Flutter apps.

Dart is a UI-oriented language. For C/C#/Java developers, Dart’s syntax will be rather familiar and easy to learn. It’s object-oriented, including support for classes and interfaces. The language is type-safe, meaning it combines static and runtime types checking.

Dart is supported by its virtual machine, which also provides – amongst others – a garbage collector (if you don’t know what the GC is, check out this post).

Here’s a simple program written in Dart:

You can play with the code yourself in the DartPad.

Another interesting feature that is possible thanks to Dart is the hot reload. We’ll explore it later, but it significantly speeds up the development and testing time.

If you want to learn more about Dart, check out the official docs.

Everything as a widget

The main concept in building Flutter apps are widgets. In Flutter, everything is a widget – buttons, texts, menus, colors, themes, spacings and paddings. Even your Flutter app is a widget.

What’s very interesting is that Flutter doesn’t use platform native widgets. Instead, it provides its own set of widgets for each platform, e.g. Material Design for Android and Cupertino widgets for iOS. Additionally, as a programmer, you can create your own widgets. Thanks to that, all Flutter apps look pretty much the same on every Android/iOS version. You don’t need to worry about some UI elements changes between OS releases. At the same time, an app built using these widgets looks like native GUI.

Thanks to the widgets concept, Flutter apps can be easily personalized and branded. Recent researches show that customers are now starting to prefer more specific-looking apps to standard and boring native-designed UIs.

The drawback which I see about widgets is that there’s normally A LOT of source code in Flutter apps. Don’t get confused straightaway

Installation and configuration

Now, let’s get into the real work. It surprised me how easy it is to start working with Flutter. As you’ll see in a moment, you can build quite a nice-looking mobile app with Flutter in less than 30 minutes!

There are several possibilities to work with Flutter. You can easily set up Android Studio or IntelliJ. For example purposes, we’ll focus on running and debugging an Android application on Windows PC using Visual Studio Code. If you’re on Mac or Linux, check out a corresponding official installation guide.

Install Flutter and Android SDK

The installation process is quite easy. Initially I wanted to describe it here for you, but actually the official installation docs do it pretty well I’ll just guide you through the steps below with links to the official installation guide.

Install Flutter SDK and Android Studio

First of all, install Flutter SDK and Android Studio (which is required for Android SDK) following this installation guide. The process is fairly easy and should not take more than 15 minutes. Remember about using flutter doctor command to verify if everything is installed correctly – it gives very clear messages. In the end, using VS Code and having Android phone connected in USB Debugging mode, your flutter doctor command should have an output similar to mine:

Configure Visual Studio Code

The next step is to configure Visual Studio Code to be able to develop, compile, run and debug Flutter apps. You only need to install the Flutter extension, which is very well described here. It should also automatically install the Dart VS Code extension which adds Dart language support to VS Code.

Your first Flutter app

Now let’s finally create this first Flutter Android application It’s probably gonna be the quickest part!

Create and run a sample app

First of all, open Visual Studio Code. Use Ctrl+Shift+P to open a Command Palette. Start typing “Flutter” and select Flutter: New Project:

In two next steps specify your project’s name (e.g. “hello_flutter”) and choose a location where the template should be generated.

Wait until VS Code generates the whole project and you see main.dart file in lib folder:

Open the main.dart file and replace its contents with the following, a bit cleaned-up code:

We won’t focus on the source code here – I hope to dig more in the coming posts Just notice there are quite a few widgets – can you count them all? I found at least 12 different widgets used in this small template code.

Now the best part – having your Android phone connected (you should see it in the right-bottom corner of VS Code) press F5 to run the application. After a few seconds (usually longer for the first time) you should see this beautiful application on your smartphone’s screen:

As soon as you press the “+” button the green counter increments. Yaaaaay!

Debug your Flutter app

Now, try putting a breakpoint in main.dart file at line 30 (beginning of _incrementCounter() function). When you click the “+” button next time, VS Code should stop at the breakpoint:

Try hot reload

The best for the end. As I mentioned before, Flutter lets you use a hot reload. It lets you change the code while running the app and see the changes immediately after saving the source code file. I love it especially because it’s a stateful hot reload, meaning that except UI the state is also reloaded (or rather kept).

With your Flutter app running in debug mode, click the “+” button several times so the counter has value > 0. Then go directly into VS Code and modify line 50 by changing the counter text color from Colors.green to Colors.red. Line 50 should now look as follows:

Save main.dart file by pressing Ctrl+S. Take a look at your smartphone and see the magic:

Notice how the color of number “7” (counter value) changed to red while its value remains untouched. Quite a nice feature for quick development

I noticed that sometimes it doesn’t work that smoothly and you need to restart the app to see the changes. However, it happens only with some bigger code changes. Flutter quite young SDK and tools are still developing quickly so I hope such drawbacks will be eliminated soon.

Summary

Today we’ve seen how easy it is to start working with Flutter. We got familiar with basic Flutter concepts like widgets. We’ve also created our first Flutter app and debugged it. Finally, we’ve seen the very cool hot reload feature in action

For me, Flutter looks promising. After my adventures with Xamarin, which mostly felt like changing Java to C# and Android Studio to Visual Studio, I’m excited to try something fresh and totally different.

I know this was just a simple introduction to Flutter, but there’s more coming! I hope to publish the next articles about Flutter as I continue playing with it. If you’ve ever used Flutter and have some good sources to recommend – let me know in the comments!

Stay tuned!

The post Your First Flutter App in 30 Minutes appeared first on CodeJourney.net.

Why to synchronize with remote database?

First question to ask is why to synchronize with a remote database at all?

There are a few obvious advantages:

(+) users’ data is stored “in a cloud” and can be accessed from any device

(+) users don’t need to worry about backing-up their data

(+) data storage logic is moved to the web part of the system and with API exposed it can be easier to port it to other platforms

(+) having web API, a web client can be easily added to the system.

However, there are also some harms:

(-) synchronization of local and remote data (online and offline) must be handled

(-) synchronization uses some network data and battery of a mobile device

(-) web API must be maintained and after each change in it mobile app must be adjusted.

Despite all these aspects I’ve been wondering to implement a web API for few different reasons. First of all this could be a great programming experience, very interesting from architectural point of view. Secondly, I think this is a bit old-fashioned and messy that a user needs to export some database/app files backup to his GDrive in order to not lose his data.

Frankly, I just want to have some fun with ASP.NET Core, implement a web API and make MoneyBack working with it Maybe some Linux deployment after all? Let’s create some nice programming playground here

How to synchronize with web API?

That’s the question I’ve been searching an answer for recently. Long story short, the idea is to have a back-end database management system hosted on a web server and mobile app having its own local “mirror” of the database, bidirectionally synchronizing local data with remote database through web API. Mobile app should work in offline-first mode, which means that all operations must be possible to be done locally and potential (not mandatory) synchronization to happen as soon as it’s possible (user is connected to WiFi, has mobile network access etc.)

There are various possibilities and solutions to handle synchronization of mobile app’s data and remote database storage, from synchronization system built from scratch to Azure cloud hosting.

Custom synchronization mechanism

We could of course implement our own data synchronization mechanism. There are many tutorials available, including for instance this one, which describes all the contents quite nicely and I recommend reading it even if you don’t want to implement sync on your own – it helps understanding all the concepts.

Custom synchronization can be a lot of fun, but… why to reinvent the wheel?

Azure Mobile App Service

Microsoft’s Azure Mobile App Service is recommended almost everywhere – on StackOverflow, in the official Xamarin documentation and on a lot of blogs, but its free plan seems to not be worth using (except of performing some simple tests) while paid plans are more enterprisy. It seems great, but for my playground I neither want to pay nor use free plan which may become unusable after re-implementing the whole back-end.

Realm.io

Finally, out of a sudden, I found it. Realm.io is a totally separate database system built especially for mobile solutions. Its Mobile Database may be used as the db framework for a mobile app (Xamarin is also supported), replacing for instance SQLite. After all, Realm Mobile Platform can be used on a server-side handling mobile/web APIs and data synchronization – documentation says it supports .NET Core 1.1. Let’s hope they add support for 2.0 soon.

What’s more it’s all open-source and provides really nice free plans.

Realm.io looks very promising. I’m just a bit worried it’s almost never recommended on the web – is there something wrong with it? Maybe it’s a new stuff? Where’s a catch? Let me know if you’ve had any experience with it.

SQLite-sync.com

Last but maybe not least, I found SQLite-sync.com. The idea seems to be similar to Realm.io, however this product looks less mature. Not even 100 commits on their GitHub with just few contributors. Looking poor compared to Realm.io’s GitHub with more than 2.5k commits only for its .NET component.

The main (and the only?) benefit of using it would be the possibility to keep SQLite database in Xamarin.Android app. Apart from that, I don’t see any dominance over Realm.io.

Summary

As my research shows there are a lot of existing frameworks that help keeping data synchronized between mobile app and a remote back-end, allowing Xamarin app to work in offline-first approach. Microsoft offers great stuff in Azure, but in my opinion it’s not worth investing money for small playground apps.

For the moment I’m for Realm.io. It seems to provide very extended free plan, there’s a lot of resources on the web, folks talk about it on SO…

So now I’m asking you – do you have any experience with data sync in Xamarin apps? If yes, please share your insights and help me to choose the best approach

I’d be grateful for any suggestions!

After the framework is chosen, I will try to design the whole synchronization system and share it with you here.

The post Xamarin.Android – ASP.NET web api synchronization – research appeared first on CodeJourney.net.

Using ADB to debug Android apps

By default, adb is configured to “map” Android devices connected via USB ports to the computer as debug devices, which are then available e.g. in Visual Studio as the device on which our app can be deployed and debugged. In may cases we debug apps on Android emulators, which is frequently fair enough, but at some point we need to make our tests on a physical device.

It may not be very comfortable to have the phone connected using USB cable all the time, especially when testing some physical sensors like accelerometer or gyroscope. For such purposes, ADB gives us the possibility to connect Android devices via WiFi instead of USB. Let’s see how to configure it.

Configure ADB to work on WiFi

The first requirement is – obviously – that both our development PC and Android device must be connected to the same WiFi network. Then we need to find out what is the IP address of our Android device – it can be checked by going to Settings -> WiFi -> Menu – Advanced settings (Android 6.0):

As soon as you have IP address of the device noted, connect it to the computer via USB port.

Now we need to use adb.exe to configure it for connecting with the device via WiFi. You can either add system environmental variable pointing to where the adb.exe is stored or just open cmd, go to the catalogue where it’s located (Android\platform-tools\) and execute the following commands:

1. Change ADB to listen on TCP port:

adb tcpip 5555
This will make ADB listening on TCP port 5555 instead of USB ports (NOTE: since now the computer won’t listen to any devices connected by USB ports):

Now, disconnect the Android device from USB port.
2. Make ADB connect to your Android device:
adb connect 192.168.0.101:5555
This command is used to connect to Android device (of course IP address must be changed with your device’s one) on port 5555 using WiFi:


3. Since now you should see the device in Visual Studio connected using WiFi connection:

and you can of course deploy the app remotely on the device and debug it 
4. As soon as you’re done with WiFi debugging, run the following command:
adb usb
It will make ADB listening for USB devices again:

TIP: if during performing any cmd commands adb.exe is stuck or not reacting, try plugging out and re-plugging in your Android device to USB port.
Summary
This post described how to use remote debugging on Android devices using WiFi connection.
I hope you’ll find it useful 
The post Xamarin.Android – debugging via WiFi appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/xamarin-android-debugging-via-wifi/feed/
			4
		
		
		2296	
		
		
		https://www.codejourney.net/managing-activity-state-changes-using-bundle/
					https://www.codejourney.net/managing-activity-state-changes-using-bundle/#respond
		
		
		Mon, 29 May 2017 21:28:42 +0000
				
		
		
		
		
		
		
		http://www.dsibinski.pl/?p=2281

					Today we’re going to see how to manage (keep and restore) state of Activities in Xamarin.Android application in order to keep the app consistent and reactive for configuration/state changes. Why to keep and restore Activity’s state? As I already described in my post about Android Activities, the OS may react to some “constant” state changes…

The post Managing Activity state changes using Bundle appeared first on CodeJourney.net.
]]>
										Today we’re going to see how to manage (keep and restore) state of Activities in Xamarin.Android application in order to keep the app consistent and reactive for configuration/state changes.


Why to keep and restore Activity’s state?
As I already described in my post about Android Activities, the OS may react to some “constant” state changes by calling lifecycle methods during Activity’s life, which may be overridden by the programmer in order to take some additional actions. However, there are some behaviors in Android apps that may change its configuration, after which the state of the Activity (for instance: arrangement or some UI elements or checkboxes’ selections) may be lost if not handled properly.
To give you a real example: in MoneyBack application there is a main screen with two tabs. I noticed that when the second tab is selected:

and the device is rotated:

first tab becomes selected. User is losing his input (selection of the 2nd tab).
Screen orientation change is one of the reasons why we should care about saving and restoring Activities’ states.
Keeping state changes – OnSaveInstanceState()
Each Activity allows us to override OnSaveInstanceState(Bundle outState) method, which is called when the current Activity is to be killed (e.g. when device’s screen orientation is changing or the Activity needs to be killed by Android in order to release some resources).
Please don’t confuse it with Activity Lifecycle Methods (which I already described here), like OnPause() or OnStop() which are always called by the OS when particular action occurs. OnSaveInstanceState() method is generally called after OnPause() and before OnStop(), but it’s not always the case. For instance, it won’t be called at all when user navigates back from ActivityB to ActivityA, as in this case ActivityB will never be killed. More details can be found in official Android documentation.
OnSaveInstanceState() is called with Bundle parameter provided. It represents a simple key-value dictionary, which is additionally serialized, so it should be used for storing simple values like strings, integers etc. There are other structures and techniques for storing more complex data on state changes events (see the link in “Summary” section of this post).
In order to save currently selected tab, we can implement the method as follows:








  





  protected override void OnSaveInstanceState(Bundle outState)



  {



      var tabSelectedPosition = this.ActionBar.SelectedNavigationIndex;



      outState.PutInt("selectedTabPosition", tabSelectedPosition);








      base.OnSaveInstanceState(outState);



  }






        view raw

        

          OnSaveInstanceState.cs

        

        hosted with ❤ by GitHub
      


Now, each screen orientation change will make this method called and the index of selected tab will be saved into Bundle outState dictionary under “selectedTabPosition” key.
Restoring state changes – OnRestoreInstanceState()
As soon as the Activity considered backs to life (is being resumed), OnRestoreInstanceState(Bundle savedInstanceState) method is called by the OS. It will only be called if there is a saved instance kept by calling OnSaveInstanceState() method before. As you can see, this method also comes with a Bundle parameter, which is the same key-value serialized dictionary we used for saving the Activity’s state.
In case of tabs selection restoring, we can implement this method as the following code presents:








  





  protected override void OnRestoreInstanceState(Bundle savedInstanceState)



  {



      base.OnRestoreInstanceState(savedInstanceState);








      var previouslySelectedTabPosition = savedInstanceState.GetInt("selectedTabPosition", 0);



      this.ActionBar.SetSelectedNavigationItem(previouslySelectedTabPosition);



  }






        view raw

        

          OnRestoreInstanceState.cs

        

        hosted with ❤ by GitHub
      


previouslySelectedTabPosition variable will be initialized with integer value from Bundle dictionary saved under “selectedTabPosition” key, or default value (0) if nothing saved for the key is found.
NOTE: Bundle parameter provided in OnRestoreInstanceState() is exactly the same, as the one available in OnCreate(Bundle bundle) method called on Activity’s creation. We could actually also retrieve our saved value there, but in many cases restoring the state (like selecting previously selected tab) requires some UI elements to be already initialized, which should be handled within OnCreate() method before. Because of that, I’d rather suggest to restore Activity’s state using OnRestoreInstanceState() as a general rule (of course there may be some exceptional cases  ). OnRestoreInstanceState() will always be called after OnCreate().
Moreover, if we wanted to use Bundle parameter in OnCreate() method, we’d need to check each time if bundle is not NULL (as we don’t know whether OnSaveInstanceState() had been called before).
As a result, the same tab as previously is selected even after rotating the device on MoneyBack‘s MainActivity:

“Automatic” state changes handled by Android OS
Maybe you noticed in your Android application, that not every UI element needs to be handled “manually” by implementing the above-mentioned methods in order to save its state. Android performs some kind of “automatic” saving and restoration of basic UI elements’ states.
The rule here is that as long as UI element (like TextView or Button) has its android:id set in .axml layout file, OS will automatically manage those elements’ states (e.g. text entered into EditText).
For example, for EditText declared like that:








  





  <EditText



  android:layout_width="match_parent"



  android:layout_height="wrap_content"



  android:id="@+id/inputEventName"



  android:fadingEdge="none" />






        view raw

        

          EditText.axml

        

        hosted with ❤ by GitHub
      


its properties (especially its Text property) will be automatically saved and restored on screen orientation changes.
Summary
We’ve seen how to handle Android Activities’ state changes caused by configuration modification (e.g. screen orientation change, Activity being killed by the OS in order to free some resources etc.) by implementing OnSaveInstanceState() and OnRestoreInstanceState(), where we added and retrieved key-value data to/from Bundle serialized dictionary. We just need to remember that those methods are not always called (e.g. when navigating between Activities using “back” button), so these should be used only for certain kind of state changes.
We’ve also seen that UI controls with their android:id defined in layout files have their states resistant for configuration changes (handled automatically by Android OS).
Bundle dictionary is serialized for better performance and memory utilization, so only simple-typed values should be stored in it (like strings or integers). In order to store more complex data, Android provides different possibilities of managing it (e.g. using OnRetainNonConfigurationInstance).
The post Managing Activity state changes using Bundle appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/managing-activity-state-changes-using-bundle/feed/
			0
		
		
		2281	
		
		
		https://www.codejourney.net/date-selection-using-datepickerdialog-in-xamarin-android/
					https://www.codejourney.net/date-selection-using-datepickerdialog-in-xamarin-android/#respond
		
		
		Sat, 27 May 2017 13:19:47 +0000
				
		
		
		
		
		
		
		http://www.dsibinski.pl/?p=2266

					In this post, we’re going to see how to provide a nice Android UI control for selecting the date using DatePickerDialog. The dialog looks as follows: It may be opened e.g. when clicking on a button in the app, as I used it in MoneyBack. Creating DatePickerFragment First of all, we will implement the dialog to be displayed…

The post Date selection using DatePickerDialog in Xamarin.Android appeared first on CodeJourney.net.
]]>
										In this post, we’re going to see how to provide a nice Android UI control for selecting the date using DatePickerDialog.


The dialog looks as follows:

It may be opened e.g. when clicking on a button in the app, as I used it in MoneyBack.
Creating DatePickerFragment
First of all, we will implement the dialog to be displayed within DialogFragment. Doing that our dialog will be able to be displayed as independent piece of UI on the top of any Activity.
The second requirement is to implement IOnDateSetListener interface (coming from Java/Android), which provides a callback on date selection action done by the user.
The DatePickerFragment meeting those two requirements may look as follows:








  





  public class DatePickerFragment : DialogFragment, DatePickerDialog.IOnDateSetListener



  {



      public static readonly string TAG = "X:" + typeof(DatePickerFragment).Name.ToUpper();








      Action<DateTime> _dateSelectedHandler = delegate { };








      public DatePickerFragment(Action<DateTime> onDateSelected)



      {



          _dateSelectedHandler = onDateSelected;



      }








      public override Dialog OnCreateDialog(Bundle savedInstanceState)



      {



          DateTime now = DateTime.Now;



          return new DatePickerDialog(Activity, 



              this,



              now.Year,



              now.Month,



              now.Day);



      }








      public void OnDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth)



      {



          DateTime selectedDate = new DateTime(year, monthOfYear + 1, dayOfMonth);



          _dateSelectedHandler(selectedDate);



      }



  }






        view raw

        

          DatePickerFragment.cs

        

        hosted with ❤ by GitHub
      


There are few crucial parts in above-listed class:

Line 1: as said before, the class derives from DialogFragment and implements IOnDateSetListener interface
Line 3: here we have public static readonly string TAG variable defined – it is used as a unique identifier of the Fragment; in some cases, Fragments can be displayed without any UI – in such case the only possibility to identify and get the Fragment is by using findFragmentByTag() method
Lines 5-10: define _dateSelectedHandler delegate which may be provided to the constructor of our DatePickerFragment with the method to be called-back when user selects a date
Lines 12-20: inheriting from DialogFragment allows us to override its lifecycle methods – one of them is Dialog OnCreateDialog(Bundle savedInstanceState), in which we actually create the Dialog-inheriting class – in our case – DatePickerDialog – with initially selected date (set to current date in the provided example)
Lines 22-26: implementing IOnDateSetListener interface requires to implement OnDateSet method, which is called when the user selects the date and clicks “OK” button;

NOTE: one of this method’s arguments is monthOfYear integer value, which contains month number expressed as values 0-11 (NOT 1-12) for compatibility with java.util.Calendar.MONTH

Using DatePickerFragment
In MoneyBack application I’ve used DatePickerFragment on creating/modifying an event, when user needs to select its date:

As soon as the button is clicked, the following code executes:








  





  private void _btnSelectDate_Click(object sender, EventArgs e)



  {



      new DatePickerFragment(delegate(DateTime time)



          {



              _selectedDate = time;



              _btnSelectDate.Text = _selectedDate.ToLongDateString();



          })



          .Show(FragmentManager, DatePickerFragment.TAG);



  }






        view raw

        

          EventDetailsActivity_DateClick.cs

        

        hosted with ❤ by GitHub
      


As you can see, to DatePickerFragment‘s constructor I’m providing the delegate with a method to be called when the date is selected by the user (setting _selectedDate property with selected time and putting the date in short format as button’s Text).
In order to display a dialog, Show method is called, taking current FragmentManager and already mentioned per-Fragment-unique tag string, defined statically in DatePickerFragment class.
Summary
Today’s short post presented how to easily create a DialogFragment showing DatePickerDialog for date selection, which allows to provide any method to be called-back when the date is selected by the user.
I hope you’ll find it useful 
The post Date selection using DatePickerDialog in Xamarin.Android appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/date-selection-using-datepickerdialog-in-xamarin-android/feed/
			0
		
		
		2266	
		
		
		https://www.codejourney.net/sqlite-net-extensions-one-to-many-relationships/
					https://www.codejourney.net/sqlite-net-extensions-one-to-many-relationships/#comments
		
		
		Mon, 22 May 2017 22:01:46 +0000
				
		
		
		
		
		
		
		http://www.dsibinski.pl/?p=2251

					In the 3rd post from SQLite-Net Extensions series we are covering the last type of relationship – one-to-many (and the opposite – many-to-one). One-to-many, many-to-one One-to-many relationships are used in general for parent-children or whole-elements relations. Classic examples are: bus and passengers, document and elements etc. One-to-many relationship means that the one-end entity knows about its…

The post SQLite-Net Extensions – one-to-many relationships appeared first on CodeJourney.net.
]]>
										In the 3rd post from SQLite-Net Extensions series we are covering the last type of relationship – one-to-many (and the opposite – many-to-one).


One-to-many, many-to-one
One-to-many relationships are used in general for parent-children or whole-elements relations. Classic examples are: bus and passengers, document and elements etc.
One-to-many relationship means that the one-end entity knows about its children and many-end entity has a reference (foreign key) to its parent (but not necessarily knows about it).
On the other hand, the opposite relationship to one-to-many is many-to-one. In that case, many-end entity has a reference to its parent and knows about it, but the one-end entity doesn’t necessarily know about its children (at least not directly).
I used a verb to know several times – so it’s time to explain it 🙂 By “knowing” about the other end of a relationship I understand having a reference to it. It means that, for instance, in many-to-one relationship, the one-end of it doesn’t have a reference to its children.
However in most cases what we’d like to have is a hybrid of one-to-many and many-to-one relationships. I will call it one-to-many with inversion. We want both parent to know about its children, and each children to know about its parent.
In this post we’ll cover one-to-many with no reversion and one-to-many with reversion, as it also includes many-to-one relationship so you can have a comprehensive overview. We are going to see it on the example of Employee and Duty* entities. Each employee has a list of his duties, whilst each single duty is assigned to only one employee.
* “Task” would probably be a better name, but I didn’t want to make it confused with .NET Tasks 🙂
One-to-many with no inversion
Firstly, let’s model this kind of relationship:

Now we can transform it into C# classes:








  





    [Table("Employees")]



    public class Employee



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string Name { get; set; }



        public string LastName { get; set; }








        [OneToMany]



        public List<Duty> Duties { get; set; }



    }






        view raw

        

          Employee.cs

        

        hosted with ❤ by GitHub
      


In the Employee class (parent, one-end of the relationship) we define the collection of children, decorated with OneToManyAttribute. Collections types supported as for the time of writing this post by SQLite-Net Extensions are List and Array and can be used as you prefer.
Let’s now see how the child entity (Duty) looks like:








  





    [Table("Duties")]



    public class Duty



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string Description { get; set; }








        public DateTime Deadline { get; set; }








        [ForeignKey(typeof(Employee))]



        public int EmployeeId { get; set; }



    }






        view raw

        

          Duty.cs

        

        hosted with ❤ by GitHub
      


In the Duty class (child, many-end of the relationship) we need to have a foreign key to parent entity defined. For that purpose, we create a property representing it (EmployeeId), decorating it with ForeignKeyAttribute, additionally specifying the type of parent referenced (Employee).
That’s it. We can already use it in our code:








  





  var db = new SQLiteConnection(new SQLitePlatformAndroid(), Constants.DbFilePath);



  db.CreateTable<Employee>();



  db.CreateTable<Duty>();








  var employee = new Employee



  {



      Name = "Andrew",



      LastName = "Programmer"



  };








  var duty1 = new Duty()



  {



      Description = "Project A Management",



      Deadline = new DateTime(2017, 10, 31)



  };








  var duty2 = new Duty()



  {



      Description = "Reporting work time",



      Deadline = new DateTime(2022, 12, 31)



  };








  db.Insert(employee);



  db.Insert(duty1);



  db.Insert(duty2);








  employee.Duties = new List<Duty> {duty1, duty2};



  db.UpdateWithChildren(employee);








  var employeeStored = db.GetWithChildren<Employee>(employee.Id);






        view raw

        

          EmployeeDuty_noInv.cs

        

        hosted with ❤ by GitHub
      


No rocket-science here. What’s interesting for us it how employeeStored looks in the end:

As you can see, GetWithChildren method returned object of type Employee with its Duties collection properly retrieved (containing two duties assigned to the employee before). Moreover, each children has its foreign key (EmployeeId) automatically retrieved from the DB – there is no overhead here, this is simply foreign key field stored in the same SQLite database table (Duties).
One-to-many with inversion (one-to-many + many-to-one)
As previously, let’s first see how the class diagram changes after adding inversion:

What changed is that now each Duty has a property of type Employee.
To realize the above class diagram and make each children (each Duty in our case) knowing about its parent (having a reference to responsible Employee), the only thing we need to do is to add the following property to Duty model class:
[ManyToOne]
public Employee Employee { get; set; }
so the model class finally looks as follows:








  





  [Table("Duties")]



  public class Duty



  {



      [PrimaryKey, AutoIncrement]



      public int Id { get; set; }








      public string Description { get; set; }








      public DateTime Deadline { get; set; }








      [ForeignKey(typeof(Employee))]



      public int EmployeeId { get; set; }








      [ManyToOne]



      public Employee Employee { get; set; }



  }






        view raw

        

          Employee_withInv.cs

        

        hosted with ❤ by GitHub
      


As you can see, we have just created many-to-one relationship by using ManyToOneAttribute. So currently we have the hybrid of both types of relationships within out two models.
The usage in our code doesn’t need to be changed at all. Now, employeeStored entity after being initialized by the same GetWithChildren method as previously, for each Duty in addition to EmployeeId field also contains Employee property properly retrieved by SQLite-Net Extensions:

Again, there is no db overhead here, because when retrieving Employee entity from the database we already have it, so the operation of initializing the Employee entity in each Duty contained within Duties collection doesn’t require any more database querying.
Summary
Today we’ve seen how to model and use one-to-many (with and without inversion) relationships in SQLite database with the usage of SQLite-Net Extensions. The automatic initialization of one-end or many-end entities by the ORM is extremely helpful when dealing with such kind of objects in our app. The amount of code to be written is also minimal.
We’ve covered one-to-many and a hybrid of one-to-many + many-to-one relationships, but of course you can also define just many-to-one relationship – the models would then look as in this Gist. For me, it makes very limited sense, but maybe can be useful in some specific situations.
I invite you to read my other posts about SQLite-Net Extensions ORM, where we also covered the other types of relationships that can be modeled using this library.
As this is already the third post from this series, I’d like to ask you: what do you think about SQLite-Net Extensions ORM? Do you find it useful? Do you use it in your apps? Can you can recommend some other libraries/ORMs to use with SQLite database that allow to model different kind of relationships?
The post SQLite-Net Extensions – one-to-many relationships appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/sqlite-net-extensions-one-to-many-relationships/feed/
			2
		
		
		2251	
		
		
		https://www.codejourney.net/sqlite-net-extensions-one-to-one-relationships/
					https://www.codejourney.net/sqlite-net-extensions-one-to-one-relationships/#comments
		
		
		Sun, 21 May 2017 10:18:15 +0000
				
		
		
		
		
		
		http://www.dsibinski.pl/?p=2238

					In this second short post from SQLite-Net Extensions series, we’re going to see how to create one-to-one relationships using this tiny ORM. One-To-One This is the simplest type of database relationship. An example could be vehicle and registration certificate – each vehicle has one and only one registration certificate, and one registration certificate is associated…

The post SQLite-Net Extensions – one-to-one relationships appeared first on CodeJourney.net.
]]>
										In this second short post from SQLite-Net Extensions series, we’re going to see how to create one-to-one relationships using this tiny ORM.


One-To-One
This is the simplest type of database relationship. An example could be vehicle and registration certificate – each vehicle has one and only one registration certificate, and one registration certificate is associated with one and only one vehicle (excluding some extraordinary law rules in other countries that I don’t know  ).
We can model it in two ways:

as a one-way relationship – in this case only one of the relationship’s ends knows about the other one
as a both-ways (with inversion) relationship – both relationship’s ends know about each other.

One-To-One with no inversion (one-way)
This kind of relationship looks as follows:

We use it when we assume it’s enough that Vehicle knows about RegistrationCertificate, but the document doesn’t necessarily need to know which car/motor it’s associated with (at least directly).
In the code, we then create two model classes using SQLite-Net Extensions:








  





    [Table("RegistrationCertificates")]



    public class RegistrationCertificate



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string RegistrationNumber { get; set; }








        public string VIN { get; set; }








        public string OwnerData { get; set; }



    }






        view raw

        

          RegistrationCertificate.cs

        

        hosted with ❤ by GitHub
      










  





    [Table("Vehicles")]



    public class Vehicle



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string Brand { get; set; }








        public DateTime ProductionDate { get; set; }








        public decimal EngineCapacity { get; set; }








        [ForeignKey(typeof(RegistrationCertificate))]



        public int RegistrationCertificateId { get; set; }








        [OneToOne]



        public RegistrationCertificate RegistrationCertificate { get; set; }



    }






        view raw

        

          Vehicle.cs

        

        hosted with ❤ by GitHub
      


What’s interesting here is the ForeignKeyAttribute defined on RegistrationCertificateId property. It is – as its name says – the foreign key to the primary key of related entity (of type RegistrationCertificate).
The related entity property itself is decorated with OneToOneAttribute.
There’s nothing more we need to do to have this relationship modeled. We can already use it:








  





    var db = new SQLiteConnection(new SQLitePlatformAndroid(), Constants.DbFilePath);



    db.CreateTable<Vehicle>();



    db.CreateTable<RegistrationCertificate>();








    var vehicle = new Vehicle



    {



        Brand = "Renault",



        EngineCapacity = 1.9m,



        ProductionDate = new DateTime(2001, 01, 01)



    };








    var certificate = new RegistrationCertificate



    {



        RegistrationNumber = "AB 12345",



        OwnerData = "Dawid Sibiński",



        VIN = "1312BS1312ASDSSVVW"



    };








    db.Insert(vehicle);



    db.Insert(certificate);








    vehicle.RegistrationCertificate = certificate;



    db.UpdateWithChildren(vehicle);








    var vehicleStored = db.GetWithChildren<Vehicle>(vehicle.Id);






        view raw

        

          OneToOne_noInv.cs

        

        hosted with ❤ by GitHub
      


Nothing special here, right? It looks very similar to what we’ve seen in the previous post about many-to-many relationships. What’s interesting for us it that in the end, when Vehicle object is retrieved from the database using GetWithChildren method, its RegistrationCertificate property is filled as well:

One-To-One with inversion (both-ways)
This kind of relationship models itself as below:

What actually changed on the diagram compared to the relationship with no inversion is that now RegistrationCertificate has a property of type Vehicle (in the code – a reference to Vehicle related object and a foreign key).
In our case, this is even more “real” – it would be nice if a Vehicle knows about its RegistrationCertificate, but also when we look at the certificate we’d like to see to which car it belongs.
We can now model it in the code. The only thing that changes in the model classes is addition of a reference and foreign key to Vehicle in RegistrationCertificate model, so I’m presenting only this class’s updated code:








  





    [Table("RegistrationCertificates")]



    public class RegistrationCertificate



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string RegistrationNumber { get; set; }








        public string VIN { get; set; }








        public string OwnerData { get; set; }








        // added to have Inversion relationship



        [ForeignKey(typeof(Vehicle))]



        public int VehicleId { get; set; }








        [OneToOne]



        public Vehicle Vehicle { get; set; }



    }






        view raw

        

          RegistrationCertificate_withInv.cs

        

        hosted with ❤ by GitHub
      


What’s cool here is that we don’t need to modify our code for saving entities with relationships into SQLite database. We can simply add the following line at the end:
var certificateStored = db.GetWithChildren&lt;RegistrationCertificate&gt;(certificate.Id);
and notice that certificateStored already contains its associated Vehicle object:

Summary
In today’s short post we’ve seen how to create one-to-one relationship between two entities in SQLite database, using SQLite-Net Extensions ORM. It’s very easy and doesn’t require using Entity Framework  or writing SQL queries directly in our code.
We’ve covered two types of one-to-one relationships: one-way and both-ways. The choice between those two depends on the usage and purpose of the relationship we model.
I hope you’ll find it useful one day 
The post SQLite-Net Extensions – one-to-one relationships appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/sqlite-net-extensions-one-to-one-relationships/feed/
			2
		
		
		2238	
		
		
		https://www.codejourney.net/sqlite-net-extensions-many-to-many-relationships/
					https://www.codejourney.net/sqlite-net-extensions-many-to-many-relationships/#comments
		
		
		Thu, 18 May 2017 21:23:31 +0000
				
		
		
		
		
		
		http://www.dsibinski.pl/?p=2218

					In today’s post we’re going to see what is SQLite-Net Extensions ORM and how to use it to create many-to-many relationship in SQLite database. The other types of relationships will be described in separate posts. What is SQLite-Net Extensions ? As you develop any mobile app, sooner than later you need to keep your app’s data…

The post SQLite-Net Extensions – many-to-many relationships appeared first on CodeJourney.net.
]]>
										In today’s post we’re going to see what is SQLite-Net Extensions ORM and how to use it to create many-to-many relationship in SQLite database. The other types of relationships will be described in separate posts.


What is SQLite-Net Extensions ?
As you develop any mobile app, sooner than later you need to keep your app’s data in some persistent storage. In my MoneyBack project I’ve chosen SQLite database using SQLite.NET library for performing operations on it. This is actually very simple and easy-to-use database framework, but I recently realized I need to model some relations in my database.  SQLite.NET doesn’t offer any nice utilities to model such relations.
However, if you need to model any relations in your SQLite database, there is a wrapper on SQLite.NET which allows to do that – it is SQLite-Net Extensions. It basically extends the core functionalities of SQLite.NET by adding elements that allow to easily handle relationships, including one-to-one, one-to-many, many-to-one and many-to-many.
In this post we are going to see how to create many-to-many relationship using this library. I needed this kind of relationship to model the connection between Person and Event entities in my app.
Many-to-many relationship
Let’s see many-to-many relationship on an example of two entities: Person and Event. An event (entity of type Event) may contain zero or more participants (entities of type Person) whilst a person may be assigned to zero or more events. This is a typical many-to-many relationship which we are going to set up in our database now.
Install SQLite-Net Extensions
If you’ve previously been using SQLite.NET in your project – uninstall it first. I didn’t do it before starting to use SQLite-Net Extensions and I have many troubles with Visual Studio resolving my references incorrectly. SQLite-Net Extensions is a wrapper for SQLite.NET, so it already contains this library and additionally extends it by adding some extra functionalities for handling relationships.
SQLite-Net Extensions can be installed as a Nuget package into your solution. According to the version you’d like to use, execute appropriate command in Package Manager Console in Visual Studio:

synchronous:
Install-Package SQLiteNetExtensions -Version 1.3.0

asynchronous:
Install-Package SQLiteNetExtensions.Async -Version 1.3.0


Define model classes
Next we need to define our Person and Event model classes and establish the relationships between them. Below, you can find the code of both classes:








  





// Person class modelling People table



[Table("People")]



public class Person



{



    [PrimaryKey, AutoIncrement]



    public int Id { get; set; }








    public string Name { get; set; }








    public string LastName { get; set; }








    public string PhoneNumber { get; set; }








    public string Email { get; set; }








    [ManyToMany(typeof(PersonEvent))]



    public List<Event> Events { get; set; }



}













// Event class modelling Events table



[Table("Events")]



public class Event



{



    [PrimaryKey, AutoIncrement]



    public int Id { get; set; }








    public string Name { get; set; }



    public DateTime Date { get; set; }



    public string Place { get; set; }








    [ManyToMany(typeof(PersonEvent))]



    public List<Person> Participants { get; set; }



}






        view raw

        

          Person_Event.cs

        

        hosted with ❤ by GitHub
      


As you can see, the models look almost the same as SQLite.NET db entities, with the following exceptions:

ManyToManyAttribute – on both entities you can notice this attribute defined. On Person model class I decorate Events collection with it whereas on Event model class I decorate Participants collection with it. Simple as that.
PersonEvent – you may have noticed that as an argument to ManyToManyAttribute on both models I passed PersonEvent type. As you may know, in modelling many-to-many relationships we need an intermediate entity in order to store such kind of relationship in the database tables. The classic example is Student-Course relationship:


We also need to define such intermediate entity in our code.


The implementation of PersonEvent intermediate model class looks as follows:








  





public class PersonEvent



{



    [ForeignKey(typeof(Person))]



    public int PersonId { get; set; }








    [ForeignKey(typeof(Event))]



    public int EventId { get; set; }



}






        view raw

        

          PersonEvent.cs

        

        hosted with ❤ by GitHub
      


Thanks to PrimaryKey attributes defined on Person and Event entities the ORM will be able to determine to which primary keys the foreign keys in this intermediate table relate.
In the ManyToManyAttribute, except the type of intermediate entity, you can set CascadeOperations, which specifies how the cascading should be handled when working with the entities (e.g. if cascade delete operation should be performed when one of the relationship’s sides is removed).
Inserting and reading data
As soon as our model classes are defined, we can write and read the data with many-to-many relationships. The following code presents a simple way to create a new person and assign it to an event:








  





var db = new SQLiteConnection(new SQLitePlatformAndroid(), Constants.DbFilePath);



db.CreateTable<Person>();



db.CreateTable<Event>();



db.CreateTable<PersonEvent>();








var event1 = new Event



{



    Name = "Volleyball",



    Date = new DateTime(2017, 06, 18),



    Place = "Sports hall"



};








var person1 = new Person



{



    Name = "A",



    LastName = "B",



    PhoneNumber = "123456789"



};













db.Insert(person1);



db.Insert(event1);








person1.Events = new List<Event> { event1 };



db.UpdateWithChildren(person1);








var personStored = db.GetWithChildren<Person>(person1.Id);



var eventStored = db.GetWithChildren<Event>(event1.Id);






        view raw

        

          SavingPersonEvent.cs

        

        hosted with ❤ by GitHub
      


Lines 1-4 contain the database initialization (Constants.DbFilePath just returns an Android path of SQLite database file) and creation of all 3 tables in the database.
Lines 6-18 are simply the creation of Person and Event objects, filled with most basic details.
In lines 21 and 22 we firstly save our person1 and event1 entities separately, because in order to establish the relationships we need the primary keys of those entities, that are assigned by the database while saving. This can be also simplified by using recursive operations – more details in the official documentation of the ORM.
After that, we assign just created person to the event (line 24) and then the most rocket-science part comes:
db.UpdateWithChildren(person1);
This method does the write magic – it updates the person with all its children – so in our case, the Events collection. It will make the relationship established.
In order to prove it, in lines 27 and 28 we can check if the relationship collections are populated with children in both entities by calling GetWithChildren extension methods:
 

That’s how SQLite-Net Extensions ORM works. It doesn’t provide any lazy-loading of related entities – it just adds/retrieves to/from the database exactly what you tell it to. The limitation here is that if you access Person.Events collection you can see the events this person is in relation with, but if you access Person.Events[0] you will not see all people registered for this event.
Summary
SQLite-Net Extensions is an ORM, which is a wrapper for classic SQLite.NET library. It adds the extension methods/attributes to handle relationships in SQLite database. It doesn’t provide any lazy-loading mechanism, instead exposing methods for getting/saving entities along with their children (related entities). It’s lightweight and rather easy to implement, so for small solutions like mobile apps I totally prefer it to writing and maintaining SQL queries directly in C# in order to handle relationships.
In the next posts from the series about SQLite-Net Extensions ORM, I will present to you the other types of relationships this ORM offers. Stay tuned 
 
The post SQLite-Net Extensions – many-to-many relationships appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/sqlite-net-extensions-many-to-many-relationships/feed/
			8
		
		
		2218	
		
		
		https://www.codejourney.net/android-apps-localization/
					https://www.codejourney.net/android-apps-localization/#comments
		
		
		Wed, 19 Apr 2017 20:48:55 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=1803

					Hello everyone 🙂 As you might have noticed, I’ve recently decided to take a longer break in DSP competition. Few things to do, Easter in the meantime… but of course I didn’t give up and today I’m back 😉 In this post I’d like to show you how do we localize Android apps. Let’s see! What…

The post Android Apps Localization appeared first on CodeJourney.net.
]]>
										Hello everyone 🙂

As you might have noticed, I’ve recently decided to take a longer break in DSP competition. Few things to do, Easter in the meantime… but of course I didn’t give up and today I’m back 😉
In this post I’d like to show you how do we localize Android apps. Let’s see!


What is localization ?
Generally, localization is a process of adapting the product or application to specific markets by adjusting its language and cultural resources accordingly.
People often think that localization is only a process of translating documentation and user interface into multiple languages, but in fact it may concern many other not less important topics, e.g. formats of numeric values or dates, currencies, numbers comparison/sorting methods, symbols, national flags or even country-specific law requirements.
Android supports app’s resources localization in pretty easy way. We can quite conveniently provide different versions of strings, images and layouts used in our application for different languages/regions. Let’s take a look at the basics of Android app’s localization.
Android localization basics
In every Android application, localization is based on the language user has set on his/her device. The language can be changed in Settings -> Language & input. Changing the language in this place affects both user interface’s language and region-specific settings (e.g. dates formats).
To retrieve the current locale (constant/object representing selected language) in code the following statement can be used:
var currentLang = Resources.Configuration.Locale;
In case user has Polish language set on his/her phone, currentLang variable would contain “pl_PL” locale symbol. For the full list of locales symbols, see for example this list.
Basically, everything that is placed under Resources folder in Android solution can be localized. All of you probably have values folder in Resources, which contains Strings.xml file. We’ll see more details about this file in a while, but to present the ease of localization to you, it’s enough to create another folder under Resources called e.g. values-pl, which makes retrieving strings from Strings.xml file located in this folder on devices with language set to Polish. Simple as that. The same can be done with every type of resource. It means we can create totally different layouts of our Activities or use different images (e.g. countries’ flags) depending on user’s device’s language.
Strings localization
Strings.xml file
To-be-localized strings (BTW, I think that we should do it straightaway with all strings we use in our app) should be put in values/Strings.xml file, which has the following structure:








  





<?xml version="1.0" encoding="utf-8"?>



<resources>



    <string name="ApplicationName">MoneyBack</string>



    <string name="titleMenu">Menu:</string>



    <string name="btnPeople">People management</string>



    <string name="titleName">Name</string>



    <string name="titleLastName">Last name</string>



    <string name="titlePhoneNumber">Phone number</string>



    <string name="btnSavePerson">Save person</string>



    <string name="btnPeopleList">List of people</string>



    <string name="peopleListTitle">List of people</string>



</resources>






        view raw

        

          Strings.xml

        

        hosted with ❤ by GitHub
      


The file is built in accordance with standard XML rules. The name represents Android resource ID (cannot contain any spaces or dashes) to which we will refer from code and other places in order to retrieve the value of this resource, which is placed between “>” and “<” characters.
For instance, first resource from above-pasted Strings.xml has name = “ApplicationName” and value = “MoneyBack”.
As mentioned in the previous paragraph, I also created Strings.xml file in values-pl folder, containing the same resources’ Polish translations. The contents of values-pl/Strings.xml file:








  





<?xml version="1.0" encoding="utf-8"?>



<resources>



    <string name="ApplicationName">MoneyBack</string>



    <string name="titleMenu">Menu:</string>



    <string name="btnPeople">Zarządzaj osobami</string>



    <string name="titleName">Imię</string>



    <string name="titleLastName">Nazwisko</string>



    <string name="titlePhoneNumber">Numer telefonu</string>



    <string name="btnSavePerson">Zapisz osobę</string>



    <string name="btnPeopleList">Lista osób</string>



    <string name="peopleListTitle">Lista osób</string>



</resources>






        view raw

        

          Strings.xml

        

        hosted with ❤ by GitHub
      


Usage in layout files
In our Activities’ layout files (AXML) we can retrieve resources’ values by using @string/id syntax. For example, TextView‘s text can be set in the following way:








  





    <TextView



        android:text="@string/titleMenu"



        android:id="@+id/titleMenu" />






        view raw

        

          Main.axml

        

        hosted with ❤ by GitHub
      


It can be used exactly the same way in the UI designer in Visual Studio.
Usage directly in code
In the code we can retrieve values of particular resources using Resources.GetText method giving it selected resource’s id as Resource.String class’s property:
string titleMenuText = Resources.GetText(Resource.String.titleMenu);
With all strings translated, I can see UI of MoneyBack translated when my device’s language is set to Polish:




Quantity strings
Very interesting concept are so called quantity strings. It allows to define differently formatted strings depending on a number of some elements determined at runtime. For instance, on the list of people we could have the following strings displayed depending on the number of people:
“There is 1 person in your database.”
“There are 2 people in your database.”
To declare such kind of quantity string, we’d add to Strings.xml the following section:








  





<plurals name="numberOfPeople">



         <item quantity="one">There is %d person in your database.</item>



         <item quantity="other">There are %d people in your database..</item>



 </plurals>






        view raw

        

          Strings_plurals.xml

        

        hosted with ❤ by GitHub
      


To illustrate: in order to retrieve and format appropriate string depending on value stored in numPeople variable, the following code might be used:
var text = Resources.GetQuantityString(Resource.Plurals.numberOfPeople, numPeople, numPeople);
Second parameter passed is used to determine which string (plural) to use, and third parameter is the actual value passed to the final string (in the place of %d in that case).
The quantity of each plural can contain one of the following values:

zero
one
two
few
many
other

More details can be found here.
Application’s/Activity’s name
We can also localize the name of our app, by using string resource in the ActivityAttribute defined on MainActivity:
[Activity(Label = "@string/ApplicationName", MainLauncher = true, Icon = "@drawable/icon")]
The same can be done for any of our app’s activities. However, be careful here if you are referencing your main Android project from another one (e.g. from tests project) – I’ve experienced really annoying issue with that (more details below).
Other resources
As we already said, not only strings can be localized. You can localize any kind of resources placed within Resources folder, for example images or data files.
The file “obj\Debug\android\bin\packaged_resources” does not exist
Two weeks ago, when I finally decided to take a break in publishing DSP posts, I wanted to work on MoneyBack a bit, however I encountered very frustrating issue, which I even described in this StackOverflow post. I’ve been fighting with that problem for few days and I still actually don’t know the real cause of the issue.
Basically, when I used resource string on my PeopleListActivity in order to translate its title:
[Activity(Label = "@string/peopleListTitle")]
I couldn’t build my MoneyBack.Android.Tests (yes, different project!) project. I was getting the following build error message:

I explored all existing forums threads on this topic and couldn’t resolve this issue. Finally, by setting build output verbosity to Diagnostic in Tools -> Options -> Projects and Solutions -> Build and Run I was able to see the detailed error my build process is giving. It was telling me that @string/peopleListTitle doesn’t exist (or something similar). So when I changed the Label‘s value in ActivityAttribute to use a string directly (not taken as a resource), it worked fine and the build passed.
Today I tried once more to use resource string, obviously getting the same error message. Then I realized that my MoneyBack.Android.Tests project is referencing  MoneyBack project in which I define those somehow missing strings:

so I removed that reference (commenting out my unit tests which use MoneyBack‘s logic) and the build worked fine. Apparently when trying to build tests project, which references the main one, in which my strings are defined, it somehow needs those strings resources to be present in tests project’s output directory. I have no idea why, because I’m not directly using those strings resources in my tests project.
Then I added the reference back and in MoneyBack.Android.Tests project I just created values folder and copy-pasted Strings.xml file to it from the MoneyBack project:

and it builds OK!
Does any of you have some idea why it may happen? If you have a clue, you can answer here or even on SO.


For me it seems like a bug in the build process. I wanted to share it with you, because I wasted so much time because of this issue and maybe some of you will also find it useful.
BTW, I really recommend using Diagnostic verbosity of the build output for debugging such issues.
Summary
We’ve seen how Android application can be easily localized. I really recommend to put all strings visible for the end user from the beginning in Strings.xml file. Thanks to that, in case our application needs to be localized, we can even hire/ask some foreign languages’ interpreters to create country-specific values folder and translate strings resources conveniently. This is even very common in mobile apps communities, that people who are non-technical can contribute to the project by translating the application into their own language.
I hope I won’t meet any other issues like the one I described today on my further DSP way 🙂 It would allow me to write more stuff here and hopefully implement some usable app finally! Keep your fingers crossed 🙂
PS: If I already mentioned taking breaks in DSP competition, I will also take one more during the first week of May (1-5.05.2017). In case anyone cares 😉
 
 
The post Android Apps Localization appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/android-apps-localization/feed/
			12
		
		
		1803	
		
		
		https://www.codejourney.net/android-layout-types/
					https://www.codejourney.net/android-layout-types/#comments
		
		
		Sun, 02 Apr 2017 06:55:49 +0000
				
		
		
		
		http://www.dsibinski.pl/?p=1695

					If you’re just an Android user, you may not even know that each screen in your application has controls composed within different Layouts. Let’s see what are the main Layout Types in designing Android app. What is a Layout ? Layout defines a visual structure of an Activity (or app widget). It may be considered as…

The post Android Layout Types appeared first on CodeJourney.net.
]]>
										If you’re just an Android user, you may not even know that each screen in your application has controls composed within different Layouts. Let’s see what are the main Layout Types in designing Android app.


What is a Layout ?
Layout defines a visual structure of an Activity (or app widget). It may be considered as a set of rules according to which controls (buttons, text fields, input fields etc.) are placed on the View.
Layouts structure
Basically, user interface in Android apps is built using Layouts. Each Layout is a subclass of ViewGroup class, which derives from View class, which is the basic UI building block. View is the base class for buttons, text fields etc., more precisely: for widgets (don’t confuse it with app widgets you place on your Android screen  ).
The following diagram presents this hierarchy based on RelativeLayout:

Let’s now see what are the most important Layout Types. Below each screenshot used to present a particular Layout Type you can find its source, which leads to a tutorial or more detailed explanation on how to work with it.
Linear Layout
LinearLayout is the most basic type of Layout. When Android app is created in Visual Studio 2017, its MainActivity has by default LinearLayout set:

This type of Layout enforces you to put your controls in a linear direction, either horizontally or vertically:

Relative Layout
RelativeLayout enforces to display elements in relations to each other. You can specify that, for instance, one UI element can be said to be placed on the left of another element, or on the bottom of another etc. Each UI element can also be positioned according to the layout’s borders (e.g. aligned to the right):

RelativeLayout is very powerful. Consider that for building mobile apps’ interfaces these can be run on multiple devices with different screens’ resolutions. RelativeLayout allows (if properly built, of course) to adjust your set of controls easily to almost every type of screen. It’s quite specific and I personally found it difficult to understand and use initially, but it seems to be worth it.
Table Layout
As its name suggests, TableLayout allows to group elements into rows and columns:

May be useful when displaying some statistics or reports.
Grid View
GridView displays items in two-dimensional grid. The list can be easily scrolled. This type of Layout is often used on screens displaying photos or similar sets of “blocks” to click:

Tab Layout
Tabbed layouts allow to introduce tabs in our Android application. Then, a single Activity may contain several tabs and user can easily switch between them. On each tab you can use different type of Layout.
Consider that tabs design has changed between Android 2.X and 4.X:

List View
ListView allows to display a list of items. It may be used in multiple places, from short lists of menu options to long list of emails or news feed. It allows to easily and quickly present a list of items:

I used it in MoneyBack for displaying a very simple list of people from the database. You can check how it’s done in this public Gist (there is even no AXML layout file for it, it’s just an Activity class).
However, Android and Xamarin teams recommend to use RecyclerView for new apps development, which is said to be more advanced and flexible version of ListView. I just noticed it seems to be a bit more complex to set up. You can check more details here.
Summary
We’ve explored some basic Layout Types that can be used for grouping UI elements in Android application. Remember that all types of layouts we’ve gone through may be nested into each other (as we’ve seen for tabs – you can use tabbed layout and then in each tab “nest” any other type of layout).
It may seem to be a bit strict, that we shouldn’t just put the controls whatever we’d like to (as we are used to do in WinForms, for example  ), but mobile development requires such restrictions.
Especially building for Android – as for September 2015, there were 1.5 billion registered devices running Android system. This implies thousands of different screens resolutions, which must be handled by the UI of our apps.
What types of Layouts do you use the most in your Android apps? Do you have any best practices using them ? Share your knowledge! 
The post Android Layout Types appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/android-layout-types/feed/
			1
		
		
		1695	
		
		
		https://www.codejourney.net/xamarin-android-intents/
					https://www.codejourney.net/xamarin-android-intents/#respond
		
		
		Sat, 01 Apr 2017 10:19:59 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=1499

					We’ve already seen what are Activities, the most basic pieces of every Android app and today’s topic is associated with it. We’re going to see how to communicate between Activities (or Application Blocks) using Intents. Android Application Blocks Android apps are composed of Application Blocks, which are special kind of Android classes consisting several elements bundled together,…

The post Xamarin – Android Intents appeared first on CodeJourney.net.
]]>
										We’ve already seen what are Activities, the most basic pieces of every Android app and today’s topic is associated with it. We’re going to see how to communicate between Activities (or Application Blocks) using Intents.


Android Application Blocks
Android apps are composed of Application Blocks, which are special kind of Android classes consisting several elements bundled together, including:

Activities
Services
Resources (images, themes, classes)

Everything that comes in such package is coordinated by AndroidManifest.XML file. Especially, in this XML file (or by using various attributes on Activity class) it’s possible to register our Application Block to be “callable” by the others.
We’ll see more details in a while, but generally your app block is “callable” when it can be used by the other apps – probably you’ve already seen Application Chooser screen on your Android phone, e.g. when you wanted to open downloaded movie and the system asked you which video player you want to use. The same can be done with your own app – if you’re developing a dialer app, you can register it to be callable for ACTION_DIAL Activity Action. Then, as soon as any other app uses Intent to make a phone call (which we’ll see in this post), Application Chooser appears and your app will be one of the possible ones to use for making this phone call.
What is an Intent ?
Android system is designed to be loosely-coupled. Moreover, there is a principle of least privilege introduced in system’s architecture. It means that each app has access only to Blocks which it requires to work. Different Blocks don’t know much about each other (even if defined within the same application). Here’s where an Intent comes into play. Application Blocks use Intents to asynchronously communicate with each other.


In general, you can think of an Intent literally – it’s the intent (or a will) to do something. By sending Intents between different components, we can coordinate complex actions such as launching email app to send a message, using Location for obtaining user’s coordinates or navigating between application’s screens.
For me, we can think of Intents and their usage from two perspectives:

Intent as an intent – a will to do something. In this case, you use Intent to execute some action. When creating a new Intent you need to tell it what you want to do and give it necessary parameters for such operation (e.g. for send email action, you need to provide email address parameter)
Intent as a message – bidirectional information having sender, recipient and potentially some content. This can be for instance navigating to a new screen (Activity), where sender is the original Activity, recipient is the destination Activity to be opened and the content may consist some parameters to pass between two screens.

We’ll now see those two approaches in details.
Intent as an intent
In order to trigger another (external) action, e.g. camera recording or email sending, we can create an Intent and start a new Activity. Let’s see it by the example I implemented in MoneyBack – I added an additional ListActivity (PeopleListActivity class) which is the list of people added to app’s database. When a person on the list is clicked, I create an Intent in order to call his/her phone number as the following code presents:








  





  private void ListView_ItemClick(object sender, AdapterView.ItemClickEventArgs e)



  {



      var person = _peopleList[e.Position];








      var uri = Android.Net.Uri.Parse("tel:" + person.PhoneNumber);








      var intent = new Intent(Intent.ActionDial, uri);








      StartActivity(intent);



  }






        view raw

        

          PeopleListActivity_clicking.cs

        

        hosted with ❤ by GitHub
      


What those 4 lines of code do, is when tapping an entry from the list:

it opens the phone dialer app with selected person’s phone number to call:

NOTE: If I had more than one dialer app installed (if the other dialer app has itself registered as receiver for ACTION_DIAL, of course) Android would ask me to choose which app I want to use.

How did that happen? First actually interesting line of code is the following one:
var intent = new Intent(Intent.ActionDial, uri);
It creates a new Intent, giving to it – as we said in the previous paragraph – two things:

what we want to do – it this case, we set action to Intent.ActionDial, which corresponds to ACTION_DIAL Activity Action
operation’s parameters – in our case there is just one parameter, which is the phone number in URI format

For each type of Activity Action you want to trigger, you can find what parameters it needs in official Android Documentation.
In the end, we just need to finally start a new Activity with the Intent we just created:
StartActivity(intent);
and we’re all done.
Intent as a message
Now, let’s think about our app as a set of Activities, which are loosly-coopled. We have MainActivity class, which represents the main screen of our app. We’ve also built another Activity, which we want to open from the main one. In that case, we already see everything which fits into intent-as-a-message template – two Activities want to “talk” with each other.
In MoneyBack I changed the MainActivity to look as follows:

When clicking on “People Management” button, I’d like another Activity (represented by PeopleActivity class) to open.
In order to achieve that, MoneyBack executes the following code when clicking on the button:








  





  private void _btnPeople_Click(object sender, EventArgs e)



  {



      var intent = new Intent(this, typeof(PeopleActivity));



      StartActivity(intent);



  }






        view raw

        

          MainActivity_peopleManagementClick.cs

        

        hosted with ❤ by GitHub
      


What you can see here, is that we create a new Intent that takes two parameters:

Context – being the class storing information about current application’s/Activity’s state, from the place where the Intent is created; in our case, we set it to this, which is the calling Activity class reference. Context is our message’s sender
Type – this is our message’s recipient; in our case it’s the Type of destination Activity we want to start (PeopleActivity)

NOTE: Notice that we have no content provided in that case.

Then we just start the Activity as in the previous example and another screen appears:

If the back button is now pressed, it goes back to previous (calling) Activity. That’s how the Activities stack is built, by the way 
Passing additional content using Intent as a message
I mentioned we can also pass some additional data (message’s content) within an Intent. In the above example we didn’t do it, because there is no sense to pass anything from MainActivity to PeopleActivity for now. However, if we’d like to do that, we can add a simple modification to button’s pressing code in MainActivity:








  





  private void _btnPeople_Click(object sender, EventArgs e)



  {



      var intent = new Intent(this, typeof(PeopleActivity));








      var msgContent = "Hello! This is a secret sent from MainActivity! Don't tell anyone!";



      intent.PutExtra("secret_message", msgContent);








      StartActivity(intent);



  }






        view raw

        

          MainActivity_peopleManagementClick_msg.cs

        

        hosted with ❤ by GitHub
      


As you see, I used PutExtra method of the Intent class to insert msgContent into Intent’s simple key-value Bundle Dictionary called Extras, using “secret_message” string as a key. Then, in the destination Activity’s OnCreate method we can retrieve such value back using Intent.Extras.GetString (for String data type) method:

This kind of data-passing between Activities using Intent.Extras should be used only for simple, mostly key-value data transferring. There are other methods for passing/storing more complex data in an app or between different applications.
Summary
Today we’ve seen what is an Intent, how to use it to trigger external actions such as calling a phone number, sending email etc., but also how to use it to handle navigation between Activities. We’ve also passed key-value data between two Activities using Intent.Extras.
Intent, as well as Activity, is one of the fundamental concepts of Android. It’s essential to know how Intents work, how they relate to Activities, Services (which we’ll also cover one day) and Application Blocks.  I hope you’ll find it useful 
The post Xamarin – Android Intents appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/xamarin-android-intents/feed/
			0
		
		
		1499	
		
		
		https://www.codejourney.net/unit-testing-xamarin-application/
					https://www.codejourney.net/unit-testing-xamarin-application/#respond
		
		
		Sat, 25 Mar 2017 23:07:19 +0000
				
		
		
		
		
		
		http://www.dsibinski.pl/?p=1166

					Today we’ll see how to add unit tests to Xamarin Android application, testing both platform-independent logic and Android-specific features. Issue with unit tests in Visual Studio 2017 When I started to create my data access methods in MoneyBack, I really wanted to start writing even some basic unit tests of that logic. My first trial was to…

The post Unit Testing Xamarin application appeared first on CodeJourney.net.
]]>
										Today we’ll see how to add unit tests to Xamarin Android application, testing both platform-independent logic and Android-specific features.


Issue with unit tests in Visual Studio 2017
When I started to create my data access methods in MoneyBack, I really wanted to start writing even some basic unit tests of that logic.
My first trial was to add a new project to my solution which contains unit tests. So I checked what kind of projects templates I have available and I I found Unit Test App (Android) project template and added it to my solution. Generated project contained TestsSample class with some unit-looking tests methods, but I had no idea how to execute them. With ReSharper installed, I didn’t have any “Run Tests” option on this project. I read somewhere on the web that this project type is used to execute tests on the device, but I couldn’t figure out how to do it. I gave up.
Then I found another project template – Class Library (Android) with nUnit. Sounds better, nUnit in the name suggests unit tests, so I added this project to my solution. This time when right-clicking the project I had “Run Tests” option, but when clicking on it I got the following exception coming from ReSharper:

“Hmm… Visual Studio 2017”, I thought. “Some bugs for sure”. And I…
… didn’t give up this time and with some help of folks from StackOverflow I figured out how unit tests should be done in Xamarin app. Let’s see that in the next chapters.
Levels of testing Xamarin application
There are basically three “levels” of testing Xamarin apps:

Classic unit tests of pure .NET/Mono

standard, good old unit tests of logic independent from targeting platform (Xamarin.Android/iOS/Windows Phone)
unit-testing frameworks can be used (nUnit / xUnit)


Platform-specific tests

unit tests of functionalities specific to targeting platform (e.g. Bluetooth, Location, GPS, SMS etc.)
specific for each platform
don’t contain GUI tests
executed on the emulator/device


UI tests

tests of UI elements of the app and how those react for input (touch) events
executed by cloud/testing lab services (local or remote)



We’ll dive into the first two, UI tests is more complex topic, which requires setting up tests lab or using cloud testing services. For small projects, in the beginning it’s not necessary.
Classic platform-independent unit tests
In order to simply use ReSharper for executing unit tests of logic, which is independent from Android/iOS/Windows Phone, there is a need to add a new project using template Unit Test Project (.NET Framework) to our Xamarin solution.
To such project, you can add your favourite unit-testing framework (such as nUnit or xUnit) by simply installing it from Nuget.  After, ReSharper allows to run your unit tests as in old good times:

The exception I was getting with ReSharper previously was because I added the project using template Class Library (Android) which has its target set to Android device/emulator. ReSharper doesn’t know about any Android-specific (or Xamarin-specific) testing, so it was displaying unhandled error.
Platform-specific unit tests
In order to test platform-specific (in out case Android-specific) functionalities of your application, the tests need targeting runtime environment to run. It means they need to be executed on the physical device or emulator. Providers of the most popular unit-testing frameworks created wrappers for on-device testing. I’m using NUnit Xamarin Runners.
First of all, a new project should be added to our solution. To make things easier, download NUnit Templates for Visual Studio (although it officially supports VS up to 2015, it also works in VS 2017) and install it. After, add new project using appropriate template – I chose NUnit 3 Test Project (Android). What’s interesting, the newly created project contains MainActivity class with the following content:








  





  public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsApplicationActivity



  {



      protected override void OnCreate(Bundle savedInstanceState)



      {



          base.OnCreate(savedInstanceState);








          global::Xamarin.Forms.Forms.Init(this, savedInstanceState);








          // This will load all tests within the current project



          var nunit = new NUnit.Runner.App();








          // If you want to add tests in another assembly



          //nunit.AddTestAssembly(typeof(MyTests).Assembly);








          // Do you want to automatically run tests when the app starts?



          nunit.AutoRun = true;








          LoadApplication(nunit);



      }



  }






        view raw

        

          MainActivity_Tests.cs

        

        hosted with ❤ by GitHub
      


As you can see, this is an Activity, so it will be launched as a separate app with its own GUI. It’s built using Xamarin.Forms. The comments in auto-generated class are obvious, so I won’t explain the details here. That’s just what nUnit wrapper for Android on-device tests does – it allows to be run as a separate, small application with a GUI allowing to run unit tests directly on the device (similarly to ReSharper tests runner we use directly in Visual Studio).
One testable piece of MoneyBack application is the Repository used for database operations (by the way I refactored and made it generic, you can see how it looks currently on GitHub), so I added RepositoryTests class to MoneyBack.Android.Tests project with two test methods:








  





[Test]



public void one_new_person_inserted_adds_one_new_row()



{



    // given



    var person = new Person()



    {



        Name = "A",



        LastName = "B"



    };








    var repo = new Repository<Person>(InMemorySqliteConnection);








    // when



    var numRows = repo.Insert(person).Result;








    // then



    Assert.AreEqual(1, numRows);



}








[Test]



public void new_person_added_has_id_primarykey_generated()



{



    // given



    var person1 = new Person



    {



        Name = "A",



        LastName = "B"



    };








    var person2 = new Person



    {



        Name = "A",



        LastName = "B"



    };








    var repo = new Repository<Person>(InMemorySqliteConnection);








    // when



    var n1 = repo.Insert(person1).Result; // getting Result in order to force Task's completion before continuing



    var n2 = repo.Insert(person2).Result;








    // then



    Assert.Greater(person1.Id, 0);



    Assert.AreEqual(person2.Id, person1.Id + 1);



}






        view raw

        

          RepositoryTests_methods.cs

        

        hosted with ❤ by GitHub
      


The interesting part is that as I’m using SQLite database in my app, I wanted to test it without creating database file on the device. For that purpose, when creating SQLiteAsyncConnection in order to initialize my Repository, I passed to its constructor a “:memory:” string, which makes SQLite database created in-memory (there is no physical file created):








  





  public SQLiteAsyncConnection InMemorySqliteConnection;








  [OneTimeSetUp]



  public void Init()



  {



      InMemorySqliteConnection = new SQLiteAsyncConnection(":memory:");



  }






        view raw

        

          RepositoryTests_sqlite.cs

        

        hosted with ❤ by GitHub
      


 
Such database lives in device’s memory only for the time of our unit tests.
After having tests written, there’s a time to execute them. As the project contains MainActivity class, we simply deploy and run it on a device/emulator, which presents the following view:

If any of our tests is not passed, we can see the failure’s details:

We can of course debug our units tests in Visual Studio. The GUI on the device also allows to re-run the tests and see results of all of them.
Summary
We’ve seen how to add two new projects to Xamarin solution: one containing platform-independent unit tests (old good ones), the other one testing Android-specific stuff which is run directly on the device or emulator.
For bigger and more “real” apps, UI testing would also be necessary. This however requires using some cloud testing lab or setting up your own testing environment. More details can be found here.
If you have any experience in testing Xamarin applications, share your insights/advices 
 
 
The post Unit Testing Xamarin application appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/unit-testing-xamarin-application/feed/
			0
		
		
		1166	
		
		
		https://www.codejourney.net/using-sqlite-database-in-xamarin-android/
					https://www.codejourney.net/using-sqlite-database-in-xamarin-android/#comments
		
		
		Sun, 19 Mar 2017 22:32:29 +0000
				
		
		
		
		
		
		http://www.dsibinski.pl/?p=970

					I started to define development tasks to be done within MoneyBack project in the coming days (maybe I’ll even publish my Trello board soon 🙂 ) and it turned out that each functionality the app is going to offer needs persistent storage (e.g. to store people, payments, events etc.). The obvious choice is the local database in which…

The post Using SQLite database in Xamarin.Android appeared first on CodeJourney.net.
]]>
										I started to define development tasks to be done within MoneyBack project in the coming days (maybe I’ll even publish my Trello board soon  ) and it turned out that each functionality the app is going to offer needs persistent storage (e.g. to store people, payments, events etc.). The obvious choice is the local database in which I could store my entities and application’s data.

In this post, I’d like to show you how quickly and easily SQLite database can be added and started to be used in Xamarin.Android project using SQLite.NET and Visual Studio 2017.


What is SQLite?
SQLite is an open-source database engine, which allows to store data in SQL structures. The whole database is stored in a single file, which makes it easily manageable on mobile devices. It’s lightweight, small and easily portable. It’s also prepared to work on multiple platforms.
There are some limitations in contrast to “classic” SQL database engines, including:

OUTER join syntax is not fully supported
for altering tables, only “RENAME” and “ADDCOLUMN” operations are available
writing to views is impossible (views are read-only).

SQLite database can be easily operated using SQLite.NET ORM library available to download and install via Nuget. Let’s see how to do it.
Installing SQLite.NET package
In order to install SQLite.NET package, simply open Android.Xamarin solution in Visual Studio, open Package Manager Console and type the following command:
install-package Sqlite-Net
After few seconds, two files are added to our project:

It means we’re all set 
Entity definition
We have SQLite ORM ready to use. Now we need to define our first entity. In case of MoneyBack, I decided to start with defining Person (plural: People) entity. First thing we need to do is to define entity class. I created “Entities” folder for that and added the following class file:








  





namespace MoneyBack.Entities



{



    [Table("People")]



    public class Person



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string Name { get; set; }








        public string LastName { get; set; }








        public string PhoneNumber { get; set; }








        public string Email { get; set; }








        public override string ToString()



        {



            return $"[Person: Id={Id}, Name={Name}, LastName={LastName}, PhoneNumber={PhoneNumber}, Email={Email}]";



        }



    }



}






        view raw

        

          Person.cs

        

        hosted with ❤ by GitHub
      


Just a class, in which we define basic properties of a Person – Name, LastName, PhoneNumber and Email. As we are designing a database entities, we also need to have keys for each of them – in this case we add Id property, and decorate it with two attributes:

PrimaryKeyAttribute – marks the column as PRIMARY KEY
AutoIncrementAttribute – marks the column with AUTO_INCREMENT (unique number is generated when a new record is added into a table).

We also have TableAttribute defined on Person class. This attribute’s constructor takes a single argument name, which is the name of the table which will be created underneath. In our case, single entity is called Person, but the table should be named in plural (table == set of entities) so we want it to be called People.
I also implemented ToString() method in order to be able to easily see details of our entity if needed.
Location of database file
Before database can be used, a database file must be created on the device. ORM does it for us before any query is made on the database, but we need to specify where we want to keep the db file. On Android, it can be stored either on internal or external storage.
I created Constants.cs class in which I put a read-only constant string returning path to database file. As a folder to store db file, I used Environment.GetFolderPath(Environment.SpecialFolder.Personal) which returns local path defined in Android system’s environmental variable $HOME:








  





public class Constants



{



    public static readonly string DbFilePath = 



        Path.Combine(



                Environment.GetFolderPath(Environment.SpecialFolder.Personal), 



                "moneyback.db"



        );



}






        view raw

        

          Constants_dbPath.cs

        

        hosted with ❤ by GitHub
      


Database access methods
As soon as we have entity class defined and location of database file, we can start performing operations on the db – define tables, add new entities (rows), retrieve rows from the database, delete them etc. In general, it comes down to creating SQLiteConnection object and performing operations on it.
There are several approaches of exposing Data Access Layer services/methods – we can create a database service, entities repository or use complex services location and dependency injection in order to operate our persistent data. I don’t know what is a standard way in Android applications, but I decided to create a very simple repository for our Person entity and expose database-access methods in it:








  





public class PeopleRepository



{



    private SQLiteConnection db = null;



    protected static PeopleRepository me;








    static PeopleRepository()



    {



        me = new PeopleRepository();



    }








    protected PeopleRepository()



    {



        db = new SQLiteConnection(Constants.DbFilePath);



        db.CreateTable<Person>();



    }








    public static int SavePerson(Person person)



    {



        me.db.Insert(person);



        return person.Id;



    }








    public static Person GetPerson(int id)



    {



        return me.db.Get<Person>(p => p.Id == id);



    }



}






        view raw

        

          PeopleRepository.cs

        

        hosted with ❤ by GitHub
      


I haven’t even created any abstract layer for the repository (e.g. interface), as I simply don’t know what approach I will use for the next entities. I’m not sure if the repository is the right choice. On the other hand, I don’t think such rather simple app requires something more. What do you think ?


As you can see, PeopleRepository executes its static constructor when any of static methods is called for the first time, in which it instantiates db variable of type SQLiteConnection, giving it the path to db file we defined. If database file doesn’t exist, it will be automatically created. Then, db.CreateTable<Person>() creates People table if it doesn’t exist, according to what we defined in Person entity model.
Two static methods – SavePerson and GetPerson allow to save and retrieve Person entity to/from the database accordingly. The first one is additionally returning the integer Id of newly added row.
Usage in the code
I added two text fields to MoneyBack app to enter name and last name of person to be added and one button which actually allows to perform saving operation:

On clicking the button, the following method is executed:








  





private void _btnAddPerson_Click(object sender, EventArgs e)



{



    var name = _inputName.Text;



    var lastName = _inputLastName.Text;








    var id = PeopleRepository.SavePerson(new Person



    {



        Name = name,



        LastName = lastName



    });








    var person = PeopleRepository.GetPerson(id);








    if (person == null)



        Toast.MakeText(this, $"Person: Name={name}, LastName={lastName} wasn't properly saved!", ToastLength.Long).Show();



    else



        Toast.MakeText(this, $"Person saved, details: {person}", ToastLength.Long).Show();








}






        view raw

        

          addPersonButtonClick.cs

        

        hosted with ❤ by GitHub
      


 
Here’s the result of clicking the button in the app:

As you can see, in the toast message received, Id of the Person added has value 3. That’s because when I launched the app previously I’ve already added two new people. It shows that the data is really persistently stored and doesn’t disappear when the app is restarted.
Summary
Today we’ve seen that using SQLite file database in Xamarin.Android is very easy. Thanks to SQLite.NET lightweight ORM library we were able to quickly start working with the db.
To make the code ready for “production” use, I should also make it thread-safe (more details e.g. here) and add unit tests (which I’m BTW not able to do for now, I’m getting TargetInvocationException when trying to run any NUnit tests adding Unit Test App (Android) project in VS 2017…).
I’m also not sure if repository is a proper concept for managing local db entities in Android project. If you have more experience, I’d be grateful to hear how it should be done in a really “Android way” 
The post Using SQLite database in Xamarin.Android appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/using-sqlite-database-in-xamarin-android/feed/
			7
		
		
		970	
		
		
		https://www.codejourney.net/xamarin-android-activities/
					https://www.codejourney.net/xamarin-android-activities/#comments
		
		
		Sat, 11 Mar 2017 18:53:10 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=405

					Today we’re going to take a look at Android’s most basic and in the same time most important concept, which is an Activity. To create even the simplest “HelloWorld” app one should know what are the Activities and how to work with them. What is an Activity ? The simplest, an Activity is a single…

The post Xamarin – Android Activities appeared first on CodeJourney.net.
]]>
										Today we’re going to take a look at Android’s most basic and in the same time most important concept, which is an Activity. To create even the simplest “HelloWorld” app one should know what are the Activities and how to work with them.


What is an Activity ?
The simplest, an Activity is a single screen in Android application. The concept of Activities is unusual in programming and it’s specific to Android platform.
Every Activity in Xamarin consists of two components:

UI (XML) – layout with user controls defined
Code (C#) – implementing the behavior

Let’s consider email client application – it’d probably have several Activities: “New email”, “List of emails”, “Email details”, “Settings” – notice all of them having both UI and behavior. We’d probably need “Email sending service”, which doesn’t necessarily need UI, so it wouldn’t be created as an Activity, but rather as a separate class realizing concrete task.
As we can already see, every Android app contains several Activities:

In most programming platforms, the application has a static method which is called on the application’s startup. This is not the case in Android – do you remember our MainActivity class from the previous post ? It’s decorated with ActivityAttribute which registers the Activity within the Android system, but what’s more important by having MainLauncher attribute’s property set to true it tells the system it’s the startup Activity for the application within which it’s registered. It means nothing more than when our app is launched, Android creates MainActivity as the first one from all Activities in our application. Apart from that, OS operates the MainActivity as all other Activities.
Activities Back Stack
Android app starts its own Activities from other Activities. It may also start Activities that are defined by different apps, e.g. your Android app can offer a possibility to send an email. You don’t have to implement your own email sending client for that – it’s possible to use already existing email sending Activities (using Android Intents, which we’ll also cover one day) registered within another apps installed in the system which expose such “external calling” possibility. Then, this external app launches looking as if it was the part of your application. This is very powerful!
When your email is finally sent, you are redirected back to your app from which you triggered email’s sending. How is that possible?


In order to ensure such way of functioning, Android keeps all the Activities needed to perform a certain job (even if they come from different apps) in the same task. The “scope” of a task (when new task is created, what Activities it contains etc.) depends, among others, on Android version (e.g. starting from Android 7.0 many apps can be started in multiple windows in the same time on a single screen – in that case, the system keeps a separate task for each window).
Within a particular task, several Activities are started. Each started Activity is pushed to the Activities Back Stack. The Activity being on the top of the stack has focus (is visible to the user). The previous Activities remain on the stack, but are stopped or even destroyed by Android system in certain cases (few more words about it in the next chapter).
Activities Back Stack is a LIFO objects structure: when user presses Back button the current Activity is popped from the top of the stack and the state of the previous Activity is restored. The following figure visualizes this behavior:

Android Activities Lifecycle
We already know the Activities are kept on Back Stack. We also need to know that Android OS may try to restart the application (after it crashed, for instance) at the last opened Activity. The OS may also pause the Activities when they’re not active or kill them when the device is low on memory. All those possible operations and states’ changes form Android Activities Lifecycle, which is a set of defined states in which every Activity may be:

Let’s see what those states mean:

Running – Activity is in the foreground (top of the activities stack); highest-priority Activity for OS
Paused – Activity is in this state when still visible, but covered by another non-full sized Activity or when the device enters sleep mode; second-highest-priority Activity for OS
Backgrounded/Stopped– Activity enters Backgrounded state when it’s overtaken by another, completely new Activity which is pushed on the top of the back stack; lowest-priority Activity for OS, which will be killed firstly in order to free resources
Restarted – this state is not visible on the diagram, however it’s possible that Android (e.g. user using task manager or similar app) kills the app being in any of above-mentioned states; if the user wants to go back to this Activity later, it must be restarted (previous state must be retrieved).

Handling states changes – lifecycle methods
Android (and Xamarin) provides SDK methods that are called by the OS each time an Activity’s state changes. Those methods may be overridden and implemented for each Activity in order to react on states changes and ensure application’s stability. The following diagram visualizes the dependencies and flow of methods being called:

Let’s see in what cases the particular methods should be implemented:

OnCreate() – called when an Activity is created; used for initializing views and variables
OnStart() – called immediately after OnCreate() finishes; UI refreshing can be handled here
OnResume() – called after OnStart() finishes and also when Activity is restarted after being paused
OnPause() – called when OS is about to pause or move the Activity to the background; here all resources-consuming objects should be cleaned-up, unsaved changes should be stored in some kind of persistent storage to be able to restore it when the Activity is revealed
OnStop() – called when the Activity stops being visible to the user or is destroyed (e.g. when OS needs to release some resources)
OnDestroy() – final method called on Activity just before it’s destroyed; it may not be called in some cases, so it’s better to clean-up resources in OnPause() and OnStop() methods.

Let’s see some code
In order to really test those lifecycle methods, I added a stunning functionality to MoneyBack app:

As you could already realize, you can enter amount of money spent, number of people involved and it will make a simple division operation to split the costs equally. That’s already kinda costs splitting, right ?! 
I implemented the lifecycle-control methods to check how it really behaves.
OnCreate








  





protected override void OnCreate(Bundle bundle)



{



    base.OnCreate(bundle);








    // Set our view from the "main" layout resource



    SetContentView(Resource.Layout.Main);








    _amount = 0.00m;



    _result = 0.00m;



    _numberOfPeople = 0;








    InitializeUserControls();



}








// …








private void InitializeUserControls()



{



    _inputAmount = this.FindViewById<EditText>(Resource.Id.inputAmount);



    _inputNumberOfPeople = this.FindViewById<EditText>(Resource.Id.inputNumberOfPeople);



    _txtResultDecimal = this.FindViewById<EditText>(Resource.Id.txtResultDecimal);



    _btnCalculate = this.FindViewById<Button>(Resource.Id.btnCalculate);



}






        view raw

        

          MainActivity_OnCreate.cs

        

        hosted with ❤ by GitHub
      


Here I only initialize my view from layout, Activity’s private variables and instantiate user controls. Nothing more for this simple example.
OnStart








  





protected override void OnStart()



{



    base.OnStart();



    RefreshUserInputsFromVariables();



}



// …



private void RefreshUserInputsFromVariables()



{



    _inputAmount.SetText(_amount.ToString(CultureInfo.InvariantCulture), TextView.BufferType.Editable);



    _txtResultDecimal.SetText(_result.ToString(CultureInfo.InvariantCulture), TextView.BufferType.Editable);



    _inputNumberOfPeople.SetText(_numberOfPeople.ToString(CultureInfo.InvariantCulture),



        TextView.BufferType.Editable);



}






        view raw

        

          MainActivity_OnStart.cs

        

        hosted with ❤ by GitHub
      


In OnStart() method I just refresh UI elements – in that case initialize their Text properties with values stored in private variables.
OnResume








  





protected override void OnResume()



{



    base.OnResume();



    InitializeUserControlsEvents();



    // TODO: retrieving variables (amount, number of people) from persistent storage (file, database)



}








// …



private void InitializeUserControlsEvents()



{



    _btnCalculate.Click += _btnCalculate_Click;



}






        view raw

        

          MainActivity_OnResume.cs

        

        hosted with ❤ by GitHub
      


As we know, OnResume method is called every time our Activity is brought to the top of Activities stack (either after OnCreate -> OnStart or when revealing it after being backgrounded). That’s a very good place to initialize dependencies to external services (e.g. open communication with DB or remote service). In my case, I just subscribed to Click events of the button. If I had any persistent storage present (for instance local DB) I would in this place retrieve recently saved values from it to my Activity’s variables to restore its state (OnResume might be called when Activity class’s state is already cleaned up).
OnPause








  





protected override void OnPause()



{



    base.OnPause();



    DetatchUserControlsEvents();



    // TODO: saving variables (amount, number of people) to persistent storage (file, database)



}



// …



private void DetatchUserControlsEvents()



{



    _btnCalculate.Click -= _btnCalculate_Click;



}






        view raw

        

          MainActivity_OnPause.cs

        

        hosted with ❤ by GitHub
      


In OnPause method I need to be consistent with what I do in OnResume – when my app is taken to the background, I don’t need to wait for my button’s click events anymore, so let’s detach from it (maybe button’s Click event is not the best example here, but it’s just to visualize the purpose of the method). When my app is resumed, we will subscribe to this event again. Again, if I had any persistent storage, I’d save all variables’ (which are necessary for restoring Activity’s state) values here to this storage, so they are able to be retrieved back as soon as OnResume is called.
OnStop & OnDestroy
I didn’t implement those two methods in my app, it’s too simple to need anything in those places.
I deployed the app, attached with debugger and checked the order of methods’ calls – all of them were called as described in previous paragraph.
Summary
It’s vital to understand how Android Activities and their states work. Even though it seems to be Android-specific, I’d rather say such approach is reasonable and even required by hardware on which mobile apps run (BTW, similar states seem to exist in iOS apps).
When building Android app we need to think about Activities, especially make sure that each Activity in our application properly implements necessary lifecycle methods.
Do you have or know any best practices while working with Activities and managing their lifecycle? I’d appreciate if you share it in the comments 
 
 
 
The post Xamarin – Android Activities appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/xamarin-android-activities/feed/
			3
		
		
		405	
		
		
		https://www.codejourney.net/hello-xamarin-world-first-steps/
					https://www.codejourney.net/hello-xamarin-world-first-steps/#respond
		
		
		Sat, 04 Mar 2017 23:12:14 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=244

					This time I want to say “Hello” to Xamarin world. First thing that needs to be done before starting Xamarin development, is obviously the installation of all necessary components. In this post I want to share my feelings about the installation (not without issues of course), configuration of my Xamarin Android solution and deployment process to…

The post Hello Xamarin World – first steps appeared first on CodeJourney.net.
]]>
										This time I want to say “Hello” to Xamarin world.

First thing that needs to be done before starting Xamarin development, is obviously the installation of all necessary components.
In this post I want to share my feelings about the installation (not without issues of course), configuration of my Xamarin Android solution and deployment process to the device.


Xamarin installation into Visual Studio 2015
I’ve created my account at xamarin.com, logged in and chose Download Xamarin for free to download the installation package. There are generally two IDEs that can be used for Xamarin development: Visual Studio or Xamarin Studio. I’ve already had VS 2015 installed and decided I don’t want to explore a new IDE, so I downloaded installer for Visual Studio. What’s more, following Xamarin’s website, “Xamarin Studio is no longer included” in the Windows installer and they “encourage Windows developers to move to Visual Studio”. Well, that’s understandable, Microsoft acquired Xamarin, didn’t they? 😉
BTW, when downloading Xamarin I was obliged to fill the “Company” field – does anyone know why is that?
 Android SDK and emulator images size
Interesting parts of the installation (if there could by any at all?) are Android Emulator installation which is then integrated into Visual Studio as well as Android SDK installation – fortunately it’s possible to change the location of Android SDK installation, because right after the setup it takes an enormous amount of disk space (with mandatory tools mentioned in the installation guide and two Android APIs):

I’ve examined a bit more and it turns out that system images take the most of this space. Those are used only by emulators to be able to create a virtual device and debug on a simulator instead of deploying the app to a physical device every rime.
When I used to write some Android apps in Java and Android Studio long time ago, I found it very hard and complex to debug/test anything using emulator – it was simply very, very slow to load and work. This time I’ll see if emulator built in Visual Studio will do the job – if yes, why not using it ? I will of course also deploy directly to the device for tests, but it also takes time. I remember that when I wanted to test some small adjustments done “on the fly” (e.g. UI modifications/alignments) I dreamt about doing it quicker then deploying app to the phone every time. We’ll see, if emulator won’t do the job – I will clean up those folders.
 First issue in DSP
I had to create a separate paragraph for that 🙂 Of course, it must have finally happened – first issue on my DSP way! Installation error, of course – “Installation of ‘Xamarin’ failed with more then one exception (attempt 3). It was not possible to complete an automatic installation.”


I expected the installation to terminate and evening spent on looking for a solution, exploring StackOverflow threads, but to my surprise a quite familiar-looking screen appeared explaining what to do next, i.e. how to install all the components manually. I had to download and install Java JDK, Android SDK and Xamarin.
After the next 30 minutes everything seemed to be installed. Just two last configuration steps in Visual Studio as described here. Finally, to be able to run Android emulator Android Virtual Device Manager needs to be configured, as this tutorial describes.
Android Solution Creation
I cloned my Git repository, opened Visual Studio and created MoneyBack solution 😉 I chose the project of type Blank App (Android). Here’s what VS produced:

Android Xamarin solution contains the following elements out-of-the-box:

Properties – here AssemblyInfo.cs is probably well-known to all .NET developers (for the others: this file is .NET assembly’s metadata file, containing basic data about our application, like its name, version, company etc.), but there is also AndroidManifest.xml, which contains details and requirements for Android application, e.g. app’s name, supported SDKs versions numbers and required permissions for which the end user is asked when installing the app
References – contains other assemblies required for the application to build; in case of Xamarin Android solution, it references both .NET assemblies like System or System.Core and Mono.Android assembly
Components – stores Xamarin development packages that can be retrieved from Components Store (something like Xamarin-specific Nuget, I guess 😉 )
Assets – allows to store additional files needed by the app (e.g. text files) available easily from the code
Resources – contains strings, images and layouts of the application

MainActivity
Apart from above-mentioned folders, solution contains an Activity class (MainActivity.cs) which is decorated with ActivityAttribute:
[Activity(Label = "MoneyBack", MainLauncher = true, Icon = "@drawable/icon")]
We’ll get into details of activities soon. For now, let’s just assume that:
MainLauncher = true
means that this class is the starting point of the application. It contains only one method:
protected override void OnCreate(Bundle bundle)
{
   base.OnCreate(bundle);

   // Set our view from the "main" layout resource
   SetContentView (Resource.Layout.Main);

}
Again, we’ll dive into Android activity’s lifecycle very soon, but we can already imagine that “OnCreate” method is called when the activity is created.
MoneyBack on the phone
I plugged my Huawei P8 to the laptop, hit F5 and hoped to see my app running on the device. Instead, two components were installed first as separate apps – Mono Shared Runtime and Xamarin.Android API-25. Those two are used in debug build mode to allow debugging stuff. It would be fine if I didn’t have to re-plug my phone after installation of each of these two, as phone was doing nothing after.
 Finally,  MoneyBack appeared on Huawei’s screen with sad, black empty canvas. I added some well-known sentence to become a real Xamarin-newbie:

MoneyBack on the emulator
I couldn’t initially manage to deploy my application to Android Emulator device. I tried creating few emulator devices – firstly I had issues with very strange resolution on the emulated device, then I created another one and when I tried to deploy on it I got an error saying “2>Emulator is not ready to be used”. What I came up to is creating new Android Emulator Device, trying to start it (without deployment) and having “android” text on the device’s screen for the last 20 minutes. Then I found this emulation acceleration guide, so I installed HAXM and it helped A LOT. Emulator is now starting within 30 seconds and I managed to deploy my app on it. Cool.
Summary
Automatic installation of Xamarin on Windows with Visual Studio didn’t work, so I had to install all the packages manually, however it wasn’t problematic. Deployment to the phone was OK, but the installation of two additional components (Mono Shared Runtime and Xamarin.Android API) forced me to re-plug the device twice. I hope I won’t have this case very often, because if every deployment looks like that I’ll never finish this app…
I recommend everyone who wants to work with Android device emulator installing HAXM – it really boosts the emulation.



Get ready for a deep dive into Xamarin soon 😎



 
The post Hello Xamarin World – first steps appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/hello-xamarin-world-first-steps/feed/
			0
		
		
		244