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

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

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

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


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

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

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

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








  





namespace MoneyBack.Entities



{



    [Table("People")]



    public class Person



    {



        [PrimaryKey, AutoIncrement]



        public int Id { get; set; }








        public string Name { get; set; }








        public string LastName { get; set; }








        public string PhoneNumber { get; set; }








        public string Email { get; set; }








        public override string ToString()



        {



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



        }



    }



}






        view raw

        

          Person.cs

        

        hosted with ❤ by GitHub
      


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

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

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








  





public class Constants



{



    public static readonly string DbFilePath = 



        Path.Combine(



                Environment.GetFolderPath(Environment.SpecialFolder.Personal), 



                "moneyback.db"



        );



}






        view raw

        

          Constants_dbPath.cs

        

        hosted with ❤ by GitHub
      


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








  





public class PeopleRepository



{



    private SQLiteConnection db = null;



    protected static PeopleRepository me;








    static PeopleRepository()



    {



        me = new PeopleRepository();



    }








    protected PeopleRepository()



    {



        db = new SQLiteConnection(Constants.DbFilePath);



        db.CreateTable<Person>();



    }








    public static int SavePerson(Person person)



    {



        me.db.Insert(person);



        return person.Id;



    }








    public static Person GetPerson(int id)



    {



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



    }



}






        view raw

        

          PeopleRepository.cs

        

        hosted with ❤ by GitHub
      


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


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

On clicking the button, the following method is executed:








  





private void _btnAddPerson_Click(object sender, EventArgs e)



{



    var name = _inputName.Text;



    var lastName = _inputLastName.Text;








    var id = PeopleRepository.SavePerson(new Person



    {



        Name = name,



        LastName = lastName



    });








    var person = PeopleRepository.GetPerson(id);








    if (person == null)



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



    else



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








}






        view raw

        

          addPersonButtonClick.cs

        

        hosted with ❤ by GitHub
      


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

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

					It’s been a really tough week, so today I have a non-technical post for you. I’m going to move on with the project this weekend, so I can put some technical stuff here tomorrow. If you don’t really care about productivity, organization of your days, planning of tasks to be done during next X days,…

The post Simple habits for better productivity appeared first on CodeJourney.net.
]]>
										It’s been a really tough week, so today I have a non-technical post for you. I’m going to move on with the project this weekend, so I can put some technical stuff here tomorrow.

If you don’t really care about productivity, organization of your days, planning of tasks to be done during next X days, this post is for you  I totally didn’t care as well, but I felt a bit disorganized, I knew I could do more or at least be conscious of what I’m able to do and what I’m not. Finally, without studying anything like GTD, I managed to introduce few simple habits to my everyday life that make my life easier, allow to complete some tasks faster and make me aware of what I have to do and when. I’d like to share those manners with you – maybe you’ll also find them helpful.


Write everything down
I heard from many people promoting better life organization, that writing things down is a very important step in being more productive. I definitely confirm. Writing things down cleans up your brain – it makes you not thinking about something you have to do – you just write it down and you are sure you’ll take care of it when the time comes. Such brain-liberty is very powerful. You can use your brain to think about the activity you’re actually working on at the moment, not having many “background” topics taking your brain’s “resources”.
Of course, you need to find a place in which you store your notes (or tasks – whatever you call it). For me, such place must meet the following requirements:

be easy and fast to use in every situation
be accessible from every place, on every device
synchronizing across multiple devices
allowing to set deadlines for each task
giving a possibility to group tasks

