Time to sum it up!

General feelings

Today I can definitely say I feel proud of myself Even though I could have made some of my posts published during the competition better. Even though I could have made my MoneyBack app developed during the project faaaaar more advanced.

I already wrote in the beginning of the competition, that for me neither completing the application nor becoming a perfect blogger with thousands of readers was the point here. The real goal was to arrive to the end, meet the competition’s requirements and feel proud at the end of this story – and this is undoubtedly how I feel now

Statistics

I’d like to shortly presents a few interesting statistics concerning the content I produced during the 3 months of the competition (March-May 2017):

• I wrote 21 competition’s posts (including 1 published in February, so not really counted)
• I checked-in (added, changed or removed) 19,381 lines of code (including auto-generated parts)
• top-viewed post: Simple habits for better productivity with ~2600 views for the time of writing this post
• best-ever number of daily blog’s views: 2121 views on 28.05.2017
• top referrers: Reddit with 613 views, dotnetomaniak.pl with 603 views, Google Search with 365 views
• most views from: United States (1503), Poland (1418), United Kingdom (274)
• 33 comments added in total on the published blog posts.

What was good

I have listed several aspects of taking part in DSP competition that I feel especially good about. These include achieved goals, as well as some activities I wanted to begin doing since a piece of time.

(+) Blogging

Starting a technical blog is one of my best achievements in the competition. It showed me that I really like to publish my insights, share my knowledge with the others and just write solutions to precise issues I’ve met here. Even during those 3 months I referred back to the posts I’ve wrote few weeks ago when I needed to refresh something I already did. Writing a blog post about something, which is public and read by other people (in many cases more experienced programmers) enforces the writer to organize and collect the knowledge he or she is willing to share. This helps making self-learning process really solid and more effective.

(+) Learning mobile development with Xamarin

For a piece of time already I’ve wanted to start mobile development with Xamarin platform. Maybe I haven’t arrived to deeply advanced development stuff, but I definitely learnt the basics of Xamarin and implementing Android apps using it. I was able do it with my daily-used C#, so there was no big entry threshold here, even with many really frustrating issues met on my “Xamarin way” which I’ve been sharing with you here

(+) Open-source contribution

I had an opportunity to publish my source code on public GitHub repository, so other people can potentially see and make a use of it.  I really love the idea of open-source, so it was another nice experience. I even found out that each public repository should have a license file added to be considered “really open-source”

(+) Reading other participants’ blogs

During my DSP adventure I’ve been reading many blog posts published by the other competition’s members. I’d even say that I’ve never read that many posts from different authors in such short period of time. It allowed me to see different writing styles and get the knowledge about various kinds of technologies I had never worked with.

(+) Learning, learning, learning…

Basically – I learn maaaany things during the competition. Starting from technical stuff about Xamarin, through writing a blog, configuring and setting-up WordPress, promoting myself on Twitter, Facebook, LinkedIn or Reddit to gaining a lot of knowledge by reading another blog posts on totally various topics. Those 3 months definitely generated a lot of valuable knowledge of different kinds in my head.

What was bad

Of course I also have few aspects of my activity during the competition that I consider as done in a wrong way. I’m also putting here few things that made me frustrated during the competition and wasn’t even my personal mistakes.

(-) Wrong planning

The most basic mistake I’ve made (and I make it in many aspects of my life, as many of us, probably ) was a wrong planning. I wanted to write it was too ambitious, but it’s not even really the case. In the beginning of the competition I should have made a long-perspective planning (what parts of my app should be completed until what date, how many posts should I publish each week/month etc). It would probably help me to do more and eliminate lack of time I’ve met during the contest.

(-) Irregularity in posts’ publishing

I know that I was publishing my posts totally irregularly, sometimes at late hours when everyone potentially interested was already sleeping I also didn’t establish any constant days on which posts on my blog were to be published. This was wrong. It’s another consequence of wrong planning.

(-) Not promoting the blog enough

In general, promotion of my blog posts boiled down to publishing the URLs on Twitter, Facebook and LinkedIn. By the end of DSP I realized the power of Reddit – it’s really worth thinking about promoting good content we produce there. I also could have been more involved in DSP channel on Devs PL Slack – many interesting discussions were held there and people got to know each other

(-) Too long blog posts

