diff --git a/mobile/android/Android_Studio_Setup.md b/mobile/android/Android_Studio_Setup.md
new file mode 100644
index 0000000..c65ca84
--- /dev/null
+++ b/mobile/android/Android_Studio_Setup.md
@@ -0,0 +1,18 @@
+## Setup Android Studio
+###Download/Install Android Studio
+To build our Android app we'll be using an IDE called Android Studio. An IDE is a programming environment that allows you to edit files, compile and run your code, and has other features built into it like debugging. Lets start by [Downloading Android Studio](http://developer.android.com/training/basics/firstapp/index.html) To get it to work you'll also need to install [Java](TODO:link).
+
+###Download SDK tools
+TODO: SDK stuff here or after? test fresh install studio on windows.
+
+###Setting up a New Project
+Once Android studio is set up we'll need to start a [New Project](http://developer.android.com/training/basics/firstapp/creating-project.html). Open Android studio and select 'Start a new Android Studio Project', use a Minimum SDK of API 16 (Jelly Bean), and when prompted to choose starting Activity, choose 'Empty Activity'
+Minimum SDK is the minimum version of the Android Operating System required to run your app. We chose 16 because most phones run that or newer, and it allows us to use new Android features.
+The starting Activity is the code that Android Studio will generate to start your project. Well explain what Activity and Fragment are in a bit.
+Android studio should now generate your starting project, once it finishes indexing (loading bar at the bottom of the screen) it will drop you into the screen pictured below (TODO: Get screenshot from windows AS).
+
+### Running project on Device/Emulator
+To make sure it worked correctly, click the green 'Run' arrow at the top of the screen. This will compile the starting code and prompt you for a device to run it on. If you are using the emulator for testing, check Launch Emulator at the bottom and click OK, this will start a virtual device and run the app on it (may take while to start). If you are using a real device, plug in your phone and accept the prompt on the device, then it should appear under 'Choose a running device'. Select it and click OK to run the app on your phone. Your app should open with a white screen that says 'Hello World'. (TODO: add picture)
+
+### Problems?
+Thats what mentors are here for, feel free to ask for help with any problems you have, if you feel up to the challenge you can also try searching your problem on [StackOverflow](http://stackoverflow.com/) or just Google.
diff --git a/mobile/android/Android_Studio_Tips.md b/mobile/android/Android_Studio_Tips.md
new file mode 100644
index 0000000..ca96542
--- /dev/null
+++ b/mobile/android/Android_Studio_Tips.md
@@ -0,0 +1,9 @@
+## Android Studio Tips
+### Android studio view (structure project preview)
+- Project (left): Shows files in android structure
+- Structure (right): Shows functions and inner classes of files
+- Android (bottom right): Shows logs from device
+- Run (bottom left): Options for running project
+- Terminal (bottom left): Command line
+
+### [Android studio shortcuts](https://teamtreehouse.com/library/android-tools/getting-started-with-android-studio/helpful-keyboard-shortcuts)
\ No newline at end of file
diff --git a/mobile/android/Beautify_App.md b/mobile/android/Beautify_App.md
new file mode 100644
index 0000000..7ec5b4b
--- /dev/null
+++ b/mobile/android/Beautify_App.md
@@ -0,0 +1,36 @@
+# Beautify app
+## Colors
+### Defining colors in colors.xml
+- Colors
+
+### Using Colors in Layouts
+- Change text color
+
+### Using Colors in Java
+- Change Map properties if possible?
+
+## Themes
+### Create Dark/Light Theme
+- Create new colors
+- Define theme
+
+### Using Theme
+- Use theme attributes in styles
+
+### Add Theme to Settings
+- If made settings
+
+## Defining Styles
+### Defining Styles
+- Text Style2
+- CardStyle
+- Button Style
+
+### Using styles
+
+## Portrait/Landscape Layouts
+### Dimensions
+- Use Dimens for different sizes
+
+### Alternate Layouts
+- Use Alternate layout for found screen
diff --git a/mobile/android/Caching_Data.md b/mobile/android/Caching_Data.md
new file mode 100644
index 0000000..d50fd3c
--- /dev/null
+++ b/mobile/android/Caching_Data.md
@@ -0,0 +1,4 @@
+# Cacheing Data
+- Store json to use off network
+- Take in onError Callbacks
+- Check connectivity
\ No newline at end of file
diff --git a/mobile/android/Found_Caches_Page.md b/mobile/android/Found_Caches_Page.md
new file mode 100644
index 0000000..0a66a4f
--- /dev/null
+++ b/mobile/android/Found_Caches_Page.md
@@ -0,0 +1,320 @@
+# Found Caches Page
+## RecyclerView
+### Add the RecyclerView to Layout
+Lets start with building the found caches page, basically this page is a list of the name and difficulty of caches you have found. We will build this list with what is called a `RecyclerView`, lets add one to our found caches layout underneath our Button.
+``` xml
+
+```
+
+### Getting the Support Design Library
+To use `RecyclerView` you need to grab some code that doesnt come packaged with android, we will do this through `gradle`. In the project tab on the left there is a section called 'Gradle Scripts', open up `build.gradle (Module: app)`. `Gradle` is Android's build system that you can also use to automate some build related tasks. Basically it takes our Java code and XML and packages them into an APK that you can run on your phone, we wont be working with it much today besides using it to fetch code like we are now. In the `dependencies` section add `compile 'com.android.support:design:23.2.0'`, this will allow us to use elements from the support design library (version 23.2.0) by including it when we build our app.
+
+### What is RecyclerView
+`RecyclerView`s are a bit tricky to work with, lets take a look at what they are before we dive in. To work a `RecyclerView` needs an `Adapter`, `LayoutManager`, `ViewHolder`, a list of data to display, and a layout to show it in. It will show this data as a list of `Views`
+
+**Adapter:** When a `RecyclerView` is displayed it asks its `Adapter` to create `View`s from the data it has until it fills the screen completely. As the user scrolls the `Adapter` 'recycles' the `View`s that go off screen to make new ones by changing the data in the `View`'s `ViewHolder`, and gives the `View` back to the `RecyclerView` to show.
+
+**ViewHolder:** The `ViewHolder`s are attached to each `View` and when given an entry from the data list 'bind' the data to their `View`, meaning it sets the information in the `View` based on the data it received.
+
+**Data List:** The `RecyclerView` needs a data entry for every element is displays in its list, this data will be used to show the proper `Views` through the `ViewHolder`s.
+
+**Layout:** The `RecyclerView` needs a layout to inflate for the items it will display. For our first example we will use a `TextView`, later we will made our own layout.
+
+**LayoutManager:** The `LayoutManager` tells the `RecyclerView` how to lay out or display its list of items.
+
+### LayoutManager
+Back in FoundCachesFragment, get a reference to the `RecyclerView` the same way as we did the `Button` or `TextView`. Lets start by setting our `LayoutManager` like so `yourRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));`, you wont have to worry about what this is doing but basically LinearLayoutManager means the data will display in a straight vertical list.
+
+### ViewHolder
+Our RecyclerView will be really simple for now, we'll show a List of `TextView`s which means our `ViewHolder` will be pretty simple. Classes inside files, or 'inner' classes are defined the same place a method would go.
+``` java
+private class CacheHolder extends RecyclerView.ViewHolder {
+
+ // We will modify the text in this TextView when we get bound to data
+ private final TextView nameTextView;
+
+ // itemView is the View this ViewHolder controls
+ public CacheHolder(TextView itemView) {
+ super(itemView);
+ nameTextView = itemView;
+ }
+
+ // This is called when a View is recycled and given new data, or first created
+ // cacheName will be from our data list
+ public void bindCache(String cacheName) {
+ nameTextView.setText(cacheName);
+ }
+}
+```
+Our `ViewHolder` will be created with a `View` that it will then modify when it is Bound to some data. In this case the data is just the name of the cache, later on we will bind a data object to this view that will have all the information we want to display about it.
+
+### Adapter
+Our adapter is responsible for inflating or recycling `View`s for the `RecyclerView` to display, as well as keeping track of the data definind the list. This class is a bit longer but still fairly simple.
+``` java
+private class CacheAdapter extends RecyclerView.Adapter {
+
+ // This is our list of data
+ private List itemNames;
+
+ // Our adapter is created with this data list to display
+ public CacheAdapter(List itemNames) {
+ this.itemNames = itemNames;
+ }
+
+ // Called when a new view needs to be created, creates a View and ViewHolder
+ @Override
+ public CacheHolder onCreateViewHolder(ViewGroup parent, int pos) {
+ TextView view = new TextView(getContext());
+ return new CacheHolder(view);
+ }
+
+ // Binds a given ViewHolder to data at the same position in the list
+ @Override
+ public void onBindViewHolder(CacheHolder holder, int pos) {
+ String name = itemNames.get(pos);
+ holder.bindCache(name);
+ }
+
+ // If we have no value for itemNames we cant create any items,
+ // otherwise we can create as many as we have data point
+ @Override
+ public int getItemCount() {
+ if (itemNames == null) {
+ return 0;
+ }
+ return itemNames.size();
+ }
+}
+```
+
+### Data List
+The last thing we have to do to make our `RecyclerView` work is give it data, and set the `Adapter`. Becuase our adapter just has a list of names, lets make an `ArrayList` of names and add some.
+``` java
+ArrayList itemNames = new ArrayList<>();
+itemNames.add("Cache 1");
+// Add more elements to data list
+```
+Then all have have to do to put everything together is create and set your `Adapter`.
+``` java
+yourRecyclerView.setAdapter(new CacheAdapter(itemNames));
+```
+You should now have a working recycler view, make sure it compiles and runs correctly, you should see your names that you put in `itemNames` underneath your `Button`
+
+## Getting Data
+### JSON
+Now that we have our `RecyclerView` its time to get some real data to put in it, eventually were going to be getting this data from our server online, but for now were going to read the data from a file locally in resources. The format were going to store our data in is called JSON, basically it's a way to write our data that is easy for us to read, as well as for a computer to use.
+``` json
+{
+ "Cache 1": {
+ "name": "Cache 1",
+ "difficulty": 3,
+ "found": 1456883400000
+ },
+ "Cache 2": {
+ "name": "Cache 2",
+ "difficulty": 3,
+ "found": 1456531200000
+ },
+ "Cache 3": {
+ "name": "Cache 3",
+ "difficulty": 3,
+ "found": 1456531200000
+ }
+}
+```
+This is what the JSON file looks like for our found caches, lets go through whats happening here. In JSON, everything is stored by some 'key' like in a `Map`. Our first element has the key `Cache 1` and the value
+``` json
+"name": "Cache 1",
+"difficulty": 3,
+"found": 1456883400000
+```
+Each of these values still maps a key, for example `difficulty` to a value `3`. We will be using the cache names as their keys.
+
+## Create JSON Resource
+Now that we know a bit about JSON lets start using it, create a new 'Android Resource Directory' in `res` called `raw` with resource type `raw`, then inside `raw` (you might have to refresh the menu to see it) create a file called `caches_found.json`. Copy the response from before into this file.
+``` json
+{
+ "Cache 1": {
+ "name": "Cache 1",
+ "difficulty": 3,
+ "found": 1456883400000
+ },
+ "Cache 2": {
+ "name": "Cache 2",
+ "difficulty": 3,
+ "found": 1456531200000
+ },
+ "Cache 3": {
+ "name": "Cache 3",
+ "difficulty": 3,
+ "found": 1456531200000
+ }
+}
+```
+
+## Reading from Resources
+Since we dont want to make our `FoundCachesFragment` too large we'll write our code to load this JSON file ielsewhere create a new Java Class in your java folder with `MainActivity` and `FoundCachesFragment` called `DataUtilities`. This is where we will write all our code related to reading, and later fetching and sending data. Lets write a method called `getFoundCaches` inside this class that takes in a `Context` like so `public static void getFoundCaches(Context context) {`. This method is `static` meaning that it can be called without an instance of the class like so `DataUtilities.getResponseText(context)`. When reading from raw resources we use something called an `InputStream` to read the file, The next block of code seems scary and I wont go into how it works, but it reads the json file `caches_found` we wrote earlier into a `String` called `json`.
+``` java
+try {
+ InputStream is = context.getResources().openRawResource(R.raw.caches_found);
+ int size = is.available();
+ byte[] buffer = new byte[size];
+ is.read(buffer);
+ is.close();
+ String json = new String(buffer, "UTF-8");
+} catch (IOException ex) {
+ ex.printStackTrace();
+}
+```
+The `try` and `catch` are keyword we use if something might go wrong. We try to run the code in the first block and if something goes wrong trying to read the file the system will 'throw' and `IOException` object that would normally crash the app. If this happens within the first block we instead 'catch' the exception, give up on what we were trying to do and run some other code instead. In this example we print out the exceptions 'stack trace' which is a log of what went wrong to cause the exception to get thrown.
+
+## Serializing JSON Objects
+Now we have a String of our JSON file, which is really hard to use as is. What were going to do now is convert this String to a more useable object, a `Map` of cache names to `FoundCache` objects, which will have `name`, `difficulty` and `found` as variables. What were going to use to do this is a tools called Gson, which will take our String and automatically convert it to an object we define. Lets start by creating our 'model' object that mirrors how our JSON data is set up. Create a new Java class called `FoundCache` that looks like we just described.
+``` java
+public class FoundCache {
+ public String name;
+ public int difficulty;
+ public long found;
+}
+```
+When using Gson the variable names we use here have to match the keys in the JSON file.
+
+To use Gson we have to include it with `gradle`, add `compile 'com.google.code.gson:gson:2.3'` to the gradle file the same place we did before. Now if we go back to `DataUtilities` we can add
+``` java
+Gson gson = new Gson();
+// This responseType is what we will convert our json into, a 'Map'
+Type responseType = new TypeToken>() {}.getType();
+Map foundCacheMap = gson.fromJson(json, responseType);
+```
+underneath `String json = new String(buffer, "UTF-8");`, notice the method `fromJson` takes `responseType` as a parameter which tells gson what type of object it is creating. We now have a method that reads our JSON file and gets an object with the information we need to fill our `RecyclerView`.
+
+## Callbacks
+Now that we have a way to get this data let's send it to our `FoundCachesFragment`. The easiest way to do this would be to return the object from the function, but this causes problems later on when we get the information from online. When we call a method our phone waits till it finishes before moving on to do anything else, this causes issues if it takes a while for the method to finish as it would freeze your phone until it was done. We can get around this by running our code on a seperate 'thread' which we'll explain later, but that means we cant return from this method.
+
+What we do instead is define a 'callback', an object that defines a function to run when something happens like our OnClickListener running code when our `Button` got clicked. To create a callback we define an `interface` with one method `onResults(Map results)` which we will call when we finish serializing the JSON file.
+``` java
+public interface FoundCachesReceiver {
+ void onResults(Map results);
+}
+```
+Add this to DataUtilities above the method `getFoundCaches`. When we call `getFoundCaches` we want to get a callback to send back the data with so add `FoundCachesReceiver receiver` as a parameter to the `getFoundCaches` method and add `receiver.onResults(foundCacheMap);` after serializing our JSON file. Now our method takes in a callback, and fires its function when it has the data ready.
+
+## Using DataUtilities
+In our `FoundCachesFragment` we can now get the list of found caches easily by calling
+``` java
+DataUtilities.getFoundCaches(getContext(), new DataUtilities.FoundCachesReceiver() {
+ @Override
+ public void onResults(Map results) {
+ // Do something with the results
+ }
+});
+```
+
+## Display Cache names in RecyclerView
+Since we want this list to get displayed in the `RecyclerView` let's modify it a bit to take in `FoundCache` values instead of `String`s. First change the `CacheAdapter` constructor to take in a `List` of `FoundCache`s, also change the type of the `items` variable. The last thing we have to do to in the `Adapter` is change `String item = items.get(pos);` to `FoundCache item = items.get(pos).name;` in `onBindViewHolder`. Next in `CacheHolder` modify `bindCache` to take in a `FoundCache cache` and display `cache.name`. The last thing we have to do is supply the right data. Let's replace
+``` java
+ArrayList itemNames = new ArrayList<>();
+itemNames.add("Cache 1");
+itemNames.add("Cache 2");
+itemNames.add("Cache 3");
+cachesRecycerViewAdapter = new CacheAdapter(itemNames);
+cachesRecycerView.setAdapter(cachesRecycerViewAdapter);
+```
+with the DataUtilities call from before, and where we have `// Do something with the results` we can create an adapter from our fetched data
+``` java
+// This takes our Map and makes a List of the values
+List caches = new ArrayList(results.values());
+cachesRecycerViewAdapter = new CacheAdapter(caches);
+cachesRecycerView.setAdapter(cachesRecycerViewAdapter);
+```
+Try running the app and make sure it works, for now it should display the names of the caches (`Cache 1`, `Cache 2`, `Cache 3`)
+
+## Cache info Layout
+Let's continue by showing the rest of the data in our list. To do this we'll first need something to display the data in, create a layout called `found_cache_list_item` or something similar under res/layouts (Note that you can't use capital letters or spaces in resource names). Because creating layouts can be time consuming I've created this one for you to copy into your new file.
+``` xml
+
+
+
+
+
+
+
+
+
+
+
+
+```
+Theres a few things here you haven't seen before, lets list them quick.
+- `CardView`: a special layout that shows its contents in 'cards', if you want to see what this looks like switch to the design view.
+- `layout_margin`: similar to padding, but pushes other elements away from it rather than making itself bigger to fit its contents with space inside. Defined in `dp` or Density-independent Pixels which are a size unit that scales with pixel density on the screen (`dp` stays the same physical size).
+- `textSize`: fairly self explanatory, this sets the text size in `sp` which is similar to `dp` but takes users font size into consideration.
+- `layout_marginEnd` and `layout_toEndOf`: not all phones are layed out right to left, if it isn't then `End` refers to the end of the layout which would be right for us. `layout_marginStart` or `layout_toStartOf` would be the opposite.
+
+To use `CardView` we need to add `compile 'com.android.support:cardview-v7:23.2.0'` to our gradle file to fetch the code we need the same way we did `gson` and the design library.
+
+## Using the Cache info Layout
+Now that we have our layout let's put it to use, go back to our `CacheAdapter` and where we have `TextView view = new TextView(getContext());` we will inflate our new layout instead `View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.found_cache_list_item, parent, false);`.
+
+We should also modify our `CacheHolder` to give it two extra variables `difficultyTextView;` and `findTimeTextView;` both of which are `TextView`s, these will come from the layout we just defined. In the constructor change `TextView itemView` to `View itemView` and set `nameTextView = (TextView) itemView.findViewById(R.id.cache_name);`, doing the same for the other two variables using `R.id.cache_difficulty` and `R.id.cache_find_time` as the element Ids. Now we have all the data we need to display, in `bindCache` add
+``` java
+difficultyTextView.setText(Integer.toString(cache.difficulty));
+findTimeTextView.setText(Long.toString(cache.found));
+```
+
+## Formatting and FormattingUtilities
+If we run our app now it shows a list of all our data but not in a format that we can read, Lets creat another class called `FormattingUtilities` where we'll put any methods we use to format data to be readable. First lets add two methods to format difficulties and find times, each will take in the data we have and output a `String` that we can display.
+``` java
+public static String getDifficultyString(int difficulty, Context context) {
+ return "";
+}
+
+public static String getTimeAgoString(long timestamp, Context context) {
+ return "";
+}
+```
+Notice that these methods are both `static` meaning that this class doesn't need to be instantiated to use these methods. Both methods also take in a `Context` which will be used to get `String`s from resources.
+
+Let's add two new entries in `strings.xml` that will be used in our cards with values `Found %s` and `Difficulty %d of 5`, you can pick names for them that make sense. Remember from before that `%d` is a number placeholder, `%s` is a placeholder but for a `String`.
+
+Back in FormattingUtilities `getDifficultString` will work the same way as our button click counter did before, simply return `context.getString(R.string.difficulty_out_of_five, difficulty)` and it will fill in the placeholder with our difficulty. For `getTimeAgoString` we're going to use something bulid into Android called called DateUtils to format our time nicely. `DateUtils.getRelativeTimeSpanString(context, timestamp).toString();` returns a `String` which formats our time nicely eg. "42 minutes ago". Inject this value into our other `String` the same way we did the number placeholder by using `getString` and passing the result of `getRelativeTimeSpanString`.
+
+If we go back to our `CacheHolder` we can replace our `Integer.toString` and `Long.toString` with `FormattingUtilities.getDifficultyString(cache.difficulty, getContext())` and `getTimeAgoString(cache.found, getContext())`.
+
+Try running the app, you should see our list of caches display with all the data from our `caches_found.json`.
+
+## Cleaning up
+We're finished work on the 'Found' page for now, if you feel like it go through and take out the stuff we added at the start, `helloWorldTextView` + `clickMeButton` in our `FoundCachesFragment` fragment and `my_text_view` + `my_button` in the `fragment_found_caches` layout.
diff --git a/mobile/android/Geocaching_App.md b/mobile/android/Geocaching_App.md
new file mode 100644
index 0000000..ca1011d
--- /dev/null
+++ b/mobile/android/Geocaching_App.md
@@ -0,0 +1,172 @@
+# Building the GeoCaching App
+## What are we making
+Now that we have an app compiling and running, lets start customizing it to make our Geocaching app. In our app we will have three screens shown below, a list of caches the user has found, a map showing caches at their locations, and a settings page.
+TODO: add pics
+
+## Whats here now
+If you open up the project tab on the left you will be able to view all the files in the project, for the most part we will be worried about files in java folder which will be your code, and files in the res (resources) folder which will define how your views are laid out and a few other things like colors, images, and text. To start we will look at the Fragment and Activity that we start with, and the xml layouts that go with them.
+
+### MainActivity.java
+Activities in Android are entry points into the app that let you show something on the screen, and interact with the system. If you open up MainActivity under the java/yourApplicationName folder you will see the following.
+``` java
+package com.example.jzukewich.geocaching;
+
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ }
+}
+```
+The first line, `package com...` is where our file is located in the project, we wont worry about this. Our imports are Android built in classes that we need, like when we used `import java.util.Arraylist;` before. In `onCreate`, which you might notice Overrides the method from `MainActivity`'s parent class `AppCompatActivity`, we call `AppCompatActivity`s onCreate and the method `setContentView` that sets the screen to show `R.layout.activity_main`, our activity's view. `R` means resources, so we can find this file in `res/layout/activity_main`, lets go take a look.
+
+### activity_main.xml
+Welcome to XML, this is how we usually define our Views in Android. XML allows us to set values like width, height, text, and a bunch more depending what kind of View we are describing. In this case, our Activity's View is very simple, all it is displaying is one line of text, which says "Hello World!".
+``` xml
+
+
+
+
+```
+`
+
+
+```
+If we click 'Design' at the bottom of the file we can preview what this will look like, notice that the button appeared on top of the text, thats because in a `RelativeLayout` every child needs to define its position relative to something else. Lets have our `Button` appear below the text, to do this we first need to give our `TextView` an Id, add `android:id="@+id/text_view"` at the start of the `TextView`.
+``` xml
+
+```
+Adding this Id allows our `Button` to use the `TextView`, we can now add `android:layout_below="@+id/text_view"` to our `Button`. Lets also give our `Button` an Id the same way we did the `TextView`
+``` xml
+
+```
+Lets make sure this works by going back to the 'Design' tab (if it doesn't ask a mentor for help)
+
+### Strings
+You might have noticed that Android Studio has highlighted `android:text="Test Button"`, if you hover over the text, it says you should use an @string reference instead of a hardcoded string. What this means is that we should write "Test Button" elsewhere, in a file called `strings.xml` and reference it here. If you look at the 'Project' tab on the left, underneath the `layout` folder there will be one called `values`, open up the file called `strings.xml` inside. You should see
+``` xml
+
+ Geocaching
+
+```
+This file is where we will put all the text that our app uses, which will make it easier to make changes later on, as well as having a few other benifits we wont talk about today. Each String one has a name which us used to access it, and a value. For example `Hello world! ` has the name `hello_world` and value "Hello World!". Lets define another String called `button_title` to put on our `Button`. Add `Click Me ` on a new line under `Geocaching `.
+
+If we go back to `activity_main.xml` we can now replace `"Button Text"` with `"@string/button_title"` which will fill in the text from our strings file, "Click Me". Check again to make sure this worked.
+
+## Button Clicks
+### Finding the Button in Java
+Now we have our button, lets make it do something. To do this we'll need to write some java code to go with our button, the first thing we need to do is get a reference to the button in our `MainActivity`. To do this we use a method built in to `Activity` called findViewById, which returns a `View` object of whatever type the element is. Let's add `Button clickMeButton;` as a variable above the `onCreate` method, and add `clickMeButton = (Button) findViewById(R.id.my_button);` under the call to `setContentView`. What this does is give our MainActivity a variable called `clickMeButton` of type `Button`, and assign it to the object returned by `findViewById`, which will be our `Button` we made earlier as `my_button` is the Id we gave it. The `(Button)` before `findViewById` is called a cast, `findViewById` returns a `View` object, meaning anything that extends the `View` class. By casting it we are specifying what type of `View` this is, in our case a `Button`. Notice that `Button` is red everywhere, this is because we didn't import the class. If you click on `Button` and press (TODO: get Windows Shortcut) or `alt+return` on a Mac, it should automatically import the class for you.
+
+### OnClickListener
+Now we have a reference to our `Button`, lets make it do something when we click it. To do something when a `Button` is clicked we give the `Button` an object that imlements a class called `OnClickListener` with one function `onClick(View v)`. Add the following under where you assign `clickMeButton`
+```java
+clickMeButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // This method will get called when the Button is clicked
+ Log.i("Geocaching", "Button Clicked");
+ }
+});
+```
+What we are doing here is creating an `OnClickListener` and defining what is does when clicked, then passing that object to our `Button`. When the `Button` is clicked this objects `onClick` is called and calls `Log.i("Geocaching", "Button Clicked");`. `Log` is a bit like Androids version of `System.out.println`, you give it a Tag (Geocaching) and some text to output (Button Clicked) and it gets printed in something called `logcat`. If we click on the tab labeled "Android" at the bottom right of the screen out `logcat` should open up, it shows a list of things our app has outputted. If we tap the `Button` we created it should print "Button Clicked" here.
+
+### Debugging
+When we write code there's a lot that can go wrong, lets go through one of these and how to fix it. Let's say we forgot to get a reference to our clickMeButton before we set its click listener, comment out the line `clickMeButton = (Button) findViewById(R.id.my_button);` by adding `//` at the start. If we run our app now it will try to run on our phone and crash, showing a dialog that says "Unfortunately, Geocaching has stopped.". To tell what went wrong open up `logcat`, you should see a really long red block of text which represents what went wrong and made our app crash. If you scroll down to the last section of this crash log you should see
+```
+Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.Button.setOnClickListener(android.view.View$OnClickListener)' on a null object reference
+ at com.example.jzukewich.geocaching.FoundCachesFragment.onCreateView(FoundCachesFragment.java:38)
+ at android.support.v4.app.Fragment.performCreateView(Fragment.java:1974)
+ ...
+```
+What this means is that a `NullPointerException` happened in our code when we tried to call the method `setOnClickListener` on an object that was `null`. It happened at `FoundCachesFragment.onCreateView(FoundCachesFragment.java:38)` or line 38 of `FoundCachesFragment` in our `onCreateView` method. If you search for `NullPointerException` online you might find something like [this](http://stackoverflow.com/questions/218384/what-is-a-null-pointer-exception-and-how-do-i-fix-it) that explains what this exception is and how to fix it. For today mentors will be around to help you sort out issues like this, but before asking for help try googling to see if you can figure out your issue, you'll find a lot of really helpful answers on sites like [StackOverflow](http://stackoverflow.com/).
+
+### Changing TextView
+Lets change the text in our textView when the button gets clicked, to do that well first need to get a reference to our `TextView`. We do this the same as we did our `Button` earlier. Add a variable of type `TextView` to the class and get the object by the id `my_text_view`, make sure to cast it to `TextView`. Now in the `OnClickListener` after Logging the click, add `yourTextView.setText("Button has been clicked");`.
+
+### Formatting Text
+Maybe we want the user to know how many times they clicked the button, lets start by adding a variable to count the clicks. Add `private int buttonClicks = 0;` with your other variables, when the button is clicked, increment `buttonClicks` by one (`buttonClicks++;`). Now we want to set our `TextView` to something like 'Clicked _ times', to do this we'll use specials Strings. In strings.xml define a new string with some name and a value of `Clicked %d times`, the `%d` is a number placeholder that will get replaced by our times clicked. In `MainActivity`, to use this String we will need access to our apps resourses, we get this using `getResources()` which returns a `Resources` object. We can use this object to call `getString(R.string.my_string_name, buttonClicks)`, buttonClicks will replace the `%d` in the string. To chain these functions together we write `String clicks = getResources().getString(R.string.button_clicks, buttonClicks);`. Now that we have our `String`, set it as the text in your `TextView` the same way as before.
+
+## Fragments
+### Creating a Fragment
+Right now our `Activity` which will run our whole app holds our view. This is a problem because as you saw before we want to show a few different screens in our app. We solve this problem by using `Fragments`, which are screens that our `Activity` can show, and switch between.
+
+Lets start by creating a new Java file called `FoundCachesFragment.java` (this `Fragment` will become our found caches list). Right click on com.yourpackagename under java and select new -> Java Class, enter `FoundCachesFragment` for the name. The first thing were going to do is make our class extend Fragment so add `extends Fragment` after the class name. We also need to import the `Fragment` class so add `import android.support.v4.app.Fragment;` below the package name. You might notice were using `android.support.v4.app.Fragment` instead of `android.app.Fragment`, `support.v4` is a Library that lets you run things on older devices, dont worry much about this as were doing it to avoid some complex stuff later on.
+
+Now that we have our `Fragment`, lets build a layout for it to use, create a new Layout resource File under `layout` called `fragment_found_caches` (the same way you did the class) and replace the generated LinearLayout with the contents of activity_main. Then remove the line `tools:context="com.example.jzukewich.geocaching.MainActivity"` from the new file.
+
+Going back to our `FoundCachesFragment`, lets make it display the file we just made. `Fragment`s have a built in function called `onCreateView` where you can set what it should show, lets start by Overriding it. Add the method below to `FoundCachesFragment`
+``` java
+@Override
+public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+ return null;
+}
+```
+Now whenever our `Fragment` gets shown, this method will be called and some `View` will be returned to display. Right now we return `null` which basically means nothing. Two of the parameters pased to the `onCreateView` function are a `LayoutInflater` and a `ViewGroup`. The first we will use to create a `View` out of our layout file (or 'inflate' the layout), the other is what we will attach our newly created view to.
+``` java
+View rootView = inflater.inflate(R.layout.fragment_found_caches, container, false);
+return rootView;
+```
+What this does is get our `fragment_found_caches` layout, and use the `LayoutInflater` called `inflater` to create a `View` called `rootView` from the layout. We then return `rootView` to be displayed on the screen.
+
+### Showing our Fragment
+Now that we have a `Fragment` that will display our layout, lets get our `Activity` to use it. We'll start by opening up `activity_main.xml` and replacing everything in that file with
+``` xml
+
+```
+Our `Activity`'s layout now contains a `](Found_Caches_Page.md)
diff --git a/mobile/android/Geocaching_App_Extentions.md b/mobile/android/Geocaching_App_Extentions.md
new file mode 100644
index 0000000..3d781d3
--- /dev/null
+++ b/mobile/android/Geocaching_App_Extentions.md
@@ -0,0 +1,4 @@
+## Extend it further
+- [Camera](#)
+- Other cool apis
+- Device functionalities (Accelerometer etc)
\ No newline at end of file
diff --git a/mobile/android/Java_Introduction.md b/mobile/android/Java_Introduction.md
new file mode 100644
index 0000000..8d34a02
--- /dev/null
+++ b/mobile/android/Java_Introduction.md
@@ -0,0 +1,452 @@
+##Java
+
+To start todays lesson were going to take a quick look at the language Android apps are written in, Java. Open up the [Java Online Editor](https://www.compilejava.net/) to get started.
+
+### Main
+To start, replace the generated code with the following
+```java
+public class JavaExamples {
+ // The main method is the start of a normal Java program
+ public static void main(String[] args) {
+ // This will print out "Hello world!" to the console
+ System.out.println("Hello World!");
+ }
+}
+```
+If we run our code now, after compiling, it will run the `main` method and execute the command `System.out.print("Hello World!");` which prints "Hello World!" to the console. Note that anything after `//` does not run as code, this is called a comment. For now all the code we write will go inside the `main` method, where `System.out.println("Hello World!");` is now.
+
+
+### Data types
+In Java, we store a few different types of values, the most common are `Integers` (numbers), `Strings` (text), and `Booleans` (true or false values). We store these values in things called variables by writing
+```java
+String someText = "Text to Print";
+```
+After we have stored our variable, a `String` (or text) named `myText`, we can access its value with just the variable name. Replace our old `System.out.println("Hello World!");` with
+```java
+String someText = "Text to Print";
+System.out.println(someText);
+```
+and rerun our program.
+
+We can also store numbers or booleans like so
+```java
+int someNumber = 13;
+System.out.println("My favorite number is: " + someNumber);
+
+boolean areWeDoneYet = false;
+System.out.println("Are we done yet: " + areWeDoneYet);
+```
+As you can see in the above code, Strings (things in quotes) can be joined with numbers or booleans and they will display as their text values.
+
+Variables can also be modified after they have been created (initialized).
+```java
+int countdown;
+countdown = 10;
+System.out.println("Count: " + countdown);
+
+countdown = 9; // Reassign countdown to 9
+System.out.println("Count: " + countdown);
+
+countdown = countdown - 1; // Lower countdowns value by 1
+System.out.println("Count: " + countdown);
+
+countdown -= 2; // Short form of writing countdown = countdown - 2
+System.out.println("Count: " + countdown);
+
+int countdownSpeed = 3;
+countdown -= countdownSpeed; // Lower coundowns value by ammount in a variable we define
+System.out.println("Count: " + countdown);
+```
+### Logic
+Storing variables is nice, but you cant do very much with just variables. There are a few different ways to control what happens in our code. The first is `if` statements, which will check if a value is true, and if so run the code inside. Try running the following inside our main method in the online editor.
+```java
+boolean someValue = false; // Try setting this to true after
+if (someValue) {
+ System.out.println("The value chosen was true");
+}
+```
+Comparing numbers also results in boolean values (true or false), for example `4 == 4` or `5 > 3` are true, while `4 == 5` and `5 < 3` are false. `if` statements can also choose to run some other code if the value is false
+```java
+int someNumber = 7; // Try setting this to different numbers
+if (someNumber < 8) {
+ System.out.println(someNumber + " is smaller than 8");
+} else {
+ System.out.println(someNumber + " is not smaller than 8");
+}
+```
+You can also check if multiple things are true using 'and' (written `&&`) or if one of a list of things is true with 'or' (written `||`), try running the code below with different values for myNumber and shouldPrint.
+```java
+int someNumber = 7;
+boolean shouldPrint = false;
+if (someNumber < 8 && shouldPrint) {
+ System.out.println(someNumber + " is smaller than 8 and shouldPrint is true");
+}
+if (someNumber < 8 || shouldPrint) {
+ System.out.println(someNumber + " is smaller than 8 or shouldPrint is true (or both)");
+}
+```
+
+### Loops
+Often we encounter situations when we want to run a command many times, one way to accomplish this is using a `while` loop. A while loop keeps running the code inside while the condition in brackets is true, in this case while countdown is greater than or equal to 0.
+```java
+int countdown = 10;
+while (countdown >= 0) {
+ System.out.println(countdown);
+ // `--` after a variable decreses its value by 1, `++` increases by 1
+ countdown--;
+}
+System.out.println("Finished");
+```
+Another way to accomplish this result is with a for loop. A for loop has a few forms which we'll discuss later, but for now a for loop has an initialization step, which runs once before looping starts, a condition that decides whether the loop will run or not, and an incremement step which runs every time after the code in the body.
+```java
+// initialization; condition; increment
+for (int countdown = 10; countdown >= 0; countdown--) {
+ System.out.println(countdown);
+}
+System.out.println("Finished");
+```
+
+### Data Structures
+We also have a lot of situations where we want to store values together, like a list of names. We call the things we use to store these values data structures. The first data structure well use is an `Array`, basically a list of values with a fixed size, in the code below the array has 3 elements.
+```java
+// String[] means array of Strings, new String[5] gives the length
+String[] names = new String[3];
+// names[0] is the first item in our list, w'ere setting it to "Jason"
+names[0] = "Bob";
+names[1] = "Betty";
+names[2] = "Barnaby";
+```
+One cool thing we can do with our data structures is iterate through them with loops.
+```java
+// For every index in the array print name at that index
+for (int i = 0; i < names.length; i--) {
+ System.out.println(names[i]);
+}
+```
+Since iterating over arrays happens a lot, Java has a shorter way to write it
+```java
+// For every String in names, print
+for (String name : names) {
+ System.out.println(name);
+}
+```
+
+Another common data structure is the `ArrayList` which is very similar to an array, but has a size you can change (mutable size) which means you can keep adding elements to it.
+```java
+// ArrayList of Strings called names
+ArrayList names = new ArrayList<>();
+names.add("Bob");
+names.add("Betty");
+names.add("Barnaby");
+System.out.println("The first name in the list is " + names.get(0));
+
+// Same as going through an array
+for (String name : names) {
+ System.out.println(name);
+}
+```
+If you try to run the above code it will complain that it cant find the symbol `Arraylist`. This is because ArrayList isnt built directly into the language. Add `import java.util.ArrayList;` above `public class HelloWorld` at the top of the file to import the `ArrayList` class.
+
+The last data structure we'll cover for now is called `HashMap`. With `Array` and `ArrayList` we get elements by their position in the list eg. `names[0]` with an `Array` or `names.get(0)` with an `ArrayList`, however with `HashMap` we store and retrieve values by a 'key' value. For example we could store peoples ages by their names. For the code below to run, add `import java.util.HashMap;` at the top or the file.
+```java
+// HashMap mapping name (String) to age (Integer)
+HashMap nameToAgeMap = new HashMap<>();
+nameToAgeMap.put("Bob", 19);
+nameToAgeMap.put("Betty", 17);
+nameToAgeMap.put("Barnaby", 21);
+
+// Get a value by the key in the map, in this case "Bob" is the key
+System.out.println("Bob's age is " + nameToAgeMap.get("Bob"));
+
+// Here we'll iterate through all the entries in the map
+// '.keySet()' returns the list of keys
+for (String name : nameToAgeMap.keySet()) {
+ System.out.println(name + "'s age is " + nameToAgeMap.get(name));
+}
+```
+
+### Methods
+Sometimes we want to reuse code we write, for this we use methods. Methods are blocks of code that we pass a set of values, called parameters, and then run. In our last example we have some printing code that looks very similar, we could replace these calls with our own method, like below.
+```java
+public static void main(String[] args) {
+ HashMap nameToAgeMap = new HashMap<>();
+ nameToAgeMap.put("Bob", 19);
+ nameToAgeMap.put("Betty", 17);
+ nameToAgeMap.put("Barnaby", 21);
+
+ // We now call printNameAndAge with the name and age instead of printing here
+ printNameAndAge("Bob", nameToAgeMap.get("Bob"));
+
+ for (String name : nameToAgeMap.keySet()) {
+ printNameAndAge(name, nameToAgeMap.get(name));
+ }
+}
+
+// Void means the method returns no value
+// String name, int age are the parameters that we give this method when we call it
+public static void printNameAndAge(String name, int age) {
+ System.out.println(name + "'s age is " + age);
+}
+```
+Variables can be made avaliable across methods by declaring them outside of a method, making them 'instance' variables.
+```java
+// Declare the map outside of any methods
+static HashMap nameToAgeMap;
+
+public static void main(String[] args) {
+ nameToAgeMap = new HashMap<>();
+ nameToAgeMap.put("Bob", 19);
+ nameToAgeMap.put("Betty", 17);
+ nameToAgeMap.put("Barnaby", 21);
+
+ // We only need to pass in the name now, the method can access the map
+ printNameAndAge("Bob");
+
+ for (String name : nameToAgeMap.keySet()) {
+ printNameAndAge(name);
+ }
+}
+
+public static void printNameAndAge(String name) {
+ // Inside this method we can now use nameToAgeMap to get the age
+ System.out.println(name + "s age is " + nameToAgeMap.get(name));
+}
+```
+Methods can also return values instead of `void` meaning no return type.
+```java
+static HashMap nameToAgeMap;
+
+public static void main(String[] args) {
+ nameToAgeMap = new HashMap<>();
+ nameToAgeMap.put("Bob", 19);
+ nameToAgeMap.put("Betty", 17);
+ nameToAgeMap.put("Barnaby", 21);
+
+ // We can use our method here now as it returns an integer
+ System.out.println("Bobs age is " + getAgeFromName("Bob"));
+
+ for (String name : nameToAgeMap.keySet()) {
+ System.out.println(name + "s age is " + getAgeFromName(name));
+ }
+}
+
+// Declare return type as int here
+public static int getAgeFromName(String name) {
+ // Instead of printing well return the age for a given name
+ return nameToAgeMap.get(name);
+}
+```
+
+### Objects
+In Java, we can create things called `Object`s. An `Object` is a collection of values and methods, you can think of them like most objects in the real world. Each `Object` is an instance of some `Class`, a template that describes what values as object has, and what it can do. Lets try defining a `Class` Dog and instantiating (creating) an `Object` of class, or type Dog, called `firstDog`.
+```java
+public class JavaExamples {
+ public static void main(String[] args) {
+ // Create new dogs, call their constructor methods with their names
+ Dog firstDog = new Dog("Buddy");
+ Dog secondDog = new Dog("Lassie");
+ // Print the name of the dog objects we instantiated
+ System.out.println("The first dogs name is " + firstDog.getName());
+ System.out.println("The second dogs name is " + secondDog.getName());
+ }
+}
+
+// This is the definition of our class Dog
+class Dog {
+ // Our dogs will each have some name
+ // private means it cant be accessed outside of this class
+ private String name;
+
+ // This is the constructor method for the Dog class,
+ // note the lack of return type, and the name being the same as the class
+ // Our constructor takes in a String name, so to create a dog call `new Dog("someName");`
+ public Dog(String name) {
+ this.name = name;
+ }
+
+ // Each dog has a method to return its name
+ // Notice that unlike the methods earlier, this has no 'static' before the return type
+ // Static means a method or variable can be used by referring to the class itself instead of an instance or Object of that class
+ public String getName() {
+ return name;
+ }
+}
+```
+Our `Class` Dog has been defined as having one value `name`, and one method `getName` which returns the dogs name as a `String`. In our `main` function, we create two new Dogs called with the names "Buddy" and "Lassie" and print their names.
+
+### Extension
+Sometimes we need to be able to treat different kinds of `Object`s as one, for example if we want an `ArrayList` (which holds only one type of thing eg. `ArrayList`) of Cats and Dogs. One way we can get around this is using inheritance. Inheritance is when a class, in this case Cat and Dog, inherits the values and methods from a 'parent' class using `extends`, as well as adding new methods or values and optionally overriding the behavior of its 'parent's methods.
+```java
+import java.util.ArrayList;
+public class JavaExamples {
+ public static void main(String[] args) {
+ // Add a Cat and Dog to a list of Animals
+ ArrayList animals = new ArrayList<>();
+ animals.add(new Dog("Rover"));
+ animals.add(new Cat("Garfield"));
+
+ // Print the Animals names and sounds
+ for (Animal animal : animals) {
+ System.out.println("The animals name is " + animal.getName());
+ System.out.println("Its favorite food is " + animal.getFavoriteFood());
+ }
+ }
+}
+
+// Abstract means it cannot be instantiated, you cant say new Animal("name");
+abstract class Animal {
+ // Every Animal will now have a name
+ private String name;
+
+ // Base constructor for any Animal
+ public Animal(String name) {
+ this.name = name;
+ }
+
+ // Every Animal has the getName function
+ public String getName() {
+ return name;
+ }
+
+ // Every Animal also likes some kind of food
+ public String getFavoriteFood() {
+ return "unknown";
+ }
+}
+
+class Dog extends Animal {
+ // Dogs constructor calls Animals instructor with the same arguments 'super(name)'
+ public Dog(String name) {
+ super(name);
+ }
+
+ // Override means this method replaces getFavoriteFood() in its parent class
+ @Override
+ public String getFavoriteFood() {
+ return "Bones";
+ }
+}
+
+// Same structure as Dog without a defined favorite food
+class Cat extends Animal {
+ public Cat(String name) {
+ super(name);
+ }
+}
+```
+Note here that Cat didn't Override getFavoriteFood(), so when the method was called it used the version written in its parent class, Animal. `Object`s like Cat or Dog can also be extended, leading to a heirarchy structure similar to the classification of animals. We could define
+```java
+class Corgi extends Dog
+```
+Or put things in between like
+```java
+class Mammal extends Animal { ... }
+class Dog extends Mammal { ... }
+```
+And define some values and methods at each level.
+
+### Implementation
+One problem with Extension is that you can only `extend` one Class, which means you can't share values or methods over different parts of the heirarchy. For example if we have
+```java
+class Fish extends Animal { ... }
+class Mammal extends Animal { ... }
+class Whale extends Mammal { ... }
+```
+We can no longer inherit the method swim() in both Fish and Whales without also having it for all Mammals. To solve this problem we use Implementation instead of Extension. Implementation is when you implement an Interface (a set of undefined methods), and you define the behavior for every method given. For example the Interface LandAnimal might have the methods `walk` and `run`. Below is a small example of inheratance.
+
+```java
+import java.util.ArrayList;
+public class JavaExamples {
+ public static void main(String[] args) {
+ Shark shark = new Shark();
+ Dog dog = new Dog("Buddy");
+
+ ArrayList animals = new ArrayList<>();
+ animals.add(shark);
+ animals.add(dog);
+
+ ArrayList fourLeggeds = new ArrayList<>();
+ fourLeggeds.add(dog);
+
+ ArrayList swimmers = new ArrayList<>();
+ swimmers.add(shark);
+
+ System.out.println("Animals:");
+ for (Animal animal : animals) {
+ System.out.println("The animals name is " + animal.getName());
+ animal.makeSound();
+ }
+ System.out.println("");
+
+ System.out.println("FourLeggeds:");
+ for (FourLegged animal : fourLeggeds) {
+ animal.run();
+ }
+ System.out.println("");
+
+ System.out.println("Swimmers:");
+ for (Swimmer animal : swimmers) {
+ animal.swim();
+ }
+ }
+}
+
+// Anything extending Animal must define what these methods do
+interface Animal {
+ public String getName();
+ public void makeSound();
+}
+
+interface FourLegged {
+ public void run();
+}
+
+interface Swimmer {
+ public void swim();
+}
+
+// A Dog is an Animal that has four legs (can run)
+class Dog implements Animal, FourLegged {
+ private String name;
+
+ public Dog(String name) {
+ this.name = name;
+ }
+
+ // Override means this method replaces getName() in a parent class
+ @Override
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public void makeSound() {
+ System.out.println(getName() + " says Woof");
+ }
+
+ @Override
+ public void run() {
+ System.out.println(getName() + " goes running...");
+ }
+}
+
+class Shark implements Animal, Swimmer {
+ public Shark() {
+ }
+
+ @Override
+ public String getName() {
+ return "Shark...";
+ }
+
+ @Override
+ public void makeSound() {
+ System.out.println("The shark makes no sound");
+ }
+
+ @Override
+ public void swim() {
+ System.out.println("The Shark swims away");
+ }
+}
+```
diff --git a/mobile/android/Map_Page.md b/mobile/android/Map_Page.md
new file mode 100644
index 0000000..f832132
--- /dev/null
+++ b/mobile/android/Map_Page.md
@@ -0,0 +1,332 @@
+# Map Page
+## Empty Map Fragment
+Now that we have our `FoundCachesFragment` working let's start work on the Map page. Create a new class called `MapFragment` that extends `SupportMapFragment`, well need to compile `'com.google.android.gms:play-services:8.4.0'` in our gradle file to use `SupportMapFragment`. `SupportMapFragment` is a special fragment that contains a `GoogleMap`.
+
+## Getting a Maps API Key
+Before using the Google Maps in our app we have to get an 'API key' from Google that will let you use their data. Start by going to the [Google Developers Console](https://console.developers.google.com/start) and creating an account (TODO: test new user). Then were going to 'Create an empty project' at the bottom, the name doesn't matter. (TODO actually do this whole thing not on a work computer)
+
+http://www.truiton.com/2013/05/google-maps-android-api-v2-introduction/
+Getting api key
+- https://code.google.com/apis/console/
+- Create project
+- Use Google APIs
+- Google Maps Android API
+- Enable
+- Go to credentials
+- Calling from: Android
+- Click 'Find out what kind of credentials you need'
+- Click 'Create an API key'
+- Copy Key into Android Manifest meta-data 'com.google.android.maps.v2.API_KEY' also com.google.android.gms.version
+
+Now that we have our API key open up `AndroidManifest.xml` under the `manifests` folder which is where we will put our API key. Under the `activity` tag (still inside `application`) add
+``` xml
+
+```
+and copy in your API key we just generated.
+
+## Displaying the Map
+Now that we have our API Key set up we can start using the Maps API. In our `MainActivity` layout `activity_main.xml` replace `FoundCachesFragment` with `MapFragment` for the `android:name` property, this will make our `MainActivity` show the `MapFragment`. Try running the app, you should see a map when it opens.
+
+## Getting the Map
+Now that we have our map showing up we can start using it. To start we need to get the `GoogleMap` object being displayed, we do this by calling the `getMapAsync` method built into `SupportMapFragment` and then implementing `OnMapReadyCallback` which gets called when our `GoogleMap` is ready to be displayed and used. The full code looks like this
+``` java
+public class MapFragment extends SupportMapFragment implements OnMapReadyCallback {
+
+ // We will use this Object to control the map shown on the screen
+ private GoogleMap googleMap;
+
+ // onCreate is called when the Fragment is created
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ // This requests access to the GoogleMap, we will talk about what Async means later
+ getMapAsync(this);
+ }
+
+ // Called when the map is ready to use
+ @Override
+ public void onMapReady(GoogleMap googleMap) {
+ // Save this object to use later
+ this.googleMap = googleMap;
+ }
+}
+```
+
+## Controlling the Map
+After we get our `GoogleMap` let's try to zoom to our current location, create a new method called `zoomToUserLocation` or something similar. Getting the users location is a bit tricky, start by getting a `LocationManager` which will let us access location data
+``` java
+LocationManager locationManager = (LocationManager) getContext().getSystemService(Context.LOCATION_SERVICE);
+```
+Next we will get a `Location` from `locationManager.getLastKnownLocation` and animate our `googleMap` to that `Location`'s lattitude and longitude with a zoom factor of `13`, if we can't get a location (location == null) then use a default location in Waterloo.
+``` java
+Location location = locationManager.getLastKnownLocation(locationManager.getBestProvider(new Criteria(), false));
+if (location != null) {
+ googleMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(location.getLatitude(), location.getLongitude()), 13));
+} else {
+ // Default to a location in Waterloo
+ googleMap.animateCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(43.38224, -80.32682), 13));
+}
+```
+`getBestProvider` gets us a system service that can provide us the location and `newLatLngZoom` returns a `CameraUpdate` that will move our map. Don't worry much about this code as it's a bit complicated.
+
+## Permissions
+Notice that Android Studio is complaining about `getLastKnownLocation`, this is because we tried to access the users location without the proper 'Permission'. Go to `AndroidManifest.xml` and add the following permissions before the `application` tag.
+``` xml
+
+
+
+
+
+
+
+
+
+```
+These give us access to a bunch of the systems properties (If the user allows).
+
+In Android M the complexity of permissions was increased quite a bit, since we want to avoid this for today open up your gradle file and change `targetSdkVersion` (in `defaultConfig`) to 22 which will build our app for a slightly older version of Android.
+
+## Caches Data
+We now have our map and access to the users location, lets get some cache data and display it on the map. Add another file called `caches_map.json` in res/raw with our `caches_found.json` file, copy the following inside.
+``` json
+{
+ "Cache 1": {
+ "name": "Cache 1",
+ "description": "Hey a cache description 1",
+ "difficulty": 3,
+ "location": {
+ "latitude": 43.38224,
+ "longitude": -80.32682
+ }
+ },
+ "Cache 2": {
+ "name": "Cache 2",
+ "description": "Another one",
+ "difficulty": 3,
+ "location": {
+ "latitude": 43.38224,
+ "longitude": -80.32582
+ }
+ },
+ "Cache 3": {
+ "name": "Cache 3",
+ "description": "Buy your momma a house",
+ "difficulty": 3,
+ "location": {
+ "latitude": 43.38454,
+ "longitude": -80.32382
+ }
+ },
+ "Cache 4": {
+ "name": "Cache 4",
+ "description": "Buy your whole family houses",
+ "difficulty": 3,
+ "location": {
+ "latitude": 43.38024,
+ "longitude": -80.32382
+ }
+ }
+}
+```
+This is our cache data, it tells us where the caches are located as well as giving the name, description, and difficulty. The structure is the same as in `caches_found.json`. Next up lets creates a java class called `MapCache` that we will read our json file into (same use as `FoundCache`). It has the same structure as `FoundCache` but has some extra information.
+``` java
+public class MapCache {
+ public String name;
+ public String description;
+ public int difficulty;
+ public Location location;
+
+ public static class Location {
+ public double latitude;
+ public double longitude;
+ }
+}
+```
+In `DataUtils` duplicate `FoundCachesReceiver` and `getFoundCaches` and replace the `FoundCache` stuff with `MapCache`, make sure to read `R.raw.caches_map` instead of `caches_found` and serialize our json into a `Map` of `MapCache` objects `new TypeToken>() {}.getType()`. We are now ready to use this data in our `MapFragment`.
+
+## Displaying Caches on the Map
+Back in `MapFragment`, after calling `zoomToUserLocation` add a call to `DataUtilities.getMapCaches` that look similar to the one in `FoundCachesFragment`. At the top of `MapFragment` define a new variable `private Map mapCaches;`, inside the callback set `mapCaches` to `results` and call a method `makeMarkers()` that we'll write next.
+
+Now create the `makeMarkers` method that will return `void` and take in no parameters. In this method we will draw the caches on our map. The body of this method should iterate over each `Map.Entry` in `mapCaches.entrySet()` and create a marker for each cache, an `Entry` is one Key/Value pair (`` is the type of the Key and Value).
+``` java
+for (MapCache cache : mapCaches.values()) {
+ // Draw cache marker on map
+}
+```
+To create a marker we first need a location. Create a `new LatLng(paramaters)` called `position` passing `cache.location.latitude` and `longitude` as parameters to the constructor. Next we'll define `float iconColor = BitmapDescriptorFactory.HUE_RED;` which will be the color of our markers. We can now call
+``` java
+googleMap.addMarker(new MarkerOptions()
+ .position(position)
+ .icon(BitmapDescriptorFactory.defaultMarker(iconColor))
+ .title(cache.name));
+```
+This will add out marker to the map, try it out and make sure the markers got added around waterloo.
+
+## Marking Found Caches
+Some of these caches have already been found, let's mark these ones by changing the icon color to blue. In order to do this we first have to get the `FoundCaches` data. Create a variable `foundCaches` at the top that's a `Map` of `FoundCache`s, before your call to `DataUtilities.getMapCaches` add one to `DataUtilities.getFoundCaches`. In the callback set `foundCaches = results;`, this will let us use `foundCaches' in our `makeMarkers` method.
+
+Replace `float iconColor = BitmapDescriptorFactory.HUE_RED;` with
+``` java
+// Check if this cache id is in the Map of found caches. If so it has already been found
+boolean hasBeenFound = foundCaches.containsKey(cache.name);
+
+// This pattern someBoolean? value1 : value2 is called a ternary
+// It is equivalent to if (someBoolean) { value1 } else { value2 }
+// If hasBeenFound is true we use the first value 'BitmapDescriptorFactory.HUE_AZURE', else we use 'BitmapDescriptorFactory.HUE_RED'
+float iconColor = hasBeenFound? BitmapDescriptorFactory.HUE_AZURE : BitmapDescriptorFactory.HUE_RED;
+```
+The ternary is choosing between two values `BitmapDescriptorFactory.HUE_AZURE` and `BitmapDescriptorFactory.HUE_RED` based on whether hasBeenFound is true, then we set the color to red if unfound or azure if found.
+
+## Cache Click Popup
+To make things a bit more interesting and useful we're going to change the popup that appears when we click a marker on the map to display some cache information, we'll start by making a layout that we want to display when we tap on a marker. Create a new layout called `marker_click_popup` that we will inflate when a marker gets clicked. Feel free to try creating your own layout to display whatever cache information you want, the one I wrote displays the name and difficulty. You don't need to show everything as when we click this popup it will open something with the rest of the cache details.
+``` xml
+
+
+
+
+
+
+
+
+
+```
+I also defined a string in values/strings with name `marker_info_window_see_more` and value `See Details…`
+
+Now that we have our layout create a new methodin `MapFragment` called `private void setMarkerPopupAdapter()` and call it after `makeMarkers` in your `DataUtilities.getMapCaches` callback. Inside this method call `googleMap.setInfoWindowAdapter` and pass it a `GoogleMap.InfoWindowAdapter`.
+``` java
+googleMap.setInfoWindowAdapter(new GoogleMap.InfoWindowAdapter() {
+ @Override
+ public View getInfoWindow(Marker marker) {
+ return null;
+ }
+
+ // This method is called when a marker is clicked, return the popup to display
+ @Override
+ public View getInfoContents(Marker marker) {
+ return null;
+ }
+});
+```
+Inside getInfoContents we will inflate our layout and get references to the `TextView`s inside that we want to modify.
+``` java
+View infoView = getLayoutInflater(null).inflate(R.layout.marker_click_popup, null);
+TextView name = (TextView) infoView.findViewById(R.id.name);
+TextView difficulty = (TextView) infoView.findViewById(R.id.difficulty);
+```
+Now we can get the cache name from our marker and use it to get the cache info, and then set our layout's text properly.
+``` java
+final String cacheName = marker.getTitle();
+MapCache cache = mapCaches.get(cacheName);
+name.setText(cache.name);
+difficulty.setText(FormattingUtilities.getDifficultyString(cache.difficulty, getContext()));
+```
+Lastly we need to `return infoView;` so that it is displayed. If we run our app now and click a marker it should show the layout we just created.
+
+## See More Dialog
+Next we're going to show a `Dialog` when the user clicks on our marker popup. In order to get when a user clicks the popup we need to call `setOnInfoWindowClickListener` on our `googleMap`, do this after our call to `googleMap.setInfoWindowAdapter`.
+```java
+googleMap.setOnInfoWindowClickListener(new GoogleMap.OnInfoWindowClickListener() {
+ @Override
+ public void onInfoWindowClick(Marker marker) {
+ String cacheName = marker.getTitle();
+ // We will write this function next to open the Dialog
+ openSeeMoreDialog(cacheName);
+ }
+});
+```
+Now create the method `openSeeMoreDialog` that takes in a `String cacheName` and returns `void`. In this method we will open a `Dialog` which is a large popup in the middle of the screen. Again let's start by creating a layout for the dialog called `see_more_dialog`, feel free to make your own layout or customize this one.
+``` xml
+
+
+
+
+
+
+
+
+
+
+
+```
+You'll also need to add a string with name `found_it_button_text` and value `found_it_button_text`.
+
+Back in `openViewDetailsDialog` inflate this new layout `R.layout.see_more_dialog` and save in `View dialogView`. Get references to `R.id.cache_name`, `R.id.cache_difficulty`, `R.id.cache_description`, and `R.id.cache_found` and save them in `TextView`s. Now get the `MapCache` by `cacheName` and set `dialogView`s name and difficulty text the same as before, also set the description `TextView` to `cache.description`.
+
+Next let's check if we have already found this cache by checking `if (foundCaches.containsKey(cacheName))`. If we have we can set this `Button` to say when it was found, otherwise we will set this cache to found when the `Button` is clicked (this part we'll write later).
+``` java
+if (foundCaches.containsKey(cacheName)) {
+ FoundCache foundCache = foundCaches.get(cacheName);
+ found.setClickable(false);
+ found.setText(FormattingUtilities.getTimeAgoString(foundCache.found, getContext()));
+} else {
+ found.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // Set this cache to found
+ }
+ });
+}
+```
+We can now call
+``` java
+new AlertDialog.Builder(getContext()).setView(dialogView).create().show();
+```
+to create and show our `Dialog`, setting it's view to the one we just made.
diff --git a/mobile/android/Putting_it_Together.md b/mobile/android/Putting_it_Together.md
new file mode 100644
index 0000000..40d9e1b
--- /dev/null
+++ b/mobile/android/Putting_it_Together.md
@@ -0,0 +1,102 @@
+# Putting it Together
+## ViewPager
+### Create the ViewPager
+We now have two `Fragment`s and we need a way to switch between them easily. A `ViewPager` is a class that allows you to swipe between different pages, we will be using this to hold our `Fragment`s. To start lets replace the current contents on `activity_main.xml` with
+``` xml
+
+
+
+
+
+
+```
+Basically we have two views, a `TabLayout` at the top which will have a list of `Fragment`s you will be able to click to navigate to and the `ViewPager` which will hold our `Fragment`s.
+
+Over in `MainActivity` lets get references to these views like we did in our fragments. Create two variables `private ViewPager viewPager;` and `private TabLayout tabLayout;` and after calling `setContentView` set their values as we did before.
+``` java
+tabLayout = (TabLayout) findViewById(R.id.tab_layout);
+viewPager = (ViewPager) findViewById(R.id.view_pager);
+```
+Now let's create a custom adapter for our `ViewPager` which will return the proper fragments for each position, similar to our `RecyclerView` adapter earlier. Create a new inner class in `MainActivity` called `GeocachingPagerAdapter` that `extends FragmentStatePagerAdapter`.
+``` java
+class GeocachingPagerAdapter extends FragmentStatePagerAdapter {
+
+ // Constructor that mimics FragmentStatePagerAdapter's
+ public GeocachingPagerAdapter(FragmentManager fm) {
+ super(fm);
+ }
+
+ // This will return our Fragments for each position
+ @Override
+ public Fragment getItem(int position) {
+ return null;
+ }
+
+ // This will return our Fragment titles for each position
+ @Override
+ public CharSequence getPageTitle(int position) {
+ return null;
+ }
+
+ // The number of Fragments in the ViewPager (Found and Map)
+ @Override
+ public int getCount() {
+ return 2;
+ }
+}
+```
+In `getItem` we want to return a `FoundCachesFragment` if we're viewing the first tab (`position == 0`) or a `MapFragment` for the second. We write that as follows
+``` java
+if (position == FOUND_TAB) {
+ return new FoundCachesFragment();
+} else if (position == MAP_TAB) {
+ return new MapFragment();
+} else {
+ return null;
+}
+```
+And define
+``` java
+public static final int FOUND_TAB = 0;
+public static final int MAP_TAB = 1;
+```
+at the top of our `GeocachingPagerAdapter` class
+In `getPageTitle` we want to return "Found" for the first and "Map" for the second. Define two new entries in `strings.xml` and return the correct one from this method using `getString(R.string.your_string);`.
+
+Up in `onCreate` after `viewPager = (ViewPager) findViewById(R.id.view_pager);` add the following
+``` java
+// Create a new adapter for our ViewPager and set it
+viewPagerAdapter = new GeocachingPagerAdapter(getSupportFragmentManager());
+viewPager.setAdapter(viewPagerAdapter);
+
+// Set up out TabLayout to control our ViewPager
+tabLayout.setupWithViewPager(viewPager);
+
+// This removes the shadow from the top bar, you can ignore this
+if(getSupportActionBar() != null) {
+ getSupportActionBar().setElevation(0);
+}
+```
+If you run the app now you should be able to swipe between your Found and Map fragments.
+
+## API
+### Getting data from actual API
+- Making the request
+
+### Sending back to API from found
+- Make the request, handle errors
diff --git a/mobile/android/README.md b/mobile/android/README.md
new file mode 100644
index 0000000..7d4aa74
--- /dev/null
+++ b/mobile/android/README.md
@@ -0,0 +1,25 @@
+# Mobile/Android
+
+## What you'll make
+Gif of demo
+
+## Table of Contents
+### Getting ready
+- [Java Introduction](Java_Introduction.md)
+- [Android Studio Setup](Android_Studio_Setup.md)
+
+### Building the Geocaching app
+- [Starting the App](Geocaching_App.md)
+- [Found Caches Page](Found_Caches_Page.md)
+- [Map Page](Map_Page.md)
+- [Putting it Together](Putting_it_Together.md)
+
+### Extending the app
+- [Settings Page](Settings_Page.md)
+- [Caching Data](Caching_Data.md)
+- [Beautify the App](Beautify_App.md)
+- [Using Libraries](Using_Libraries.md)
+
+### Reference Material
+- [Android Studio Tips](Android_Studio_Tips.md)
+- [Vocabulary](Vocabulary.md)
diff --git a/mobile/android/Settings_Page.md b/mobile/android/Settings_Page.md
new file mode 100644
index 0000000..4d61dfa
--- /dev/null
+++ b/mobile/android/Settings_Page.md
@@ -0,0 +1,124 @@
+# Settings Page
+## Preferences.xml
+Most Android applications have some sort of settings or preference page, for ours we'll allow the user to change some settings on the Map page as well as perform some actions like clearing all their found caches. Preferences in Android are defined in xml, create a Android resource directory in res called `xml` of type xml (right click on res -> new -> Android resource directory, you might have to close and reopen the res folder to see it) and create a new file inside called `preferences` with the following content.
+``` xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+This file has have a `PreferenceScreen` as its root tag and nested `PreferenceCategory`s inside. Each `PreferenceCategory` contains one or more `Preference` elements which can be of many types, we'll use `CheckBoxPreference` and normal `Preference`s. `PreferenceCategory`s can be nested further or `Preference` elements can go straight into `PreferenceScreen` if you want, this is just how we're organizing our screen for now. We also need our strings for this to work.
+``` xml
+Settings
+
+Actions
+Do Something
+Performs an action when clicked
+
+Map settings
+Zoom Buttons Enabled
+Show on screen zoom control buttons
+Toolbar Enabled
+Show directions toolbar when you select a cache
+```
+The last things we need to do for preferences to work is to define the preference theme by adding
+``` xml
+- @style/PreferenceThemeOverlay.v14.Material
+```
+to res/values/styles and adding
+``` xml
+
+```
+to `AndroidManifest.xml` in the same section we put permissions.
+
+## SettingsFragment
+Now that we have our preferences defined, compile `'com.android.support:preference-v14:23.2.0'` in gradle and create a new java class called `SettingsFragment` that extends `PreferenceFragmentCompat`.
+``` java
+public class SettingsFragment extends PreferenceFragmentCompat {
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ }
+
+ @Override
+ public void onCreatePreferences(Bundle bundle, String s) {
+
+ }
+}
+```
+Now all we have to do to get our preferences to display is add `addPreferencesFromResource(R.xml.preferences);` to our `onCreate` method. To get our `action_settings_do_something` preference to perform an action we need to first get a reference to it by calling `Preference doSomething = findPreference("action_settings_do_something");` and then set its `OnPreferenceClickListener`.
+``` java
+doSomething.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
+ @Override
+ public boolean onPreferenceClick(Preference preference) {
+ // Perform the action
+ return true;
+ }
+});
+```
+
+## Add SettingsFragment to ViewPager
+We now have a third `Fragment` to show in our `ViewPager`. Go back to `MainActivity.GeocachingPagerAdapter` and add entries in `getItem` and `getPageTitle` for `SettingsFragment`, make sure to update `getCount` as well.
+
+## Accessing Preferences
+Let's create a new class called `PreferenceUtilities` where we will retreive the users preferences. First define two String constants
+``` java
+private static final String ZOOM_ENABLED = "map_settings_zoom_buttons_enabled";
+private static final String TOOLBAR_ENABLED = "map_settings_toolbar_enabled";
+```
+which are the preference keys defined in preferences.xml. To get the users preference we first get a `SharedPreference` object from `PreferenceManager`, `SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);` and then get the value from this object by its key, `boolean zoomEnabled = preferences.getBoolean(ZOOM_ENABLED, true);`. Write two static methods `getZoomEnabled` and `getToolbarEnabled` that take in a `Context` and return a boolean of whether the preference was set to true.
+
+## Using PreferenceUtilities
+If we now go to our `MapFragment` we can start implementing these preferences. Create a method `setMapSettings` that takes in no parameters and call it in `onMapReady`. Inside this method get a reference to our `googleMap`'s `UiSettings`, `UiSettings settings = googleMap.getUiSettings();` and then call `settings.setZoomControlsEnabled` and `setMapToolbarEnabled` passing in `PreferenceUtilities.getZoomEnabled(getContext())` and `getToolbarEnabled` as parameters.
+
+Because `onMapReady` only gets called when the Fragment is first created and the `ViewPager` saves it, we need to listen for preference changes if we want things to change immediately after returning to the map. Create a variable in `MapFragment`, `private SharedPreferences.OnSharedPreferenceChangeListener listener;` and set
+``` java
+listener = new SharedPreferences.OnSharedPreferenceChangeListener() {
+ @Override
+ public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
+ setMapSettings();
+ }
+};
+```
+in `onMapReady`. This will listen for changes in our preferences and set our map options when anything changes. Now we have to register our listener in `onMapReady` as follows
+``` java
+SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getContext());
+preferences.registerOnSharedPreferenceChangeListener(listener);
+```
+This gets our `SharedPreferences` and registers our listener to fire when anything changes. We also have to unregister our listener so it stops listening when our app is closed or the `MapFragment` is killed. To do this we override `onDestroy` in `MapFragment` that gets called when the fragment is being destroyed.
+``` java
+@Override
+public void onDestroy() {
+ super.onDestroy();
+ PreferenceManager.getDefaultSharedPreferences(getContext()).unregisterOnSharedPreferenceChangeListener(listener);
+}
+```
+Our Settings page should now modify the map as we change them, run the app and try it out.
diff --git a/mobile/android/Using_Libraries.md b/mobile/android/Using_Libraries.md
new file mode 100644
index 0000000..a6b742e
--- /dev/null
+++ b/mobile/android/Using_Libraries.md
@@ -0,0 +1,28 @@
+# Using Libraries
+## Importing Libraries with Gradle
+### CardLayout
+- We already did this for a ui element, heres how it worked, also Gson etc.
+
+## Where to find Libraries
+### Android Arsenal
+- https://android-arsenal.com
+
+### Github
+- https://github.com/trending/java
+
+## What are Libraries used for (Short)
+### UI polish
+- Material
+- Etc
+
+### Functionality
+- Downloads
+- Etc
+
+### Architecture
+- RxJava
+- Etc
+
+## Using the _ Library (possibly https://android-arsenal.com/details/1/3337, https://android-arsenal.com/details/1/3318, (super short) https://android-arsenal.com/details/1/3310)
+### Importing the Library
+- Etc
diff --git a/mobile/android/Vocabulary.md b/mobile/android/Vocabulary.md
new file mode 100644
index 0000000..9f7245b
--- /dev/null
+++ b/mobile/android/Vocabulary.md
@@ -0,0 +1,63 @@
+## Vocabulary
+### User Interface (UI)
+- **View:** An element on the screen, like a text block, a button, or a collection or other elements
+- **XML:** The format android uses to store view data like text, color, and size
+- **Resources:** All our data files defining our views, strings, or a bunch of other things
+- **Layout:** Layouts define how views are organized and laid out
+
+### Top level classes
+- **Activity:** Our Activity is the entry point into the app, and holds the UI not contained in fragments. Also used as a Context.
+- **Fragment:** A Fragment is what holds the Views for our UI pages
+- **Controller:** The Controller is what we will use to handle and logic and data for our fragments.
+- **Utility:** Utilities consist of useful functions to share across our fragments, like fetching data, or getting preferences
+
+### Data Structures
+- **Data Class:** An class of Objects that holds data
+- **HashMap:** A HashMap stores values by 'keys' or unique id's used to access them later
+- **Array:** An Array stores an ordered list of values
+
+### Methods
+- **Method:** Reusable block of code, take in parameters and returns some value
+- **Parameters:** Values passed to methods
+- **Return:** Values passed back from methods
+
+### Types
+- **Class:** Set of values and methods
+- **Interface:** Set of methods to implement behaviors for in an Object
+- **Type:** What kind of value a given variale is eg. some Object, or an int
+- **Variable:** Some value of a given type
+- **Casting:**
+- **Generic:** Allowing a method or class to use different types of Objects
+- **Primitive:** Value that is not an object eg. int
+- **Null:** Variable that isn't set to an Object
+
+### Objects
+- **Object:** A collection of values and things you can do with them
+- **Instance:** One Object of a given class
+- **Extends:** A class has the values and functions of its parent, as well as any more you define, can only extend one class. A class can be casted to the class it extends
+- **Implements:** A class must define how the methods in an implemented interface work. A class can be casted to any interface it implements
+- **Interface:** A collection of methods that can be implemented
+- **Override:** Notation used to show that a function replaces the same named function in a class it extends or implements
+
+### Primitive Data Types
+- **Integer:** Whole numbers eg -1, 0, 1 up to 2147483647
+- **Long:** Whole numbers larger in magnitude than ints
+- **Double:** Decimal numbers
+- **Boolean:** True of False
+- **String:** Group of characters (Word, sentence, or longer)
+
+### Variable/Method Access
+- **Public:** Accessible by anyone
+- **Private:** Accessible only in this class
+- **Static:** Code that can be called without an object of that class
+- **Final:** Variable that cannot be modified
+- **Constant:** Variable that is hard coded to have some value (Never changes)
+
+### Android
+- **Context:** Used to get resources and interact with a lot of Andriod internal stuff
+- **Gradle:** Android build system
+- **SharedPreferences:** One place to store data on a device
+
+### Misc
+- **Callback:** An Object that implements a method to call on some event
+- **Asynchronous:** Code that runs in the background