Pushing our own projects to GitHub is certainly useful, but

what if we want to contribute to an outside project?

How can we do that from within Android Studio?

Luckily, Android Studio makes this easy as well, but

first, let's take a look at the project we'll be contributing to.

We are going to be making changes to the fun facts project

from the beginning of the Android track.

If you're not familiar with the project, that's okay.

It's a fairly simple project with only one button.

When the button is pressed, we randomly select a fun fact and

a background color for the screen.

Let's open the project on GitHub.

It's located at github.com/treehouse/android-fun-facts-gi-

thub, which is in the Teacher's Notes

along with a link to the Fun Facts course.

Once we're here, we can click the Fork button on the upper-right,

to fork this project into our own repository.

If you're not interested in contributing to a project,

you can skip the forking step, and just clone the project from the source.

Since we'd like to contribute to this project, we'll stick with forking.

Once forking is finished,

we'll want to find the clone URL on the right side of the screen.

Let's copy that, as we'll need it to clone the repository.

Now that we know what project we're working with, and

we've created our fork, let's start up Android Studio.

But this time, instead of creating or opening an existing project,

let's click on Check Out Project from Version Control, and select GitHub.

Next, if it isn't already saved, we'll be prompted for our login information.

Now we can paste in the clone URL from earlier, and

hit Test to verify it's a valid GitHub URL.

Then we select the Project Directory and the name of our project,

I'm going to pick FunFacts, and click Clone.

And let's click Yes to open the project.

Awesome!

We've successfully pulled a project from GitHub and everything looks good to go.

But what if it didn't work?

How would we fix that?

I'm going to quickly pull in an older version of this project to show how to fix

some common issues you might find when checking out a project from GitHub.

Right off the bat, things are a bit different.

Let's leave this as the recommended option and click Okay.

Android Studio then lets us know that it will update the local.properties file

to use our default SDK.

This just means that the Project Creator keeps the SDK in a different folder

structure than we do.

Next we can click Add Root to let Android Studio know what's going on.

At the top of the screen,

there seems to be a lot of options grayed out that shouldn't be.

Let's sync the project with Gradle to see if everything's all right.

This should generally be the first thing we try,

because it will often help narrow down the specific issue.

It looks like we're targeting a version of Android that we don't have in our SDK.

Rather than installing the missing platform and

then targeting an older SDK, let's just change our target to one we do have.

An easy way to find out what Gradle settings work for

us is to inspect the Gradle files in a recent project.

Let's use the GitHub test project from earlier so we can compare Gradle files.

To get a better view of things,

I'm going to change both projects to the Project Perspective.

Then, I'll drill down into the app folder, and we'll compare build.gradle files.

Unfortunately, our new project doesn't seem to show the whole project

in the Project Perspective.

Luckily, we can find the files we need by clicking up here.

Looks like there are a couple of differences.

Let's change the compile SDK version, build tools version,

and target SDK version to all be more current.

Also, why do we have a RunProGuard property where GitHub test has

a minifyEnable?

A quick Google search for RunProGuard shows us that RunProGuard was renamed to

MinifyEnabled in a recent Gradle update.

Let's replace RunProGuard with MinifyEnabled.

Before we sync the project,

let's quickly compare the projects build.gradle file as well.

Looks like we should be using a newer version of Gradle here too.

Let's update that.

Now we can sync the project and hope it all works.

Still an error?

This looks complicated.

Before we dig too deep into this, let's poke around and

see if we can't find a file that looks like it could be updated.

Let's start with settings.gradle.

Looks pretty simple, but let's see if it's different over here.

Nope, exactly the same.

Hmm.

Let's try going into the gradle folder and

comparing the gradle wrapper.properties files.

Looks like there's a difference at the end of the distribution URL property.

Taking a closer look at the difference, it seems to be a version number.

Let's try updating the distribution URL to be the more current version.

And then we can try syncing it again.

And there we go.

We've successfully updated our project.

Awesome!