Started guidelines folder for new developers.
Added missing drawable resources.

Need to have fallback resources in the default folders.  Added a few extra configuration categories for completeness.
Added new preference screen for mapping buttons/axes.

A more visual layout that minimizes localization requirements.

Slightly different interactions with user that permits more flexible mapping implementations.
 - Current method: user picks an N64 button/axis, and then mupen listens for input signals and maps the first input it hears
 - New method: user presses inputs, then taps a particular N64 button/axis on screen, and then mupen adds the entry to the map

The difference is subtle but important. Imagine that the user wants to map N64 button Z to positive analog trigger.  Many analog triggers produce a value of -1 at rest, +1 at fully depressed, and float values in between.  The native gamepad listener is notified as soon as the trigger changes state from -1 to -0.99.  With the current approach, mupen maps the first thing it hears and thus maps N64 button Z to negative analog trigger (i.e. trigger at rest).  Not the desire of the user.  With the new method, the user can move the trigger through its intermediate states to the desired state, and then ask for mupen to map it.  Problem solved, and equally intuitive to the user.
Temporary feature removal: localized string resources.

In preparation for major reworking of preference menu system.  Will significantly ease debugging in the interim.  Feature will be re-inserted if/when the branch is ready for integration with master.
[Broken] Commit 1/3: Deleted current menu system (xml and java).

Breaking these commits into parts so that git history is more readable.
[Broken] Commit 2/3: Updated strings and implemented new preference menu.

Breaking these commits into parts so that git history is more readable.

Changed string key names to follow a more systematic convention.  Re-localization will be a small chore later, but I think this approach scales better and is easier to maintain.  Also decouples the design elements (strings) from the procedures (java) better.  For example, string key name isn't an abbreviated form of the english string (what happens if the designer wants to change the string? does the programmer update the key name?).  Instead, the new approach uses key names that are organized by the widget they pertain to (key=myExampleWidget, title=myExampleWidget_title, summary=myExampleWidget_summary, etc.)

Changed some of the English strings to follow the capitalization and stylistic conventions officially recommended by Android.  Changed names of some concepts to reduce my own confusion.  E.g. "touchpad" confuses me because it refers to xperia controls (not the touchscreen); "gamepad" confuses me because it refers to the touchscreen (not an external gamepad/joystick), etc.

Using Android's built-in Preference classes (CheckboxPreference, ListPreference, PreferenceScreen, PreferenceGroup).  Should make it much easier to maintain and extend the menu system, and reduce the amount of boiler-plate code needed to persist user configuration settings to storage.

Created a convenience class, Settings, which just wraps the native preference data to simplify read access, promote type-safety, and consolidate code maintenance to just a few files (Settings.java and preferences.xml).  Also, makes it harder for run-time errors to hide, since all the "risky" accessor functions (SharedPreferences.getBoolean, getString, etc.) are consolidated into the constructor.  So we don't have to wait for a corner case to reveal a broken access attempt; instead it just happens up front.
[Broken] Commit 3/3: Updated java files to use new preference system.

Breaking these commits into parts so that git history is more readable.
New universal architecture for input mapping/listening across all hardware/Android versions/IMEs.

Inputs are collected from the hardware (keyboard, gamepad, touchscreen, xperia hw) and converted to an intermediate "input code" and "strength".  "Strength" is always a float in the range 0-1 (NOT 0-80).  For digital buttons, strength only takes on the values of 0 and 1, but analog axes can range anywhere between.  "Input code" is a signed integer that extends the current notion of "key codes".  Keys, buttons, and IME-mapped analog axes are mapped to positive input codes in the range 1-255.  Native analog axes provided by Android 3.1+ are mapped to negative input codes, with the LSB encoding axis direction.

Inputs are collected by the "InputFunnel" class and its hardware-specific subclasses.  Funnels provide a universal language for abstracting away the hardware variations.  E.g. we should be able to make a funnel for the xperia touchpad and integrate it into the architecture as well.  Input funnels are agnostic to all things N64; they merely provide "input codes" and "strengths" to the subscribed listeners.

Funneled inputs are mapped to N64 controls using the "InputMapPreference" class.  This class encapsulates the entire bidirectional map between "input codes" and N64 buttons/axes.  These maps will be persistable using Android's built-in preference architecture.  Each player's controller will be associated with its own InputMapPreference instance.

Finally, the GameActivity* classes will listen to a single (hardware-dependent) InputFunnel object, and use the InputMapPreference objects to translate from the input codes and strengths to the correct player's N64 buttons/axes, passing them to the core.

Simple!
[Checkpoint] Stable build, incomplete functionality.