I’ve personally tested few todo lists / tasks management applications, including Freedcamp, Todoist or Wunderlist, but finally I found the perfect one – Nozbe. You can use my affiliate link to register, if you don’t mind  As a bonus you’ll get one additional month if you decide to but a premium subscription. This project has been started and is developed by Michał Śliwiński who is productivity enthusiast. You can hear more about him and his project in DevTalk#44 podcast (Polish only).
Nozbe allows to store tasks, set their deadlines, group them into projects and categories. It’s very simple and that’s the best about it. Free version allows to create maximally 5 projects, which is fair enough for me. Nozbe can be installed on Windows, Mac, Linux, Android or iOS, which allows for quick adding of tasks (there is a keyboard shortcut in Windows and notifications panel’s widget for Android). I’ve already been using it for few months and I’m very happy, it helps me a lot, really.
As soon as you have your place chosen, just work out that simple habit of writing things down (in case of Nozbe – adding them to your Inbox). When someone comes to you and asks you for something – write it down and say “Sure, added to my tasks list”. The person is then confident that you’ll take care of what he/she asks for and your brain is not occupied by it until you have time for it. When you’re on a meeting, and something to be done by you appears – write it down. If you suddenly recall you need to visit your dentist soon – write it down. Simple as that. You’ll see how much it helps.
Review and plan your tasks
As soon as you write everything down, try to work out the habit to review your list of tasks. If you have only one place in which you put everything you want to do, review such tasks inbox every day (e.g. in the evenings) and decide what to do with each task – either add it to the project/category and set the deadline, leave as it is if there’s nothing to do for now or delete if there’s actually nothing more to be done in a particular topic.
Apart from daily tasks review, perform a general, weekly-review of all your tasks in all projects/categories. I do such reviews every Sunday in the evening. It allows me to know the scope of things to be done on a higher level – across different projects and categories. I can also see if all the tasks are properly scheduled so I can manage to complete them. It’s better to plan than not, even if you finally don’t realize all tasks as planned.
Create what-to-take lists
When you pack for a business trip or holidays, don’t you forget something every time ? If yes, just create a check-box list containing all the things to take for particular type of trip. When you pack for the next time, add necessary things to it. If during the journey you notice you forgot something, add it to your list, so the next time you don’t forget it. Very simple, but saves a huge amount of time for packing.
I use Google Keep for storing such lists. Here you can see how my list of the things to take for a business trip looks like:

Having such what-to-take lists, I don’t wonder what I should take when I go for a business trip, what should I take when I go for holidays etc. Firstly packing is fast, and secondly I know I won’t forget anything. I totally recommend such approach.
Create what-to-bring lists
Does it sound familiar to you: your family members asking you “Oh, bring me that nice shirt when you visit me the next time if you’re not using it anymore!” ? Or your mum calling you and saying “I bought you a beautiful sweater, don’t forget to take it when you visit us!” ? If yes, then for each such place you visit (parent’s house, sister’s house, brother’s house etc.) create what-to-bring list and just add to it each thing you need to either bring from or take to there. Then when you spontaneously visit your sister, you just open the sister’s home list and see if you have something to bring her or to take with you. Again – simple, but helpful.
Digitize your receipts
Have you ever wasted few hours on looking for a receipt, when wanting to return something for a warranty repair ? Maybe you finally found the receipt, but it got blank ? If yes, move your receipts to the cloud. As soon as you buy something and you know the receipt or invoice may be useful in the future, make a photo of it using your smartphone and store it in some cloud files storage service.
I use Android application called CamScanner for that – it allows to make a photo of a document, cut it, make it look as scanned and send to Google Drive, on which I store all my receipts and invoices. If you name your scanning files properly, it may save much of your time looking for a receipt or even make it possible at all to return something on a warranty repair if needed.
Use calendar only for time-important events
Before I discovered todo list apps and finally found Nozbe, I used to store everything I need to do in my Google Calendar. I treated it as my inbox – if I had something to do, I added it as a reminder to the calendar and set its reminding date at certain time, usually in the evenings. It happened that around 9 PM I had 5 or 6 pending calendar reminders notifications on my phone. When I mistakenly cleaned up my notifications panel, all those reminders were lost.
Calendar – as its name suggests – should be used only for events for which the time really matters. For instance, when you arrange a doctor’s visit in a month or two for concrete day and hour, add it to your calendar setting event’s time to exactly your visit’s day and hour. If you need a reminder few days/hours before, don’t add another calendar event few days/hours before (as I used to do) reminding you about the event – instead – if you use Google Calendar – use “remind before” notifications:

I also use Google Calendar for recurring events, for instance end of my car’s insurance or family members birthdays. The time is the most important for such events.
Summary
I’m not any kind of productivity fanatic. I also didn’t read any productivity/GTD books or courses. I think that such involvement in productivity management is not needed in many cases. In this post I presented few simple habits I introduced in my life that help me to be a lot more productive and just make my life simpler. If you want, you can try them out yourself 
What productivity habits do you have ? What kind of tasks management tools/todo lists are you using ? Share your thoughts in the comments!
The post Simple habits for better productivity appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/simple-habits-for-better-productivity/feed/
			1
		
		
		790	
		
		
		https://www.codejourney.net/solving-performance-issues-with-dottrace/
					https://www.codejourney.net/solving-performance-issues-with-dottrace/#comments
		
		
		Sun, 12 Mar 2017 14:40:24 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=728

					If you’ve ever had any performance issues with your .NET applications, you may find this writing interesting. In this post I’d like to present to you a tool produced by JetBrains – dotTrace, showing how using only one of its functionalities can help in finding causes of performance issues in .NET applications. Performance issue on production Months…

The post Solving performance issues with dotTrace appeared first on CodeJourney.net.
]]>
										If you’ve ever had any performance issues with your .NET applications, you may find this writing interesting.

In this post I’d like to present to you a tool produced by JetBrains – dotTrace, showing how using only one of its functionalities can help in finding causes of performance issues in .NET applications.


Performance issue on production
Months ago some of your colleagues implemented an application and delivered it to the Customer. The app is “Countries and Cities Manager”, which is used by some administrator working in local government unit. That’s how it looks:

That’s cool, isn’t it ? This “administration panel” allows to add a new city to the country. User fills name of the city and provides ISO code of the country considered. You may think “who would ever use it and for what?”. True. But first of all, this is just an example  , and secondly, imagine that Russia annexes some big European country. What happens then ? User administrating local government system must use your manager application to insert hundreds or thousands of new cities in Russia. Gotcha!
The next day you receive a ticket in your company’s issues tracking system. Taking into consideration that an average number of cities in east-European countries is ~600, the ticket’s priority is set to “Blocking”. The description of the issue is:

User fills the “City” and “Country ISO Code”, clicks “Add city”
Waits for 10 seconds…
Waits for 20 seconds…
Waits for 30 seconds…
Error message received:



User corrects “RU” to “RUS”
 

Waits for 10 seconds…
Waits for 20 seconds…
Waits for 30 seconds…
 City added!
Scenario repeats for each new city to be added. Performance is unacceptable.

Initially you have no idea what could be the reason. Such simple operation and such terrible performance? Let’s see…
Looking for issue with dotTrace profiling
In such cases, especially if I don’t know the code of the application considered, the very first thing I do it to use dotTrace in order to profile the application when executing bad-performance actions. It provides many features, including:

detecting performance bottlenecks in .NET applications
getting information about calls execution times
analyzing calls order on a timeline
profilling SQL queries and HTTP requests
profiling unit tests
… and many more.

We will use only the simplest profiling mode which is called Sampling.
After you downloaded and installed dotTrace, launch the application you want to profile first. Then, launch dotTrace and in Attach to Process section find and select process of your app and select Sampling mode:

Then, click “Run” button just below Sampling mode selection – you’ll see the profiling session has started:

Next, go to your application and execute bad-performance action. In our case, we click on “Add city” button:

App is not responding – cool! Now we wait those 10, 20, 30 seconds until we get the error message described by the user. To be sure what’s happening, we can click the button few more times (maybe the next executions are better?). I clicked it 3 times are the times were pretty the same.
That’s the end of our bad-performance action, so in dotTrace session’s window click “Get Snapshot and Wait”:

After few seconds, JetBrains dotTrace Performance Viewer opens. Open “Threads Tree” on “All Calls” tab:

In this section we normally see all the threads running within our application during profiling time. We had only one thread, so let’s expand the details to see the time and percentage duration of particular calls from the calls stack:

At this moment, without even opening the code, we already see that method called GetAllEuropeanCountries takes 83.63% of our thread’s execution time. What’s more, we can see that this method is defined in CountriesCitiesDbService which apperently retrieves list of European countries from the database or some external source.
The most percipient of you probably noticed there is Thread.Sleep(Int32) method called one level down – yes, that’s for example’s purposes  , but in real world this would be a database query or a web service call here. The most important is that we know what takes the longest during our operation. Let’s now fix it!
Fixing the issue
Let’s open CountriesCitiesManager solution and use the knowledge we already have from the profiling. We go to the AddNewCity(String, String) method, in which the method for getting countries was called (this is deductible from the calls tree in performance viewer). Here’s the code:








  





