Let's get back to our original project.

The first thing I want to point out is the version control button on the bottom.

This button gives us quick access to some important version control options.

It starts on the local changes tab,

which shows us a list of our uncommitted changes.

It's empty for now, but once we make a change, we'll be able to see it here.

Over on the Log tab, we can see a history of all the commits on the project

starting with the most recent commits on top.

Scrolling to the bottom,

we can see that the initial commit was made on July 24th at 7:22 AM.

Scrolling up a bit, we can also tell that when fact selection was refactored,

it was done on a new branch which was later merged back into the master branch,

leaving us with the one branch we have now.

Now that we've got a feel for the project, let's start making some changes.

The first change we'll make is to add another background color.

I've already found a good gold color for us to use.

Let's create a new branch for this change called add gold color.

Using branches is a good idea,

because it allows many developers to work on the same code change

while keeping the master branch unharmed by development that isn't yet ready.

To make a new branch we'll open the VCS menu, pick the Git option,

open the Branches menu, and, then click New Branch.

Then we type in the name of our branch, add_gold_color, and hit OK.

If we look at the log, we can see our new branch was created,

and we're currently on it.

Adding the gold color will be done in the color wheel class.

Let's type CMD+O on Mac or Ctrl+N on Windows to show the open class dialog.

Type in colorwheel and hit Enter to open it.

Now that we're in the color wheel class we can add our gold color to

the bottom of the colors array.

We'll be using ddca8b as the color.

And we can add it to the bottom like so.

Hopping over to the Local Changes tab on the Version Control menu,

we can now see that our change is listed.

If we're curious about why a file is showing up here, we can right-click it and

select Show Diff.

This shows us the differences between the new and old versions of the file.

As expected, it only shows the change we just made.

Now we can click the up arrow VCS button or

hit CMD+K on Mac or CTRL+K on Windows to commit our change.

Add a quick commit message.

And hit Commit.

Warnings are fine to ignore.

Let's hit Commit again.

Looking at the log again, we can see that our add_gold_color branch is now one

commit ahead of the master branch.

Let's add another color, but this time let's add it in the master branch.

Typically, we wouldn't do development in the master branch, but

we'll let it slide so we can see how to resolve a merge conflict.

To switch back to the master branch, we can open up the Branches menu

click on the master branch, and then click Checkout.

Looking back at the log,

we can see that the head tag has been moved to the master branch.

The color we'll be adding this time is a bronze color.

Back in the color wheel class,

let's add 8b4513 to the bottom of the end colors array.

The gold color isn't yet on the master branch.

It will show up once we merge the branches.

But for now, let's go ahead and commit our most recent change.

We'll change the commit message to say bronze, and hit Commit.

The log now shows that the master branch is ahead of the add_gold_color branch,

and it's a bit more obvious that add_gold_color is a separate branch.

At this point, the add_gold_color branch is finished, and

we should probably merge it back into master.

To merge, we'll open the VCS menu, pick the Git option, and select Merge Changes.

Then we select the branch we want to merge into our current branch,

add_gold_color, and hit Merge.

Normally this wouldn't encounter a conflict, but

it looks like we've got a merge conflict we'll need to resolve.

Let's click the Merge button to start resolving the conflict.

In this view we have the changes from the current branch master on the left,

the changes from the branch we're trying to merge on, add gold color on the right.

And the merge result in the middle.

It looks like the problem is on line 23.

One version says that line should be bronze, and

the other version says it should be gold.

To resolve this, we can pick one of the two branches and

ignore the other branch, or we could combine them ourselves.

Clicking the angle quotes, will apply the change, and

clicking the x will ignore the change.

We'd like to keep both changes.

So let's click the angle quotes next to both branches.

Now that we've processed both changes, Android Studio thinks we're done merging,

and asks if want to save and finish.

But if we take a closer look,

it didn't do a great job of merging the two changes together.

Let's click Continue and fix our merge result into something that

makes a bit more sense, mostly getting rid of the duplicate light gray row.

That looks better.

Now we can click apply to resolve the conflict.

Next we can commit the changes and

accept the default message about merging the brands.

We're done making changes and everything has been committed locally.

It's now time to push our commits to GitHub.

Let's open the VCS menu, pick the Git option, and pick Push.

Everything looks good,

let's hit Push again to send our local commits out to GitHub.

Great, now our changes are on our forked GitHub project.

The last step is to get those changes into the original GitHub project.

We'll accomplish this to a pull request.

Back in our familiar Git menu,

we can pick the create pull request option to initiate a pull request.

Let's change the title to something a bit better.

Add a short description.

And click OK.

Now we can click on the link to see our pull request.

Looks great, now the owner of the project will be able to merge our changes

into the original project.

Hopefully, you've now got a good understanding of how Android Studio can

make help make some typical GitHub tasks just a little easier.

It's definitely nice to not have to do all of this from the command line.

If you do get in to trouble, don't hesitate to jump into the command line.

There are many options, and commands, which have yet

to be integrated into Android Studio.