During few weeks in those 3 last months, I had really limited time to work on my DSP project – especially when it came to publishing a blog post, which was a mandatory requirement. Sometimes I really felt this is a mandatory requirement, not a pleasure. However, if I’d have written shorter blog posts, but maybe with a bit less of content, I wouldn’t have such feeling. When writing my posts I was many times starting a post with “In this short post (…)” and then, after 1 or 2 hours writing it, I came back to the introduction in order to remove the “short” word from it

(-) Fighting with “machines”

That’s the part I surely never enjoy about the programming – fighting with weird, unknown issues met during development. Few weeks during the last 3 months were really hard in terms of time for the competition’s tasks, but some were really loose during which I was initially highly motivated to make a significant progress in development of MoneyBack app. However, then I was encountering mysterious problems with Xamarin, Visual Studio and other things which only made me really frustrated and burnt out all the motivation I’ve had. There are some positive aspects of it – for instance creating and self-answering a StackOverflow’s thread which really bumped my statistics on that portal

What I would change the next time

If I take part in the competition again (next year, maybe? ), I’d obviously try to get rid of all above-mentioned bad aspects of my work. The must-dos for the next time are:

• plan the work from the beginning to the end of the competition (set concrete, long-perspective deadlines)
• publish tasks list (like Trello board) in the beginning on the project so the deadlines set are “promised” publicly
• set-up fixed days and times during the week when blog posts are published (use WordPress’s automatic delayed publishing)
• write shorter blog posts that can be read in ~5 minutes with less, but more decent content
• before using a particular solution for an issue, better examine the other possibilities, i.e. don’t choose to use the UI component firstly found in Xamarin docs (which are not always very good quality) – explore the other blog posts on that topic and see what other people used.

Summary – so what’s next?

For sure I will still work on MoneyBack project. You can follow the progress on its GitHub repository. It’s a great app for pet-project which I was missing before.

Of course, I will also run this blog as I really enjoy sharing my knowledge here, both for the others and for myself to be able to refer back to it after some time.

I’d like to congratulate all DajSiePoznac2017’s participants for your endurance and the commitment we all did to both open-source world and programming blogosphere. I wish you all the best of luck in voting for the best DSP blog/project. Hopefully see you on 17.06.2017 in Warsaw on the official closing of the competition

I also want to say thank you to Daga who supported me in my way throughout the competition and many evenings spent on writing blog posts or programming

I’m also very grateful to all blog’s readers and supporters who left any feedback or comments here – your insights were very helpful!

See ya!

The post DajSiePoznac2017 – summary 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/moneyback-3-weeks-before-the-end-of-dsp/
					https://www.codejourney.net/moneyback-3-weeks-before-the-end-of-dsp/#respond
		
		
		Tue, 09 May 2017 22:09:45 +0000
				
		
		
		
		
		
		http://www.dsibinski.pl/?p=2192

					In today’s post I’d like to present what’s the current status of works on MoneyBack application, 3 weeks before the end of DSP competition. In general, the project hasn’t been going as well as I expected and is currently not as advanced as I’d expect it to be at this stage. There are many reasons behind that,…

The post MoneyBack – 3 weeks before the end of DSP appeared first on CodeJourney.net.
]]>
										In today’s post I’d like to present what’s the current status of works on MoneyBack application, 3 weeks before the end of DSP competition.


In general, the project hasn’t been going as well as I expected and is currently not as advanced as I’d expect it to be at this stage. There are many reasons behind that, including lack of time recently and many issues met during development, however, as I already wrote in my DSP introducing post, the most important is to survive with the project to the end of the competition and meet all requirements. The end of DSP doesn’t equal the end of MoneyBack 
That’s why in this post I’d like to show you how the project looks currently and what’s still to be done. Moreover, as I promised before, I’m publishing my Trello board with tasks still to be done within the project.
UI changes
For the last days working on the project I’ve been trying to make the UI of MoneyBack some kind of “final” version, so I can easily extend it adding new functionalities and focus on development instead of spending time on interface design, which is not important for me at the moment. I met many issues with that, which I think came from using some deprecated UI elements I used (e.g. ListView and Adapters) that are not fully-supported in the newest versions of Android. Tutorials are also not really up-to-date for those components. Maybe that’s also because when I wanted to implement displaying a list of entities I looked in Google for something like “xamarin android list of elements” which lead me to this ListView and Adapters tutorial. Instead of firstly reading the whole User Interface tutorial, I wanted to implement displaying the list quickly, so I used those deprecated elements instead of implementing for instance newer and recommended RecyclerView from the beginning, which would be easier extensible now. That definitely teaches me that I should get to know a particular topic/area better and wider before deciding to use one of the possible solutions to solve a problem. Sometimes we want to implement something particular quickly, but later it produces more issues than benefits.
Finally I added tabs (only one tab for People for now, but it will be easy to add new ones now) and ActionBar menu on the main Activity of the app:

On the screenshot above, in the right-upper corner there is “Add” button visible when clicking on ActionBar menu. It opens a new person’s adding screen, on which I made name and email fields mandatory:

People added are then displayed on the main screen of the app in “People” tab:

Code – interesting parts
Using tabs layout in an Activity
It turned out that using tabs-like layout in the Activity is pretty easy. In the AXML layout file for MainActivity I just added a FrameLayout container, within which the tabs and their contents are to be displayed:








  





<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"



    android:orientation="vertical"



    android:layout_width="match_parent"



    android:layout_height="match_parent"



    android:minWidth="25px"



    android:minHeight="25px">



    <FrameLayout



        android:minWidth="25px"



        android:minHeight="25px"



        android:layout_width="match_parent"



        android:layout_height="match_parent"



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



</LinearLayout>






        view raw

        

          Main.axml

        

        hosted with ❤ by GitHub
      


I called it tabFragmentsContainer, because within each tab we will display a Fragment. Fragment represents a part of UI and/or behavior, which is displayed within an Activity. You can think of Fragments as smaller pieces, that can be placed onto (inside) Activities.
Basically, I changed PeopleListActivity to PeopleListFragment, which in fact only required changing inheritance from being a child of Activity to inheriting from ListFragment (which is a special kind of Fragment used for displaying lists of elements). The complete code of PeopleListFragment can be found in this public Gist.
In the end, making MainActivity displaying tabs requires setting its ActionBar’s navigation mode to ActionBarNavigationMode.Tabs:
this.ActionBar.NavigationMode = ActionBarNavigationMode.Tabs;
and adding as many tabs as you wish, using for instance code similar to the following one:








  





void AddTab(string tabText, Fragment view)



{



    var tab = this.ActionBar.NewTab();



    tab.SetText(tabText);








    tab.TabSelected += delegate (object sender, ActionBar.TabEventArgs e)



    {



        var fragment = this.FragmentManager.FindFragmentById(Resource.Id.tabFragmentsContainer);



        if (fragment != null)



            e.FragmentTransaction.Remove(fragment);



        e.FragmentTransaction.Add(Resource.Id.tabFragmentsContainer, view);



    };



    tab.TabUnselected += delegate (object sender, ActionBar.TabEventArgs e) {



        e.FragmentTransaction.Remove(view);



    };








    this.ActionBar.AddTab(tab);



}






        view raw

        

          MainActivity_AddTab.cs

        

        hosted with ❤ by GitHub
      


The arguments are name of the tab and an instance of a Fragment we want to have displayed in this tab (PeopleListFragment‘s instance in our case).
Lines 6-12 present what happens when the tab is selected by the user – Fragment‘s instance is added to previously defined tabFragmentsContainer.
Lines 13-15 define callback method on tab deselection – Fragment is removed from the container.
Adding ActionBar with menu to the Activity
Addition of ActionBar with menu button in right-upper corner of the Activity requires creating an XML view in Resources/menu folder first (with one button in our case):








  





<menu xmlns:android="http://schemas.android.com/apk/res/android">



  <item android:id="@+id/menuAdd"



        android:title="@string/menuAddTitle"/>



</menu>






        view raw

        

          ActionBarMenu.xml

        

        hosted with ❤ by GitHub
      


and then in the Activity considered overriding OnCreateOptionsMenu method inflating ActionBar’s menu using created view:








  





public override bool OnCreateOptionsMenu(IMenu menu)



{



    MenuInflater.Inflate(Resource.Menu.ActionBarMenu, menu);



    return base.OnPrepareOptionsMenu(menu);



}






        view raw

        

          MainActivity_OnCreateOptionsMenu.cs

        

        hosted with ❤ by GitHub
      


We also need to define what happens when a menu option is selected. For that purpose, override OnOptionsItemSelected method:








  





public override bool OnOptionsItemSelected(IMenuItem item)



{



    if (item.ItemId == Resource.Id.menuAdd)



    {



        OpenAddingNewPerson();



        return true;



    }








    return base.OnOptionsItemSelected(item);



}






        view raw

        

          MainActivity_OnOptionsItemSelected.cs

        

        hosted with ❤ by GitHub
      