private bool AddNewCity(string cityName, string countryIso)



{



    var city = CountriesCitiesDbService.GetNewCity();



    var europeanCountries = CountriesCitiesDbService.GetAllEuropeanCountries();



    var country = europeanCountries.FirstOrDefault(ec => ec.IsoCode.Equals(countryIso));








    if (country == null)



        throw new ArgumentException($"Country with ISO Code {countryIso} does not exist!");








    city.Name = cityName;



    city.Country = country;








    CountriesCitiesDbService.SaveCity(city);



    return true;








}






        view raw

        

          AddNewCity.cs

        

        hosted with ❤ by GitHub
      


AddNewCity method is called every time the “Add city” button is pressed. In line number 4. we are getting the list of all 46 European countries:

How probable it is that the number of countries in Europe changes during our application’s runtime? Very close to 0, I’d say. So there is totally no sense in retrieving the list of EU countries (from the DB, web service or whatever) every time the button is clicked!


We need to cache this list somehow. Let’s simply extract the variable for storing EU countries as read-only class property initialized only when used for the first time:








  





private List<Country> _europeanCountries;








public List<Country> EuropeanCountries => 



    _europeanCountries ?? (_europeanCountries = CountriesCitiesDbService.GetAllEuropeanCountries());






        view raw

        

          EuropeanCitiesProperty.cs

        

        hosted with ❤ by GitHub
      


and use it in AddNewCity method:








  





private bool AddNewCity(string cityName, string countryIso)



{



    var city = CountriesCitiesDbService.GetNewCity();








    var country = EuropeanCountries.FirstOrDefault(ec => ec.IsoCode.Equals(countryIso));



    // the rest of method's code…



}






        view raw

        

          AddNewCity_Corrected.cs

        

        hosted with ❤ by GitHub
      


When the application is now launched, sampling started and button clicked 3 times, we already see the improvement:

AddNewCity takes 65.96% now. This is average value from all the calls we made, so let’s now perform sampling starting from the 2nd click:

The whole AddNewCity method is now taking only 0.41% of the calls during the operation.
Now, if we want to make Customer’s life beautiful, we’d extract initialization of EU countries list to another thread, so it can happen when the application launches and UI is not frozen. We will however stop here. You get the idea, don’t you ? 
Summary
Today we’ve seen how easily – by performing just the simplest profiling session that can be done in dotTrace – it may be to detect what causes real performance issues in .NET application. Of course the example was pretty naive and simple, but I didn’t make it up – many times I’ve already worked with performance issues in production code which were caused by retrieving so called “dictionary” or static data using some API or database connection every time in a loop or repetitive process, which was totally unnecessary. By only implementing some kind of cache (maybe a bit more reasonable than the one we did, which in our case was actually enough), I managed to optimize processes executing time from 3 or 4 hours to several seconds.
Obviously if you’re an experienced developer, you’d probably identify such places in which caching or similar mechanism should be used when writing code. Profiling may however be useful for less experienced programmers or when working with legacy code we didn’t write (or we wrote months or years ago  ). It doesn’t cost much, except the cost of dotTrace itself, which is a part of ReSharper Ultimate, but this tool is just an example, you are not limited to it. For sure there are many other tools that offer the same (or maybe even more?) functionalities.
What are the tools you use for debugging performance issues ? Maybe you also use dotTrace, but can share some experience in using its other functionalities?
The post Solving performance issues with dotTrace appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/solving-performance-issues-with-dottrace/feed/
			3
		
		
		728	
		
		
		https://www.codejourney.net/xamarin-android-activities/
					https://www.codejourney.net/xamarin-android-activities/#comments
		
		
		Sat, 11 Mar 2017 18:53:10 +0000
				
		
		
		
		
		http://www.dsibinski.pl/?p=405

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

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


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

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

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

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


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

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

Let’s see what those states mean:

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

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

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

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

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

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








  





protected override void OnCreate(Bundle bundle)



{



    base.OnCreate(bundle);








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



    SetContentView(Resource.Layout.Main);








    _amount = 0.00m;



    _result = 0.00m;



    _numberOfPeople = 0;








    InitializeUserControls();



}