Change summary:
- Moved preference-related java files to a sub-package.
- Moved input-related java files to a sub-package.
- Implemented InputMapPreference.java for mapping gamepad inputs to N64 commands (replaces ScancodeDialog.java, IScancodeListener.java, scancode_dialog.xml).
- Implemented FilePreference.java for selecting files (replaces FileChooserActivity.java, MenuOption.java, OptionArrayAdapter.java, IOptionChooser.java, menu_option.xml).
- Consolidated many global settings into Settings.java (replaces Globals.java)
- Removed JoystickListener.java (functionality will be replaced by KeyAxisTranslator.java)
- Removed AlertFragment.java (not currently used, requires higher API).
- Worked out most kinks in input-related classes (InputMap.java, InputTranslator.java, KeyTranslator.java, KeyAxisTranslator.java).
- Stubbed-out abstractor classes for Sensor, Touchscreen, and Xperia-based input.
- Many updates to string, array, preference XML files, reorganization of menu structure a bit.
- Moved developer guides, config files to separate subdirectory

TODO:
- Figure out why key listening isn't working in InputMapPreference.java.
- Figure out strange focus behavior in InputMapPreference.java.
- Consolidate/remove more global variables into Settings.java.
- Re-wire broken functionality (mostly settings rewiring).
[Unstable] Continued refactoring, consolidating, *small changes to cpp*.

--> Eclipse's refactoring tools are really impressive.  Highly highly recommend. <--

Broken:
- Force close on game launch.  Menus are fine.

Changelog:
- Moved all native methods into separate java class, and updated function calls in the cpp source to match new names.
- Consolidated all the GameActivity*.java files back into one file (since xperia and default code were practically identical).
    - I'm probably ignorant of all the stability ramifications... but it was killing me to see so many duplicated lines of code.
    - For now it invokes xperia-play-specific logic based on the user preference... dangerous?
    - Seems like there just has to be a way to auto-detect the hardware and take this issue out of the user's hands.
- Lots more consolidation of global variables, game-state stuff, and user preferences.
    - Renamed some classes/methods for better consistency, clarity IMO.
- All GUI settings are now persisted through android's built-in Preference system.
    - One preference file for user, exposed via menus
    - One preference file for device, hidden from user and used by app to persist internal state between sessions.
    - gui.cfg file removed.
- Error logging functionality encapsulated into a small class (separate interface from implementation).
- Lots of menu tweaks, resource updates, icon changes.
    - Audio and RSP plug-ins can now be disabled.
    - Volume keys can be enabled/disabled for use as control inputs.
- Continuing to work on file and folder preference dialogs (far from perfect).
    - Two classes at the moment, will merge back to one class at some point.
    - Tinkering with implementation, seeing how much mileage we can get with the least amount of code.

TODO:
- Continue consolidating globals, reconnecting functionality.
- Identify cause for force close on game launch (need to git bisect).
- The play option in main menu should be disabled or not present until a game is selected (or possibly bring up the file browser)
- The ROM selection file browser should start in [sdcard]/roms/n64/ by default, or [sdcard]/ if it doesn't exist
- Improve file/folder preference dialog
    - The radio button next to ".." and other folders looks out of place; will likely be confusing to new users
- Improve input mapping dialog
    - Improve user friendliness
    - Is it necessary to have user hold down an icon while pushing a button at the same time?  A listener that pops up after selecting a button to map is more intuitive.
    - There needs to be a way to unmap a button [Actually there is, it just needs to be obvious]
    - While it shouldn't be necessary to show what key a button is mapped to, it might be good to somehow indicate if a button is not mapped
    - Figure out why key listening isn't working in InputMapPreference.java.
    - Figure out strange focus behavior in InputMapPreference.java.
[Checkpoint] Major refactoring, stable menus, broken emulation.

Changelog:
- Major refactoring over entire source.
    - MenuActivity, MainActivity, GameActivity streamlined a bit, implementation broken down, some moved to feature-specific classes.
    - Trying to factor touchpad and touchscreen code into a common abstraction (AbstractController.java), still a lot of work to do, left it pretty messy for the moment.
    - Migrated many global variables into classes, limiting many to local scope now.
    - Renamed a lot of classes and functions, trying to use a consistent taxonomy of names to highlight code structure and class relationships (e.g. AbstractController, TouchscreenController, XperiaPlayController, GamepadController)
- Added more subpackages to simplify code browsing and highlight code structure.
    - Activities and views still in root package.
    - Utility classes in 'util' subpackage.
    - Classes relating to persistent data (appdata, user prefs, pathnames, etc.) in 'persistent' subpackage.
    - Controller abstractions (touchscreen, touchpad, gamepad, etc) in the 'input' subpackage.
    - Hardware listeners and translators in 'input.transform'.
