Added the Notelist Screen

- A WebView is used to display unmodifiable text when the Note Screen is
  in the locked state. This allows for the most flexibility in styling
  and design as opposed to a TextView widget.

- Drawable definitions have been added to give the list components a
  base style.

- Implemented a fragment for containing the list view.

- UnlockedState.java has been updated to invoke update if insertion
  fails. This way, when a user edits a file, changes will be stored in
  the database properly.

How The Fragment System Works

- How Fragments are Added/Attached

  NotelistActivity.java contains all the Fragment management methods.
  Fragments are considered views. An alternative approach may be to move
  or delegate Fragment management to the View class that actually
  contains the Fragments. For now, the current implementation is the
  simplest solution since Android Activities provide fragment services.

  When the activity is launched, the fragment is created only if it has
  not already been created. The FragInfo class is used to create objects
  that store data for each Fragment. A hashmap field and a "current"
  fragment field is provided to assist in the management operations.
  Currently, only one fragment is used, but this is future-proofing for
  any new fragments that may need to be added.

- How Fragment components communicate with the controller

  The "controller" in this context is NotelistActivity.java and the
  "view" is NotelistFragmentView.java.

  Fragments are treated as views. Fragments communicate with the
  controller using the same MVC architecture applied to standard View
  classes. Fragments define a listener interface that the controller can
  instantiate and pass to the Fragment during the creation of the
  fragment. The fragment can then use this instance of the listener
  object to delegate view event handling to the controller.

- How a notes ArrayList populates a ListView

  NoteModelListAdapter.java uses the "Adapter" design pattern to adapt
  an ArrayList containing all notes to a ListView. It does this by
  extending the BaseAdapter class which itself implements interfaces
  that ensure you implement the proper methods so that you can provide
  the necessary data to the ListView. The necessary data includes the
  count, the item id (SQLite row id which is used to distinguish it from
  other row items), and finally the actual View object that will be
  displayed per row. The rows are homogenous, thus the View objects
  contain the same structure for each row item.

  View creation is handled by the getView() method. getView() implements
  a concept known as the "ViewHolder" pattern. The ViewHolder pattern
  ensures that a row's view is created only if it has not already been
  created. NoteModelListAdapter.java inflates the
  fragment_notelist_browse.xml resource and uses it as the view object
  for each row. A ViewHolder inner class is used to create an object
  that will contain all the views used in each row.  In this
  implementation, we are simply using a TextView in each row. Then the
  ViewHolder object is set as the row view's tag. That way, if a view
  was already created, we can retrieve all view references by simply
  calling the getTag() method on the view.

  The TextView uses custom drawable color resources for the list item
  styling.

Signed-off-by: Byron Sanchez <bfs5030@gmail.com>