Next coding tasks
From now on you can watch my public Trello board, where I have all tasks to be done in the nearest future in MoneyBack defined. I will try to define deadlines for those tasks as well.
At the moment of writing this post, I’ve started adding a possibility to create Events. I will need to keep many-to-many relationship between Person and Event entities and I will probably use SQLite-Net Extensions library for that. You can expect a separate post about defining relationships using this library soon 
Other tasks left to be done
Apart from coding and developing the project, I still need to fulfill the DSP competition’s requirements. This is my 14th post within DajSiePoznac2017, so 6 posts still to be written. I have the ideas in my mind already and few next posts planned. There are only 3 weeks left to the end of the competition, so those days will need to be more intensive that it recently was, but that’s good, it means that you should be receiving more content here in the coming days and I will be spending more time on developing MoneyBack. Only positive changes, I hope 
Summary
We saw the status of MoneyBack project today. There are still many things to be done in the app to at least fulfill the minimal requirements I assumed in the beginning of the competition. but as I mentioned, the end of DSP is not the end of MoneyBack  On the other hand, DSP is a very good motivator, so I’ll try to make coming days and weeks more intensive. The most important goal for now is to fulfill the competition’s requirements for having 20 posts written until the end of May, which shouldn’t be problematic at all 
I’ve also published my Trello dashboard. You can find a link to it here.
Using this opportunity, I’d like to wish all DSP’17 participants good luck in the last weeks of the competition. I’m constantly reading the others’ blogs and I see a lot of very nice and decent quality stuff appearing in Polish programming community on your blogs and repositories – great job!
Keep your fingers crossed! 
The post MoneyBack – 3 weeks before the end of DSP appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/moneyback-3-weeks-before-the-end-of-dsp/feed/
			0
		
		
		2192	
		
		
		https://www.codejourney.net/wifi-and-bluetooth-interference-diagnosing-and-fixing/
					https://www.codejourney.net/wifi-and-bluetooth-interference-diagnosing-and-fixing/#comments
		
		
		Tue, 25 Apr 2017 21:40:14 +0000
				
		
		http://www.dsibinski.pl/?p=2015

					Have you ever had issues with weaker WiFi connection’s signal while listening to music via Bluetooth speaker ? Or maybe you noticed that your WiFi speed gets worse when you turn on your Bluetooth mouse or keyboard ? I’ve met those issues recently and would like to share a diagnosis process and a potential solution with you…

The post WiFi and Bluetooth interference – diagnosing and fixing appeared first on CodeJourney.net.
]]>
										Have you ever had issues with weaker WiFi connection’s signal while listening to music via Bluetooth speaker ? Or maybe you noticed that your WiFi speed gets worse when you turn on your Bluetooth mouse or keyboard ? I’ve met those issues recently and would like to share a diagnosis process and a potential solution with you today.


How can Bluetooth interfere with WiFi ?
Both WiFi and Bluetooth may work on the same, 2.4 GHz frequency. Bluetooth is designed to work on 2.4 GHz and also most popular WiFi routers (e.g. TL-WR845N which I have) are configured to broadcast their signal on the same frequency by default.
What makes Bluetooth and WiFi different then ? Wireless networks, like BT and WiFi, apart from the frequency, operate on different channels. A channel can be imagined as a swimming lane – the wider the lane is, the more people can swim on it. On the other hand, the more people use the lane, the slower they swim. The same happens with WiFi channels – if there are many WiFi networks in our neighborhood working on the same WiFi channel, our network may work slower.
In most WiFi routers’ settings channel on which the router works can be changed manually. We can also change channel’s width  – it can be either 20MHz or 40MHz. Channel’s width can be imagined as a width of swimming area used by a swimmer. To illustrate: if our router is set to work on channel 1 and the channel’s width is set to 40MHz, it behaves like a swimmer who uses two swimming lanes in the same time – he can either swim on lane (channel) 1 or lane 5 (when lane 1 is too crowded). Consequently, when router’s channel’s width is set to 20MHz, it behaves like a swimmer using only a single swimming lane at a time (lane [channel] 1, in this case).
If there are too many people at the pool, swimming becomes uncomfortable and slow. So let’s see how we can improve it 

Bluetooth and WiFi interference problem
I recently noticed that when I’m using my Zenbook working on WiFi having Bluetooth speaker connected in the same time and listening to music, my WiFi speed decreases significantly. To show you the scale of the problem, here is the basic Internet tracert I performed when BT was turned off:

and here is the same tracert, but when listening to music via BT speaker:

35 ms without BT to 2532 ms with BT. Nice! That’s 72 times worse! Plus the request didn’t even complete with BT turned on. Something is wrong here.
The same happened on my Huawei P8, when I had my MiBand 2 connected via Bluetooth.
Reconfiguring WiFi router to not interfere with Bluetooth
As we already know that WiFi and BT may work on the same frequencies and interrupt each other, we should be able fix this issue by changing some basic router’s settings.
Changing router’s WiFi channel
By default, WiFi routers automatically choose channels on which they work. It might be problematic in case there are more networks in our area using the same channels. I’m using TP-LINK WiFi router and the producer on their website advises to switch router to work on channel 1, 6 or 11 in case of interference issues. Those channels are generally not the most occupied ones, however it’s not always the case. Imagine that all your neighbors are WiFi-issues-solving-geeks-using-Bluetooth-devices and they all set their routers to work on channel 11. According to what we’ve said in the previous paragraph, changing our router’s to work on the same channel won’t help much.
I prefer using apps that help detecting what is the less used WiFi channel at our place. I personally recommend using free inSSIDer Home application.  When you install it, you see the list of available WiFi networks. The one you’re connected to will be marked as your favorite (with a blue star), given Link Score (quality of your WiFi signal) and analyzed in terms of router’s configuration improvements. When I launched it, my WiFi network got Link Score 70:

After a while, I also got the recommendation:

With such recommendation, you can go for your router’s settings page (for TP-LINK routers accessible by http://tplinkwifi.net/) and perform the change:

After that, my Link Score improved to 80. I performed a tracert test again with BT speaker working:

288 ms for step 8 – much better than initial 2532 ms, but still far away from 35 ms with Bluetooth turned off. Let’s see what’s more we can do apart from changing the channel.
Changing router’s WiFi Channel Width
After changing my router’s channel to 1, I noticed in inSSIDer app that it’s actually working on channels 1+5:

Why was that ? As I already explained, there is a setting called WiFi Channel Width. This setting may by default be set to 40MHz – which was the case in my router’s settings – making router working on 2 channels in the same time (1 and 5 in my case). This setting can fortunately also be changed manually in router’s settings:

After that change, my router started working on channel 1 only (as recommended) and Link Score became 94:

Tracert also looks much better now with BT speaker working:

187 ms compared to 35 ms with no BT. Apparently, Bluetooth still makes WiFi 5 times slower, but considering that the maximum speed of router’s WiFi transmission in 300MBs/s, even being 5 times reduced it remains around 60MBs/s which should be fair enough.
In the end of this optimization process, in inSSIDer application we can see our WiFi network placed between other networks in our area:

Changing WiFi’s frequency to 5GHz
If your router supports 5GHz WiFi frequency, the obvious solution for all BT/WiFi interference issues would be changing it to work in 5GHz mode, because as we already said, Bluetooth is using 2.4GHz so they wouldn’t interrupt each other anymore at all in that case. This is however not always acceptable, because some older or simpler devices like WiFi printers may not support WiFi in 5GHz frequency. That’s the reason why I didn’t change it in my router’s settings. If you can afford that, try changing your router to work on 5GHz frequency – it may eliminate all your interference issues.
Summary
Today we’ve seen how to fix interference issues between WiFi network and Bluetooth devices, which may be really frustrating. Especially that Bluetooth is currently coming back in with BT speakers, smartbands and IoT devices in general.
I hope you’ll find those advises useful 
The post WiFi and Bluetooth interference – diagnosing and fixing appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/wifi-and-bluetooth-interference-diagnosing-and-fixing/feed/
			16
		
		
		2015	
		
		
		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/my-list-of-must-have-apps/
					https://www.codejourney.net/my-list-of-must-have-apps/#comments
		
		
		Sun, 26 Mar 2017 17:33:52 +0000
				
		
		http://www.dsibinski.pl/?p=1364

					In this post I’d like to share with you a few applications I use (both mobile and PC ones) that are must-haves for me. Maybe you’ll find some of them useful (if you’re not using them yet). You can click on each application’s logo to go to its homepage. Windows PC apps Evernote Evernote allows to…

The post My list of must-have apps appeared first on CodeJourney.net.
]]>
										In this post I’d like to share with you a few applications I use (both mobile and PC ones) that are must-haves for me. Maybe you’ll find some of them useful (if you’re not using them yet). You can click on each application’s logo to go to its homepage.


