Initial Commit:

An application that allows a user to generate a song (or individual
parts of a song). The generated song itself may not be great, but it can
serve as at least serve as a starting point or inspiration for a song.

Initial commit includes the following functionality:
-A basic screen with a single button and a single text display.
-Pressing the button will generate and display a simple song structure
	-The song structure consists of Verse, Chorus, and Bridges
	-The order of these is determined based on some very basic probability
stuff (that needs some improvement)
Commenting out settings menu for now (since it doesn't do anything)

Also removing /bin and /gen directories ('cause a guy in a youtube video
said to do that..)
Added spinners to allow selecting a time signature.

Added basic chord progression generation 
	-shows scale degree... no modifiers, like Major, minor, 7th, etc. yet)

Added basic rhythm creation
	-shows an array containing durations in half beats, with rests as
negative values
	-based on time signature
	-currently generates 2 rhythms.
Committing a bunch of changes:

Probably the biggest is the addition of MIDI support. Generating a song
now creates a temporary MIDI file, which can then be played via the
built-in MediaPlayer. As it is currently, it plays the verse chords.

Speaking of the verse chords, I added a new method the generate a
(hopefully) better chord progression. It should eliminate repeated
chords. It could still use osme improvements... I'm just going for
incremental changes right now.

Back to MIDI for a minute... this uses an external library (may need to
do some work to make sure licensing is handled appropriately). Including
the .jar. The MidiManager handles most of the Midi processing.

Created some helper classes (Utils and SongStructure) to handle some of
the common operations and constants.

One goal I have is to abstract things enough so that the SongWriter and
MidiManager classes (along with the helper classes) could be used for
Java in general, so I could theoretically create a desktop app that does
a similar thing. I need to learn some Java GUI stuff first, but Android
makes this pretty easy for now.

Anyway, that was pretty long for a commit message...

Oh, also removing some (hopefully) unnecessary files
A bit of refactoring (and removing more stuff? Why the heck do these
files keep ending up in the commit! They are in the freaking ignore fie!
RAAAAGHHHH!!!)
A bit more refactoring work. Song is now in its own class, and is more
"struct-like." Songs were previously writing themselves... which seems
weird. Now, a song is generated by the SongWriter, and the song just
holds the information in a relatively organized way.
Added some code to generate a pretty random "melody". It plays a little
tune over top of the chord progression. What it generates is pretty
horrid right now. I still haven't really implemented any of the music
theory stuff yet. Still working on just getting the basics to work. I'll
add that stuff later.

Also, did a little bit of cleanup. However, I also added some really
nasty code doing the above stuff, so it is definitely gonna need some
more.
Fix for generating melodies. When picking a melody note based on the
current chord, use the actual semi-tone offset value within the scale
rather than the scale degree of the chord. This makes the melody more
bearable to listen to (since it is actually picking notes in the scale
now. It is still pretty boring and generic, though.)
Recovering state on recreating activity. Partially recreating Song
object (at least the important parts).

A little more refactoring as well:
	-Songs now maintain their own time signature
	-moved some code into separate functions for more clarity (and
hopefully reusability)
Added ability to generate a song with using a minor scale (Natural or
Harmonic). Most likely, a Major scale will be generated.
I'm pretty excited about this one...

Added the ability to save the song to an external MIDI file (it will be
stored in the main music directory on external storage). It can be
played back using various media players, and can also be viewed and
edited in other software (such as MuseScore, which I am using on my PC).
This is useful for viewing it in musical notation.

As part of this, I implemented a dialog fragment that allows the user to
specify a file name to save the MIDI under (the .mid extension is
automatically added). Ideally, this fragment could be reused.

One other thing I learned... android dialogs are a good bit different
than MFC dialogs... Anyway, I digress.
Add a check to see if the file we are trying to save to already exists.
For now, if it does, then just cancel the save and add an awkward
message that the file already exists.
Hopefully this fixed some issues I was having with the .gitignore file
-Added in ability to generate different keys (added a little support for
MIDI skey signatures, but still needs some work
-Added in random time signature generation (the time signature spinners
now don't do anything)
-Added in random instrument generation (from a relatively small subset
of instruments). Did some refactoring work after the fact so that the
instrument is persisted on the song object as well.
A fair bit of refactoring. Added classes for Chord progressions, chord
patterns (sort of like sub-progressions), and Notes (Notes are still not
being used yet). This should help with generation and management of
these items, particularly when it  comes to using the SongWriter.

As part of this, I added a pretty serious hack to restore state when the
activity is recreated from a saved instance. What I should probably do
is have the objects be serializable (or parseable), or at least be
little more careful about reading and writing them on save/restore.

This check in is mostly to give me a relatively stable point to come
back to as I plan to continue refactoring the code to be a little more
OO and organized.
Did a bit more refactoring to change how "sub-melodies" are generated.
The ChordPattern object turned into a Pattern object since it now
actually holds a sub-melody. This helps with being able to repeat parts
of a melody, which seems a bit more realistic for music (otherwise, the
meldoy seems incredibly random... now it is a bit less so).
Do a good bit of clean up of extra comments and to-dos

Add tempo generation and display

Add a few more instruments

Lower the chord pitches by an octave (instruments like the guitar sound
much better in this range)
Make some changes so that melodies no longer just consist of quarter
notes. This makes songs at least marginally more unique and interesting.

Also made some more changes to introduce more ways to have a chance of
repeating a part. This will likely continue, since repetition seems to
be a big part in music. It helps unify a song (as opposed to having it
sound so random, as most songs that this is generating sound now).
Added two new "scales" (commonly called modes... not sure if there is
actually a difference): Mixolydian and Dorian. This adds a slight bit
more variation to the songs that are genereated.

Also, added some utility functions to translate between an interval
relative to a scale and an interval relative to the root of a chord in
that scale (and vice versa). Isn't being used yet, though (and hasn't
been tested...)
Handle audio focus like a good little app should. Now, we request audio
focus before playing, and the abandon focus when we are asked. This also
(should) pause for transient focus loss (not really tested)