- Migrated a lot of app data to a SharedPreferences-based implementation, to simplify persistence, access, and reset.
- Expanded the convenience/wrapper classes that simplify and speed read access for user prefs, app data.
- Consolidated native code into NativeMethods.java
    - Just a bunch of wrappers, implementation in focused classes.
    - Names properly updated in the C++ code.
- Notification (toast and status bar) encapsulated in a simple class, callable from any activity.
- Re-implemented the file/directory preference (PathPreference.java) for more intuitive behavior.
    - Removed radio button icons (confusing)
    - Optionally, user can be limited to selecting only files or only directories
    - This option can be set in the XML file
- Simplified the selection of touchscreen layout (layout and size are separate options).
- Added a user preference for the save-game location.
- Moved the ingame menu definition to an XML resource, removed exit function from menus.
- Lots of tweaks to various XML resource files
- Removed some obsolete activities from AndroidManifest.xml.
- Thorough javadoc comments for a number of files.

TODO:
- Diagnose and correct force close on game launch (something broke during refactoring)
- Get basic emulation capabilities back up and running
- Continue consolidating globals, reconnecting functionality.
- The play option in main menu should be disabled or not present until a game is selected (or possibly bring up the file browser)
- Improve input mapping dialog
    - Improve user friendliness
    - Is it necessary to have user hold down an icon while pushing a button at the same time?  A listener that pops up after selecting a button to map is more intuitive.
    - There needs to be a way to unmap a button [Actually there is, it just needs to be obvious]
    - While it shouldn't be necessary to show what key a button is mapped to, it might be good to somehow indicate if a button is not mapped
    - Figure out why key listening isn't working in InputMapPreference.java.
    - Figure out strange focus behavior in InputMapPreference.java.
[Checkpoint] Basic emulation capability working, touchscreen controls and in-game menu broken.

Stupid bug in UserPrefs.java - isLastGameNull was computed improperly, so app was just exiting, as per design.
[Checkpoint] Touchscreen controls and in-game menu functional again.

Changelog:
- Touchscreen controller functional again.
- In-game menu functional again.
- Changed slot menu item behavior in in-game menu (now provides a dropdown to select the slot directly).
- Fixed bug in hardware type not persisting properly.
- Removed some of the System.exit(0) calls.
- Changed activity finish() semantics to better follow recommended practice (I think).
    - No longer finish() MenuActivity when GameActivity starts.
    - Reduced number of System.exit(0) calls.
    - GameActivity calls finish() from ingame menu, and Android naturally pops the stack and brings the last MenuActivity back to the foreground.
    - We still call finish() on MainActivity after it launches MenuActivity, since we never want to return to the splash screen.

TODO:
- Returning to MenuActivity from GameActivity still creates a force-close -- may be a threading issue, other thread calling stale objects
- ResumeLastSession==true causes the emulator to hang when GameActivity is launched.  Temporary workaround is to set to false.
- The TODO's in the last commit still apply.
Japanese translation for the new UI.
Missed a string for the Japanese TL. Also fixed spacing in one string.
Custom touchscreen skins functional again, and more refactoring

Changelog:
 - Custom and standard touchscreen skins available in preferences (a
   little different organization than before).
 - All translatable strings moved out of res/values/arrays.xml and into
   strings.xml.
    - All translation done by overriding one file, strings.xml.
    - Old method with raw strings in arrays.xml could lead to code
      maintenance issues as more elements are added to the array.
 - Moved some string literals out of the java code and into strings.xml
 - Changed pattern in MenuActivity.java for accessing menu items (from
   object comparisons to key comparisons), simplifies code maintenance
   and extension a bit.
 - Layout and menu resources now named after the class they're used in
   (simplifies lookup).
 - Minor code tweaks (formatting, comment touch-ups, etc for consistent
   look and feel).
 - Trying to reduce the size of some class implementation by factoring
   out utilities, etc. into other classes.  For now Utility.java is
   a dumping ground to be cleaned up later.

TODO:
 - See last
Simplification in PathPreference.java (get rid of a for loop)

Clean up the horrible looking array declarations at one part in SDLSurface.java

Also fix some javadoc params.
Remove a static modifier that slipped through.

Wish I'd have caught this before committing.
Centralize the Controller button/stick values into its own class. Now this doesn't need to be pasted in both controller classes.

Fix up XperiaPlayController.java a bit. Removed some redundant code, used the Utility equivalents of Point, etc.
Minor changes to class names, strings, comments

Changelog:
 - Renamed GamepadController to PeripheralController, since it
   encapsulates many types of peripherals (keyboard, gamepad, joystick)
 - Added some comments to clarify AbstractController architecture.
 - Fixed a few broken string resources/keys
 - Added annotations to disable code formatter in some places