// …








private void InitializeUserControls()



{



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



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



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



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



}






        view raw

        

          MainActivity_OnCreate.cs

        

        hosted with ❤ by GitHub
      


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








  





protected override void OnStart()



{



    base.OnStart();



    RefreshUserInputsFromVariables();



}



// …



private void RefreshUserInputsFromVariables()



{



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



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



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



        TextView.BufferType.Editable);



}






        view raw

        

          MainActivity_OnStart.cs

        

        hosted with ❤ by GitHub
      


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








  





protected override void OnResume()



{



    base.OnResume();



    InitializeUserControlsEvents();



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



}








// …



private void InitializeUserControlsEvents()



{



    _btnCalculate.Click += _btnCalculate_Click;



}






        view raw

        

          MainActivity_OnResume.cs

        

        hosted with ❤ by GitHub
      


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








  





protected override void OnPause()



{



    base.OnPause();



    DetatchUserControlsEvents();



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



}



// …



private void DetatchUserControlsEvents()



{



    _btnCalculate.Click -= _btnCalculate_Click;



}






        view raw

        

          MainActivity_OnPause.cs

        

        hosted with ❤ by GitHub
      


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

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

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

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


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

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


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

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

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

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

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

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

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



Get ready for a deep dive into Xamarin soon 😎



 
The post Hello Xamarin World – first steps appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/hello-xamarin-world-first-steps/feed/
			0
		
		
		244	
		
		
		https://www.codejourney.net/moneyback-requirements-functionalities-and-technologies/
					https://www.codejourney.net/moneyback-requirements-functionalities-and-technologies/#comments
		
		
		Fri, 03 Mar 2017 22:30:51 +0000
				
		
		http://www.dsibinski.pl/?p=269

					Hello again 🙂 It’s been a short while, WROC# conference was held in the meantime (it was great, by the way), but it’s time to write again. Write about DSP. More precisely: about MoneyBack, my project for the competition. Today I’d like to share with you my idea for the application – what I require…

The post MoneyBack – requirements, functionalities and technologies appeared first on CodeJourney.net.
]]>
										Hello again  It’s been a short while, WROC# conference was held in the meantime (it was great, by the way), but it’s time to write again. Write about DSP. More precisely: about MoneyBack, my project for the competition.


Today I’d like to share with you my idea for the application – what I require from it, what functionalities I imagine it to have and what technologies I want to use. This is going to be rather short post, I don’t want to spend too much time on imagining the functionalities (I rather prefer to start working on it). It won’t be much detailed also, just a high-level overview of what I imagine my project to look like.
A need
As I already described in my DSP introduction post, the idea for MoneyBack came from a need. I just need a kind of system, which would allow me to make splitting the money spent on a group’s needs easier. Currently I perform such tasks quite often and I do it manually. Those include any types of activities/things you paid for, whilst being used also by the others: food ordered with your workmates, beer you paid for in the pub with your friends, shopping made with your girlfriend, sports event you attended with a group of others or any other types of activities you can imagine.
I know there are many mobile/web applications doing that job, however MoneyBack will rather focus on the person who is the payer – it will help him/her firstly just to properly and easily split the costs and secondly – what is maybe more important – to keep the others informed/reminded (if necessary) about the money they owe.
Requirements and functionalities
I will divide the requirements that MoneyBack application is going to meet into two groups: must-haves and nice-to-haves. By a must-have I understand something I essentially want the application to help me (and the people using it, hopefully  ) with, like the core and basic functionalities without which I can’t imagine it finished. Like the minimum requirements for my DSP project. On the other hand, by a nice-to-have I see a part of the system I’d love to have, but is not essential for the project being.
Must-haves:

[Android] Adding people (that are meant to be included in money splitting) by email (+ other personal details)
[Android] Creating one-time events/expenses with amount paid, people assigned, payment due date, bank account details, attachments (e.g. invoice/receipt PDF)
[Android] Automatic calculation of costs split per person
[Android] Generating one-time event’s/expense’s summary email to be sent to all participants with all the details
[Android] Marking particular event’s participants as “paid” (to indicate that person has already paid what he/she owes)
[Android] Notifications about a possibility to generate and send a reminder email to people who haven’t paid yet if the due date is coming
[Android] Creating recurring events (e.g. once per week, once per month etc.) + notifications about the summary emails to send when the recurring event’s date is coming
[Android] Possibility to export application’s data backup to GoogleDrive / file

