Integrating a version control system into the development process is a fundamental step, without which creating high-quality software is almost impossible. For platform developers using an integrated environment, setting up is the first step after installing the IDE itself. A competent configuration allows you not only to save the history of code changes, but also to work effectively in a team, avoiding merge conflicts and data loss. Androidusing an integrated environment Android Studio, setting Git is the first step after installing the IDE itself. Proper configuration allows you not only to save the history of code changes, but also to work effectively in a team, avoiding merge conflicts and data loss.
Many beginners encounter difficulties already at the initialization stage, trying to understand where exactly in the interface to look for the necessary settings and how to correctly specify the path to the system executable files. In this article, we will analyze in detail the process of connecting VCS (Version Control System) to your project, consider the nuances of authorization through SSH i HTTPS, and also touch on the issues of solving typical errors that arise during the first launch.
A properly configured tool saves hours of routine work and reduces stress when reverting unsuccessful edits. You will learn not just to press buttons in the menu, but also to understand what is happening “under the hood” when executing commands commit, push and pull. This knowledge is critical for any professional mobile application developer.
Initial installation and determining the path to Git
Before you start working with repositories, you need to make sure that the version control system itself is correctly installed on your computer and the development environment can find it. In most cases, during installation Android Studio it is also suggested to install Git, but sometimes the paths to the executable files are confused or specified incorrectly. To check and configure, go to the main settings menu through the item File → Settings (on macOS this is Android Studio → Preferences).
In the window that opens, in the left navigation panel, find the section Version Control, and then select the subsection Git. Here you will see the field Path to Git executable. If the system found the utility automatically, the path will be indicated there, for example, C:\app Files\Git\cmd\git.exe or /usr/bin/git. Next to the field there is a button Test, clicking on which should display the version of the installed tool. If you see an error message, it means that the path is specified incorrectly or the app is not installed.
⚠️ Attention: If you are using a portable version of Git or have installed it in a non-standard directory, the automatic search may not work. Manually specify the full path to the file
git.exeto avoid problems with executing commands in the IDE terminal.
Also in this section you should pay attention to the option SSH executableThe option is selected by default. Built-in, which is fine for most use cases. However, if you have specific issues with keys or authentication agents, switching to Native may resolve the issue by forcing Android Studio to use the system SSH client instead of the internal one.
☑️ Checking your Git installation
Initializing the repository and first commits
After the environment has “seen” the version control system, the next step is to create a local repository for your project. If you are starting development from scratch, you need to initialize the repository in the project's root folder. This can be done through the menu VCS → Enable Version Control Integration. In the dialog box that appears, select Git from the list of available systems.
After confirming the action, your project files will turn red, which indicates that they are not yet being tracked by the system. Now you need to add them to the staging area index. Open the tab Commit (usually located on the left or bottom of the interface), select all the necessary files and click the button + or simply enter the commit message. It is better to make the first message concise, for example, “Initial commit.”
When creating a commit, it is important to correctly configure ignoring service files. Android Studio automatically suggests creating a file that excludes build folders, local environment configuration files, and other temporary data from tracking. Ignoring these objects is critical to the cleanliness of the repository and to avoid conflicts when working together. .gitignore, which excludes build folders from tracking build, local environment configuration files .idea and other temporary data. Ignoring these objects is critical to the cleanliness of the repository and to avoid conflicts when collaborating.
- 📂 Always check the content
.gitignorebefore the first push so as not to accidentally send compiled.apkfiles. - ✍️ Write meaningful ones Commit messages that describe the essence of the changes, and not just “fix” or “update”.
- 🔄 Make small commits regularly so that in case of an error you can roll back to a specific working version.
Use the keyboard shortcut Ctrl+K (Cmd+K on Mac) to quickly open the commit window. This significantly speeds up the process of saving changes to history.
Connecting a remote repository (GitHub, GitLab)
Local storage of code protects against hard drive failure, but for team work and backup a remote server is required. The most popular platforms are GitHub, GitLab and Bitbucket. Integration with them in modern versions of Android Studio is implemented at a high level. To link a local project to a remote repository, select from the menu VCS → Git → Remotes or use the button in the window Commit.
You will need to add the URL of your repository. The default remote host name is origin. After adding the address, you will be able to perform synchronization operations. However, before the first one push authorization will be required. Modern versions of IDEs support logging in through a browser or using access tokens, which is safer than entering your login and password directly.
| Operation type | Description of action | Hotkeys |
|---|---|---|
| Push | Sending local commits to the server | Ctrl+Shift+K |
| Pull | Downloading changes from the server and merging | Ctrl+T |
| Fetch | Downloading changes without automatic merging | No by default |
| Rebase | Rebasing the current branch on top of the updated one | In the Git menu |
When working with private repositories, make sure your account has write permissions. A common mistake is to try to push to a repository where you only have read permissions. In this case, the system will return a permission error, and you will need to contact the project owner to add your user to collaborators.
Set up SSH keys for secure access
Using the protocol SSH is a more reliable and convenient way to interact with remote repositories compared to HTTPS, as it eliminates the need to constantly enter credentials. To set up, you will need to generate a pair of keys: private (stored on your computer) and public (uploaded to the hosting server).
In Android Studio, this process can be automated. Go to settings Version Control → Git and make sure built-in SSH is selected. Then click the button Generate SSH Key. The wizard will prompt you to specify the path to save (by default, this is a folder .ssh in your home directory) and a passphrase. Although using passphrase increases security, for everyday development on a personal computer, many people choose an empty passphrase for convenience.
⚠️ Attention: Never share your private key (a file without an extension or with a .pem/.ppk extension) to third parties and do not upload it to the public. The public key (usually with a .pub extension) can be freely copied and pasted into your GitHub or GitLab account settings.
After generating the key, you need to copy the contents of the public file. The Android Studio interface has a button to copy the key to the clipboard. Next, go to your profile settings on the hosting website (section SSH and GPG keys), create a new key and paste the copied line there. After this, the connection should be established without asking for a password.
What to do if the key does not work?
Make sure that the access rights to the .ssh folder and key files are set correctly. On Linux/Mac, the permissions for the private key should be 600, and for the .ssh folder - 700. Also check if ssh-agent is running.
Working with branches and resolving merge conflicts
One of the main advantages of Git is the ability to work with branches (branches). This allows you to develop new features without affecting the stable main version of the code. In Android Studio, branch management is placed in the lower right corner of the interface, where the current active branch is displayed. By clicking on it, you can create a new one, switch to an existing one, or delete an old one.
When merging branches, conflicts often arise when two developers changed the same line of code differently. Android Studio provides a powerful visual tool to solve such situations. When a conflict occurs, a window will open with three panels: your modified code, the code from the branch with which you are merging, and the result that will be obtained after applying the changes.
In the visual conflict editor, you can accept changes line by line by selecting the arrows to move code from the left or right panel to the central one. After all conflicts are resolved, you must mark the files as resolved and complete the merge operation with a commit. Do not rush to accept all changes automatically - careful analysis of the code is necessary so that the application logic is not broken.
- 🌿 Create a separate branch for each new feature or bug fix.
- 🔀 Regularly pull changes from the main branch (main/master) into your working branch to minimize the number of conflicts in the future.
- 🧹 Delete merged branches after completing work on a task so as not to clutter the list.
Branching is a safe testing ground for experiments. Don't be afraid to create new branches to test hypotheses, as they can be easily deleted if the idea doesn't work.
Setting up users and global settings
Each commit in the Git history must be signed with the name and email of the author. This is necessary to identify the developers' contribution to the overall project. If this data is not configured, the system may use the standard OS username or not sign commits at all, which will lead to errors when pushing to some servers that require author validation.
You can configure these parameters either through the command line or directly in the Android Studio interface. In the Git settings section there are fields User name and Email address. Enter information here that matches your GitHub or GitLab account. This will ensure that commits are correctly associated with your hosting profile, and your avatar will be displayed next to the change history.
In this section you can also configure commit message templates or formatting rules if your project uses strict standards (for example Conventional Commits). Although Android Studio does not have a built-in hard message syntax validator, discipline in writing them makes it easier to read the project history and automatically generate a changelog.
⚠️ Attention: app interfaces and menu items may vary slightly depending on the version of Android Studio and installed plugins. If you do not find the described option, use the settings search (Ctrl+Alt+S) by entering a keyword, for example, "Git" or "User".
Frequently asked questions (FAQ)
Why doesn't Android Studio see installed Git?
The most common problem lies in the incorrect path to the executable file. Check if Git is installed on the system (try entering git --version in the OS terminal). If the command works, copy the full path to the file git.exe and paste it into the IDE settings manually. Also make sure you restart Android Studio after installing Git.
How to undo the last commit if I forgot to add a file?
You can use the function Undo Commit in the commit history window (Log). Right-click on the latest commit and select the appropriate option. The changes will return to the indexing stage, and you can add the forgotten file and commit again. This is safe as long as the commit has not yet been pushed to the server.
What is the difference between Merge and Rebase?
Merge creates a new merge commit, preserving the full history of the branch, which is useful for understanding the context, but makes the history "messy". Rebase rewrites history, moving your commits to the top of the updated branch, making the story linear and clean. For personal branches, Rebase is preferable, for public ones - Merge.
Is it possible to work with Git in Android Studio without the Internet?
Yes, all basic operations (commit, create branches, view history, rollback changes) are performed locally and do not require a network connection. The Internet is only needed for synchronization with a remote repository (push/pull/fetch) and authorization on hosting servers.
How to delete a file from the repository, but leave it on disk?
To do this, you need to use the command git rm --cached filename. In the Android Studio interface, this can be done through the Commit tab: find the file, right-click and select Git → Remove from Version Control (make sure that you select deleting only from the index, and not physically deleting the file).