Windows PC apps
Evernote

Evernote allows to store notes and synchronize them across multiple devices. I’d say it’s a very good alternative to OneNote used by many people. I prefer it to OneNote, because it’s simpler.
Saved notes can contain photos, files and be quite rich-formatted. Free basic plan allows to synchronize two devices, which is enough for me. I don’t use Evernote on my mobile, I only use it for longer notes, e.g. meeting minutes, blog posts drafts/ideas etc. As you may know, I use GoogleKeep for storing short notes or something I need to write down quickly on my mobile phone.
SublimeText3

The best and the only right text editor ever. I started using Sublime around 2 years ago and today I can’t imagine my life without it. Even though I almost don’t write code in Sublime, I just love it. It’s very fast and intuitive. Syntax highlighting, text selection and finding text/regex features are fabulous. Nothing to add. Just install and use it.
Total Commander

Actually, I should’ve started from TC. This is absolutely essential part of any files exploring I do on Windows. I’ve already been using it for around 1.5 years, couldn’t get used to it for a long time, but believe me – it’s definitely worth it. It really increases productivity when working with files copying, changing extensions, transferring files between FTP servers, basically anything that requires operations on files or folders. It may take you some time to learn it, but you’ll be pleased after  and never willing to use Windows Explorer again.
Greenshot

Greenshot is a screenshot-making application. If you need to make a screenshot more than once per week, than it’s really helpful. It can be integrated into your Print Screen button, allowing to quickly open the screenshot made in image editor in which you can highlight some parts of the screenshot or easily put consecutive numbers (e.g. to present the orders of actions performed):

Nozbe

Nozbe allows to store tasks, group them into projects, set their deadlines etc. You can read more about it in my recent post about productivity. Its desktop client is very useful, especially providing keyboard shortcut (Ctrl+Shift+Space by default) for quick tasks adding.
F.lux

F.lux adjusts the temperature of your screen’s (or screens’) colors with the sky colors changes. Incredibly useful when working with few monitors for many hours, especially at night when it gets darker. For me, it lets my eyes rest and prevent headaches I often used to have before installing F.lux.
Android apps
CamScanner

This one I also described in my last post, in which I proposed few simple habits you can introduce into your everyday life to make your productivity better. CamScanner is a must-have for me, it allows to make a photo of a document using mobile phone’s camera, then it automatically detects the document’s edges, cuts the image (you can adjust it if needed) and transforms it into scanned-looking JPEG/PDF. Since I started using CamScanner, I don’t remember using my printer’s scanner anymore. Scans produced using the app look good even if the picture is done in low-light conditions.
AirDroid

AirDroid allows you to wirelessly connect your smartphone to any PC being in the same WiFi network. You open the web app on your PC, open mobile app, scan QR code and you’re all set. Using web interface you can copy files to/from your phone, as well as send SMS messages, explore photos etc. Very handy.
Listonic

Listonic is a shopping list app. I use it only for that purpose. I share the shopping lists with my girlfriend, so we always know what to buy or what has already been bought by one of us. The only drawback I noticed recently in its Android version is that the app launches a bit long (3-4 seconds) which may be annoying sometimes. Apart from that, I can recommend it as shopping helper.
Podcast Addict

If you’re used to (or addicted to) listening podcasts, Podcast Addict will be a perfect app for you. It allows to search for podcast channels and subscribe them (e.g. you can find DevTalk or Hanselminutes there). As soon as new episode is published, you can get a notification. What’s more, you can download each episode when connected to WiFi and then listen it offline.
Nozbe

I’ll repeat myself here  Nozbe is also available on most popular mobile platforms, including Android one which I use.  It’s important to have it installed on the mobile phone, because it comes with notifications panel’s widget allowing to quickly add a new task:

May become useful when no PC available to quickly note something down.
UpNext

UpNext allows to add a widget on Android’s screen, which displays the list of incoming calendar events:

It’s very handy for me and I’m using it all the time. It also allows to easily add new calendar event or open calendar app.
Summary
The list I presented contains apps that I use every day and can’t imagine my computer/mobile life without them. I think they make activities I perform on my PC or smartphone simple and painless. If I find some more must-have apps, I’ll try to keep this list updated.
What are your favourite apps you couldn’t live without ? Let me know!
The post My list of must-have apps appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/my-list-of-must-have-apps/feed/
			2
		
		
		1364	
		
		
		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