Nice-to-haves:

[Android] Adding people (that are meant to be included in money splitting) by phone number
[Android] Possibility to connect person added with the Contact (integration with phonebook)
[Android/Web] Possibility of account creation in the application for synchronization of application’s data to the web service
[Web] Web interface allowing to login and see the details of events created in the mobile app
[Web] Possibility to share a link to the event’s summary that can be given to all participants (so there is no need to send summary email)
[Web] Managing the expenses/events in the web application
[Web] Possibility of account creation on the web app
[Web] Possibility to mark events as “monitored” so the reminder emails about payments are sent automatically to the participants from the server
[Android] Support of multiple currencies (manual exchange rates definition) so that some people can pay in PLN, some in EUR for the same event
[Android] Defining groups of people
[Android] Possibility to download exchange rates from the Internet
[Android] Defining expenses’ categories
[Android/Web] Logging with social media (Fb, Google)
[Android/Web] Charts/statistics for the payments/events/expenses


Those are just general requirements which came to my mind and they may change during the project’s development. Maybe you have some other ideas for such application’s functionalities that you’d find useful ? If yes, let me know in the comments.
Technologies
Above all, MoneyBack is going to be an Android application written in C# language using Xamarin platform. I will also need some good, but tiny local database on the device. I don’t know what are the best ones to use in Android/Xamarin (maybe some of you can advise me something?), but I suppose it could be for instance SQLite. I will mostly focus on the mobile app. In the worst case, as the very minimum, I’d like to finish mobile application so it meets the minimal requirements and is possible to be used by the others.
The second and very interesting part of MoneyBack project would be to have a web service with which the application would synchronize. It would require the replication of device’s local database structures on the server side and exposing some API after (maybe JSON?). Then it would be perfect to have a possibility to at least see created events/expenses details in the web app, which would require adding some web UI to the application. If I ever manage to get to this part, I would like to use ASP.NET Core for creating a simple server-side web app, maybe hosting it on some Linux machine. I’d also need some simple, but reliable database system, for example MySQL which could also be easily hosted on Linux server.
Summary
MoneyBack will primarily be an Android app. If I manage to create web app it’s great. No more declarations for now, let’s start working. The next post in the scope of DSP will cover Xamarin installation into Visual Studio, configuration, first pieces of code and deployment of the application to the mobile phone.
I encourage you to give your feedback in the comments 


PS: I need to make a small disclaimer here: I have to admin – what I didn’t mention in my previous post – that it was my creative girlfriend who came up with the name of the project (MoneyBack, initially GiveMyMoneyBack) who I’m cordially greeting from this place  I hope she will be supportive enough so I don’t arrive to the end of DSP with MoneyBack, but no girlfriend  Plus as I’ve just made the disclaimer, she won’t have any claims to the app when it already makes millions of dollars 
The post MoneyBack – requirements, functionalities and technologies appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/moneyback-requirements-functionalities-and-technologies/feed/
			16
		
		
		269	
		
		
		https://www.codejourney.net/hello-dajsiepoznac2017/
					https://www.codejourney.net/hello-dajsiepoznac2017/#comments
		
		
		Sat, 25 Feb 2017 16:36:55 +0000
				
		
		http://www.dsibinski.pl/?p=187

					Today I’d like to say “hello” to the programming competition Daj Sie Poznac 2017 (en. Get Noticed)  which I decided to take part in. For those who don’t know, DSP is organized by Maciej Aniserowicz, the owner of devstyle.pl blog, and it’s already its third edition this year. Basic concept of DSP Long story short, the…

The post Hello DajSiePoznac2017 ! appeared first on CodeJourney.net.
]]>
										Today I’d like to say “hello” to the programming competition Daj Sie Poznac 2017 (en. Get Noticed)  which I decided to take part in. For those who don’t know, DSP is organized by Maciej Aniserowicz, the owner of devstyle.pl blog, and it’s already its third edition this year.


Basic concept of DSP
Long story short, the main concept behind DSP is to develop an open-source project of any kind, in any technology, in the same time sharing your knowledge and project’s development processes by blogging about it. The competition lasts for 3 months – from March to May – during which at least 10 weeks must be spent on project’s development and blogging. At least 2 blog posts per week must be written, from which one must be about the project itself, and the other may be on any IT-related topic. As the project is open-source, source code is stored on public Git repository on GitHub.
My way for DajSiePoznac
When the competition was held last year I regretted I finally didn’t take part. I was sure I must try the next year, so now it’s happening 
Normally I have not much time for programming or developing pet projects after work, as I’m still finishing my Master’s studies on weekends, but this time I decided to take part in the competition as I think it may be (actually it already is!) very motivating to develop myself, broaden my horizons by exploring new technologies and finally to open for the programming community by blogging. I’m very excited, so let’s see how it goes!
Looking for a project’s idea
I spent few weeks trying to find an idea for the project to do for DSP’17. I had two assumptions looking for it:

technology must be .NET-related
the app/framework/solution to develop should solve a real life problem


Apart from those two, I’ve always wanted to develop an Android application using Xamarin, writing C# code. During my engineering studies I’ve had a chance to take part in a great project in which I was responsible for back-end development of an Android application, but it was written in Java. I also had almost no programming experience that time, so the quality of this product wasn’t the best (it was however very good project in the end).
I even installed Xamarin last year, but it wasn’t free for use yet that time – I had some student license, but I had that feeling that even if I create an app using it, after my license expires I would need to stop developing it or pay quite much for it. Now, as Xamarin was acquired by Microsoft and it’s free, it’s even more motivating to use it.
Apart from that, I’ve never finally programmed using Xamarin, so it’s totally new technology for me which is also the advantage I can learn it.
So I’ve had my technology chosen. Then, I considered many different ideas for the project, each time realizing that something like that already exists, which made me very demotivated… And then I realized that actually it doesn’t matter what idea or project I choose, if it already exists or not – it should be something I’d like to do and what seems interesting to myself. In the end that would be me developing that product*, right? 
* I used word “product” above, which means something that may be really used by the other people, but for me this may only be a “side effect” of DSP’s contribution. If I manage to create something useful for the others – that’d be great. If I don’t –  it’s still cool. The most important is to take a part in the competition, survive  to the end and be proud.
MoneyBack – my project for DSP’17
Finally I decided to create an Android mobile application, written in Xamarin using C#, which purpose is to help settling the money between group of people (friends, family, workmates etc.).
Many times I’ve personally been in the situations when I pay for some activity in which a group of people take part. After, the money needs to be split between all participants. First of all, I’ve always done it manually, creating some Excel file which counted how much money does the particular person owns and to whom. Secondly, sometimes there are cumbersome situations when someone owns you the money, but just forgets about it (even you reminded him/her few times already) – you don’t want to be rude coming to the person all the time asking “give my money back, *****!”  ), so the app will do that for you. That’s why I called the project MoneyBack (wanted it to be GiveMyMoneyBack initially, but I consider it too long!) – there are already many costs-splitting applications, but this one will rather focus on the person who pays for the others. Of course its other purposes are just to split the amounts between the people, calculate who owns how much to whom, send notifications to the participants etc. so you don’t need to use Excel or contact everyone separately to tell them how much they owe you and for what.
More details to come. I’ll focus on the mobile app first. I’d like to create also some kind of web service (e.g. using ASP.NET Core, which would also be the technology I’ve not used so far), with which the app would synchronize (e.g. to present the summary and current state of settlements on the web page visible to all participants or keep the history and backups), but I don’t want to make any declarations. First, let’s focus on the Android side, then we’ll see 
You will be able to find MoneyBack‘s source code on GitHub.
Summary
Next weeks and months (hopefully!) are going to be intensive. I hope I’ll arrive to the end of DSP’17. I wish all the participants good luck and all the best in your daily works on your projects  See you soon!
The post Hello DajSiePoznac2017 ! appeared first on CodeJourney.net.
]]>
					
					https://www.codejourney.net/hello-dajsiepoznac2017/feed/
			9
		
		
		187